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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
39,400 | link_command::link_command() | msxemulator/build_O3/_deps/picotool-src/main.cpp | link_command() : cmd("link") {} | O3 | cpp | link_command::link_command():
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6e465(%rip), %rsi # 0xa68e9
leaq 0x6e462(%rip), %rdx # 0xa68ed
movq %rsp, %r14
movq %r14, %rdi
callq 0x5c00c
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%r14), %rcx
cmpq %r15, %rcx
je 0x384b5
movq %rcx, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbx)
jmp 0x384bc
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
leaq 0xa76e4(%rip), %rax # 0xdfbb0
movq %rax, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN12link_commandC2Ev:
push r15
push r14
push rbx
sub rsp, 20h
mov rbx, rdi
lea r15, [rsp+38h+var_28]
mov [r15-10h], r15
lea rsi, aFilesToLink+9; "link"
lea rdx, aFilesToLink+0Dh; ""
mov r14, rsp
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rax, [rbx+18h]
mov [rbx+8], rax
mov rcx, [r14]
cmp rcx, r15
jz short loc_384B5
mov [rbx+8], rcx
mov rax, [rsp+38h+var_28]
mov [rbx+18h], rax
jmp short loc_384BC
loc_384B5:
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
loc_384BC:
mov rax, [rsp+38h+var_30]
mov [rbx+10h], rax
lea rax, off_DFBB0
mov [rbx], rax
add rsp, 20h
pop rbx
pop r14
pop r15
retn
| void link_command::link_command(link_command *this)
{
_QWORD v1[2]; // [rsp+0h] [rbp-38h] BYREF
_OWORD v2[2]; // [rsp+10h] [rbp-28h] BYREF
v1[0] = v2;
std::string::_M_construct<char const*>(v1, "link", "");
*((_QWORD *)this + 1) = (char *)this + 24;
if ( (_OWORD *)v1[0] == v2 )
{
*(_OWORD *)((char *)this + 24) = v2[0];
}
else
{
*((_QWORD *)this + 1) = v1[0];
*((_QWORD *)this + 3) = *(_QWORD *)&v2[0];
}
*((_QWORD *)this + 2) = v1[1];
*(_QWORD *)this = off_DFBB0;
}
| link_command:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LEA RSI,[0x1a68e9]
LEA RDX,[0x1a68ed]
MOV R14,RSP
MOV RDI,R14
CALL 0x0015c00c
LEA RAX,[RBX + 0x18]
MOV qword ptr [RBX + 0x8],RAX
MOV RCX,qword ptr [R14]
CMP RCX,R15
JZ 0x001384b5
MOV qword ptr [RBX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x18],RAX
JMP 0x001384bc
LAB_001384b5:
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
LAB_001384bc:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x10],RAX
LEA RAX,[0x1dfbb0]
MOV qword ptr [RBX],RAX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* link_command::link_command() */
void __thiscall link_command::link_command(link_command *this)
{
int8 *local_38;
int8 local_30;
int8 local_28;
int8 uStack_20;
local_38 = &local_28;
std::__cxx11::string::_M_construct<char_const*>((string *)&local_38,"link","");
*(link_command **)(this + 8) = this + 0x18;
if (local_38 == &local_28) {
*(int8 *)(this + 0x18) = local_28;
*(int8 *)(this + 0x20) = uStack_20;
}
else {
*(int8 **)(this + 8) = local_38;
*(int8 *)(this + 0x18) = local_28;
}
*(int8 *)(this + 0x10) = local_30;
*(int ***)this = &PTR__cmd_001dfbb0;
return;
}
| |
39,401 | my_printf_error | eloqsql/mysys/my_error.c | void my_printf_error(uint error, const char *format, myf MyFlags, ...)
{
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printf_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
} | O0 | c | my_printf_error:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
testb %al, %al
je 0xefa47
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %r9, -0x2c8(%rbp)
movq %r8, -0x2d0(%rbp)
movq %rcx, -0x2d8(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
movq %rdx, -0x228(%rbp)
jmp 0xefa7f
leaq -0x240(%rbp), %rax
leaq -0x2f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x210(%rbp), %rsi
movq -0x220(%rbp), %rcx
leaq -0x240(%rbp), %r8
leaq 0x3838de(%rip), %rdi # 0x4733a0
movl $0x200, %edx # imm = 0x200
callq 0x14ac30
leaq -0x240(%rbp), %rax
leaq 0x1d0286(%rip), %rax # 0x2bfd60
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq *%rax
jmp 0xefaf5
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xefb10
addq $0x2f0, %rsp # imm = 0x2F0
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| my_printf_error:
push rbp
mov rbp, rsp
sub rsp, 2F0h
test al, al
jz short loc_EFA47
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_EFA47:
mov [rbp+var_2C8], r9
mov [rbp+var_2D0], r8
mov [rbp+var_2D8], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
mov [rbp+var_228], rdx
jmp short $+2
loc_EFA7F:
lea rax, [rbp+var_240]
lea rcx, [rbp+var_2F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
lea rsi, [rbp+var_210]
mov rcx, [rbp+var_220]
lea r8, [rbp+var_240]
lea rdi, my_charset_utf8mb3_general_ci
mov edx, 200h
call my_vsnprintf_ex
lea rax, [rbp+var_240]
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_228]
call rax
jmp short $+2
loc_EFAF5:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EFB10
add rsp, 2F0h
pop rbp
retn
loc_EFB10:
call ___stack_chk_fail
| unsigned long long my_printf_error(int a1, long long a2, long long a3, ...)
{
va_list va; // [rsp+B0h] [rbp-240h] BYREF
long long v5; // [rsp+C8h] [rbp-228h]
long long v6; // [rsp+D0h] [rbp-220h]
int v7; // [rsp+DCh] [rbp-214h]
_BYTE v8[520]; // [rsp+E0h] [rbp-210h] BYREF
unsigned long long v9; // [rsp+2E8h] [rbp-8h]
va_start(va, a3);
v9 = __readfsqword(0x28u);
v7 = a1;
v6 = a2;
v5 = a3;
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v8, 512LL, a2, va);
error_handler_hook();
return __readfsqword(0x28u);
}
| my_printf_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2f0
TEST AL,AL
JZ 0x001efa47
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_001efa47:
MOV qword ptr [RBP + -0x2c8],R9
MOV qword ptr [RBP + -0x2d0],R8
MOV qword ptr [RBP + -0x2d8],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
MOV qword ptr [RBP + -0x228],RDX
JMP 0x001efa7f
LAB_001efa7f:
LEA RAX,[RBP + -0x240]
LEA RCX,[RBP + -0x2f0]
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],0x18
LEA RSI,[RBP + -0x210]
MOV RCX,qword ptr [RBP + -0x220]
LEA R8,[RBP + -0x240]
LEA RDI,[0x5733a0]
MOV EDX,0x200
CALL 0x0024ac30
LEA RAX,[RBP + -0x240]
LEA RAX,[0x3bfd60]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x228]
CALL RAX
JMP 0x001efaf5
LAB_001efaf5:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001efb10
ADD RSP,0x2f0
POP RBP
RET
LAB_001efb10:
CALL 0x0012a250
|
void my_printf_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [24];
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int4 local_248;
int4 local_244;
int1 *local_240;
int1 *local_238;
int8 local_230;
int8 local_228;
int4 local_21c;
int1 local_218 [520];
long local_10;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_238 = local_2f8;
local_240 = &stack0x00000008;
local_244 = 0x30;
local_248 = 0x18;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
local_230 = param_11;
local_228 = param_10;
local_21c = param_9;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_218,0x200,param_10,&local_248);
(*(code *)error_handler_hook)(local_21c,local_218,local_230);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,402 | my_printf_error | eloqsql/mysys/my_error.c | void my_printf_error(uint error, const char *format, myf MyFlags, ...)
{
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_printf_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d format: %s",
error, MyFlags, errno, format));
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
(*error_handler_hook)(error, ebuff, MyFlags);
DBUG_VOID_RETURN;
} | O3 | c | my_printf_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movq %rdx, %rbx
movq %rsi, %r10
movl %edi, %r14d
leaq -0x2f0(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x9e1b9
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movabsq $0x3000000018, %rax # imm = 0x3000000018
leaq -0x240(%rbp), %r8
movq %rax, (%r8)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r8)
movq %rdx, 0x10(%r8)
leaq 0x35ae73(%rip), %rdi # 0x3f9060
leaq -0x220(%rbp), %r15
movl $0x200, %edx # imm = 0x200
movq %r15, %rsi
movq %r10, %rcx
callq 0xd5bbc
leaq 0x2e7935(%rip), %rax # 0x385b40
movl %r14d, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *(%rax)
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x9e233
addq $0x2d8, %rsp # imm = 0x2D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
| my_printf_error:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 2D8h
mov rbx, rdx
mov r10, rsi
mov r14d, edi
lea rdx, [rbp+var_2F0]
mov [rdx+18h], rcx
mov [rdx+20h], r8
mov [rdx+28h], r9
test al, al
jz short loc_9E1B9
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_9E1B9:
mov rax, fs:28h
mov [rbp+var_20], rax
mov rax, 3000000018h
lea r8, [rbp+var_240]
mov [r8], rax
lea rax, [rbp+arg_0]
mov [r8+8], rax
mov [r8+10h], rdx
lea rdi, my_charset_utf8mb3_general_ci
lea r15, [rbp+var_220]
mov edx, 200h
mov rsi, r15
mov rcx, r10
call my_vsnprintf_ex
lea rax, error_handler_hook
mov edi, r14d
mov rsi, r15
mov rdx, rbx
call qword ptr [rax]
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_9E233
add rsp, 2D8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_9E233:
call ___stack_chk_fail
| unsigned long long my_printf_error(
_DWORD a1,
long long a2,
_DWORD 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-2F0h] BYREF
long long v17; // [rsp+18h] [rbp-2D8h]
long long v18; // [rsp+20h] [rbp-2D0h]
long long v19; // [rsp+28h] [rbp-2C8h]
__m128 v20; // [rsp+30h] [rbp-2C0h]
__m128 v21; // [rsp+40h] [rbp-2B0h]
__m128 v22; // [rsp+50h] [rbp-2A0h]
__m128 v23; // [rsp+60h] [rbp-290h]
__m128 v24; // [rsp+70h] [rbp-280h]
__m128 v25; // [rsp+80h] [rbp-270h]
__m128 v26; // [rsp+90h] [rbp-260h]
__m128 v27; // [rsp+A0h] [rbp-250h]
_QWORD v28[4]; // [rsp+B0h] [rbp-240h] BYREF
_BYTE v29[512]; // [rsp+D0h] [rbp-220h] BYREF
unsigned long long v30; // [rsp+2D0h] [rbp-20h]
v20 = a7;
v21 = a8;
v22 = a9;
v23 = a10;
v24 = a11;
v25 = a12;
v26 = a13;
v27 = a14;
v17 = a4;
v18 = a5;
v19 = a6;
v30 = __readfsqword(0x28u);
v28[0] = 0x3000000018LL;
v28[1] = &a15;
v28[2] = &v16;
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v29, 512LL, a2, v28);
error_handler_hook();
return __readfsqword(0x28u);
}
| my_printf_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x2d8
MOV RBX,RDX
MOV R10,RSI
MOV R14D,EDI
LEA RDX,[RBP + -0x2f0]
MOV qword ptr [RDX + 0x18],RCX
MOV qword ptr [RDX + 0x20],R8
MOV qword ptr [RDX + 0x28],R9
TEST AL,AL
JZ 0x0019e1b9
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_0019e1b9:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,0x3000000018
LEA R8,[RBP + -0x240]
MOV qword ptr [R8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RAX
MOV qword ptr [R8 + 0x10],RDX
LEA RDI,[0x4f9060]
LEA R15,[RBP + -0x220]
MOV EDX,0x200
MOV RSI,R15
MOV RCX,R10
CALL 0x001d5bbc
LEA RAX,[0x485b40]
MOV EDI,R14D
MOV RSI,R15
MOV RDX,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x0019e233
ADD RSP,0x2d8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0019e233:
CALL 0x00129250
|
void my_printf_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [24];
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int8 local_248;
int1 *local_240;
int1 *local_238;
int1 local_228 [512];
long local_28;
local_238 = local_2f8;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_28 = *(long *)(in_FS_OFFSET + 0x28);
local_248 = 0x3000000018;
local_240 = &stack0x00000008;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_228,0x200,param_10);
(*(code *)error_handler_hook)(param_9,local_228,param_11);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,403 | my_thread_global_reinit | eloqsql/mysys/my_thr_init.c | void my_thread_global_reinit(void)
{
struct st_my_thread_var *tmp;
DBUG_ASSERT(my_thread_global_init_done);
#ifdef HAVE_PSI_INTERFACE
my_init_mysys_psi_keys();
#endif
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
tmp= my_thread_var;
DBUG_ASSERT(tmp);
my_thread_destory_thr_mutex(tmp);
my_thread_init_thr_mutex(tmp);
} | O0 | c | my_thread_global_reinit:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x265fa
callq 0x28b80
callq 0x264a0
callq 0x26640
callq 0x26550
callq 0x26710
callq 0x26770
movq %rax, -0x8(%rbp)
jmp 0x2661e
movq -0x8(%rbp), %rdi
callq 0x26790
movq -0x8(%rbp), %rdi
callq 0x267c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_thread_global_reinit:
push rbp
mov rbp, rsp
sub rsp, 10h
jmp short $+2
loc_265FA:
call my_init_mysys_psi_keys
call my_thread_destroy_common_mutex
call my_thread_init_common_mutex
call my_thread_destroy_internal_mutex
call my_thread_init_internal_mutex
call _my_thread_var
mov [rbp+var_8], rax
jmp short $+2
loc_2661E:
mov rdi, [rbp+var_8]
call my_thread_destory_thr_mutex
mov rdi, [rbp+var_8]
call my_thread_init_thr_mutex
add rsp, 10h
pop rbp
retn
| long long my_thread_global_reinit()
{
long long v1; // [rsp+8h] [rbp-8h]
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
v1 = my_thread_var();
my_thread_destory_thr_mutex(v1);
return my_thread_init_thr_mutex(v1);
}
| my_thread_global_reinit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
JMP 0x001265fa
LAB_001265fa:
CALL 0x00128b80
CALL 0x001264a0
CALL 0x00126640
CALL 0x00126550
CALL 0x00126710
CALL 0x00126770
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0012661e
LAB_0012661e:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00126790
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001267c0
ADD RSP,0x10
POP RBP
RET
|
void my_thread_global_reinit(void)
{
int8 uVar1;
my_init_mysys_psi_keys();
my_thread_destroy_common_mutex();
my_thread_init_common_mutex();
my_thread_destroy_internal_mutex();
my_thread_init_internal_mutex();
uVar1 = _my_thread_var();
my_thread_destory_thr_mutex(uVar1);
my_thread_init_thr_mutex(uVar1);
return;
}
| |
39,404 | my_mb_wc_euc_kr | eloqsql/strings/ctype-euc_kr.c | static int
my_mb_wc_euc_kr(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_ksc5601_uni_onechar((hi<<8)+s[1])))
return -2;
return 2;
} | O3 | c | my_mb_wc_euc_kr:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x6d625
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x6d5e4
movq %rdi, (%rsi)
movl $0x1, %eax
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x6d625
movzbl %dil, %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
je 0x6d625
cmpl $0xff, %ecx
je 0x6d625
movzbl 0x1(%rdx), %edx
leal 0x1(%rdx), %edi
cmpb $-0x7f, %dil
ja 0x6d626
movl %edx, %edi
andb $-0x21, %dil
addb $-0x5b, %dil
cmpb $-0x1a, %dil
jae 0x6d626
retq
pushq %rbp
movq %rsp, %rbp
shll $0x8, %ecx
leal (%rcx,%rdx), %eax
addl $0xffff7ebf, %eax # imm = 0xFFFF7EBF
cmpl $0x47bd, %eax # imm = 0x47BD
ja 0x6d647
movl %eax, %eax
leaq 0x8c49b(%rip), %rcx # 0xf9ae0
jmp 0x6d660
orl %edx, %ecx
addl $0xffff355f, %ecx # imm = 0xFFFF355F
cmpl $0x335e, %ecx # imm = 0x335E
jae 0x6d679
movl %ecx, %eax
leaq 0x95400(%rip), %rcx # 0x102a60
leaq (%rcx,%rax,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x6d685
jmp 0x6d680
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
| my_mb_wc_euc_kr:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_6D625
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_6D5E4
mov [rsi], rdi
mov eax, 1
retn
loc_6D5E4:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short locret_6D625
movzx ecx, dil
xor eax, eax
cmp ecx, 80h
jz short locret_6D625
cmp ecx, 0FFh
jz short locret_6D625
movzx edx, byte ptr [rdx+1]
lea edi, [rdx+1]
cmp dil, 81h
ja short loc_6D626
mov edi, edx
and dil, 0DFh
add dil, 0A5h
cmp dil, 0E6h
jnb short loc_6D626
locret_6D625:
retn
loc_6D626:
push rbp
mov rbp, rsp
shl ecx, 8
lea eax, [rcx+rdx]
add eax, 0FFFF7EBFh
cmp eax, 47BDh
ja short loc_6D647
mov eax, eax
lea rcx, tab_ksc5601_uni0
jmp short loc_6D660
loc_6D647:
or ecx, edx
add ecx, 0FFFF355Fh
cmp ecx, 335Eh
jnb short loc_6D679
mov eax, ecx
lea rcx, tab_ksc5601_uni1
loc_6D660:
lea rax, [rcx+rax*2]
movzx eax, word ptr [rax]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_6D685
jmp short loc_6D680
loc_6D679:
mov qword ptr [rsi], 0
loc_6D680:
mov eax, 0FFFFFFFEh
loc_6D685:
pop rbp
retn
| long long my_mb_wc_euc_kr(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // edx
int v7; // ecx
long long v8; // rax
unsigned __int16 *v9; // rcx
unsigned int v10; // ecx
long long v11; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)v5 != 128 && (unsigned __int8)v5 != 255 )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 + 1) > 0x81u || (unsigned __int8)((v6 & 0xDF) - 91) >= 0xE6u )
{
v7 = (unsigned __int8)v5 << 8;
LODWORD(v8) = v7 + v6 - 33089;
if ( (unsigned int)v8 > 0x47BD )
{
v10 = (v6 | v7) - 51873;
if ( v10 >= 0x335E )
{
*a2 = 0LL;
return 4294967294LL;
}
v8 = v10;
v9 = (unsigned __int16 *)&tab_ksc5601_uni1;
}
else
{
v8 = (unsigned int)v8;
v9 = (unsigned __int16 *)&tab_ksc5601_uni0;
}
v11 = v9[v8];
*a2 = v11;
result = 2LL;
if ( (_WORD)v11 )
return result;
return 4294967294LL;
}
}
}
}
return result;
}
| my_mb_wc_euc_kr:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0016d625
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x0016d5e4
MOV qword ptr [RSI],RDI
MOV EAX,0x1
RET
LAB_0016d5e4:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0016d625
MOVZX ECX,DIL
XOR EAX,EAX
CMP ECX,0x80
JZ 0x0016d625
CMP ECX,0xff
JZ 0x0016d625
MOVZX EDX,byte ptr [RDX + 0x1]
LEA EDI,[RDX + 0x1]
CMP DIL,0x81
JA 0x0016d626
MOV EDI,EDX
AND DIL,0xdf
ADD DIL,0xa5
CMP DIL,0xe6
JNC 0x0016d626
LAB_0016d625:
RET
LAB_0016d626:
PUSH RBP
MOV RBP,RSP
SHL ECX,0x8
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xffff7ebf
CMP EAX,0x47bd
JA 0x0016d647
MOV EAX,EAX
LEA RCX,[0x1f9ae0]
JMP 0x0016d660
LAB_0016d647:
OR ECX,EDX
ADD ECX,0xffff355f
CMP ECX,0x335e
JNC 0x0016d679
MOV EAX,ECX
LEA RCX,[0x202a60]
LAB_0016d660:
LEA RAX,[RCX + RAX*0x2]
MOVZX EAX,word ptr [RAX]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x0016d685
JMP 0x0016d680
LAB_0016d679:
MOV qword ptr [RSI],0x0
LAB_0016d680:
MOV EAX,0xfffffffe
LAB_0016d685:
POP RBP
RET
|
int8 my_mb_wc_euc_kr(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
uint uVar4;
int1 *puVar5;
if (param_4 <= param_3) {
return 0xffffff9b;
}
bVar1 = *param_3;
if (-1 < (long)(char)bVar1) {
*param_2 = (long)(char)bVar1;
return 1;
}
if (param_4 < param_3 + 2) {
return 0xffffff9a;
}
if (bVar1 == 0x80) {
return 0;
}
if (bVar1 == 0xff) {
return 0;
}
bVar2 = param_3[1];
if (((byte)(bVar2 + 1) < 0x82) && ((byte)((bVar2 & 0xdf) + 0xa5) < 0xe6)) {
return 0;
}
uVar4 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0x8141;
if (uVar4 < 0x47be) {
puVar5 = tab_ksc5601_uni0;
}
else {
uVar4 = CONCAT11(bVar1,bVar2) - 0xcaa1;
if (0x335d < uVar4) {
*param_2 = 0;
return 0xfffffffe;
}
puVar5 = tab_ksc5601_uni1;
}
uVar3 = *(ushort *)(puVar5 + (ulong)uVar4 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 == 0) {
return 0xfffffffe;
}
return 2;
}
| |
39,405 | ComputeSHA1 | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | unsigned int *ComputeSHA1(unsigned char *data, int dataSize) {
#define ROTATE_LEFT(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
static unsigned int hash[5] = { 0 }; // Hash to be returned
// Initialize hash values
hash[0] = 0x67452301;
hash[1] = 0xEFCDAB89;
hash[2] = 0x98BADCFE;
hash[3] = 0x10325476;
hash[4] = 0xC3D2E1F0;
// Pre-processing: adding a single 1 bit
// Append '1' bit to message
// NOTE: The input bytes are considered as bits strings,
// where the first bit is the most significant bit of the byte
// Pre-processing: padding with zeros
// Append '0' bit until message length in bit 448 (mod 512)
// Append length mod (2 pow 64) to message
int newDataSize = ((((dataSize + 8)/64) + 1)*64);
unsigned char *msg = RL_CALLOC(newDataSize, 1); // Initialize with '0' bits
memcpy(msg, data, dataSize);
msg[dataSize] = 128; // Write the '1' bit
unsigned int bitsLen = 8*dataSize;
msg[newDataSize-1] = bitsLen;
// Process the message in successive 512-bit chunks
for (int offset = 0; offset < newDataSize; offset += (512/8))
{
// Break chunk into sixteen 32-bit words w[j], 0 <= j <= 15
unsigned int w[80] = {0};
for (int i = 0; i < 16; i++) {
w[i] = (msg[offset + (i * 4) + 0] << 24) |
(msg[offset + (i * 4) + 1] << 16) |
(msg[offset + (i * 4) + 2] << 8) |
(msg[offset + (i * 4) + 3]);
}
// Message schedule: extend the sixteen 32-bit words into eighty 32-bit words:
for (int i = 16; i < 80; ++i) {
w[i] = ROTATE_LEFT(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1);
}
// Initialize hash value for this chunk
unsigned int a = hash[0];
unsigned int b = hash[1];
unsigned int c = hash[2];
unsigned int d = hash[3];
unsigned int e = hash[4];
for (int i = 0; i < 80; i++)
{
unsigned int f = 0;
unsigned int k = 0;
if (i < 20) {
f = (b & c) | ((~b) & d);
k = 0x5A827999;
} else if (i < 40) {
f = b ^ c ^ d;
k = 0x6ED9EBA1;
} else if (i < 60) {
f = (b & c) | (b & d) | (c & d);
k = 0x8F1BBCDC;
} else {
f = b ^ c ^ d;
k = 0xCA62C1D6;
}
unsigned int temp = ROTATE_LEFT(a, 5) + f + e + k + w[i];
e = d;
d = c;
c = ROTATE_LEFT(b, 30);
b = a;
a = temp;
}
// Add this chunk's hash to result so far
hash[0] += a;
hash[1] += b;
hash[2] += c;
hash[3] += d;
hash[4] += e;
}
free(msg);
return hash;
} | O0 | c | ComputeSHA1:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x67452301, 0x14cc84(%rip) # imm = 0x67452301
movl $0xefcdab89, 0x14cc7e(%rip) # imm = 0xEFCDAB89
movl $0x98badcfe, 0x14cc78(%rip) # imm = 0x98BADCFE
movl $0x10325476, 0x14cc72(%rip) # imm = 0x10325476
movl $0xc3d2e1f0, 0x14cc6c(%rip) # imm = 0xC3D2E1F0
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl $0x40, %ecx
cltd
idivl %ecx
addl $0x1, %eax
shll $0x6, %eax
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xa340
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0xa400
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $-0x80, (%rax,%rcx)
movl -0xc(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xd3191
leaq -0x160(%rbp), %rdi
xorl %esi, %esi
movl $0x140, %edx # imm = 0x140
callq 0xa2d0
movl $0x0, -0x164(%rbp)
cmpl $0x10, -0x164(%rbp)
jge 0xd2e86
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
movl -0x164(%rbp), %edx
shll $0x2, %edx
addl %edx, %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
shll $0x18, %ecx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movl -0x164(%rbp), %esi
shll $0x2, %esi
addl %esi, %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movl -0x164(%rbp), %esi
shll $0x2, %esi
addl %esi, %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %edx
movl -0x164(%rbp), %esi
shll $0x2, %esi
addl %esi, %edx
addl $0x3, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
orl %eax, %ecx
movslq -0x164(%rbp), %rax
movl %ecx, -0x160(%rbp,%rax,4)
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0xd2dd8
movl $0x10, -0x168(%rbp)
cmpl $0x50, -0x168(%rbp)
jge 0xd2f59
movl -0x168(%rbp), %eax
subl $0x3, %eax
cltq
movl -0x160(%rbp,%rax,4), %ecx
movl -0x168(%rbp), %eax
subl $0x8, %eax
cltq
xorl -0x160(%rbp,%rax,4), %ecx
movl -0x168(%rbp), %eax
subl $0xe, %eax
cltq
xorl -0x160(%rbp,%rax,4), %ecx
movl -0x168(%rbp), %eax
subl $0x10, %eax
cltq
xorl -0x160(%rbp,%rax,4), %ecx
shll %ecx
movl -0x168(%rbp), %eax
subl $0x3, %eax
cltq
movl -0x160(%rbp,%rax,4), %eax
movl -0x168(%rbp), %edx
subl $0x8, %edx
movslq %edx, %rdx
xorl -0x160(%rbp,%rdx,4), %eax
movl -0x168(%rbp), %edx
subl $0xe, %edx
movslq %edx, %rdx
xorl -0x160(%rbp,%rdx,4), %eax
movl -0x168(%rbp), %edx
subl $0x10, %edx
movslq %edx, %rdx
xorl -0x160(%rbp,%rdx,4), %eax
shrl $0x1f, %eax
orl %eax, %ecx
movslq -0x168(%rbp), %rax
movl %ecx, -0x160(%rbp,%rax,4)
movl -0x168(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x168(%rbp)
jmp 0xd2e90
movl 0x14ca41(%rip), %eax # 0x21f9a0
movl %eax, -0x16c(%rbp)
movl 0x14ca39(%rip), %eax # 0x21f9a4
movl %eax, -0x170(%rbp)
movl 0x14ca31(%rip), %eax # 0x21f9a8
movl %eax, -0x174(%rbp)
movl 0x14ca29(%rip), %eax # 0x21f9ac
movl %eax, -0x178(%rbp)
movl 0x14ca21(%rip), %eax # 0x21f9b0
movl %eax, -0x17c(%rbp)
movl $0x0, -0x180(%rbp)
cmpl $0x50, -0x180(%rbp)
jge 0xd3129
movl $0x0, -0x184(%rbp)
movl $0x0, -0x188(%rbp)
cmpl $0x14, -0x180(%rbp)
jge 0xd2ffb
movl -0x170(%rbp), %eax
andl -0x174(%rbp), %eax
movl -0x170(%rbp), %ecx
xorl $-0x1, %ecx
andl -0x178(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x184(%rbp)
movl $0x5a827999, -0x188(%rbp) # imm = 0x5A827999
jmp 0xd3091
cmpl $0x28, -0x180(%rbp)
jge 0xd3028
movl -0x170(%rbp), %eax
xorl -0x174(%rbp), %eax
xorl -0x178(%rbp), %eax
movl %eax, -0x184(%rbp)
movl $0x6ed9eba1, -0x188(%rbp) # imm = 0x6ED9EBA1
jmp 0xd308f
cmpl $0x3c, -0x180(%rbp)
jge 0xd306b
movl -0x170(%rbp), %eax
andl -0x174(%rbp), %eax
movl -0x170(%rbp), %ecx
andl -0x178(%rbp), %ecx
orl %ecx, %eax
movl -0x174(%rbp), %ecx
andl -0x178(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x184(%rbp)
movl $0x8f1bbcdc, -0x188(%rbp) # imm = 0x8F1BBCDC
jmp 0xd308d
movl -0x170(%rbp), %eax
xorl -0x174(%rbp), %eax
xorl -0x178(%rbp), %eax
movl %eax, -0x184(%rbp)
movl $0xca62c1d6, -0x188(%rbp) # imm = 0xCA62C1D6
jmp 0xd308f
jmp 0xd3091
movl -0x16c(%rbp), %eax
shll $0x5, %eax
movl -0x16c(%rbp), %ecx
shrl $0x1b, %ecx
orl %ecx, %eax
addl -0x184(%rbp), %eax
addl -0x17c(%rbp), %eax
addl -0x188(%rbp), %eax
movslq -0x180(%rbp), %rcx
addl -0x160(%rbp,%rcx,4), %eax
movl %eax, -0x18c(%rbp)
movl -0x178(%rbp), %eax
movl %eax, -0x17c(%rbp)
movl -0x174(%rbp), %eax
movl %eax, -0x178(%rbp)
movl -0x170(%rbp), %eax
shll $0x1e, %eax
movl -0x170(%rbp), %ecx
shrl $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x174(%rbp)
movl -0x16c(%rbp), %eax
movl %eax, -0x170(%rbp)
movl -0x18c(%rbp), %eax
movl %eax, -0x16c(%rbp)
movl -0x180(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x180(%rbp)
jmp 0xd2f9f
movl -0x16c(%rbp), %eax
addl 0x14c86b(%rip), %eax # 0x21f9a0
movl %eax, 0x14c865(%rip) # 0x21f9a0
movl -0x170(%rbp), %eax
addl 0x14c85d(%rip), %eax # 0x21f9a4
movl %eax, 0x14c857(%rip) # 0x21f9a4
movl -0x174(%rbp), %eax
addl 0x14c84f(%rip), %eax # 0x21f9a8
movl %eax, 0x14c849(%rip) # 0x21f9a8
movl -0x178(%rbp), %eax
addl 0x14c841(%rip), %eax # 0x21f9ac
movl %eax, 0x14c83b(%rip) # 0x21f9ac
movl -0x17c(%rbp), %eax
addl 0x14c833(%rip), %eax # 0x21f9b0
movl %eax, 0x14c82d(%rip) # 0x21f9b0
movl -0x20(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x20(%rbp)
jmp 0xd2daf
movq -0x18(%rbp), %rdi
callq 0xa640
leaq 0x14c7ff(%rip), %rax # 0x21f9a0
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
nopw (%rax,%rax)
| ComputeSHA1:
push rbp
mov rbp, rsp
sub rsp, 190h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov cs:ComputeSHA1_hash, 67452301h
mov cs:dword_21F9A4, 0EFCDAB89h
mov cs:dword_21F9A8, 98BADCFEh
mov cs:dword_21F9AC, 10325476h
mov cs:dword_21F9B0, 0C3D2E1F0h
mov eax, [rbp+var_C]
add eax, 8
mov ecx, 40h ; '@'
cdq
idiv ecx
add eax, 1
shl eax, 6
mov [rbp+var_10], eax
movsxd rdi, [rbp+var_10]
mov esi, 1
call _calloc
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_8]
movsxd rdx, [rbp+var_C]
call _memcpy
mov rax, [rbp+var_18]
movsxd rcx, [rbp+var_C]
mov byte ptr [rax+rcx], 80h
mov eax, [rbp+var_C]
shl eax, 3
mov [rbp+var_1C], eax
mov eax, [rbp+var_1C]
mov dl, al
mov rax, [rbp+var_18]
mov ecx, [rbp+var_10]
sub ecx, 1
movsxd rcx, ecx
mov [rax+rcx], dl
mov [rbp+var_20], 0
loc_D2DAF:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_10]
jge loc_D3191
lea rdi, [rbp+var_160]
xor esi, esi
mov edx, 140h
call _memset
mov [rbp+var_164], 0
loc_D2DD8:
cmp [rbp+var_164], 10h
jge loc_D2E86
mov rax, [rbp+var_18]
mov ecx, [rbp+var_20]
mov edx, [rbp+var_164]
shl edx, 2
add ecx, edx
add ecx, 0
movsxd rcx, ecx
movzx ecx, byte ptr [rax+rcx]
shl ecx, 18h
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
mov esi, [rbp+var_164]
shl esi, 2
add edx, esi
add edx, 1
movsxd rdx, edx
movzx eax, byte ptr [rax+rdx]
shl eax, 10h
or ecx, eax
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
mov esi, [rbp+var_164]
shl esi, 2
add edx, esi
add edx, 2
movsxd rdx, edx
movzx eax, byte ptr [rax+rdx]
shl eax, 8
or ecx, eax
mov rax, [rbp+var_18]
mov edx, [rbp+var_20]
mov esi, [rbp+var_164]
shl esi, 2
add edx, esi
add edx, 3
movsxd rdx, edx
movzx eax, byte ptr [rax+rdx]
or ecx, eax
movsxd rax, [rbp+var_164]
mov [rbp+rax*4+var_160], ecx
mov eax, [rbp+var_164]
add eax, 1
mov [rbp+var_164], eax
jmp loc_D2DD8
loc_D2E86:
mov [rbp+var_168], 10h
loc_D2E90:
cmp [rbp+var_168], 50h ; 'P'
jge loc_D2F59
mov eax, [rbp+var_168]
sub eax, 3
cdqe
mov ecx, [rbp+rax*4+var_160]
mov eax, [rbp+var_168]
sub eax, 8
cdqe
xor ecx, [rbp+rax*4+var_160]
mov eax, [rbp+var_168]
sub eax, 0Eh
cdqe
xor ecx, [rbp+rax*4+var_160]
mov eax, [rbp+var_168]
sub eax, 10h
cdqe
xor ecx, [rbp+rax*4+var_160]
shl ecx, 1
mov eax, [rbp+var_168]
sub eax, 3
cdqe
mov eax, [rbp+rax*4+var_160]
mov edx, [rbp+var_168]
sub edx, 8
movsxd rdx, edx
xor eax, [rbp+rdx*4+var_160]
mov edx, [rbp+var_168]
sub edx, 0Eh
movsxd rdx, edx
xor eax, [rbp+rdx*4+var_160]
mov edx, [rbp+var_168]
sub edx, 10h
movsxd rdx, edx
xor eax, [rbp+rdx*4+var_160]
shr eax, 1Fh
or ecx, eax
movsxd rax, [rbp+var_168]
mov [rbp+rax*4+var_160], ecx
mov eax, [rbp+var_168]
add eax, 1
mov [rbp+var_168], eax
jmp loc_D2E90
loc_D2F59:
mov eax, cs:ComputeSHA1_hash
mov [rbp+var_16C], eax
mov eax, cs:dword_21F9A4
mov [rbp+var_170], eax
mov eax, cs:dword_21F9A8
mov [rbp+var_174], eax
mov eax, cs:dword_21F9AC
mov [rbp+var_178], eax
mov eax, cs:dword_21F9B0
mov [rbp+var_17C], eax
mov [rbp+var_180], 0
loc_D2F9F:
cmp [rbp+var_180], 50h ; 'P'
jge loc_D3129
mov [rbp+var_184], 0
mov [rbp+var_188], 0
cmp [rbp+var_180], 14h
jge short loc_D2FFB
mov eax, [rbp+var_170]
and eax, [rbp+var_174]
mov ecx, [rbp+var_170]
xor ecx, 0FFFFFFFFh
and ecx, [rbp+var_178]
or eax, ecx
mov [rbp+var_184], eax
mov [rbp+var_188], 5A827999h
jmp loc_D3091
loc_D2FFB:
cmp [rbp+var_180], 28h ; '('
jge short loc_D3028
mov eax, [rbp+var_170]
xor eax, [rbp+var_174]
xor eax, [rbp+var_178]
mov [rbp+var_184], eax
mov [rbp+var_188], 6ED9EBA1h
jmp short loc_D308F
loc_D3028:
cmp [rbp+var_180], 3Ch ; '<'
jge short loc_D306B
mov eax, [rbp+var_170]
and eax, [rbp+var_174]
mov ecx, [rbp+var_170]
and ecx, [rbp+var_178]
or eax, ecx
mov ecx, [rbp+var_174]
and ecx, [rbp+var_178]
or eax, ecx
mov [rbp+var_184], eax
mov [rbp+var_188], 8F1BBCDCh
jmp short loc_D308D
loc_D306B:
mov eax, [rbp+var_170]
xor eax, [rbp+var_174]
xor eax, [rbp+var_178]
mov [rbp+var_184], eax
mov [rbp+var_188], 0CA62C1D6h
loc_D308D:
jmp short $+2
loc_D308F:
jmp short $+2
loc_D3091:
mov eax, [rbp+var_16C]
shl eax, 5
mov ecx, [rbp+var_16C]
shr ecx, 1Bh
or eax, ecx
add eax, [rbp+var_184]
add eax, [rbp+var_17C]
add eax, [rbp+var_188]
movsxd rcx, [rbp+var_180]
add eax, [rbp+rcx*4+var_160]
mov [rbp+var_18C], eax
mov eax, [rbp+var_178]
mov [rbp+var_17C], eax
mov eax, [rbp+var_174]
mov [rbp+var_178], eax
mov eax, [rbp+var_170]
shl eax, 1Eh
mov ecx, [rbp+var_170]
shr ecx, 2
or eax, ecx
mov [rbp+var_174], eax
mov eax, [rbp+var_16C]
mov [rbp+var_170], eax
mov eax, [rbp+var_18C]
mov [rbp+var_16C], eax
mov eax, [rbp+var_180]
add eax, 1
mov [rbp+var_180], eax
jmp loc_D2F9F
loc_D3129:
mov eax, [rbp+var_16C]
add eax, cs:ComputeSHA1_hash
mov cs:ComputeSHA1_hash, eax
mov eax, [rbp+var_170]
add eax, cs:dword_21F9A4
mov cs:dword_21F9A4, eax
mov eax, [rbp+var_174]
add eax, cs:dword_21F9A8
mov cs:dword_21F9A8, eax
mov eax, [rbp+var_178]
add eax, cs:dword_21F9AC
mov cs:dword_21F9AC, eax
mov eax, [rbp+var_17C]
add eax, cs:dword_21F9B0
mov cs:dword_21F9B0, eax
mov eax, [rbp+var_20]
add eax, 40h ; '@'
mov [rbp+var_20], eax
jmp loc_D2DAF
loc_D3191:
mov rdi, [rbp+var_18]
call _free
lea rax, ComputeSHA1_hash
add rsp, 190h
pop rbp
retn
| int * ComputeSHA1(long long a1, int a2)
{
int v3; // [rsp+4h] [rbp-18Ch]
int v4; // [rsp+8h] [rbp-188h]
int v5; // [rsp+Ch] [rbp-184h]
int m; // [rsp+10h] [rbp-180h]
int v7; // [rsp+14h] [rbp-17Ch]
int v8; // [rsp+18h] [rbp-178h]
int v9; // [rsp+1Ch] [rbp-174h]
unsigned int v10; // [rsp+20h] [rbp-170h]
unsigned int v11; // [rsp+24h] [rbp-16Ch]
int k; // [rsp+28h] [rbp-168h]
int j; // [rsp+2Ch] [rbp-164h]
_DWORD v14[80]; // [rsp+30h] [rbp-160h] BYREF
int i; // [rsp+170h] [rbp-20h]
int v16; // [rsp+174h] [rbp-1Ch]
long long v17; // [rsp+178h] [rbp-18h]
int v18; // [rsp+180h] [rbp-10h]
int v19; // [rsp+184h] [rbp-Ch]
long long v20; // [rsp+188h] [rbp-8h]
v20 = a1;
v19 = a2;
ComputeSHA1_hash = 1732584193;
dword_21F9A4 = -271733879;
dword_21F9A8 = -1732584194;
dword_21F9AC = 271733878;
dword_21F9B0 = -1009589776;
v18 = ((a2 + 8) / 64 + 1) << 6;
v17 = calloc(v18, 1LL);
memcpy(v17, a1, a2);
*(_BYTE *)(v17 + a2) = 0x80;
v16 = 8 * v19;
*(_BYTE *)(v17 + v18 - 1) = 8 * v19;
for ( i = 0; i < v18; i += 64 )
{
memset(v14, 0LL, sizeof(v14));
for ( j = 0; j < 16; ++j )
v14[j] = *(unsigned __int8 *)(v17 + 4 * j + i + 3) | (*(unsigned __int8 *)(v17 + 4 * j + i + 2) << 8) | (*(unsigned __int8 *)(v17 + 4 * j + i + 1) << 16) | (*(unsigned __int8 *)(v17 + 4 * j + i) << 24);
for ( k = 16; k < 80; ++k )
v14[k] = ((v14[k - 16] ^ v14[k - 14] ^ (unsigned int)(v14[k - 8] ^ v14[k - 3])) >> 31) | (2
* (v14[k - 16] ^ v14[k - 14] ^ v14[k - 8] ^ v14[k - 3]));
v11 = ComputeSHA1_hash;
v10 = dword_21F9A4;
v9 = dword_21F9A8;
v8 = dword_21F9AC;
v7 = dword_21F9B0;
for ( m = 0; m < 80; ++m )
{
if ( m >= 20 )
{
if ( m >= 40 )
{
if ( m >= 60 )
{
v5 = v8 ^ v9 ^ v10;
v4 = -899497514;
}
else
{
v5 = v8 & v9 | v8 & v10 | v9 & v10;
v4 = -1894007588;
}
}
else
{
v5 = v8 ^ v9 ^ v10;
v4 = 1859775393;
}
}
else
{
v5 = v8 & ~v10 | v9 & v10;
v4 = 1518500249;
}
v3 = v14[m] + v4 + v7 + v5 + ((v11 >> 27) | (32 * v11));
v7 = v8;
v8 = v9;
v9 = (v10 >> 2) | (v10 << 30);
v10 = v11;
v11 = v3;
}
ComputeSHA1_hash += v11;
dword_21F9A4 += v10;
dword_21F9A8 += v9;
dword_21F9AC += v8;
dword_21F9B0 += v7;
}
free(v17);
return &ComputeSHA1_hash;
}
| ComputeSHA1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x190
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [0x0031f9a0],0x67452301
MOV dword ptr [0x0031f9a4],0xefcdab89
MOV dword ptr [0x0031f9a8],0x98badcfe
MOV dword ptr [0x0031f9ac],0x10325476
MOV dword ptr [0x0031f9b0],0xc3d2e1f0
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x8
MOV ECX,0x40
CDQ
IDIV ECX
ADD EAX,0x1
SHL EAX,0x6
MOV dword ptr [RBP + -0x10],EAX
MOVSXD RDI,dword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x0010a340
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0xc]
CALL 0x0010a400
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,dword ptr [RBP + -0xc]
MOV byte ptr [RAX + RCX*0x1],0x80
MOV EAX,dword ptr [RBP + -0xc]
SHL EAX,0x3
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x10]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV dword ptr [RBP + -0x20],0x0
LAB_001d2daf:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x10]
JGE 0x001d3191
LEA RDI,[RBP + -0x160]
XOR ESI,ESI
MOV EDX,0x140
CALL 0x0010a2d0
MOV dword ptr [RBP + -0x164],0x0
LAB_001d2dd8:
CMP dword ptr [RBP + -0x164],0x10
JGE 0x001d2e86
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x164]
SHL EDX,0x2
ADD ECX,EDX
ADD ECX,0x0
MOVSXD RCX,ECX
MOVZX ECX,byte ptr [RAX + RCX*0x1]
SHL ECX,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x164]
SHL ESI,0x2
ADD EDX,ESI
ADD EDX,0x1
MOVSXD RDX,EDX
MOVZX EAX,byte ptr [RAX + RDX*0x1]
SHL EAX,0x10
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x164]
SHL ESI,0x2
ADD EDX,ESI
ADD EDX,0x2
MOVSXD RDX,EDX
MOVZX EAX,byte ptr [RAX + RDX*0x1]
SHL EAX,0x8
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x164]
SHL ESI,0x2
ADD EDX,ESI
ADD EDX,0x3
MOVSXD RDX,EDX
MOVZX EAX,byte ptr [RAX + RDX*0x1]
OR ECX,EAX
MOVSXD RAX,dword ptr [RBP + -0x164]
MOV dword ptr [RBP + RAX*0x4 + -0x160],ECX
MOV EAX,dword ptr [RBP + -0x164]
ADD EAX,0x1
MOV dword ptr [RBP + -0x164],EAX
JMP 0x001d2dd8
LAB_001d2e86:
MOV dword ptr [RBP + -0x168],0x10
LAB_001d2e90:
CMP dword ptr [RBP + -0x168],0x50
JGE 0x001d2f59
MOV EAX,dword ptr [RBP + -0x168]
SUB EAX,0x3
CDQE
MOV ECX,dword ptr [RBP + RAX*0x4 + -0x160]
MOV EAX,dword ptr [RBP + -0x168]
SUB EAX,0x8
CDQE
XOR ECX,dword ptr [RBP + RAX*0x4 + -0x160]
MOV EAX,dword ptr [RBP + -0x168]
SUB EAX,0xe
CDQE
XOR ECX,dword ptr [RBP + RAX*0x4 + -0x160]
MOV EAX,dword ptr [RBP + -0x168]
SUB EAX,0x10
CDQE
XOR ECX,dword ptr [RBP + RAX*0x4 + -0x160]
SHL ECX,0x1
MOV EAX,dword ptr [RBP + -0x168]
SUB EAX,0x3
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x160]
MOV EDX,dword ptr [RBP + -0x168]
SUB EDX,0x8
MOVSXD RDX,EDX
XOR EAX,dword ptr [RBP + RDX*0x4 + -0x160]
MOV EDX,dword ptr [RBP + -0x168]
SUB EDX,0xe
MOVSXD RDX,EDX
XOR EAX,dword ptr [RBP + RDX*0x4 + -0x160]
MOV EDX,dword ptr [RBP + -0x168]
SUB EDX,0x10
MOVSXD RDX,EDX
XOR EAX,dword ptr [RBP + RDX*0x4 + -0x160]
SHR EAX,0x1f
OR ECX,EAX
MOVSXD RAX,dword ptr [RBP + -0x168]
MOV dword ptr [RBP + RAX*0x4 + -0x160],ECX
MOV EAX,dword ptr [RBP + -0x168]
ADD EAX,0x1
MOV dword ptr [RBP + -0x168],EAX
JMP 0x001d2e90
LAB_001d2f59:
MOV EAX,dword ptr [0x0031f9a0]
MOV dword ptr [RBP + -0x16c],EAX
MOV EAX,dword ptr [0x0031f9a4]
MOV dword ptr [RBP + -0x170],EAX
MOV EAX,dword ptr [0x0031f9a8]
MOV dword ptr [RBP + -0x174],EAX
MOV EAX,dword ptr [0x0031f9ac]
MOV dword ptr [RBP + -0x178],EAX
MOV EAX,dword ptr [0x0031f9b0]
MOV dword ptr [RBP + -0x17c],EAX
MOV dword ptr [RBP + -0x180],0x0
LAB_001d2f9f:
CMP dword ptr [RBP + -0x180],0x50
JGE 0x001d3129
MOV dword ptr [RBP + -0x184],0x0
MOV dword ptr [RBP + -0x188],0x0
CMP dword ptr [RBP + -0x180],0x14
JGE 0x001d2ffb
MOV EAX,dword ptr [RBP + -0x170]
AND EAX,dword ptr [RBP + -0x174]
MOV ECX,dword ptr [RBP + -0x170]
XOR ECX,0xffffffff
AND ECX,dword ptr [RBP + -0x178]
OR EAX,ECX
MOV dword ptr [RBP + -0x184],EAX
MOV dword ptr [RBP + -0x188],0x5a827999
JMP 0x001d3091
LAB_001d2ffb:
CMP dword ptr [RBP + -0x180],0x28
JGE 0x001d3028
MOV EAX,dword ptr [RBP + -0x170]
XOR EAX,dword ptr [RBP + -0x174]
XOR EAX,dword ptr [RBP + -0x178]
MOV dword ptr [RBP + -0x184],EAX
MOV dword ptr [RBP + -0x188],0x6ed9eba1
JMP 0x001d308f
LAB_001d3028:
CMP dword ptr [RBP + -0x180],0x3c
JGE 0x001d306b
MOV EAX,dword ptr [RBP + -0x170]
AND EAX,dword ptr [RBP + -0x174]
MOV ECX,dword ptr [RBP + -0x170]
AND ECX,dword ptr [RBP + -0x178]
OR EAX,ECX
MOV ECX,dword ptr [RBP + -0x174]
AND ECX,dword ptr [RBP + -0x178]
OR EAX,ECX
MOV dword ptr [RBP + -0x184],EAX
MOV dword ptr [RBP + -0x188],0x8f1bbcdc
JMP 0x001d308d
LAB_001d306b:
MOV EAX,dword ptr [RBP + -0x170]
XOR EAX,dword ptr [RBP + -0x174]
XOR EAX,dword ptr [RBP + -0x178]
MOV dword ptr [RBP + -0x184],EAX
MOV dword ptr [RBP + -0x188],0xca62c1d6
LAB_001d308d:
JMP 0x001d308f
LAB_001d308f:
JMP 0x001d3091
LAB_001d3091:
MOV EAX,dword ptr [RBP + -0x16c]
SHL EAX,0x5
MOV ECX,dword ptr [RBP + -0x16c]
SHR ECX,0x1b
OR EAX,ECX
ADD EAX,dword ptr [RBP + -0x184]
ADD EAX,dword ptr [RBP + -0x17c]
ADD EAX,dword ptr [RBP + -0x188]
MOVSXD RCX,dword ptr [RBP + -0x180]
ADD EAX,dword ptr [RBP + RCX*0x4 + -0x160]
MOV dword ptr [RBP + -0x18c],EAX
MOV EAX,dword ptr [RBP + -0x178]
MOV dword ptr [RBP + -0x17c],EAX
MOV EAX,dword ptr [RBP + -0x174]
MOV dword ptr [RBP + -0x178],EAX
MOV EAX,dword ptr [RBP + -0x170]
SHL EAX,0x1e
MOV ECX,dword ptr [RBP + -0x170]
SHR ECX,0x2
OR EAX,ECX
MOV dword ptr [RBP + -0x174],EAX
MOV EAX,dword ptr [RBP + -0x16c]
MOV dword ptr [RBP + -0x170],EAX
MOV EAX,dword ptr [RBP + -0x18c]
MOV dword ptr [RBP + -0x16c],EAX
MOV EAX,dword ptr [RBP + -0x180]
ADD EAX,0x1
MOV dword ptr [RBP + -0x180],EAX
JMP 0x001d2f9f
LAB_001d3129:
MOV EAX,dword ptr [RBP + -0x16c]
ADD EAX,dword ptr [0x0031f9a0]
MOV dword ptr [0x0031f9a0],EAX
MOV EAX,dword ptr [RBP + -0x170]
ADD EAX,dword ptr [0x0031f9a4]
MOV dword ptr [0x0031f9a4],EAX
MOV EAX,dword ptr [RBP + -0x174]
ADD EAX,dword ptr [0x0031f9a8]
MOV dword ptr [0x0031f9a8],EAX
MOV EAX,dword ptr [RBP + -0x178]
ADD EAX,dword ptr [0x0031f9ac]
MOV dword ptr [0x0031f9ac],EAX
MOV EAX,dword ptr [RBP + -0x17c]
ADD EAX,dword ptr [0x0031f9b0]
MOV dword ptr [0x0031f9b0],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x40
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001d2daf
LAB_001d3191:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010a640
LEA RAX,[0x31f9a0]
ADD RSP,0x190
POP RBP
RET
|
int4 * ComputeSHA1(void *param_1,int param_2)
{
int iVar1;
long lVar2;
int local_190;
uint local_18c;
int local_188;
uint local_184;
uint local_180;
uint local_17c;
uint local_178;
uint local_174;
int local_170;
int local_16c;
uint local_168 [80];
int local_28;
int local_24;
void *local_20;
int local_18;
int local_14;
void *local_10;
ComputeSHA1_hash = 0x67452301;
DAT_0031f9a4 = 0xefcdab89;
DAT_0031f9a8 = 0x98badcfe;
DAT_0031f9ac = 0x10325476;
DAT_0031f9b0 = 0xc3d2e1f0;
local_18 = ((param_2 + 8) / 0x40 + 1) * 0x40;
local_14 = param_2;
local_10 = param_1;
local_20 = calloc((long)local_18,1);
memcpy(local_20,local_10,(long)local_14);
*(int1 *)((long)local_20 + (long)local_14) = 0x80;
local_24 = local_14 << 3;
*(char *)((long)local_20 + (long)(local_18 + -1)) = (char)local_24;
for (local_28 = 0; local_28 < local_18; local_28 = local_28 + 0x40) {
memset(local_168,0,0x140);
for (local_16c = 0; local_16c < 0x10; local_16c = local_16c + 1) {
local_168[local_16c] =
(uint)*(byte *)((long)local_20 + (long)(local_28 + local_16c * 4)) << 0x18 |
(uint)*(byte *)((long)local_20 + (long)(local_28 + local_16c * 4 + 1)) << 0x10 |
(uint)*(byte *)((long)local_20 + (long)(local_28 + local_16c * 4 + 2)) << 8 |
(uint)*(byte *)((long)local_20 + (long)(local_28 + local_16c * 4 + 3));
}
for (local_170 = 0x10; local_170 < 0x50; local_170 = local_170 + 1) {
local_168[local_170] =
(local_168[local_170 + -3] ^ local_168[local_170 + -8] ^ local_168[local_170 + -0xe] ^
local_168[local_170 + -0x10]) << 1 |
(local_168[local_170 + -3] ^ local_168[local_170 + -8] ^ local_168[local_170 + -0xe] ^
local_168[local_170 + -0x10]) >> 0x1f;
}
local_174 = ComputeSHA1_hash;
local_178 = DAT_0031f9a4;
local_17c = DAT_0031f9a8;
local_180 = DAT_0031f9ac;
local_184 = DAT_0031f9b0;
for (local_188 = 0; local_188 < 0x50; local_188 = local_188 + 1) {
if (local_188 < 0x14) {
local_18c = local_178 & local_17c | (local_178 ^ 0xffffffff) & local_180;
local_190 = 0x5a827999;
}
else if (local_188 < 0x28) {
local_18c = local_178 ^ local_17c ^ local_180;
local_190 = 0x6ed9eba1;
}
else if (local_188 < 0x3c) {
local_18c = local_178 & (local_17c | local_180) | local_17c & local_180;
local_190 = -0x70e44324;
}
else {
local_18c = local_178 ^ local_17c ^ local_180;
local_190 = -0x359d3e2a;
}
iVar1 = (local_174 << 5 | local_174 >> 0x1b) + local_18c + local_184;
lVar2 = (long)local_188;
local_184 = local_180;
local_180 = local_17c;
local_17c = local_178 << 0x1e | local_178 >> 2;
local_178 = local_174;
local_174 = iVar1 + local_190 + local_168[lVar2];
}
ComputeSHA1_hash = local_174 + ComputeSHA1_hash;
DAT_0031f9a4 = local_178 + DAT_0031f9a4;
DAT_0031f9a8 = local_17c + DAT_0031f9a8;
DAT_0031f9ac = local_180 + DAT_0031f9ac;
DAT_0031f9b0 = local_184 + DAT_0031f9b0;
}
free(local_20);
return &ComputeSHA1_hash;
}
| |
39,406 | ComputeSHA1 | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | unsigned int *ComputeSHA1(unsigned char *data, int dataSize) {
#define ROTATE_LEFT(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
static unsigned int hash[5] = { 0 }; // Hash to be returned
// Initialize hash values
hash[0] = 0x67452301;
hash[1] = 0xEFCDAB89;
hash[2] = 0x98BADCFE;
hash[3] = 0x10325476;
hash[4] = 0xC3D2E1F0;
// Pre-processing: adding a single 1 bit
// Append '1' bit to message
// NOTE: The input bytes are considered as bits strings,
// where the first bit is the most significant bit of the byte
// Pre-processing: padding with zeros
// Append '0' bit until message length in bit 448 (mod 512)
// Append length mod (2 pow 64) to message
int newDataSize = ((((dataSize + 8)/64) + 1)*64);
unsigned char *msg = RL_CALLOC(newDataSize, 1); // Initialize with '0' bits
memcpy(msg, data, dataSize);
msg[dataSize] = 128; // Write the '1' bit
unsigned int bitsLen = 8*dataSize;
msg[newDataSize-1] = bitsLen;
// Process the message in successive 512-bit chunks
for (int offset = 0; offset < newDataSize; offset += (512/8))
{
// Break chunk into sixteen 32-bit words w[j], 0 <= j <= 15
unsigned int w[80] = {0};
for (int i = 0; i < 16; i++) {
w[i] = (msg[offset + (i * 4) + 0] << 24) |
(msg[offset + (i * 4) + 1] << 16) |
(msg[offset + (i * 4) + 2] << 8) |
(msg[offset + (i * 4) + 3]);
}
// Message schedule: extend the sixteen 32-bit words into eighty 32-bit words:
for (int i = 16; i < 80; ++i) {
w[i] = ROTATE_LEFT(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1);
}
// Initialize hash value for this chunk
unsigned int a = hash[0];
unsigned int b = hash[1];
unsigned int c = hash[2];
unsigned int d = hash[3];
unsigned int e = hash[4];
for (int i = 0; i < 80; i++)
{
unsigned int f = 0;
unsigned int k = 0;
if (i < 20) {
f = (b & c) | ((~b) & d);
k = 0x5A827999;
} else if (i < 40) {
f = b ^ c ^ d;
k = 0x6ED9EBA1;
} else if (i < 60) {
f = (b & c) | (b & d) | (c & d);
k = 0x8F1BBCDC;
} else {
f = b ^ c ^ d;
k = 0xCA62C1D6;
}
unsigned int temp = ROTATE_LEFT(a, 5) + f + e + k + w[i];
e = d;
d = c;
c = ROTATE_LEFT(b, 30);
b = a;
a = temp;
}
// Add this chunk's hash to result so far
hash[0] += a;
hash[1] += b;
hash[2] += c;
hash[3] += d;
hash[4] += e;
}
free(msg);
return hash;
} | O1 | c | ComputeSHA1:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %esi, %r14d
movq %rdi, %r15
movaps 0x682e7(%rip), %xmm0 # 0xe3400
movaps %xmm0, 0xcb7b0(%rip) # 0x1468d0
leal 0x8(%r14), %eax
leal 0x47(%r14), %ebx
testl %eax, %eax
cmovnsl %eax, %ebx
movl $0xc3d2e1f0, 0xcb7a9(%rip) # imm = 0xC3D2E1F0
andl $-0x40, %ebx
leal 0x40(%rbx), %ebp
movslq %ebp, %r12
movl $0x1, %esi
movq %r12, %rdi
callq 0x9330
movq %rax, %r13
movslq %r14d, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9410
movq %r13, %rdi
movb $-0x80, (%r13,%r14)
shlb $0x3, %r14b
movslq %ebx, %rax
movb %r14b, 0x3f(%r13,%rax)
testl %r12d, %r12d
jle 0x7b308
movl 0xcb75a(%rip), %r15d # 0x1468e0
movl 0xcb750(%rip), %eax # 0x1468dc
movl %eax, 0x8(%rsp)
movl 0xcb741(%rip), %r12d # 0x1468d8
movl 0xcb736(%rip), %r13d # 0x1468d4
movl 0xcb72c(%rip), %ebx # 0x1468d0
movl %ebp, %eax
movq %rax, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %r14
addq $0x3, %r14
xorl %ebp, %ebp
movl $0x140, %edx # imm = 0x140
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x92d0
xorl %eax, %eax
movl -0x3(%r14,%rax,4), %ecx
bswapl %ecx
movl %ecx, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x10, %rax
jne 0x7b1cc
movl $0x10, %eax
movl (%rsp,%rax,4), %ecx
xorl 0x14(%rsp,%rax,4), %ecx
xorl -0x18(%rsp,%rax,4), %ecx
xorl -0x20(%rsp,%rax,4), %ecx
roll %ecx
movl %ecx, 0x20(%rsp,%rax,4)
incq %rax
cmpq $0x50, %rax
jne 0x7b1e5
xorl %eax, %eax
movl %r15d, 0xc(%rsp)
movl %r15d, %r8d
movl 0x8(%rsp), %r10d
movl %r12d, %r11d
movl %r13d, %edi
movl %ebx, %r9d
movl %r9d, %r15d
movl %edi, %esi
movl %r11d, %edx
movl %r10d, %ecx
cmpq $0x13, %rax
ja 0x7b240
movl %edx, %r9d
xorl %ecx, %r9d
andl %esi, %r9d
xorl %ecx, %r9d
movl $0x5a827999, %r10d # imm = 0x5A827999
jmp 0x7b283
cmpq $0x27, %rax
ja 0x7b257
movl %edx, %r9d
xorl %esi, %r9d
xorl %ecx, %r9d
movl $0x6ed9eba1, %r10d # imm = 0x6ED9EBA1
jmp 0x7b283
cmpq $0x3b, %rax
ja 0x7b274
movl %ecx, %edi
orl %edx, %edi
andl %esi, %edi
movl %ecx, %r9d
andl %edx, %r9d
orl %edi, %r9d
movl $0x8f1bbcdc, %r10d # imm = 0x8F1BBCDC
jmp 0x7b283
movl %edx, %r9d
xorl %esi, %r9d
xorl %ecx, %r9d
movl $0xca62c1d6, %r10d # imm = 0xCA62C1D6
movl %r15d, %edi
roll $0x5, %edi
addl %edi, %r8d
addl %r9d, %r8d
addl %r10d, %r8d
movl %r8d, %r9d
addl 0x20(%rsp,%rax,4), %r9d
roll $0x1e, %esi
incq %rax
movl %ecx, %r8d
movl %edx, %r10d
movl %esi, %r11d
movl %r15d, %edi
cmpq $0x50, %rax
jne 0x7b21b
addl %r9d, %ebx
addl %r15d, %r13d
addl %esi, %r12d
addl %edx, 0x8(%rsp)
movl 0xc(%rsp), %r15d
addl %ecx, %r15d
addq $0x40, %rbp
addq $0x40, %r14
cmpq 0x18(%rsp), %rbp
jb 0x7b1b9
movl %ebx, 0xcb5ec(%rip) # 0x1468d0
movl %r13d, 0xcb5e9(%rip) # 0x1468d4
movl %r12d, 0xcb5e6(%rip) # 0x1468d8
movl 0x8(%rsp), %eax
movl %eax, 0xcb5e0(%rip) # 0x1468dc
movl %r15d, 0xcb5dd(%rip) # 0x1468e0
movq 0x10(%rsp), %rdi
callq 0x9650
leaq 0xcb5bc(%rip), %rax # 0x1468d0
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ComputeSHA1:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 168h
mov r14d, esi
mov r15, rdi
movaps xmm0, cs:xmmword_E3400
movaps cs:ComputeSHA1_hash, xmm0
lea eax, [r14+8]
lea ebx, [r14+47h]
test eax, eax
cmovns ebx, eax
mov cs:dword_1468E0, 0C3D2E1F0h
and ebx, 0FFFFFFC0h
lea ebp, [rbx+40h]
movsxd r12, ebp
mov esi, 1
mov rdi, r12
call _calloc
mov r13, rax
movsxd r14, r14d
mov rdi, rax
mov rsi, r15
mov rdx, r14
call _memcpy
mov rdi, r13
mov byte ptr [r13+r14+0], 80h
shl r14b, 3
movsxd rax, ebx
mov [r13+rax+3Fh], r14b
test r12d, r12d
jle loc_7B308
mov r15d, cs:dword_1468E0
mov eax, dword ptr cs:ComputeSHA1_hash+0Ch
mov [rsp+198h+var_190], eax
mov r12d, dword ptr cs:ComputeSHA1_hash+8
mov r13d, dword ptr cs:ComputeSHA1_hash+4
mov ebx, dword ptr cs:ComputeSHA1_hash
mov eax, ebp
mov [rsp+198h+var_180], rax
mov [rsp+198h+var_188], rdi
mov r14, rdi
add r14, 3
xor ebp, ebp
loc_7B1B9:
mov edx, 140h
lea rdi, [rsp+198h+var_178]
xor esi, esi
call _memset
xor eax, eax
loc_7B1CC:
mov ecx, [r14+rax*4-3]
bswap ecx
mov [rsp+rax*4+198h+var_178], ecx
inc rax
cmp rax, 10h
jnz short loc_7B1CC
mov eax, 10h
loc_7B1E5:
mov ecx, [rsp+rax*4+198h+var_198]
xor ecx, dword ptr [rsp+rax*4+198h+var_188+4]
xor ecx, [rsp+rax*4+198h+var_1B0]
xor ecx, [rsp+rax*4+198h+var_1B8]
rol ecx, 1
mov [rsp+rax*4+198h+var_178], ecx
inc rax
cmp rax, 50h ; 'P'
jnz short loc_7B1E5
xor eax, eax
mov [rsp+198h+var_18C], r15d
mov r8d, r15d
mov r10d, [rsp+198h+var_190]
mov r11d, r12d
mov edi, r13d
mov r9d, ebx
loc_7B21B:
mov r15d, r9d
mov esi, edi
mov edx, r11d
mov ecx, r10d
cmp rax, 13h
ja short loc_7B240
mov r9d, edx
xor r9d, ecx
and r9d, esi
xor r9d, ecx
mov r10d, 5A827999h
jmp short loc_7B283
loc_7B240:
cmp rax, 27h ; '''
ja short loc_7B257
mov r9d, edx
xor r9d, esi
xor r9d, ecx
mov r10d, 6ED9EBA1h
jmp short loc_7B283
loc_7B257:
cmp rax, 3Bh ; ';'
ja short loc_7B274
mov edi, ecx
or edi, edx
and edi, esi
mov r9d, ecx
and r9d, edx
or r9d, edi
mov r10d, 8F1BBCDCh
jmp short loc_7B283
loc_7B274:
mov r9d, edx
xor r9d, esi
xor r9d, ecx
mov r10d, 0CA62C1D6h
loc_7B283:
mov edi, r15d
rol edi, 5
add r8d, edi
add r8d, r9d
add r8d, r10d
mov r9d, r8d
add r9d, [rsp+rax*4+198h+var_178]
rol esi, 1Eh
inc rax
mov r8d, ecx
mov r10d, edx
mov r11d, esi
mov edi, r15d
cmp rax, 50h ; 'P'
jnz loc_7B21B
add ebx, r9d
add r13d, r15d
add r12d, esi
add [rsp+198h+var_190], edx
mov r15d, [rsp+198h+var_18C]
add r15d, ecx
add rbp, 40h ; '@'
add r14, 40h ; '@'
cmp rbp, [rsp+198h+var_180]
jb loc_7B1B9
mov dword ptr cs:ComputeSHA1_hash, ebx
mov dword ptr cs:ComputeSHA1_hash+4, r13d
mov dword ptr cs:ComputeSHA1_hash+8, r12d
mov eax, [rsp+198h+var_190]
mov dword ptr cs:ComputeSHA1_hash+0Ch, eax
mov cs:dword_1468E0, r15d
mov rdi, [rsp+198h+var_188]
loc_7B308:
call _free
lea rax, ComputeSHA1_hash
add rsp, 168h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| __int128 * ComputeSHA1(long long a1, int a2)
{
int v2; // ebx
signed int v3; // ebx
unsigned int v4; // ebp
long long v5; // r13
long long v6; // rdi
int v7; // r15d
int v8; // r12d
int v9; // r13d
int v10; // ebx
long long v11; // r14
unsigned long long v12; // rbp
long long i; // rax
long long j; // rax
unsigned long long v15; // rax
int v16; // r8d
int v17; // r10d
int v18; // r11d
int v19; // edi
int v20; // r9d
int v21; // r15d
int v22; // edx
int v23; // ecx
int v24; // r9d
int v25; // r10d
int v26; // esi
_DWORD v28[10]; // [rsp+0h] [rbp-1B8h]
int v29; // [rsp+28h] [rbp-190h]
int v30; // [rsp+2Ch] [rbp-18Ch]
long long v31; // [rsp+30h] [rbp-188h]
unsigned long long v32; // [rsp+38h] [rbp-180h]
_DWORD v33[94]; // [rsp+40h] [rbp-178h] BYREF
ComputeSHA1_hash = xmmword_E3400;
v2 = a2 + 71;
if ( a2 + 8 >= 0 )
v2 = a2 + 8;
dword_1468E0 = -1009589776;
v3 = v2 & 0xFFFFFFC0;
v4 = v3 + 64;
v5 = calloc(v3 + 64, 1LL);
memcpy(v5);
v6 = v5;
*(_BYTE *)(v5 + a2) = 0x80;
*(_BYTE *)(v5 + v3 + 63) = 8 * a2;
if ( v3 + 64 > 0 )
{
v7 = dword_1468E0;
v29 = HIDWORD(ComputeSHA1_hash);
v8 = DWORD2(ComputeSHA1_hash);
v9 = DWORD1(ComputeSHA1_hash);
v10 = ComputeSHA1_hash;
v32 = v4;
v31 = v6;
v11 = v6 + 3;
v12 = 0LL;
do
{
memset(v33, 0LL, 320LL);
for ( i = 0LL; i != 16; ++i )
v33[i] = _byteswap_ulong(*(_DWORD *)(v11 + 4 * i - 3));
for ( j = 16LL; j != 80; ++j )
v33[j] = __ROL4__(v28[j] ^ v28[j + 2] ^ *((_DWORD *)&v31 + j + 1) ^ v28[j + 8], 1);
v15 = 0LL;
v30 = v7;
v16 = v7;
v17 = v29;
v18 = v8;
v19 = v9;
v20 = v10;
do
{
v21 = v20;
v22 = v18;
v23 = v17;
if ( v15 > 0x13 )
{
if ( v15 > 0x27 )
{
if ( v15 > 0x3B )
{
v24 = v17 ^ v19 ^ v18;
v25 = -899497514;
}
else
{
v24 = v19 & (v18 | v17) | v18 & v17;
v25 = -1894007588;
}
}
else
{
v24 = v17 ^ v19 ^ v18;
v25 = 1859775393;
}
}
else
{
v24 = v17 ^ v19 & (v17 ^ v18);
v25 = 1518500249;
}
v20 = v33[v15] + v25 + v24 + __ROL4__(v21, 5) + v16;
v26 = __ROL4__(v19, 30);
++v15;
v16 = v23;
v17 = v18;
v18 = v26;
v19 = v21;
}
while ( v15 != 80 );
v10 += v20;
v9 += v21;
v8 += v26;
v29 += v22;
v7 = v23 + v30;
v12 += 64LL;
v11 += 64LL;
}
while ( v12 < v32 );
LODWORD(ComputeSHA1_hash) = v10;
DWORD1(ComputeSHA1_hash) = v9;
DWORD2(ComputeSHA1_hash) = v8;
HIDWORD(ComputeSHA1_hash) = v29;
dword_1468E0 = v23 + v30;
v6 = v31;
}
free(v6);
return &ComputeSHA1_hash;
}
| ComputeSHA1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x168
MOV R14D,ESI
MOV R15,RDI
MOVAPS XMM0,xmmword ptr [0x001e3400]
MOVAPS xmmword ptr [0x002468d0],XMM0
LEA EAX,[R14 + 0x8]
LEA EBX,[R14 + 0x47]
TEST EAX,EAX
CMOVNS EBX,EAX
MOV dword ptr [0x002468e0],0xc3d2e1f0
AND EBX,0xffffffc0
LEA EBP,[RBX + 0x40]
MOVSXD R12,EBP
MOV ESI,0x1
MOV RDI,R12
CALL 0x00109330
MOV R13,RAX
MOVSXD R14,R14D
MOV RDI,RAX
MOV RSI,R15
MOV RDX,R14
CALL 0x00109410
MOV RDI,R13
MOV byte ptr [R13 + R14*0x1],0x80
SHL R14B,0x3
MOVSXD RAX,EBX
MOV byte ptr [R13 + RAX*0x1 + 0x3f],R14B
TEST R12D,R12D
JLE 0x0017b308
MOV R15D,dword ptr [0x002468e0]
MOV EAX,dword ptr [0x002468dc]
MOV dword ptr [RSP + 0x8],EAX
MOV R12D,dword ptr [0x002468d8]
MOV R13D,dword ptr [0x002468d4]
MOV EBX,dword ptr [0x002468d0]
MOV EAX,EBP
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x10],RDI
MOV R14,RDI
ADD R14,0x3
XOR EBP,EBP
LAB_0017b1b9:
MOV EDX,0x140
LEA RDI,[RSP + 0x20]
XOR ESI,ESI
CALL 0x001092d0
XOR EAX,EAX
LAB_0017b1cc:
MOV ECX,dword ptr [R14 + RAX*0x4 + -0x3]
BSWAP ECX
MOV dword ptr [RSP + RAX*0x4 + 0x20],ECX
INC RAX
CMP RAX,0x10
JNZ 0x0017b1cc
MOV EAX,0x10
LAB_0017b1e5:
MOV ECX,dword ptr [RSP + RAX*0x4]
XOR ECX,dword ptr [RSP + RAX*0x4 + 0x14]
XOR ECX,dword ptr [RSP + RAX*0x4 + -0x18]
XOR ECX,dword ptr [RSP + RAX*0x4 + -0x20]
ROL ECX,0x1
MOV dword ptr [RSP + RAX*0x4 + 0x20],ECX
INC RAX
CMP RAX,0x50
JNZ 0x0017b1e5
XOR EAX,EAX
MOV dword ptr [RSP + 0xc],R15D
MOV R8D,R15D
MOV R10D,dword ptr [RSP + 0x8]
MOV R11D,R12D
MOV EDI,R13D
MOV R9D,EBX
LAB_0017b21b:
MOV R15D,R9D
MOV ESI,EDI
MOV EDX,R11D
MOV ECX,R10D
CMP RAX,0x13
JA 0x0017b240
MOV R9D,EDX
XOR R9D,ECX
AND R9D,ESI
XOR R9D,ECX
MOV R10D,0x5a827999
JMP 0x0017b283
LAB_0017b240:
CMP RAX,0x27
JA 0x0017b257
MOV R9D,EDX
XOR R9D,ESI
XOR R9D,ECX
MOV R10D,0x6ed9eba1
JMP 0x0017b283
LAB_0017b257:
CMP RAX,0x3b
JA 0x0017b274
MOV EDI,ECX
OR EDI,EDX
AND EDI,ESI
MOV R9D,ECX
AND R9D,EDX
OR R9D,EDI
MOV R10D,0x8f1bbcdc
JMP 0x0017b283
LAB_0017b274:
MOV R9D,EDX
XOR R9D,ESI
XOR R9D,ECX
MOV R10D,0xca62c1d6
LAB_0017b283:
MOV EDI,R15D
ROL EDI,0x5
ADD R8D,EDI
ADD R8D,R9D
ADD R8D,R10D
MOV R9D,R8D
ADD R9D,dword ptr [RSP + RAX*0x4 + 0x20]
ROL ESI,0x1e
INC RAX
MOV R8D,ECX
MOV R10D,EDX
MOV R11D,ESI
MOV EDI,R15D
CMP RAX,0x50
JNZ 0x0017b21b
ADD EBX,R9D
ADD R13D,R15D
ADD R12D,ESI
ADD dword ptr [RSP + 0x8],EDX
MOV R15D,dword ptr [RSP + 0xc]
ADD R15D,ECX
ADD RBP,0x40
ADD R14,0x40
CMP RBP,qword ptr [RSP + 0x18]
JC 0x0017b1b9
MOV dword ptr [0x002468d0],EBX
MOV dword ptr [0x002468d4],R13D
MOV dword ptr [0x002468d8],R12D
MOV EAX,dword ptr [RSP + 0x8]
MOV dword ptr [0x002468dc],EAX
MOV dword ptr [0x002468e0],R15D
MOV RDI,qword ptr [RSP + 0x10]
LAB_0017b308:
CALL 0x00109650
LEA RAX,[0x2468d0]
ADD RSP,0x168
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int4 * ComputeSHA1(void *param_1,int param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
void *__dest;
long lVar4;
ulong uVar5;
uint uVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
int iVar13;
uint uVar14;
uint uVar15;
long lVar16;
uint uVar17;
uint auStack_1b8 [6];
int8 uStack_1a0;
uint auStack_198 [4];
int8 local_188;
ulong local_180;
uint local_178 [82];
_ComputeSHA1_hash = _DAT_001e3400;
_DAT_002468d8 = _UNK_001e3408;
uVar6 = param_2 + 0x47;
if (-1 < (int)(param_2 + 8U)) {
uVar6 = param_2 + 8U;
}
_DAT_002468e0 = 0xc3d2e1f0;
uVar14 = (uVar6 & 0xffffffc0) + 0x40;
uStack_1a0 = 0x17b14d;
__dest = calloc((long)(int)uVar14,1);
uStack_1a0 = 0x17b161;
memcpy(__dest,param_1,(long)param_2);
*(int1 *)((long)__dest + (long)param_2) = 0x80;
*(char *)((long)__dest + (long)(int)(uVar6 & 0xffffffc0) + 0x3f) = (char)param_2 << 3;
if (0 < (int)uVar14) {
auStack_198[2] = _DAT_002468dc;
local_180 = (ulong)uVar14;
lVar16 = (long)__dest + 3;
uVar8 = 0;
uVar6 = _DAT_002468e0;
uVar14 = _DAT_002468d8;
uVar15 = _DAT_002468d4;
uVar7 = ComputeSHA1_hash;
local_188 = __dest;
do {
uVar17 = uVar6;
uStack_1a0 = 0x17b1ca;
memset(local_178,0,0x140);
lVar4 = 0;
do {
uVar6 = *(uint *)(lVar16 + -3 + lVar4 * 4);
local_178[lVar4] =
uVar6 >> 0x18 | (uVar6 & 0xff0000) >> 8 | (uVar6 & 0xff00) << 8 | uVar6 << 0x18;
lVar4 = lVar4 + 1;
} while (lVar4 != 0x10);
lVar4 = 0x10;
do {
uVar6 = auStack_198[lVar4] ^ *(uint *)((long)&local_188 + lVar4 * 4 + 4) ^
auStack_1b8[lVar4 + 2] ^ auStack_1b8[lVar4];
local_178[lVar4] = uVar6 << 1 | (uint)((int)uVar6 < 0);
lVar4 = lVar4 + 1;
} while (lVar4 != 0x50);
uVar5 = 0;
uVar10 = auStack_198[2];
uVar11 = uVar7;
uVar9 = uVar14;
uVar6 = uVar15;
uVar3 = uVar17;
do {
uVar2 = uVar9;
uVar1 = uVar11;
uVar12 = uVar10;
if (uVar5 < 0x14) {
uVar10 = (uVar2 ^ uVar12) & uVar6 ^ uVar12;
iVar13 = 0x5a827999;
}
else if (uVar5 < 0x28) {
uVar10 = uVar2 ^ uVar6 ^ uVar12;
iVar13 = 0x6ed9eba1;
}
else if (uVar5 < 0x3c) {
uVar10 = uVar12 & uVar2 | (uVar12 | uVar2) & uVar6;
iVar13 = -0x70e44324;
}
else {
uVar10 = uVar2 ^ uVar6 ^ uVar12;
iVar13 = -0x359d3e2a;
}
uVar11 = uVar3 + (uVar1 << 5 | uVar1 >> 0x1b) + uVar10 + iVar13 + local_178[uVar5];
uVar9 = uVar6 << 0x1e | uVar6 >> 2;
uVar5 = uVar5 + 1;
uVar10 = uVar2;
uVar6 = uVar1;
uVar3 = uVar12;
} while (uVar5 != 0x50);
uVar7 = uVar7 + uVar11;
uVar15 = uVar15 + uVar1;
uVar14 = uVar14 + uVar9;
auStack_198[2] = auStack_198[2] + uVar2;
uVar8 = uVar8 + 0x40;
lVar16 = lVar16 + 0x40;
uVar6 = uVar17 + uVar12;
auStack_198[3] = uVar17;
} while (uVar8 < local_180);
_ComputeSHA1_hash = CONCAT44(uVar15,uVar7);
_DAT_002468d8 = CONCAT44(auStack_198[2],uVar14);
__dest = local_188;
_DAT_002468e0 = uVar17 + uVar12;
}
uStack_1a0 = 0x17b30d;
free(__dest);
return &ComputeSHA1_hash;
}
| |
39,407 | ComputeSHA1 | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | unsigned int *ComputeSHA1(unsigned char *data, int dataSize) {
#define ROTATE_LEFT(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
static unsigned int hash[5] = { 0 }; // Hash to be returned
// Initialize hash values
hash[0] = 0x67452301;
hash[1] = 0xEFCDAB89;
hash[2] = 0x98BADCFE;
hash[3] = 0x10325476;
hash[4] = 0xC3D2E1F0;
// Pre-processing: adding a single 1 bit
// Append '1' bit to message
// NOTE: The input bytes are considered as bits strings,
// where the first bit is the most significant bit of the byte
// Pre-processing: padding with zeros
// Append '0' bit until message length in bit 448 (mod 512)
// Append length mod (2 pow 64) to message
int newDataSize = ((((dataSize + 8)/64) + 1)*64);
unsigned char *msg = RL_CALLOC(newDataSize, 1); // Initialize with '0' bits
memcpy(msg, data, dataSize);
msg[dataSize] = 128; // Write the '1' bit
unsigned int bitsLen = 8*dataSize;
msg[newDataSize-1] = bitsLen;
// Process the message in successive 512-bit chunks
for (int offset = 0; offset < newDataSize; offset += (512/8))
{
// Break chunk into sixteen 32-bit words w[j], 0 <= j <= 15
unsigned int w[80] = {0};
for (int i = 0; i < 16; i++) {
w[i] = (msg[offset + (i * 4) + 0] << 24) |
(msg[offset + (i * 4) + 1] << 16) |
(msg[offset + (i * 4) + 2] << 8) |
(msg[offset + (i * 4) + 3]);
}
// Message schedule: extend the sixteen 32-bit words into eighty 32-bit words:
for (int i = 16; i < 80; ++i) {
w[i] = ROTATE_LEFT(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1);
}
// Initialize hash value for this chunk
unsigned int a = hash[0];
unsigned int b = hash[1];
unsigned int c = hash[2];
unsigned int d = hash[3];
unsigned int e = hash[4];
for (int i = 0; i < 80; i++)
{
unsigned int f = 0;
unsigned int k = 0;
if (i < 20) {
f = (b & c) | ((~b) & d);
k = 0x5A827999;
} else if (i < 40) {
f = b ^ c ^ d;
k = 0x6ED9EBA1;
} else if (i < 60) {
f = (b & c) | (b & d) | (c & d);
k = 0x8F1BBCDC;
} else {
f = b ^ c ^ d;
k = 0xCA62C1D6;
}
unsigned int temp = ROTATE_LEFT(a, 5) + f + e + k + w[i];
e = d;
d = c;
c = ROTATE_LEFT(b, 30);
b = a;
a = temp;
}
// Add this chunk's hash to result so far
hash[0] += a;
hash[1] += b;
hash[2] += c;
hash[3] += d;
hash[4] += e;
}
free(msg);
return hash;
} | O2 | c | ComputeSHA1:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %esi, %r15d
movq %rdi, %r12
movaps 0x5f08c(%rip), %xmm0 # 0xc3690
movaps %xmm0, 0xc82f5(%rip) # 0x12c900
movl $0xc3d2e1f0, 0xc82fb(%rip) # imm = 0xC3D2E1F0
leal 0x8(%r15), %eax
pushq $0x40
popq %rcx
cltd
idivl %ecx
movl %eax, %r13d
shll $0x6, %r13d
leal 0x40(%r13), %eax
movslq %eax, %rdi
pushq $0x1
popq %rsi
movq %rdi, 0x10(%rsp)
callq 0x9320
movq %rax, %rbx
movslq %r15d, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x9400
movb $-0x80, (%rbx,%r15)
shlb $0x3, %r15b
movslq %r13d, %rax
movb %r15b, 0x3f(%rbx,%rax)
movq %rbx, 0x8(%rsp)
movq %rbx, %r12
addq $0x3, %r12
movl $0x67452301, %ebp # imm = 0x67452301
movl $0xefcdab89, %r13d # imm = 0xEFCDAB89
movl $0x98badcfe, %r14d # imm = 0x98BADCFE
movl $0x10325476, %r15d # imm = 0x10325476
movl $0xc3d2e1f0, %ebx # imm = 0xC3D2E1F0
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
jge 0x647ce
movq %rax, 0x18(%rsp)
movl $0x140, %edx # imm = 0x140
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x92c0
xorl %eax, %eax
cmpq $0x10, %rax
je 0x646c2
movl -0x3(%r12,%rax,4), %ecx
bswapl %ecx
movl %ecx, 0x20(%rsp,%rax,4)
incq %rax
jmp 0x646ac
pushq $0x10
popq %rax
cmpq $0x50, %rax
je 0x646e5
movl (%rsp,%rax,4), %ecx
xorl 0x14(%rsp,%rax,4), %ecx
xorl -0x18(%rsp,%rax,4), %ecx
xorl -0x20(%rsp,%rax,4), %ecx
roll %ecx
movl %ecx, 0x20(%rsp,%rax,4)
incq %rax
jmp 0x646c5
xorl %edi, %edi
movl %ebp, %r9d
movl %r13d, %r8d
movl %r14d, %edx
movl %r15d, %ecx
movl %ebx, %eax
movl %eax, %esi
movl %ecx, %eax
movl %edx, %ecx
movl %r8d, %edx
movl %r9d, %r8d
cmpq $0x50, %rdi
je 0x6478d
cmpq $0x13, %rdi
ja 0x64725
movl %ecx, %r9d
xorl %eax, %r9d
andl %edx, %r9d
xorl %eax, %r9d
movl $0x5a827999, %r10d # imm = 0x5A827999
jmp 0x6476b
cmpq $0x27, %rdi
ja 0x6473c
movl %ecx, %r9d
xorl %edx, %r9d
xorl %eax, %r9d
movl $0x6ed9eba1, %r10d # imm = 0x6ED9EBA1
jmp 0x6476b
cmpq $0x3b, %rdi
ja 0x6475c
movl %eax, %r10d
orl %ecx, %r10d
andl %edx, %r10d
movl %eax, %r9d
andl %ecx, %r9d
orl %r10d, %r9d
movl $0x8f1bbcdc, %r10d # imm = 0x8F1BBCDC
jmp 0x6476b
movl %ecx, %r9d
xorl %edx, %r9d
xorl %eax, %r9d
movl $0xca62c1d6, %r10d # imm = 0xCA62C1D6
movl %r8d, %r11d
roll $0x5, %r11d
addl %r11d, %esi
addl %r9d, %esi
addl %r10d, %esi
addl 0x20(%rsp,%rdi,4), %esi
roll $0x1e, %edx
incq %rdi
movl %esi, %r9d
jmp 0x646f5
addl %r8d, %ebp
movl %ebp, 0xc816a(%rip) # 0x12c900
addl %edx, %r13d
movl %r13d, 0xc8164(%rip) # 0x12c904
addl %ecx, %r14d
movl %r14d, 0xc815e(%rip) # 0x12c908
addl %eax, %r15d
movl %r15d, 0xc8158(%rip) # 0x12c90c
addl %esi, %ebx
movl %ebx, 0xc8154(%rip) # 0x12c910
movq 0x18(%rsp), %rax
addq $0x40, %rax
addq $0x40, %r12
jmp 0x64689
movq 0x8(%rsp), %rdi
callq 0x9640
leaq 0xc8121(%rip), %rax # 0x12c900
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ComputeSHA1:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 168h
mov r15d, esi
mov r12, rdi
movaps xmm0, cs:xmmword_C3690
movaps cs:ComputeSHA1_hash, xmm0
mov cs:dword_12C910, 0C3D2E1F0h
lea eax, [r15+8]
push 40h ; '@'
pop rcx
cdq
idiv ecx
mov r13d, eax
shl r13d, 6
lea eax, [r13+40h]
movsxd rdi, eax
push 1
pop rsi
mov [rsp+198h+var_188], rdi
call _calloc
mov rbx, rax
movsxd r15, r15d
mov rdi, rax
mov rsi, r12
mov rdx, r15
call _memcpy
mov byte ptr [rbx+r15], 80h
shl r15b, 3
movsxd rax, r13d
mov [rbx+rax+3Fh], r15b
mov [rsp+198h+var_190], rbx
mov r12, rbx
add r12, 3
mov ebp, 67452301h
mov r13d, 0EFCDAB89h
mov r14d, 98BADCFEh
mov r15d, 10325476h
mov ebx, 0C3D2E1F0h
xor eax, eax
loc_64689:
cmp rax, [rsp+198h+var_188]
jge loc_647CE
mov [rsp+198h+var_180], rax
mov edx, 140h
lea rdi, [rsp+198h+var_178]
xor esi, esi
call _memset
xor eax, eax
loc_646AC:
cmp rax, 10h
jz short loc_646C2
mov ecx, [r12+rax*4-3]
bswap ecx
mov [rsp+rax*4+198h+var_178], ecx
inc rax
jmp short loc_646AC
loc_646C2:
push 10h
pop rax
loc_646C5:
cmp rax, 50h ; 'P'
jz short loc_646E5
mov ecx, [rsp+rax*4+198h+var_198]
xor ecx, dword ptr [rsp+rax*4+198h+var_188+4]
xor ecx, [rsp+rax*4+198h+var_1B0]
xor ecx, [rsp+rax*4+198h+var_1B8]
rol ecx, 1
mov [rsp+rax*4+198h+var_178], ecx
inc rax
jmp short loc_646C5
loc_646E5:
xor edi, edi
mov r9d, ebp
mov r8d, r13d
mov edx, r14d
mov ecx, r15d
mov eax, ebx
loc_646F5:
mov esi, eax
mov eax, ecx
mov ecx, edx
mov edx, r8d
mov r8d, r9d
cmp rdi, 50h ; 'P'
jz loc_6478D
cmp rdi, 13h
ja short loc_64725
mov r9d, ecx
xor r9d, eax
and r9d, edx
xor r9d, eax
mov r10d, 5A827999h
jmp short loc_6476B
loc_64725:
cmp rdi, 27h ; '''
ja short loc_6473C
mov r9d, ecx
xor r9d, edx
xor r9d, eax
mov r10d, 6ED9EBA1h
jmp short loc_6476B
loc_6473C:
cmp rdi, 3Bh ; ';'
ja short loc_6475C
mov r10d, eax
or r10d, ecx
and r10d, edx
mov r9d, eax
and r9d, ecx
or r9d, r10d
mov r10d, 8F1BBCDCh
jmp short loc_6476B
loc_6475C:
mov r9d, ecx
xor r9d, edx
xor r9d, eax
mov r10d, 0CA62C1D6h
loc_6476B:
mov r11d, r8d
rol r11d, 5
add esi, r11d
add esi, r9d
add esi, r10d
add esi, [rsp+rdi*4+198h+var_178]
rol edx, 1Eh
inc rdi
mov r9d, esi
jmp loc_646F5
loc_6478D:
add ebp, r8d
mov dword ptr cs:ComputeSHA1_hash, ebp
add r13d, edx
mov dword ptr cs:ComputeSHA1_hash+4, r13d
add r14d, ecx
mov dword ptr cs:ComputeSHA1_hash+8, r14d
add r15d, eax
mov dword ptr cs:ComputeSHA1_hash+0Ch, r15d
add ebx, esi
mov cs:dword_12C910, ebx
mov rax, [rsp+198h+var_180]
add rax, 40h ; '@'
add r12, 40h ; '@'
jmp loc_64689
loc_647CE:
mov rdi, [rsp+198h+var_190]
call _free
lea rax, ComputeSHA1_hash
add rsp, 168h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| __int128 * ComputeSHA1(long long a1, int a2)
{
int v2; // r13d
long long v3; // rbx
long long v4; // r12
int v5; // ebp
int v6; // r13d
int v7; // r14d
int v8; // r15d
int v9; // ebx
long long v10; // rax
long long i; // rax
long long j; // rax
unsigned long long v13; // rdi
int v14; // r9d
int v15; // r8d
int v16; // edx
int v17; // ecx
int v18; // eax
int v19; // esi
int v20; // edx
int v21; // r9d
int v22; // r10d
int v23; // esi
_DWORD v25[10]; // [rsp+0h] [rbp-1B8h]
long long v26; // [rsp+28h] [rbp-190h]
long long v27; // [rsp+30h] [rbp-188h]
long long v28; // [rsp+38h] [rbp-180h]
_DWORD v29[94]; // [rsp+40h] [rbp-178h] BYREF
ComputeSHA1_hash = xmmword_C3690;
dword_12C910 = -1009589776;
v2 = ((a2 + 8) / 64) << 6;
v27 = v2 + 64;
v3 = calloc(v27, 1LL);
memcpy(v3, a1, a2);
*(_BYTE *)(v3 + a2) = 0x80;
*(_BYTE *)(v3 + v2 + 63) = 8 * a2;
v26 = v3;
v4 = v3 + 3;
v5 = 1732584193;
v6 = -271733879;
v7 = -1732584194;
v8 = 271733878;
v9 = -1009589776;
v10 = 0LL;
while ( v10 < v27 )
{
v28 = v10;
memset(v29, 0LL, 320LL);
for ( i = 0LL; i != 16; ++i )
v29[i] = _byteswap_ulong(*(_DWORD *)(v4 + 4 * i - 3));
for ( j = 16LL; j != 80; ++j )
v29[j] = __ROL4__(v25[j] ^ v25[j + 2] ^ *((_DWORD *)&v27 + j + 1) ^ v25[j + 8], 1);
v13 = 0LL;
v14 = v5;
v15 = v6;
v16 = v7;
v17 = v8;
v18 = v9;
while ( 1 )
{
v19 = v18;
v18 = v17;
v17 = v16;
v20 = v15;
v15 = v14;
if ( v13 == 80 )
break;
if ( v13 > 0x13 )
{
if ( v13 > 0x27 )
{
if ( v13 > 0x3B )
{
v21 = v18 ^ v20 ^ v17;
v22 = -899497514;
}
else
{
v21 = v20 & (v17 | v18) | v17 & v18;
v22 = -1894007588;
}
}
else
{
v21 = v18 ^ v20 ^ v17;
v22 = 1859775393;
}
}
else
{
v21 = v18 ^ v20 & (v18 ^ v17);
v22 = 1518500249;
}
v23 = v29[v13] + v22 + v21 + __ROL4__(v15, 5) + v19;
v16 = __ROL4__(v20, 30);
++v13;
v14 = v23;
}
v5 += v14;
LODWORD(ComputeSHA1_hash) = v5;
v6 += v20;
DWORD1(ComputeSHA1_hash) = v6;
v7 += v17;
DWORD2(ComputeSHA1_hash) = v7;
v8 += v18;
HIDWORD(ComputeSHA1_hash) = v8;
v9 += v19;
dword_12C910 = v9;
v10 = v28 + 64;
v4 += 64LL;
}
free(v26);
return &ComputeSHA1_hash;
}
| ComputeSHA1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x168
MOV R15D,ESI
MOV R12,RDI
MOVAPS XMM0,xmmword ptr [0x001c3690]
MOVAPS xmmword ptr [0x0022c900],XMM0
MOV dword ptr [0x0022c910],0xc3d2e1f0
LEA EAX,[R15 + 0x8]
PUSH 0x40
POP RCX
CDQ
IDIV ECX
MOV R13D,EAX
SHL R13D,0x6
LEA EAX,[R13 + 0x40]
MOVSXD RDI,EAX
PUSH 0x1
POP RSI
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00109320
MOV RBX,RAX
MOVSXD R15,R15D
MOV RDI,RAX
MOV RSI,R12
MOV RDX,R15
CALL 0x00109400
MOV byte ptr [RBX + R15*0x1],0x80
SHL R15B,0x3
MOVSXD RAX,R13D
MOV byte ptr [RBX + RAX*0x1 + 0x3f],R15B
MOV qword ptr [RSP + 0x8],RBX
MOV R12,RBX
ADD R12,0x3
MOV EBP,0x67452301
MOV R13D,0xefcdab89
MOV R14D,0x98badcfe
MOV R15D,0x10325476
MOV EBX,0xc3d2e1f0
XOR EAX,EAX
LAB_00164689:
CMP RAX,qword ptr [RSP + 0x10]
JGE 0x001647ce
MOV qword ptr [RSP + 0x18],RAX
MOV EDX,0x140
LEA RDI,[RSP + 0x20]
XOR ESI,ESI
CALL 0x001092c0
XOR EAX,EAX
LAB_001646ac:
CMP RAX,0x10
JZ 0x001646c2
MOV ECX,dword ptr [R12 + RAX*0x4 + -0x3]
BSWAP ECX
MOV dword ptr [RSP + RAX*0x4 + 0x20],ECX
INC RAX
JMP 0x001646ac
LAB_001646c2:
PUSH 0x10
POP RAX
LAB_001646c5:
CMP RAX,0x50
JZ 0x001646e5
MOV ECX,dword ptr [RSP + RAX*0x4]
XOR ECX,dword ptr [RSP + RAX*0x4 + 0x14]
XOR ECX,dword ptr [RSP + RAX*0x4 + -0x18]
XOR ECX,dword ptr [RSP + RAX*0x4 + -0x20]
ROL ECX,0x1
MOV dword ptr [RSP + RAX*0x4 + 0x20],ECX
INC RAX
JMP 0x001646c5
LAB_001646e5:
XOR EDI,EDI
MOV R9D,EBP
MOV R8D,R13D
MOV EDX,R14D
MOV ECX,R15D
MOV EAX,EBX
LAB_001646f5:
MOV ESI,EAX
MOV EAX,ECX
MOV ECX,EDX
MOV EDX,R8D
MOV R8D,R9D
CMP RDI,0x50
JZ 0x0016478d
CMP RDI,0x13
JA 0x00164725
MOV R9D,ECX
XOR R9D,EAX
AND R9D,EDX
XOR R9D,EAX
MOV R10D,0x5a827999
JMP 0x0016476b
LAB_00164725:
CMP RDI,0x27
JA 0x0016473c
MOV R9D,ECX
XOR R9D,EDX
XOR R9D,EAX
MOV R10D,0x6ed9eba1
JMP 0x0016476b
LAB_0016473c:
CMP RDI,0x3b
JA 0x0016475c
MOV R10D,EAX
OR R10D,ECX
AND R10D,EDX
MOV R9D,EAX
AND R9D,ECX
OR R9D,R10D
MOV R10D,0x8f1bbcdc
JMP 0x0016476b
LAB_0016475c:
MOV R9D,ECX
XOR R9D,EDX
XOR R9D,EAX
MOV R10D,0xca62c1d6
LAB_0016476b:
MOV R11D,R8D
ROL R11D,0x5
ADD ESI,R11D
ADD ESI,R9D
ADD ESI,R10D
ADD ESI,dword ptr [RSP + RDI*0x4 + 0x20]
ROL EDX,0x1e
INC RDI
MOV R9D,ESI
JMP 0x001646f5
LAB_0016478d:
ADD EBP,R8D
MOV dword ptr [0x0022c900],EBP
ADD R13D,EDX
MOV dword ptr [0x0022c904],R13D
ADD R14D,ECX
MOV dword ptr [0x0022c908],R14D
ADD R15D,EAX
MOV dword ptr [0x0022c90c],R15D
ADD EBX,ESI
MOV dword ptr [0x0022c910],EBX
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x40
ADD R12,0x40
JMP 0x00164689
LAB_001647ce:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00109640
LEA RAX,[0x22c900]
ADD RSP,0x168
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int1 * ComputeSHA1(void *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint uVar3;
void *__dest;
long lVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
int iVar10;
ulong uVar11;
uint uVar12;
uint uVar13;
long lVar14;
int iVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint auStack_1b8 [6];
int8 uStack_1a0;
uint auStack_198 [2];
void *local_190;
int8 local_188;
long local_180;
uint local_178 [82];
ComputeSHA1_hash._0_8_ = _DAT_001c3690;
ComputeSHA1_hash._8_8_ = _UNK_001c3698;
ComputeSHA1_hash._16_4_ = 0xc3d2e1f0;
iVar15 = ((param_2 + 8) / 0x40) * 0x40;
local_188 = (size_t)(iVar15 + 0x40);
uStack_1a0 = 0x16463a;
__dest = calloc(local_188,1);
uStack_1a0 = 0x16464e;
memcpy(__dest,param_1,(long)param_2);
*(int1 *)((long)__dest + (long)param_2) = 0x80;
*(char *)((long)__dest + (long)iVar15 + 0x3f) = (char)param_2 << 3;
lVar14 = (long)__dest + 3;
uVar9 = 0x67452301;
uVar16 = 0xefcdab89;
uVar17 = 0x98badcfe;
uVar18 = 0x10325476;
uVar8 = 0xc3d2e1f0;
lVar4 = 0;
local_190 = __dest;
while (lVar4 < (long)local_188) {
uStack_1a0 = 0x1646aa;
local_180 = lVar4;
memset(local_178,0,0x140);
for (lVar4 = 0; lVar4 != 0x10; lVar4 = lVar4 + 1) {
uVar5 = *(uint *)(lVar14 + -3 + lVar4 * 4);
local_178[lVar4] =
uVar5 >> 0x18 | (uVar5 & 0xff0000) >> 8 | (uVar5 & 0xff00) << 8 | uVar5 << 0x18;
}
for (lVar4 = 0x10; lVar4 != 0x50; lVar4 = lVar4 + 1) {
uVar5 = auStack_198[lVar4] ^ *(uint *)((long)&local_188 + lVar4 * 4 + 4) ^
auStack_1b8[lVar4 + 2] ^ auStack_1b8[lVar4];
local_178[lVar4] = uVar5 << 1 | (uint)((int)uVar5 < 0);
}
uVar12 = uVar16;
uVar2 = uVar17;
uVar7 = uVar18;
uVar3 = uVar8;
uVar5 = uVar9;
for (uVar11 = 0; uVar6 = uVar7, uVar7 = uVar2, uVar11 != 0x50; uVar11 = uVar11 + 1) {
if (uVar11 < 0x14) {
uVar13 = (uVar7 ^ uVar6) & uVar12 ^ uVar6;
iVar15 = 0x5a827999;
}
else if (uVar11 < 0x28) {
uVar13 = uVar7 ^ uVar12 ^ uVar6;
iVar15 = 0x6ed9eba1;
}
else if (uVar11 < 0x3c) {
uVar13 = uVar6 & uVar7 | (uVar6 | uVar7) & uVar12;
iVar15 = -0x70e44324;
}
else {
uVar13 = uVar7 ^ uVar12 ^ uVar6;
iVar15 = -0x359d3e2a;
}
iVar10 = uVar3 + (uVar5 << 5 | uVar5 >> 0x1b);
puVar1 = local_178 + uVar11;
uVar2 = uVar12 << 0x1e;
uVar3 = uVar12 >> 2;
uVar12 = uVar5;
uVar2 = uVar2 | uVar3;
uVar3 = uVar6;
uVar5 = iVar10 + uVar13 + iVar15 + *puVar1;
}
uVar9 = uVar9 + uVar5;
uVar16 = uVar16 + uVar12;
ComputeSHA1_hash._4_4_ = uVar16;
ComputeSHA1_hash._0_4_ = uVar9;
uVar17 = uVar17 + uVar7;
uVar18 = uVar18 + uVar6;
ComputeSHA1_hash._12_4_ = uVar18;
ComputeSHA1_hash._8_4_ = uVar17;
uVar8 = uVar8 + uVar3;
lVar14 = lVar14 + 0x40;
ComputeSHA1_hash._16_4_ = uVar8;
lVar4 = local_180 + 0x40;
}
uStack_1a0 = 0x1647d8;
free(local_190);
return ComputeSHA1_hash;
}
| |
39,408 | 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 0xe3bc9
movq -0x138(%rbp), %r14
movq -0x140(%rbp), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x64, %rdx
ja 0xe3bc9
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 0xe3b96
movq -0x150(%rbp), %rbx
movq %r12, (%rbx)
leaq -0x130(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq -0x148(%rbp), %rdx
callq 0xf3744
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 0xe3c2b
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a280
| 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_E3BC9
mov r14, [rbp+var_138]
loc_E3B96:
mov rcx, [rbp+var_140]
lea rdx, [rcx-1]
cmp rdx, 64h ; 'd'
ja short loc_E3BC9
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_E3B96
loc_E3BC9:
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_E3C2B
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E3C2B:
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 0x001e3bc9
MOV R14,qword ptr [RBP + -0x138]
LAB_001e3b96:
MOV RCX,qword ptr [RBP + -0x140]
LEA RDX,[RCX + -0x1]
CMP RDX,0x64
JA 0x001e3bc9
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 0x001e3b96
LAB_001e3bc9:
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 0x001f3744
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 0x001e3c2b
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e3c2b:
CALL 0x0012a280
|
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();
}
| |
39,409 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O0 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
39,410 | maria_rtree_insert | eloqsql/storage/maria/ma_rt_index.c | my_bool maria_rtree_insert(MARIA_HA *info, MARIA_KEY *key)
{
int res;
MARIA_SHARE *share= info->s;
my_off_t *root, new_root;
LSN lsn= LSN_IMPOSSIBLE;
DBUG_ENTER("maria_rtree_insert");
if (!key)
DBUG_RETURN(1); /* _ma_sp_make_key failed */
root= &share->state.key_root[key->keyinfo->key_nr];
new_root= *root;
if ((res= (maria_rtree_insert_level(info, key, -1, &new_root) == -1)))
goto err;
if (share->now_transactional)
res= _ma_write_undo_key_insert(info, key, root, new_root, &lsn);
else
{
*root= new_root;
_ma_fast_unlock_key_del(info);
}
_ma_unpin_all_pages_and_finalize_row(info, lsn);
err:
DBUG_RETURN(res != 0);
} | O0 | c | maria_rtree_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7d565
jmp 0x7d55c
movb $0x1, -0x1(%rbp)
jmp 0x7d621
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movzbl 0xa5(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
leaq -0x38(%rbp), %rcx
callq 0x7c950
cmpl $-0x1, %eax
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x1c(%rbp)
testb $0x1, %al
jne 0x7d5c2
jmp 0x7d5c4
jmp 0x7d610
movq -0x28(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x7d5ef
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x6cc20
movl %eax, -0x1c(%rbp)
jmp 0x7d603
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7d630
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7d660
jmp 0x7d612
cmpl $0x0, -0x1c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| maria_rtree_insert:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov [rbp+var_40], 0
cmp [rbp+var_18], 0
jnz short loc_7D565
jmp short $+2
loc_7D55C:
mov [rbp+var_1], 1
jmp loc_7D621
loc_7D565:
mov rax, [rbp+var_28]
mov rax, [rax+118h]
mov rcx, [rbp+var_18]
mov rcx, [rcx+8]
movzx ecx, byte ptr [rcx+0A5h]
shl rcx, 3
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, 0FFFFFFFFh
lea rcx, [rbp+var_38]
call maria_rtree_insert_level
cmp eax, 0FFFFFFFFh
setz al
mov cl, al
and cl, 1
movzx ecx, cl
mov [rbp+var_1C], ecx
test al, 1
jnz short loc_7D5C2
jmp short loc_7D5C4
loc_7D5C2:
jmp short loc_7D610
loc_7D5C4:
mov rax, [rbp+var_28]
cmp byte ptr [rax+7E7h], 0
jz short loc_7D5EF
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_38]
lea r8, [rbp+var_40]
call _ma_write_undo_key_insert
mov [rbp+var_1C], eax
jmp short loc_7D603
loc_7D5EF:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax], rcx
mov rdi, [rbp+var_10]
call _ma_fast_unlock_key_del_2
loc_7D603:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_40]
call _ma_unpin_all_pages_and_finalize_row_3
loc_7D610:
jmp short $+2
loc_7D612:
cmp [rbp+var_1C], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
loc_7D621:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| bool maria_rtree_insert(long long *a1, float **a2)
{
bool v2; // al
long long v4; // [rsp+0h] [rbp-40h] BYREF
long long v5; // [rsp+8h] [rbp-38h] BYREF
long long *v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
int v8; // [rsp+24h] [rbp-1Ch]
float **v9; // [rsp+28h] [rbp-18h]
long long *v10; // [rsp+30h] [rbp-10h]
v10 = a1;
v9 = a2;
v7 = *a1;
v4 = 0LL;
if ( !a2 )
return 1;
v6 = (long long *)(8LL * *((unsigned __int8 *)v9[1] + 165) + *(_QWORD *)(v7 + 280));
v5 = *v6;
v2 = (unsigned int)maria_rtree_insert_level(v10, (long long)v9, 0xFFFFFFFF, &v5) == -1;
v8 = v2;
if ( !v2 )
{
if ( *(_BYTE *)(v7 + 2023) )
{
v8 = ma_write_undo_key_insert(v10, v9, (long long)v6, v5, (long long)&v4);
}
else
{
*v6 = v5;
ma_fast_unlock_key_del_2(v10);
}
ma_unpin_all_pages_and_finalize_row_3(v10, v4);
}
return v8 != 0;
}
| maria_rtree_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x0
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0017d565
JMP 0x0017d55c
LAB_0017d55c:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017d621
LAB_0017d565:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x118]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x8]
MOVZX ECX,byte ptr [RCX + 0xa5]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0xffffffff
LEA RCX,[RBP + -0x38]
CALL 0x0017c950
CMP EAX,-0x1
SETZ AL
MOV CL,AL
AND CL,0x1
MOVZX ECX,CL
MOV dword ptr [RBP + -0x1c],ECX
TEST AL,0x1
JNZ 0x0017d5c2
JMP 0x0017d5c4
LAB_0017d5c2:
JMP 0x0017d610
LAB_0017d5c4:
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0017d5ef
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x38]
LEA R8,[RBP + -0x40]
CALL 0x0016cc20
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0017d603
LAB_0017d5ef:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0017d630
LAB_0017d603:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x0017d660
LAB_0017d610:
JMP 0x0017d612
LAB_0017d612:
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
LAB_0017d621:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int8 maria_rtree_insert(long *param_1,long param_2)
{
int iVar1;
int8 local_48;
int8 local_40;
int8 *local_38;
long local_30;
uint local_24;
long local_20;
long *local_18;
bool local_9;
local_30 = *param_1;
local_48 = 0;
if (param_2 == 0) {
local_9 = true;
}
else {
local_38 = (int8 *)
(*(long *)(local_30 + 0x118) + (ulong)*(byte *)(*(long *)(param_2 + 8) + 0xa5) * 8);
local_40 = *local_38;
local_20 = param_2;
local_18 = param_1;
iVar1 = maria_rtree_insert_level(param_1,param_2,0xffffffff,&local_40);
local_24 = (uint)(iVar1 == -1);
if (iVar1 != -1) {
if (*(char *)(local_30 + 0x7e7) == '\0') {
*local_38 = local_40;
_ma_fast_unlock_key_del(local_18);
}
else {
local_24 = _ma_write_undo_key_insert(local_18,local_20,local_38,local_40,&local_48);
}
_ma_unpin_all_pages_and_finalize_row(local_18,local_48);
}
local_9 = local_24 != 0;
local_30 = 0;
}
return CONCAT71((int7)((ulong)local_30 >> 8),local_9);
}
| |
39,411 | my_long10_to_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_long10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *e;
long int new_val;
uint sign=0;
unsigned long int uval = (unsigned long int) val;
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval= (unsigned long int)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
len= MY_MIN(len, (size_t) (e-p));
memcpy(dst, p, len);
return len+sign;
} | O3 | c | my_long10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r10
movq %rsi, %rdi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x1f(%rbp)
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %cl
orb %al, %cl
jne 0xb589b
negq %r8
movb $0x2d, (%rdi)
incq %rdi
decq %r10
movl $0x1, %r14d
jmp 0xb589e
xorl %r14d, %r14d
leaq -0x1f(%rbp), %rbx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %r8, %rax
mulq %rcx
movq %rdx, %r9
shrq $0x3, %r9
imull $0xf6, %r9d, %eax
addl %r8d, %eax
addb $0x30, %al
leaq -0x20(%rbp), %rsi
movb %al, (%rsi)
cmpq $0xa, %r8
jb 0xb58f5
movq %r9, %rax
mulq %rcx
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %r9d, %eax
addb $0x30, %al
movb %al, -0x1(%rsi)
decq %rsi
cmpq $0x9, %r9
movq %rdx, %r9
ja 0xb58d1
subq %rsi, %rbx
cmpq %rbx, %r10
cmovbq %r10, %rbx
movq %rbx, %rdx
callq 0x29080
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0xb5925
addq %r14, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29270
| my_long10_to_str_8bit:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r10, rdx
mov rdi, rsi
mov rax, fs:28h
mov [rbp+var_18], rax
mov [rbp+var_1F], 0
test ecx, ecx
setns al
test r8, r8
setns cl
or cl, al
jnz short loc_B589B
neg r8
mov byte ptr [rdi], 2Dh ; '-'
inc rdi
dec r10
mov r14d, 1
jmp short loc_B589E
loc_B589B:
xor r14d, r14d
loc_B589E:
lea rbx, [rbp+var_1F]
mov rcx, 0CCCCCCCCCCCCCCCDh
mov rax, r8
mul rcx
mov r9, rdx
shr r9, 3
imul eax, r9d, 0F6h
add eax, r8d
add al, 30h ; '0'
lea rsi, [rbp+var_20]
mov [rsi], al
cmp r8, 0Ah
jb short loc_B58F5
loc_B58D1:
mov rax, r9
mul rcx
shr rdx, 3
imul eax, edx, 0F6h
add eax, r9d
add al, 30h ; '0'
mov [rsi-1], al
dec rsi
cmp r9, 9
mov r9, rdx
ja short loc_B58D1
loc_B58F5:
sub rbx, rsi
cmp r10, rbx
cmovb rbx, r10
mov rdx, rbx
call _memcpy
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_B5925
add rbx, r14
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_B5925:
call ___stack_chk_fail
| _BYTE * my_long10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, unsigned long long a5)
{
_BYTE *v5; // r10
_BYTE *v6; // rdi
long long v7; // r14
unsigned long long v8; // r9
char *v9; // rsi
bool v10; // cf
bool v11; // zf
_BYTE *v12; // rbx
char v14; // [rsp+40h] [rbp-20h] BYREF
_BYTE v15[7]; // [rsp+41h] [rbp-1Fh] BYREF
unsigned long long v16; // [rsp+48h] [rbp-18h]
v5 = a3;
v6 = a2;
v16 = __readfsqword(0x28u);
v15[0] = 0;
if ( a4 >= 0 || (a5 & 0x8000000000000000LL) == 0LL )
{
v7 = 0LL;
}
else
{
a5 = -(long long)a5;
*a2 = 45;
v6 = a2 + 1;
v5 = a3 - 1;
v7 = 1LL;
}
v8 = a5 / 0xA;
v9 = &v14;
v14 = a5 % 0xA + 48;
if ( a5 >= 0xA )
{
do
{
*--v9 = v8 % 0xA + 48;
v10 = v8 < 9;
v11 = v8 == 9;
v8 /= 0xAuLL;
}
while ( !v10 && !v11 );
}
v12 = (_BYTE *)(v15 - v9);
if ( (unsigned long long)v5 < v15 - v9 )
v12 = v5;
memcpy(v6, v9, v12);
return &v12[v7];
}
| my_long10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R10,RDX
MOV RDI,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV byte ptr [RBP + -0x1f],0x0
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS CL
OR CL,AL
JNZ 0x001b589b
NEG R8
MOV byte ptr [RDI],0x2d
INC RDI
DEC R10
MOV R14D,0x1
JMP 0x001b589e
LAB_001b589b:
XOR R14D,R14D
LAB_001b589e:
LEA RBX,[RBP + -0x1f]
MOV RCX,-0x3333333333333333
MOV RAX,R8
MUL RCX
MOV R9,RDX
SHR R9,0x3
IMUL EAX,R9D,0xf6
ADD EAX,R8D
ADD AL,0x30
LEA RSI,[RBP + -0x20]
MOV byte ptr [RSI],AL
CMP R8,0xa
JC 0x001b58f5
LAB_001b58d1:
MOV RAX,R9
MUL RCX
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,R9D
ADD AL,0x30
MOV byte ptr [RSI + -0x1],AL
DEC RSI
CMP R9,0x9
MOV R9,RDX
JA 0x001b58d1
LAB_001b58f5:
SUB RBX,RSI
CMP R10,RBX
CMOVC RBX,R10
MOV RDX,RBX
CALL 0x00129080
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001b5925
ADD RBX,R14
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_001b5925:
CALL 0x00129270
|
char * my_long10_to_str_8bit
(int8 param_1,int1 *param_2,char *param_3,int param_4,ulong param_5)
{
ulong uVar1;
ulong uVar2;
char *__n;
char *__src;
long in_FS_OFFSET;
bool bVar3;
char local_29 [9];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_29[2] = 0;
bVar3 = (long)param_5 < 0;
if (bVar3 && param_4 < 0) {
param_5 = -param_5;
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_3 = param_3 + -1;
}
local_29[1] = (char)(param_5 / 10) * -10 + (char)param_5 + '0';
__src = local_29 + 1;
uVar2 = param_5 / 10;
while (uVar1 = uVar2, 9 < param_5) {
__src[-1] = (char)(uVar1 / 10) * -10 + (char)uVar1 + '0';
__src = __src + -1;
uVar2 = uVar1 / 10;
param_5 = uVar1;
}
__n = local_29 + (2 - (long)__src);
if (param_3 < local_29 + (2 - (long)__src)) {
__n = param_3;
}
memcpy(param_2,__src,(size_t)__n);
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return __n + (bVar3 && param_4 < 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,412 | tree_walk_left_root_right | eloqsql/mysys/tree.c | static int tree_walk_left_root_right(TREE *tree, TREE_ELEMENT *element, tree_walk_action action, void *argument)
{
int error;
if (element->left) /* Not null_element */
{
if ((error=tree_walk_left_root_right(tree,element->left,action,
argument)) == 0 &&
(error=(*action)(ELEMENT_KEY(tree,element),
(element_count) element->count,
argument)) == 0)
error=tree_walk_left_root_right(tree,element->right,action,argument);
return error;
}
return 0;
} | O0 | c | tree_walk_left_root_right:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x88a75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x889b0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x88a6d
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0x88a22
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x88a2e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %esi
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x88a6d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x889b0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x88a7c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| tree_walk_left_root_right:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz loc_88A75
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call tree_walk_left_root_right
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_88A6D
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jz short loc_88A22
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_40], rax
jmp short loc_88A2E
loc_88A22:
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov [rbp+var_40], rax
loc_88A2E:
mov rax, [rbp+var_38]
mov rdi, [rbp+var_40]
mov rcx, [rbp+var_18]
mov esi, [rcx+10h]
and esi, 7FFFFFFFh
mov rdx, [rbp+var_28]
call rax
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_88A6D
mov rdi, [rbp+var_10]
mov rax, [rbp+var_18]
mov rsi, [rax+8]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call tree_walk_left_root_right
mov [rbp+var_2C], eax
loc_88A6D:
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_88A7C
loc_88A75:
mov [rbp+var_4], 0
loc_88A7C:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long tree_walk_left_root_right(
long long a1,
long long a2,
long long ( *a3)(long long, _QWORD, long long),
long long a4)
{
unsigned int v4; // eax
unsigned int v6; // [rsp+14h] [rbp-2Ch]
if ( *(_QWORD *)a2 )
{
v6 = tree_walk_left_root_right(a1, *(_QWORD *)a2, a3, a4);
if ( !v6 )
{
if ( *(_DWORD *)(a1 + 520) )
v4 = a3(*(unsigned int *)(a1 + 520) + a2, *(_DWORD *)(a2 + 16) & 0x7FFFFFFF, a4);
else
v4 = a3(*(_QWORD *)(a2 + 24), *(_DWORD *)(a2 + 16) & 0x7FFFFFFF, a4);
v6 = v4;
if ( !v4 )
return (unsigned int)tree_walk_left_root_right(a1, *(_QWORD *)(a2 + 8), a3, a4);
}
return v6;
}
else
{
return 0;
}
}
| tree_walk_left_root_right:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x00188a75
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x001889b0
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00188a6d
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x208],0x0
JZ 0x00188a22
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x208]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00188a2e
LAB_00188a22:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x40],RAX
LAB_00188a2e:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RCX + 0x10]
AND ESI,0x7fffffff
MOV RDX,qword ptr [RBP + -0x28]
CALL RAX
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x00188a6d
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x001889b0
MOV dword ptr [RBP + -0x2c],EAX
LAB_00188a6d:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00188a7c
LAB_00188a75:
MOV dword ptr [RBP + -0x4],0x0
LAB_00188a7c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int tree_walk_left_root_right(long param_1,long *param_2,code *param_3,int8 param_4)
{
long local_48;
int local_34;
int local_c;
if (*param_2 == 0) {
local_c = 0;
}
else {
local_34 = tree_walk_left_root_right(param_1,*param_2,param_3,param_4);
if (local_34 == 0) {
if (*(int *)(param_1 + 0x208) == 0) {
local_48 = param_2[3];
}
else {
local_48 = (long)param_2 + (ulong)*(uint *)(param_1 + 0x208);
}
local_34 = (*param_3)(local_48,*(uint *)(param_2 + 2) & 0x7fffffff,param_4);
if (local_34 == 0) {
local_34 = tree_walk_left_root_right(param_1,param_2[1],param_3,param_4);
}
}
local_c = local_34;
}
return local_c;
}
| |
39,413 | convert_dirname | eloqsql/mysys/mf_dirname.c | char *convert_dirname(char *to, const char *from, const char *from_end)
{
char *to_org=to;
#ifdef BACKSLASH_MBTAIL
CHARSET_INFO *fs= fs_character_set();
#endif
DBUG_ENTER("convert_dirname");
/* We use -2 here, becasue we need place for the last FN_LIBCHAR */
if (!from_end || (from_end - from) > FN_REFLEN-2)
from_end=from+FN_REFLEN -2;
#if FN_LIBCHAR != '/'
{
for (; from != from_end && *from ; from++)
{
if (*from == '/')
*to++= FN_LIBCHAR;
else
{
#ifdef BACKSLASH_MBTAIL
uint l;
if (my_ci_use_mb(fs) && (l= my_ismbchar(fs, from, from + 3)))
{
memmove(to, from, l);
to+= l;
from+= l - 1;
to_org= to; /* Don't look inside mbchar */
}
else
#endif
{
*to++= *from;
}
}
}
*to=0;
}
#else
/* This is ok even if to == from, becasue we need to cut the string */
to= strmake(to, from, (size_t) (from_end-from));
#endif
/* Add FN_LIBCHAR to the end of directory path */
if (to != to_org && (to[-1] != FN_LIBCHAR && to[-1] != FN_DEVCHAR))
{
*to++=FN_LIBCHAR;
*to=0;
}
DBUG_RETURN(to); /* Pointer to end of dir */
} | O0 | c | convert_dirname:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe26a6
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1fe, %rax # imm = 0x1FE
jle 0xe26b8
movq -0x10(%rbp), %rax
addq $0x200, %rax # imm = 0x200
addq $-0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
callq 0x157e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xe2711
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0xe2711
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x0, %eax
je 0xe2711
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x2f, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xe2713
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| convert_dirname:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_E26A6
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 1FEh
jle short loc_E26B8
loc_E26A6:
mov rax, [rbp+var_10]
add rax, 200h
add rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_18], rax
loc_E26B8:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_10]
sub rdx, rax
call strmake
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jz short loc_E2711
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_E2711
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax-1]
cmp eax, 0
jz short loc_E2711
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
loc_E2711:
jmp short $+2
loc_E2713:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| _BYTE * convert_dirname(_BYTE *a1, long long a2, long long a3)
{
_BYTE *v3; // rax
long long v5; // [rsp+18h] [rbp-18h]
_BYTE *v6; // [rsp+28h] [rbp-8h]
v5 = a3;
if ( !a3 || a3 - a2 > 510 )
v5 = a2 + 510;
v6 = (_BYTE *)strmake(a1, a2, v5 - a2);
if ( v6 != a1 && *(v6 - 1) != 47 && *(v6 - 1) )
{
v3 = v6++;
*v3 = 47;
*v6 = 0;
}
return v6;
}
| convert_dirname:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001e26a6
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x1fe
JLE 0x001e26b8
LAB_001e26a6:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x200
ADD RAX,-0x2
MOV qword ptr [RBP + -0x18],RAX
LAB_001e26b8:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
SUB RDX,RAX
CALL 0x00257e40
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001e2711
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x001e2711
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x0
JZ 0x001e2711
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
LAB_001e2711:
JMP 0x001e2713
LAB_001e2713:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
int1 * convert_dirname(int1 *param_1,long param_2,long param_3)
{
int1 *puVar1;
long local_20;
int1 *local_10;
if ((param_3 == 0) || (local_20 = param_3, 0x1fe < param_3 - param_2)) {
local_20 = param_2 + 0x1fe;
}
puVar1 = (int1 *)strmake(param_1,param_2,local_20 - param_2);
local_10 = puVar1;
if (((puVar1 != param_1) && (puVar1[-1] != '/')) && (puVar1[-1] != '\0')) {
local_10 = puVar1 + 1;
*puVar1 = 0x2f;
*local_10 = 0;
}
return local_10;
}
| |
39,414 | js_free_function_def | bluesky950520[P]quickjs/quickjs.c | static void js_free_function_def(JSContext *ctx, JSFunctionDef *fd)
{
int i;
struct list_head *el, *el1;
/* free the child functions */
list_for_each_safe(el, el1, &fd->child_list) {
JSFunctionDef *fd1;
fd1 = list_entry(el, JSFunctionDef, link);
js_free_function_def(ctx, fd1);
}
free_bytecode_atoms(ctx->rt, fd->byte_code.buf, fd->byte_code.size,
fd->use_short_opcodes);
dbuf_free(&fd->byte_code);
js_free(ctx, fd->jump_slots);
js_free(ctx, fd->label_slots);
js_free(ctx, fd->source_loc_slots);
/* free ic */
if (fd->ic)
free_ic(ctx->rt, fd->ic);
for(i = 0; i < fd->cpool_count; i++) {
JS_FreeValue(ctx, fd->cpool[i]);
}
js_free(ctx, fd->cpool);
JS_FreeAtom(ctx, fd->func_name);
for(i = 0; i < fd->var_count; i++) {
JS_FreeAtom(ctx, fd->vars[i].var_name);
}
js_free(ctx, fd->vars);
js_free(ctx, fd->vars_htab); // XXX can probably be freed earlier?
for(i = 0; i < fd->arg_count; i++) {
JS_FreeAtom(ctx, fd->args[i].var_name);
}
js_free(ctx, fd->args);
for(i = 0; i < fd->global_var_count; i++) {
JS_FreeAtom(ctx, fd->global_vars[i].var_name);
}
js_free(ctx, fd->global_vars);
for(i = 0; i < fd->closure_var_count; i++) {
JSClosureVar *cv = &fd->closure_var[i];
JS_FreeAtom(ctx, cv->var_name);
}
js_free(ctx, fd->closure_var);
if (fd->scopes != fd->def_scope_array)
js_free(ctx, fd->scopes);
JS_FreeAtom(ctx, fd->filename);
dbuf_free(&fd->pc2line);
js_free(ctx, fd->source);
if (fd->parent) {
/* remove in parent list */
list_del(&fd->link);
}
js_free(ctx, fd);
} | O0 | c | js_free_function_def:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x9aa04
movq 0x18(%rsp), %rax
addq $-0x28, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9a990
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x9a9ba
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x138(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x140(%rax), %rax
movl %eax, %edx
movq 0x28(%rsp), %rax
movl 0x16c(%rax), %ecx
callq 0x5dc60
movq 0x28(%rsp), %rdi
addq $0x138, %rdi # imm = 0x138
callq 0x1d670
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x1a8(%rax), %rsi
callq 0x20af0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x170(%rax), %rsi
callq 0x20af0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x1b8(%rax), %rsi
callq 0x20af0
movq 0x28(%rsp), %rax
cmpq $0x0, 0x230(%rax)
je 0x9aab3
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x230(%rax), %rsi
callq 0x5dd60
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x190(%rcx), %eax
jge 0x9ab02
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x188(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x229d0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9aabb
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x188(%rax), %rsi
callq 0x20af0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x88(%rax), %esi
callq 0x27d80
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0xa4(%rcx), %eax
jge 0x9ab77
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x27d80
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9ab35
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x20af0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x98(%rax), %rsi
callq 0x20af0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0xb4(%rcx), %eax
jge 0x9abed
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xa8(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x27d80
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9abab
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xa8(%rax), %rsi
callq 0x20af0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x124(%rcx), %eax
jge 0x9ac4e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x130(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %esi
callq 0x27d80
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9ac0b
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x130(%rax), %rsi
callq 0x20af0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x198(%rcx), %eax
jge 0x9acb7
movq 0x28(%rsp), %rax
movq 0x1a0(%rax), %rax
movslq 0x24(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movq (%rsp), %rax
movl 0x4(%rax), %esi
callq 0x27d80
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x9ac6c
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x1a0(%rax), %rsi
callq 0x20af0
movq 0x28(%rsp), %rax
movq 0xf8(%rax), %rax
movq 0x28(%rsp), %rcx
addq $0x100, %rcx # imm = 0x100
cmpq %rcx, %rax
je 0x9ad00
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0xf8(%rax), %rsi
callq 0x20af0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x1d4(%rax), %esi
callq 0x27d80
movq 0x28(%rsp), %rdi
addq $0x1e0, %rdi # imm = 0x1E0
callq 0x1d670
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x210(%rax), %rsi
callq 0x20af0
movq 0x28(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9ad56
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
callq 0x22970
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x20af0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| js_free_function_def:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rax, [rsp+38h+var_10]
mov rax, [rax+20h]
mov [rsp+38h+var_20], rax
mov rax, [rsp+38h+var_20]
mov rax, [rax+8]
mov [rsp+38h+var_28], rax
loc_9A9BA:
mov rax, [rsp+38h+var_20]
mov rcx, [rsp+38h+var_10]
add rcx, 18h
cmp rax, rcx
jz short loc_9AA04
mov rax, [rsp+38h+var_20]
add rax, 0FFFFFFFFFFFFFFD8h
mov [rsp+38h+var_30], rax
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_30]
call js_free_function_def
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_20], rax
mov rax, [rsp+38h+var_20]
mov rax, [rax+8]
mov [rsp+38h+var_28], rax
jmp short loc_9A9BA
loc_9AA04:
mov rax, [rsp+38h+var_8]
mov rdi, [rax+18h]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+138h]
mov rax, [rsp+38h+var_10]
mov rax, [rax+140h]
mov edx, eax
mov rax, [rsp+38h+var_10]
mov ecx, [rax+16Ch]
call free_bytecode_atoms
mov rdi, [rsp+38h+var_10]
add rdi, 138h
call dbuf_free
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+1A8h]
call js_free
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+170h]
call js_free
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+1B8h]
call js_free
mov rax, [rsp+38h+var_10]
cmp qword ptr [rax+230h], 0
jz short loc_9AAB3
mov rax, [rsp+38h+var_8]
mov rdi, [rax+18h]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+230h]
call free_ic
loc_9AAB3:
mov [rsp+38h+var_14], 0
loc_9AABB:
mov eax, [rsp+38h+var_14]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+190h]
jge short loc_9AB02
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rax, [rax+188h]
movsxd rcx, [rsp+38h+var_14]
shl rcx, 4
add rax, rcx
mov rsi, [rax]
mov rdx, [rax+8]
call JS_FreeValue
mov eax, [rsp+38h+var_14]
add eax, 1
mov [rsp+38h+var_14], eax
jmp short loc_9AABB
loc_9AB02:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+188h]
call js_free
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov esi, [rax+88h]
call JS_FreeAtom
mov [rsp+38h+var_14], 0
loc_9AB35:
mov eax, [rsp+38h+var_14]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+0A4h]
jge short loc_9AB77
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rax, [rax+90h]
movsxd rcx, [rsp+38h+var_14]
shl rcx, 4
add rax, rcx
mov esi, [rax]
call JS_FreeAtom
mov eax, [rsp+38h+var_14]
add eax, 1
mov [rsp+38h+var_14], eax
jmp short loc_9AB35
loc_9AB77:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+90h]
call js_free
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+98h]
call js_free
mov [rsp+38h+var_14], 0
loc_9ABAB:
mov eax, [rsp+38h+var_14]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+0B4h]
jge short loc_9ABED
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rax, [rax+0A8h]
movsxd rcx, [rsp+38h+var_14]
shl rcx, 4
add rax, rcx
mov esi, [rax]
call JS_FreeAtom
mov eax, [rsp+38h+var_14]
add eax, 1
mov [rsp+38h+var_14], eax
jmp short loc_9ABAB
loc_9ABED:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+0A8h]
call js_free
mov [rsp+38h+var_14], 0
loc_9AC0B:
mov eax, [rsp+38h+var_14]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+124h]
jge short loc_9AC4E
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rax, [rax+130h]
movsxd rcx, [rsp+38h+var_14]
shl rcx, 4
add rax, rcx
mov esi, [rax+0Ch]
call JS_FreeAtom
mov eax, [rsp+38h+var_14]
add eax, 1
mov [rsp+38h+var_14], eax
jmp short loc_9AC0B
loc_9AC4E:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+130h]
call js_free
mov [rsp+38h+var_14], 0
loc_9AC6C:
mov eax, [rsp+38h+var_14]
mov rcx, [rsp+38h+var_10]
cmp eax, [rcx+198h]
jge short loc_9ACB7
mov rax, [rsp+38h+var_10]
mov rax, [rax+1A0h]
movsxd rcx, [rsp+38h+var_14]
shl rcx, 3
add rax, rcx
mov [rsp+38h+var_38], rax
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_38]
mov esi, [rax+4]
call JS_FreeAtom
mov eax, [rsp+38h+var_14]
add eax, 1
mov [rsp+38h+var_14], eax
jmp short loc_9AC6C
loc_9ACB7:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+1A0h]
call js_free
mov rax, [rsp+38h+var_10]
mov rax, [rax+0F8h]
mov rcx, [rsp+38h+var_10]
add rcx, 100h
cmp rax, rcx
jz short loc_9AD00
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+0F8h]
call js_free
loc_9AD00:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov esi, [rax+1D4h]
call JS_FreeAtom
mov rdi, [rsp+38h+var_10]
add rdi, 1E0h
call dbuf_free
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_10]
mov rsi, [rax+210h]
call js_free
mov rax, [rsp+38h+var_10]
cmp qword ptr [rax+8], 0
jz short loc_9AD56
mov rdi, [rsp+38h+var_10]
add rdi, 28h ; '('
call list_del_0
loc_9AD56:
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_10]
call js_free
add rsp, 38h
retn
| void js_free_function_def(long long a1, long long a2)
{
long long *v2; // rax
long long v3; // [rsp+10h] [rbp-28h]
long long v4; // [rsp+18h] [rbp-20h]
int i; // [rsp+24h] [rbp-14h]
int j; // [rsp+24h] [rbp-14h]
int k; // [rsp+24h] [rbp-14h]
int m; // [rsp+24h] [rbp-14h]
int n; // [rsp+24h] [rbp-14h]
v4 = *(_QWORD *)(a2 + 32);
v3 = *(_QWORD *)(v4 + 8);
while ( v4 != a2 + 24 )
{
js_free_function_def(a1, v4 - 40);
v4 = v3;
v3 = *(_QWORD *)(v3 + 8);
}
free_bytecode_atoms(*(_QWORD *)(a1 + 24), *(_QWORD *)(a2 + 312), *(_QWORD *)(a2 + 320), *(_DWORD *)(a2 + 364));
dbuf_free(a2 + 312);
js_free(a1, *(_QWORD *)(a2 + 424));
js_free(a1, *(_QWORD *)(a2 + 368));
js_free(a1, *(_QWORD *)(a2 + 440));
if ( *(_QWORD *)(a2 + 560) )
free_ic(*(_QWORD *)(a1 + 24), *(_QWORD *)(a2 + 560));
for ( i = 0; i < *(_DWORD *)(a2 + 400); ++i )
{
v2 = (long long *)(16LL * i + *(_QWORD *)(a2 + 392));
JS_FreeValue(a1, *v2, v2[1]);
}
js_free(a1, *(_QWORD *)(a2 + 392));
JS_FreeAtom(a1, *(_DWORD *)(a2 + 136));
for ( j = 0; j < *(_DWORD *)(a2 + 164); ++j )
JS_FreeAtom(a1, *(_DWORD *)(16LL * j + *(_QWORD *)(a2 + 144)));
js_free(a1, *(_QWORD *)(a2 + 144));
js_free(a1, *(_QWORD *)(a2 + 152));
for ( k = 0; k < *(_DWORD *)(a2 + 180); ++k )
JS_FreeAtom(a1, *(_DWORD *)(16LL * k + *(_QWORD *)(a2 + 168)));
js_free(a1, *(_QWORD *)(a2 + 168));
for ( m = 0; m < *(_DWORD *)(a2 + 292); ++m )
JS_FreeAtom(a1, *(_DWORD *)(16LL * m + *(_QWORD *)(a2 + 304) + 12));
js_free(a1, *(_QWORD *)(a2 + 304));
for ( n = 0; n < *(_DWORD *)(a2 + 408); ++n )
JS_FreeAtom(a1, *(_DWORD *)(8LL * n + *(_QWORD *)(a2 + 416) + 4));
js_free(a1, *(_QWORD *)(a2 + 416));
if ( *(_QWORD *)(a2 + 248) != a2 + 256 )
js_free(a1, *(_QWORD *)(a2 + 248));
JS_FreeAtom(a1, *(_DWORD *)(a2 + 468));
dbuf_free(a2 + 480);
js_free(a1, *(_QWORD *)(a2 + 528));
if ( *(_QWORD *)(a2 + 8) )
list_del_0((_QWORD *)(a2 + 40));
js_free(a1, a2);
}
| js_free_function_def:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
LAB_0019a9ba:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x28]
ADD RCX,0x18
CMP RAX,RCX
JZ 0x0019aa04
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,-0x28
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0019a990
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0019a9ba
LAB_0019aa04:
MOV RAX,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x138]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x140]
MOV EDX,EAX
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX + 0x16c]
CALL 0x0015dc60
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x138
CALL 0x0011d670
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x1a8]
CALL 0x00120af0
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x170]
CALL 0x00120af0
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x1b8]
CALL 0x00120af0
MOV RAX,qword ptr [RSP + 0x28]
CMP qword ptr [RAX + 0x230],0x0
JZ 0x0019aab3
MOV RAX,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x230]
CALL 0x0015dd60
LAB_0019aab3:
MOV dword ptr [RSP + 0x24],0x0
LAB_0019aabb:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0x190]
JGE 0x0019ab02
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x188]
MOVSXD RCX,dword ptr [RSP + 0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001229d0
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0019aabb
LAB_0019ab02:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x188]
CALL 0x00120af0
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RAX + 0x88]
CALL 0x00127d80
MOV dword ptr [RSP + 0x24],0x0
LAB_0019ab35:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0xa4]
JGE 0x0019ab77
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x90]
MOVSXD RCX,dword ptr [RSP + 0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV ESI,dword ptr [RAX]
CALL 0x00127d80
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0019ab35
LAB_0019ab77:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x90]
CALL 0x00120af0
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x98]
CALL 0x00120af0
MOV dword ptr [RSP + 0x24],0x0
LAB_0019abab:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0xb4]
JGE 0x0019abed
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0xa8]
MOVSXD RCX,dword ptr [RSP + 0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV ESI,dword ptr [RAX]
CALL 0x00127d80
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0019abab
LAB_0019abed:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0xa8]
CALL 0x00120af0
MOV dword ptr [RSP + 0x24],0x0
LAB_0019ac0b:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0x124]
JGE 0x0019ac4e
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x130]
MOVSXD RCX,dword ptr [RSP + 0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV ESI,dword ptr [RAX + 0xc]
CALL 0x00127d80
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0019ac0b
LAB_0019ac4e:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x130]
CALL 0x00120af0
MOV dword ptr [RSP + 0x24],0x0
LAB_0019ac6c:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x28]
CMP EAX,dword ptr [RCX + 0x198]
JGE 0x0019acb7
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x1a0]
MOVSXD RCX,dword ptr [RSP + 0x24]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP]
MOV ESI,dword ptr [RAX + 0x4]
CALL 0x00127d80
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0019ac6c
LAB_0019acb7:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x1a0]
CALL 0x00120af0
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0xf8]
MOV RCX,qword ptr [RSP + 0x28]
ADD RCX,0x100
CMP RAX,RCX
JZ 0x0019ad00
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0xf8]
CALL 0x00120af0
LAB_0019ad00:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RAX + 0x1d4]
CALL 0x00127d80
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x1e0
CALL 0x0011d670
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RAX + 0x210]
CALL 0x00120af0
MOV RAX,qword ptr [RSP + 0x28]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0019ad56
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x28
CALL 0x00122970
LAB_0019ad56:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00120af0
ADD RSP,0x38
RET
|
void js_free_function_def(long param_1,long param_2)
{
int8 *puVar1;
long local_28;
long local_20;
int local_14;
local_20 = *(long *)(param_2 + 0x20);
local_28 = *(long *)(local_20 + 8);
while (local_20 != param_2 + 0x18) {
js_free_function_def(param_1,local_20 + -0x28);
local_20 = local_28;
local_28 = *(long *)(local_28 + 8);
}
free_bytecode_atoms(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x138),
*(ulong *)(param_2 + 0x140) & 0xffffffff,*(int4 *)(param_2 + 0x16c));
dbuf_free(param_2 + 0x138);
js_free(param_1,*(int8 *)(param_2 + 0x1a8));
js_free(param_1,*(int8 *)(param_2 + 0x170));
js_free(param_1,*(int8 *)(param_2 + 0x1b8));
if (*(long *)(param_2 + 0x230) != 0) {
free_ic(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x230));
}
for (local_14 = 0; local_14 < *(int *)(param_2 + 400); local_14 = local_14 + 1) {
puVar1 = (int8 *)(*(long *)(param_2 + 0x188) + (long)local_14 * 0x10);
JS_FreeValue(param_1,*puVar1,puVar1[1]);
}
js_free(param_1,*(int8 *)(param_2 + 0x188));
JS_FreeAtom(param_1,*(int4 *)(param_2 + 0x88));
for (local_14 = 0; local_14 < *(int *)(param_2 + 0xa4); local_14 = local_14 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x90) + (long)local_14 * 0x10));
}
js_free(param_1,*(int8 *)(param_2 + 0x90));
js_free(param_1,*(int8 *)(param_2 + 0x98));
for (local_14 = 0; local_14 < *(int *)(param_2 + 0xb4); local_14 = local_14 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0xa8) + (long)local_14 * 0x10));
}
js_free(param_1,*(int8 *)(param_2 + 0xa8));
for (local_14 = 0; local_14 < *(int *)(param_2 + 0x124); local_14 = local_14 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x130) + (long)local_14 * 0x10 + 0xc));
}
js_free(param_1,*(int8 *)(param_2 + 0x130));
for (local_14 = 0; local_14 < *(int *)(param_2 + 0x198); local_14 = local_14 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x1a0) + (long)local_14 * 8 + 4));
}
js_free(param_1,*(int8 *)(param_2 + 0x1a0));
if (*(long *)(param_2 + 0xf8) != param_2 + 0x100) {
js_free(param_1,*(int8 *)(param_2 + 0xf8));
}
JS_FreeAtom(param_1,*(int4 *)(param_2 + 0x1d4));
dbuf_free(param_2 + 0x1e0);
js_free(param_1,*(int8 *)(param_2 + 0x210));
if (*(long *)(param_2 + 8) != 0) {
list_del(param_2 + 0x28);
}
js_free(param_1,param_2);
return;
}
| |
39,415 | js_free_function_def | bluesky950520[P]quickjs/quickjs.c | static void js_free_function_def(JSContext *ctx, JSFunctionDef *fd)
{
int i;
struct list_head *el, *el1;
/* free the child functions */
list_for_each_safe(el, el1, &fd->child_list) {
JSFunctionDef *fd1;
fd1 = list_entry(el, JSFunctionDef, link);
js_free_function_def(ctx, fd1);
}
free_bytecode_atoms(ctx->rt, fd->byte_code.buf, fd->byte_code.size,
fd->use_short_opcodes);
dbuf_free(&fd->byte_code);
js_free(ctx, fd->jump_slots);
js_free(ctx, fd->label_slots);
js_free(ctx, fd->source_loc_slots);
/* free ic */
if (fd->ic)
free_ic(ctx->rt, fd->ic);
for(i = 0; i < fd->cpool_count; i++) {
JS_FreeValue(ctx, fd->cpool[i]);
}
js_free(ctx, fd->cpool);
JS_FreeAtom(ctx, fd->func_name);
for(i = 0; i < fd->var_count; i++) {
JS_FreeAtom(ctx, fd->vars[i].var_name);
}
js_free(ctx, fd->vars);
js_free(ctx, fd->vars_htab); // XXX can probably be freed earlier?
for(i = 0; i < fd->arg_count; i++) {
JS_FreeAtom(ctx, fd->args[i].var_name);
}
js_free(ctx, fd->args);
for(i = 0; i < fd->global_var_count; i++) {
JS_FreeAtom(ctx, fd->global_vars[i].var_name);
}
js_free(ctx, fd->global_vars);
for(i = 0; i < fd->closure_var_count; i++) {
JSClosureVar *cv = &fd->closure_var[i];
JS_FreeAtom(ctx, cv->var_name);
}
js_free(ctx, fd->closure_var);
if (fd->scopes != fd->def_scope_array)
js_free(ctx, fd->scopes);
JS_FreeAtom(ctx, fd->filename);
dbuf_free(&fd->pc2line);
js_free(ctx, fd->source);
if (fd->parent) {
/* remove in parent list */
list_del(&fd->link);
}
js_free(ctx, fd);
} | O2 | c | js_free_function_def:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsi), %r15
movq 0x20(%rsi), %rsi
cmpq %r15, %rsi
je 0x4af58
movq 0x8(%rsi), %r12
addq $-0x28, %rsi
movq %r14, %rdi
callq 0x4af28
movq %r12, %rsi
jmp 0x4af3e
movq 0x18(%r14), %rdi
leaq 0x138(%rbx), %r15
movq 0x138(%rbx), %rsi
movl 0x140(%rbx), %edx
movl 0x16c(%rbx), %ecx
callq 0x34a5c
movq %r15, %rdi
callq 0x1530d
movq 0x1a8(%rbx), %rsi
movq %r14, %rdi
callq 0x166f2
movq 0x170(%rbx), %rsi
movq %r14, %rdi
callq 0x166f2
movq 0x1b8(%rbx), %rsi
movq %r14, %rdi
callq 0x166f2
movq 0x230(%rbx), %rsi
testq %rsi, %rsi
je 0x4afc5
movq 0x18(%r14), %rdi
callq 0x34acf
pushq $0x8
popq %r15
xorl %r12d, %r12d
movslq 0x190(%rbx), %rax
movq 0x188(%rbx), %rsi
cmpq %rax, %r12
jge 0x4affc
movq -0x8(%rsi,%r15), %rax
movq (%rsi,%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x174a2
incq %r12
addq $0x10, %r15
jmp 0x4afcc
movq %r14, %rdi
callq 0x166f2
movl 0x88(%rbx), %esi
movq %r14, %rdi
callq 0x19e19
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0xa4(%rbx), %rax
movq 0x90(%rbx), %rsi
cmpq %rax, %r12
jge 0x4b040
movl (%rsi,%r15), %esi
movq %r14, %rdi
callq 0x19e19
incq %r12
addq $0x10, %r15
jmp 0x4b018
movq %r14, %rdi
callq 0x166f2
movq 0x98(%rbx), %rsi
movq %r14, %rdi
callq 0x166f2
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0xb4(%rbx), %rax
movq 0xa8(%rbx), %rsi
cmpq %rax, %r12
jge 0x4b085
movl (%rsi,%r15), %esi
movq %r14, %rdi
callq 0x19e19
incq %r12
addq $0x10, %r15
jmp 0x4b05d
movq %r14, %rdi
callq 0x166f2
pushq $0xc
popq %r15
xorl %r12d, %r12d
movslq 0x124(%rbx), %rax
movq 0x130(%rbx), %rsi
cmpq %rax, %r12
jge 0x4b0bc
movl (%rsi,%r15), %esi
movq %r14, %rdi
callq 0x19e19
incq %r12
addq $0x10, %r15
jmp 0x4b094
movq %r14, %rdi
callq 0x166f2
xorl %r15d, %r15d
movslq 0x198(%rbx), %rax
movq 0x1a0(%rbx), %rsi
cmpq %rax, %r15
jge 0x4b0ec
movl 0x4(%rsi,%r15,8), %esi
movq %r14, %rdi
callq 0x19e19
incq %r15
jmp 0x4b0c7
movq %r14, %rdi
callq 0x166f2
movq 0xf8(%rbx), %rsi
leaq 0x100(%rbx), %rax
cmpq %rax, %rsi
je 0x4b10f
movq %r14, %rdi
callq 0x166f2
movl 0x1d4(%rbx), %esi
movq %r14, %rdi
callq 0x19e19
leaq 0x1e0(%rbx), %rdi
callq 0x1530d
movq 0x210(%rbx), %rsi
movq %r14, %rdi
callq 0x166f2
cmpq $0x0, 0x8(%rbx)
je 0x4b155
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x166f2
| js_free_function_def:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
lea r15, [rsi+18h]
mov rsi, [rsi+20h]
loc_4AF3E:
cmp rsi, r15
jz short loc_4AF58
mov r12, [rsi+8]
add rsi, 0FFFFFFFFFFFFFFD8h
mov rdi, r14
call js_free_function_def
mov rsi, r12
jmp short loc_4AF3E
loc_4AF58:
mov rdi, [r14+18h]
lea r15, [rbx+138h]
mov rsi, [rbx+138h]
mov edx, [rbx+140h]
mov ecx, [rbx+16Ch]
call free_bytecode_atoms
mov rdi, r15
call dbuf_free
mov rsi, [rbx+1A8h]
mov rdi, r14
call js_free
mov rsi, [rbx+170h]
mov rdi, r14
call js_free
mov rsi, [rbx+1B8h]
mov rdi, r14
call js_free
mov rsi, [rbx+230h]
test rsi, rsi
jz short loc_4AFC5
mov rdi, [r14+18h]
call free_ic
loc_4AFC5:
push 8
pop r15
xor r12d, r12d
loc_4AFCC:
movsxd rax, dword ptr [rbx+190h]
mov rsi, [rbx+188h]
cmp r12, rax
jge short loc_4AFFC
mov rax, [rsi+r15-8]
mov rdx, [rsi+r15]
mov rdi, r14
mov rsi, rax
call JS_FreeValue
inc r12
add r15, 10h
jmp short loc_4AFCC
loc_4AFFC:
mov rdi, r14
call js_free
mov esi, [rbx+88h]
mov rdi, r14
call JS_FreeAtom
xor r15d, r15d
xor r12d, r12d
loc_4B018:
movsxd rax, dword ptr [rbx+0A4h]
mov rsi, [rbx+90h]
cmp r12, rax
jge short loc_4B040
mov esi, [rsi+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
add r15, 10h
jmp short loc_4B018
loc_4B040:
mov rdi, r14
call js_free
mov rsi, [rbx+98h]
mov rdi, r14
call js_free
xor r15d, r15d
xor r12d, r12d
loc_4B05D:
movsxd rax, dword ptr [rbx+0B4h]
mov rsi, [rbx+0A8h]
cmp r12, rax
jge short loc_4B085
mov esi, [rsi+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
add r15, 10h
jmp short loc_4B05D
loc_4B085:
mov rdi, r14
call js_free
push 0Ch
pop r15
xor r12d, r12d
loc_4B094:
movsxd rax, dword ptr [rbx+124h]
mov rsi, [rbx+130h]
cmp r12, rax
jge short loc_4B0BC
mov esi, [rsi+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
add r15, 10h
jmp short loc_4B094
loc_4B0BC:
mov rdi, r14
call js_free
xor r15d, r15d
loc_4B0C7:
movsxd rax, dword ptr [rbx+198h]
mov rsi, [rbx+1A0h]
cmp r15, rax
jge short loc_4B0EC
mov esi, [rsi+r15*8+4]
mov rdi, r14
call JS_FreeAtom
inc r15
jmp short loc_4B0C7
loc_4B0EC:
mov rdi, r14
call js_free
mov rsi, [rbx+0F8h]
lea rax, [rbx+100h]
cmp rsi, rax
jz short loc_4B10F
mov rdi, r14
call js_free
loc_4B10F:
mov esi, [rbx+1D4h]
mov rdi, r14
call JS_FreeAtom
lea rdi, [rbx+1E0h]
call dbuf_free
mov rsi, [rbx+210h]
mov rdi, r14
call js_free
cmp qword ptr [rbx+8], 0
jz short loc_4B155
mov rax, [rbx+28h]
mov rcx, [rbx+30h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+28h], xmm0
loc_4B155:
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp js_free
| long long js_free_function_def(long long a1, long long a2)
{
long long v3; // r15
long long i; // rsi
long long v5; // r12
unsigned int *v6; // rsi
long long v7; // r15
long long j; // r12
long long v9; // rsi
long long v10; // r15
long long k; // r12
long long v12; // rsi
long long v13; // r15
long long m; // r12
long long v15; // rsi
long long v16; // r15
long long n; // r12
long long v18; // rsi
long long ii; // r15
long long v20; // rsi
long long v21; // rsi
long long v22; // rax
_QWORD *v23; // rcx
v3 = a2 + 24;
for ( i = *(_QWORD *)(a2 + 32); i != v3; i = v5 )
{
v5 = *(_QWORD *)(i + 8);
js_free_function_def(a1, i - 40);
}
free_bytecode_atoms(*(_QWORD *)(a1 + 24), *(_QWORD *)(a2 + 312), *(_DWORD *)(a2 + 320), *(_DWORD *)(a2 + 364));
dbuf_free(a2 + 312);
js_free(a1, *(_QWORD *)(a2 + 424));
js_free(a1, *(_QWORD *)(a2 + 368));
js_free(a1, *(_QWORD *)(a2 + 440));
v6 = *(unsigned int **)(a2 + 560);
if ( v6 )
free_ic(*(_QWORD *)(a1 + 24), v6);
v7 = 8LL;
for ( j = 0LL; ; ++j )
{
v9 = *(_QWORD *)(a2 + 392);
if ( j >= *(int *)(a2 + 400) )
break;
JS_FreeValue(a1, *(_QWORD *)(v9 + v7 - 8), *(_QWORD *)(v9 + v7));
v7 += 16LL;
}
js_free(a1, v9);
JS_FreeAtom(a1, *(_DWORD *)(a2 + 136));
v10 = 0LL;
for ( k = 0LL; ; ++k )
{
v12 = *(_QWORD *)(a2 + 144);
if ( k >= *(int *)(a2 + 164) )
break;
JS_FreeAtom(a1, *(_DWORD *)(v12 + v10));
v10 += 16LL;
}
js_free(a1, v12);
js_free(a1, *(_QWORD *)(a2 + 152));
v13 = 0LL;
for ( m = 0LL; ; ++m )
{
v15 = *(_QWORD *)(a2 + 168);
if ( m >= *(int *)(a2 + 180) )
break;
JS_FreeAtom(a1, *(_DWORD *)(v15 + v13));
v13 += 16LL;
}
js_free(a1, v15);
v16 = 12LL;
for ( n = 0LL; ; ++n )
{
v18 = *(_QWORD *)(a2 + 304);
if ( n >= *(int *)(a2 + 292) )
break;
JS_FreeAtom(a1, *(_DWORD *)(v18 + v16));
v16 += 16LL;
}
js_free(a1, v18);
for ( ii = 0LL; ; ++ii )
{
v20 = *(_QWORD *)(a2 + 416);
if ( ii >= *(int *)(a2 + 408) )
break;
JS_FreeAtom(a1, *(_DWORD *)(v20 + 8 * ii + 4));
}
js_free(a1, v20);
v21 = *(_QWORD *)(a2 + 248);
if ( v21 != a2 + 256 )
js_free(a1, v21);
JS_FreeAtom(a1, *(_DWORD *)(a2 + 468));
dbuf_free(a2 + 480);
js_free(a1, *(_QWORD *)(a2 + 528));
if ( *(_QWORD *)(a2 + 8) )
{
v22 = *(_QWORD *)(a2 + 40);
v23 = *(_QWORD **)(a2 + 48);
*(_QWORD *)(v22 + 8) = v23;
*v23 = v22;
*(_OWORD *)(a2 + 40) = 0LL;
}
return js_free(a1, a2);
}
| js_free_function_def:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
LEA R15,[RSI + 0x18]
MOV RSI,qword ptr [RSI + 0x20]
LAB_0014af3e:
CMP RSI,R15
JZ 0x0014af58
MOV R12,qword ptr [RSI + 0x8]
ADD RSI,-0x28
MOV RDI,R14
CALL 0x0014af28
MOV RSI,R12
JMP 0x0014af3e
LAB_0014af58:
MOV RDI,qword ptr [R14 + 0x18]
LEA R15,[RBX + 0x138]
MOV RSI,qword ptr [RBX + 0x138]
MOV EDX,dword ptr [RBX + 0x140]
MOV ECX,dword ptr [RBX + 0x16c]
CALL 0x00134a5c
MOV RDI,R15
CALL 0x0011530d
MOV RSI,qword ptr [RBX + 0x1a8]
MOV RDI,R14
CALL 0x001166f2
MOV RSI,qword ptr [RBX + 0x170]
MOV RDI,R14
CALL 0x001166f2
MOV RSI,qword ptr [RBX + 0x1b8]
MOV RDI,R14
CALL 0x001166f2
MOV RSI,qword ptr [RBX + 0x230]
TEST RSI,RSI
JZ 0x0014afc5
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x00134acf
LAB_0014afc5:
PUSH 0x8
POP R15
XOR R12D,R12D
LAB_0014afcc:
MOVSXD RAX,dword ptr [RBX + 0x190]
MOV RSI,qword ptr [RBX + 0x188]
CMP R12,RAX
JGE 0x0014affc
MOV RAX,qword ptr [RSI + R15*0x1 + -0x8]
MOV RDX,qword ptr [RSI + R15*0x1]
MOV RDI,R14
MOV RSI,RAX
CALL 0x001174a2
INC R12
ADD R15,0x10
JMP 0x0014afcc
LAB_0014affc:
MOV RDI,R14
CALL 0x001166f2
MOV ESI,dword ptr [RBX + 0x88]
MOV RDI,R14
CALL 0x00119e19
XOR R15D,R15D
XOR R12D,R12D
LAB_0014b018:
MOVSXD RAX,dword ptr [RBX + 0xa4]
MOV RSI,qword ptr [RBX + 0x90]
CMP R12,RAX
JGE 0x0014b040
MOV ESI,dword ptr [RSI + R15*0x1]
MOV RDI,R14
CALL 0x00119e19
INC R12
ADD R15,0x10
JMP 0x0014b018
LAB_0014b040:
MOV RDI,R14
CALL 0x001166f2
MOV RSI,qword ptr [RBX + 0x98]
MOV RDI,R14
CALL 0x001166f2
XOR R15D,R15D
XOR R12D,R12D
LAB_0014b05d:
MOVSXD RAX,dword ptr [RBX + 0xb4]
MOV RSI,qword ptr [RBX + 0xa8]
CMP R12,RAX
JGE 0x0014b085
MOV ESI,dword ptr [RSI + R15*0x1]
MOV RDI,R14
CALL 0x00119e19
INC R12
ADD R15,0x10
JMP 0x0014b05d
LAB_0014b085:
MOV RDI,R14
CALL 0x001166f2
PUSH 0xc
POP R15
XOR R12D,R12D
LAB_0014b094:
MOVSXD RAX,dword ptr [RBX + 0x124]
MOV RSI,qword ptr [RBX + 0x130]
CMP R12,RAX
JGE 0x0014b0bc
MOV ESI,dword ptr [RSI + R15*0x1]
MOV RDI,R14
CALL 0x00119e19
INC R12
ADD R15,0x10
JMP 0x0014b094
LAB_0014b0bc:
MOV RDI,R14
CALL 0x001166f2
XOR R15D,R15D
LAB_0014b0c7:
MOVSXD RAX,dword ptr [RBX + 0x198]
MOV RSI,qword ptr [RBX + 0x1a0]
CMP R15,RAX
JGE 0x0014b0ec
MOV ESI,dword ptr [RSI + R15*0x8 + 0x4]
MOV RDI,R14
CALL 0x00119e19
INC R15
JMP 0x0014b0c7
LAB_0014b0ec:
MOV RDI,R14
CALL 0x001166f2
MOV RSI,qword ptr [RBX + 0xf8]
LEA RAX,[RBX + 0x100]
CMP RSI,RAX
JZ 0x0014b10f
MOV RDI,R14
CALL 0x001166f2
LAB_0014b10f:
MOV ESI,dword ptr [RBX + 0x1d4]
MOV RDI,R14
CALL 0x00119e19
LEA RDI,[RBX + 0x1e0]
CALL 0x0011530d
MOV RSI,qword ptr [RBX + 0x210]
MOV RDI,R14
CALL 0x001166f2
CMP qword ptr [RBX + 0x8],0x0
JZ 0x0014b155
MOV RAX,qword ptr [RBX + 0x28]
MOV RCX,qword ptr [RBX + 0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x28],XMM0
LAB_0014b155:
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x001166f2
|
void js_free_function_def(long param_1,long param_2)
{
long *plVar1;
long lVar2;
long lVar3;
lVar3 = *(long *)(param_2 + 0x20);
while (lVar3 != param_2 + 0x18) {
lVar2 = *(long *)(lVar3 + 8);
js_free_function_def(param_1,lVar3 + -0x28);
lVar3 = lVar2;
}
free_bytecode_atoms(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x138),
*(int4 *)(param_2 + 0x140),*(int4 *)(param_2 + 0x16c));
dbuf_free(param_2 + 0x138);
js_free(param_1,*(int8 *)(param_2 + 0x1a8));
js_free(param_1,*(int8 *)(param_2 + 0x170));
js_free(param_1,*(int8 *)(param_2 + 0x1b8));
if (*(long *)(param_2 + 0x230) != 0) {
free_ic(*(int8 *)(param_1 + 0x18));
}
lVar3 = 8;
for (lVar2 = 0; lVar2 < *(int *)(param_2 + 400); lVar2 = lVar2 + 1) {
JS_FreeValue(param_1,*(int8 *)(*(long *)(param_2 + 0x188) + -8 + lVar3),
*(int8 *)(*(long *)(param_2 + 0x188) + lVar3));
lVar3 = lVar3 + 0x10;
}
js_free(param_1);
JS_FreeAtom(param_1,*(int4 *)(param_2 + 0x88));
lVar2 = 0;
for (lVar3 = 0; lVar3 < *(int *)(param_2 + 0xa4); lVar3 = lVar3 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x90) + lVar2));
lVar2 = lVar2 + 0x10;
}
js_free(param_1);
js_free(param_1,*(int8 *)(param_2 + 0x98));
lVar2 = 0;
for (lVar3 = 0; lVar3 < *(int *)(param_2 + 0xb4); lVar3 = lVar3 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0xa8) + lVar2));
lVar2 = lVar2 + 0x10;
}
js_free(param_1);
lVar3 = 0xc;
for (lVar2 = 0; lVar2 < *(int *)(param_2 + 0x124); lVar2 = lVar2 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x130) + lVar3));
lVar3 = lVar3 + 0x10;
}
js_free(param_1);
for (lVar3 = 0; lVar3 < *(int *)(param_2 + 0x198); lVar3 = lVar3 + 1) {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x1a0) + 4 + lVar3 * 8));
}
js_free(param_1);
if (*(long *)(param_2 + 0xf8) != param_2 + 0x100) {
js_free(param_1);
}
JS_FreeAtom(param_1,*(int4 *)(param_2 + 0x1d4));
dbuf_free(param_2 + 0x1e0);
js_free(param_1,*(int8 *)(param_2 + 0x210));
if (*(long *)(param_2 + 8) != 0) {
lVar3 = *(long *)(param_2 + 0x28);
plVar1 = *(long **)(param_2 + 0x30);
*(long **)(lVar3 + 8) = plVar1;
*plVar1 = lVar3;
*(int8 *)(param_2 + 0x28) = 0;
*(int8 *)(param_2 + 0x30) = 0;
}
js_free(param_1,param_2);
return;
}
| |
39,416 | js_free_function_def | bluesky950520[P]quickjs/quickjs.c | static void js_free_function_def(JSContext *ctx, JSFunctionDef *fd)
{
int i;
struct list_head *el, *el1;
/* free the child functions */
list_for_each_safe(el, el1, &fd->child_list) {
JSFunctionDef *fd1;
fd1 = list_entry(el, JSFunctionDef, link);
js_free_function_def(ctx, fd1);
}
free_bytecode_atoms(ctx->rt, fd->byte_code.buf, fd->byte_code.size,
fd->use_short_opcodes);
dbuf_free(&fd->byte_code);
js_free(ctx, fd->jump_slots);
js_free(ctx, fd->label_slots);
js_free(ctx, fd->source_loc_slots);
/* free ic */
if (fd->ic)
free_ic(ctx->rt, fd->ic);
for(i = 0; i < fd->cpool_count; i++) {
JS_FreeValue(ctx, fd->cpool[i]);
}
js_free(ctx, fd->cpool);
JS_FreeAtom(ctx, fd->func_name);
for(i = 0; i < fd->var_count; i++) {
JS_FreeAtom(ctx, fd->vars[i].var_name);
}
js_free(ctx, fd->vars);
js_free(ctx, fd->vars_htab); // XXX can probably be freed earlier?
for(i = 0; i < fd->arg_count; i++) {
JS_FreeAtom(ctx, fd->args[i].var_name);
}
js_free(ctx, fd->args);
for(i = 0; i < fd->global_var_count; i++) {
JS_FreeAtom(ctx, fd->global_vars[i].var_name);
}
js_free(ctx, fd->global_vars);
for(i = 0; i < fd->closure_var_count; i++) {
JSClosureVar *cv = &fd->closure_var[i];
JS_FreeAtom(ctx, cv->var_name);
}
js_free(ctx, fd->closure_var);
if (fd->scopes != fd->def_scope_array)
js_free(ctx, fd->scopes);
JS_FreeAtom(ctx, fd->filename);
dbuf_free(&fd->pc2line);
js_free(ctx, fd->source);
if (fd->parent) {
/* remove in parent list */
list_del(&fd->link);
}
js_free(ctx, fd);
} | O3 | c | js_free_function_def:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsi), %r15
movq 0x20(%rsi), %rsi
cmpq %r15, %rsi
je 0x5aa25
movq 0x8(%rsi), %r12
addq $-0x28, %rsi
movq %r14, %rdi
callq 0x5a9f2
movq %r12, %rsi
cmpq %r15, %r12
jne 0x5aa0d
movq 0x18(%r14), %rdi
leaq 0x138(%rbx), %r15
movq 0x138(%rbx), %rsi
movl 0x140(%rbx), %edx
movl 0x16c(%rbx), %ecx
callq 0x3d3f2
movq %r15, %rdi
callq 0x1b31f
movq 0x1a8(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x170(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x1b8(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x230(%rbx), %rsi
testq %rsi, %rsi
je 0x5aa92
movq 0x18(%r14), %rdi
callq 0x3d488
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x5aae6
movl $0x8, %r15d
xorl %r12d, %r12d
movq 0x188(%rbx), %rcx
movq (%rcx,%r15), %rdx
cmpl $-0x9, %edx
jb 0x5aad7
movq -0x8(%rcx,%r15), %rsi
movq 0x18(%r14), %rdi
movl (%rsi), %ecx
leal -0x1(%rcx), %r8d
movl %r8d, (%rsi)
cmpl $0x1, %ecx
jg 0x5aad7
callq 0x20d90
movl 0x190(%rbx), %eax
incq %r12
movslq %eax, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jl 0x5aaa5
movq 0x188(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movl 0x88(%rbx), %esi
movq %r14, %rdi
callq 0x202f5
cmpl $0x0, 0xa4(%rbx)
jle 0x5ab38
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x90(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x202f5
incq %r12
movslq 0xa4(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x5ab12
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0x98(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
cmpl $0x0, 0xb4(%rbx)
jle 0x5ab8b
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0xa8(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x202f5
incq %r12
movslq 0xb4(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x5ab65
movq 0xa8(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
cmpl $0x0, 0x124(%rbx)
jle 0x5abd2
movl $0xc, %r15d
xorl %r12d, %r12d
movq 0x130(%rbx), %rax
movl (%rax,%r15), %esi
movq %r14, %rdi
callq 0x202f5
incq %r12
movslq 0x124(%rbx), %rax
addq $0x10, %r15
cmpq %rax, %r12
jl 0x5abac
movq 0x130(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
cmpl $0x0, 0x198(%rbx)
jle 0x5ac10
xorl %r15d, %r15d
movq 0x1a0(%rbx), %rax
movl 0x4(%rax,%r15,8), %esi
movq %r14, %rdi
callq 0x202f5
incq %r15
movslq 0x198(%rbx), %rax
cmpq %rax, %r15
jl 0x5abed
movq 0x1a0(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
movq 0xf8(%rbx), %rsi
leaq 0x100(%rbx), %rax
cmpq %rax, %rsi
je 0x5ac3a
movq %r14, %rdi
callq 0x1c845
movl 0x1d4(%rbx), %esi
movq %r14, %rdi
callq 0x202f5
leaq 0x1e0(%rbx), %rdi
callq 0x1b31f
movq 0x210(%rbx), %rsi
movq %r14, %rdi
callq 0x1c845
cmpq $0x0, 0x8(%rbx)
je 0x5ac80
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1c845
| js_free_function_def:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
lea r15, [rsi+18h]
mov rsi, [rsi+20h]
cmp rsi, r15
jz short loc_5AA25
loc_5AA0D:
mov r12, [rsi+8]
add rsi, 0FFFFFFFFFFFFFFD8h
mov rdi, r14
call js_free_function_def
mov rsi, r12
cmp r12, r15
jnz short loc_5AA0D
loc_5AA25:
mov rdi, [r14+18h]
lea r15, [rbx+138h]
mov rsi, [rbx+138h]
mov edx, [rbx+140h]
mov ecx, [rbx+16Ch]
call free_bytecode_atoms
mov rdi, r15
call dbuf_free
mov rsi, [rbx+1A8h]
mov rdi, r14
call js_free
mov rsi, [rbx+170h]
mov rdi, r14
call js_free
mov rsi, [rbx+1B8h]
mov rdi, r14
call js_free
mov rsi, [rbx+230h]
test rsi, rsi
jz short loc_5AA92
mov rdi, [r14+18h]
call free_ic
loc_5AA92:
mov eax, [rbx+190h]
test eax, eax
jle short loc_5AAE6
mov r15d, 8
xor r12d, r12d
loc_5AAA5:
mov rcx, [rbx+188h]
mov rdx, [rcx+r15]
cmp edx, 0FFFFFFF7h
jb short loc_5AAD7
mov rsi, [rcx+r15-8]
mov rdi, [r14+18h]
mov ecx, [rsi]
lea r8d, [rcx-1]
mov [rsi], r8d
cmp ecx, 1
jg short loc_5AAD7
call js_free_value_rt
mov eax, [rbx+190h]
loc_5AAD7:
inc r12
movsxd rcx, eax
add r15, 10h
cmp r12, rcx
jl short loc_5AAA5
loc_5AAE6:
mov rsi, [rbx+188h]
mov rdi, r14
call js_free
mov esi, [rbx+88h]
mov rdi, r14
call JS_FreeAtom
cmp dword ptr [rbx+0A4h], 0
jle short loc_5AB38
xor r15d, r15d
xor r12d, r12d
loc_5AB12:
mov rax, [rbx+90h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+0A4h]
add r15, 10h
cmp r12, rax
jl short loc_5AB12
loc_5AB38:
mov rsi, [rbx+90h]
mov rdi, r14
call js_free
mov rsi, [rbx+98h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+0B4h], 0
jle short loc_5AB8B
xor r15d, r15d
xor r12d, r12d
loc_5AB65:
mov rax, [rbx+0A8h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+0B4h]
add r15, 10h
cmp r12, rax
jl short loc_5AB65
loc_5AB8B:
mov rsi, [rbx+0A8h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+124h], 0
jle short loc_5ABD2
mov r15d, 0Ch
xor r12d, r12d
loc_5ABAC:
mov rax, [rbx+130h]
mov esi, [rax+r15]
mov rdi, r14
call JS_FreeAtom
inc r12
movsxd rax, dword ptr [rbx+124h]
add r15, 10h
cmp r12, rax
jl short loc_5ABAC
loc_5ABD2:
mov rsi, [rbx+130h]
mov rdi, r14
call js_free
cmp dword ptr [rbx+198h], 0
jle short loc_5AC10
xor r15d, r15d
loc_5ABED:
mov rax, [rbx+1A0h]
mov esi, [rax+r15*8+4]
mov rdi, r14
call JS_FreeAtom
inc r15
movsxd rax, dword ptr [rbx+198h]
cmp r15, rax
jl short loc_5ABED
loc_5AC10:
mov rsi, [rbx+1A0h]
mov rdi, r14
call js_free
mov rsi, [rbx+0F8h]
lea rax, [rbx+100h]
cmp rsi, rax
jz short loc_5AC3A
mov rdi, r14
call js_free
loc_5AC3A:
mov esi, [rbx+1D4h]
mov rdi, r14
call JS_FreeAtom
lea rdi, [rbx+1E0h]
call dbuf_free
mov rsi, [rbx+210h]
mov rdi, r14
call js_free
cmp qword ptr [rbx+8], 0
jz short loc_5AC80
mov rax, [rbx+28h]
mov rcx, [rbx+30h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+28h], xmm0
loc_5AC80:
mov rdi, r14
mov rsi, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp js_free
| long long js_free_function_def(long long a1, long long a2)
{
long long v4; // r15
long long v5; // rsi
long long v6; // r12
long long v7; // rdx
long long v8; // rcx
long long v9; // r8
long long v10; // r9
unsigned int *v11; // rsi
int v12; // eax
long long v13; // r15
long long i; // r12
long long v15; // rcx
long long v16; // rdx
_QWORD *v17; // rsi
long long v18; // rdi
long long v19; // rcx
long long v20; // r8
long long v21; // r15
long long v22; // r12
long long v23; // r15
long long v24; // r12
long long v25; // r15
long long v26; // r12
long long v27; // r15
long long v28; // rsi
long long v29; // rax
_QWORD *v30; // rcx
v4 = a2 + 24;
v5 = *(_QWORD *)(a2 + 32);
if ( v5 != v4 )
{
do
{
v6 = *(_QWORD *)(v5 + 8);
js_free_function_def(a1, v5 - 40);
v5 = v6;
}
while ( v6 != v4 );
}
free_bytecode_atoms(*(_QWORD *)(a1 + 24), *(_QWORD *)(a2 + 312), *(_DWORD *)(a2 + 320), *(_DWORD *)(a2 + 364));
dbuf_free(a2 + 312);
js_free(a1, *(_QWORD *)(a2 + 424));
js_free(a1, *(_QWORD *)(a2 + 368));
js_free(a1, *(_QWORD *)(a2 + 440));
v11 = *(unsigned int **)(a2 + 560);
if ( v11 )
free_ic(*(_QWORD *)(a1 + 24), v11, v7, v8, v9, v10);
v12 = *(_DWORD *)(a2 + 400);
if ( v12 > 0 )
{
v13 = 8LL;
for ( i = 0LL; i < v12; ++i )
{
v15 = *(_QWORD *)(a2 + 392);
v16 = *(_QWORD *)(v15 + v13);
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
{
v17 = *(_QWORD **)(v15 + v13 - 8);
v18 = *(_QWORD *)(a1 + 24);
v19 = *(unsigned int *)v17;
v20 = (unsigned int)(v19 - 1);
*(_DWORD *)v17 = v20;
if ( (int)v19 <= 1 )
{
js_free_value_rt(v18, v17, v16, v19, v20, v10);
v12 = *(_DWORD *)(a2 + 400);
}
}
v13 += 16LL;
}
}
js_free(a1, *(_QWORD *)(a2 + 392));
JS_FreeAtom(a1, *(_DWORD *)(a2 + 136));
if ( *(int *)(a2 + 164) > 0 )
{
v21 = 0LL;
v22 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 144) + v21));
++v22;
v21 += 16LL;
}
while ( v22 < *(int *)(a2 + 164) );
}
js_free(a1, *(_QWORD *)(a2 + 144));
js_free(a1, *(_QWORD *)(a2 + 152));
if ( *(int *)(a2 + 180) > 0 )
{
v23 = 0LL;
v24 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 168) + v23));
++v24;
v23 += 16LL;
}
while ( v24 < *(int *)(a2 + 180) );
}
js_free(a1, *(_QWORD *)(a2 + 168));
if ( *(int *)(a2 + 292) > 0 )
{
v25 = 12LL;
v26 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 304) + v25));
++v26;
v25 += 16LL;
}
while ( v26 < *(int *)(a2 + 292) );
}
js_free(a1, *(_QWORD *)(a2 + 304));
if ( *(int *)(a2 + 408) > 0 )
{
v27 = 0LL;
do
JS_FreeAtom(a1, *(_DWORD *)(*(_QWORD *)(a2 + 416) + 8 * v27++ + 4));
while ( v27 < *(int *)(a2 + 408) );
}
js_free(a1, *(_QWORD *)(a2 + 416));
v28 = *(_QWORD *)(a2 + 248);
if ( v28 != a2 + 256 )
js_free(a1, v28);
JS_FreeAtom(a1, *(_DWORD *)(a2 + 468));
dbuf_free(a2 + 480);
js_free(a1, *(_QWORD *)(a2 + 528));
if ( *(_QWORD *)(a2 + 8) )
{
v29 = *(_QWORD *)(a2 + 40);
v30 = *(_QWORD **)(a2 + 48);
*(_QWORD *)(v29 + 8) = v30;
*v30 = v29;
*(_OWORD *)(a2 + 40) = 0LL;
}
return js_free(a1, a2);
}
| js_free_function_def:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
LEA R15,[RSI + 0x18]
MOV RSI,qword ptr [RSI + 0x20]
CMP RSI,R15
JZ 0x0015aa25
LAB_0015aa0d:
MOV R12,qword ptr [RSI + 0x8]
ADD RSI,-0x28
MOV RDI,R14
CALL 0x0015a9f2
MOV RSI,R12
CMP R12,R15
JNZ 0x0015aa0d
LAB_0015aa25:
MOV RDI,qword ptr [R14 + 0x18]
LEA R15,[RBX + 0x138]
MOV RSI,qword ptr [RBX + 0x138]
MOV EDX,dword ptr [RBX + 0x140]
MOV ECX,dword ptr [RBX + 0x16c]
CALL 0x0013d3f2
MOV RDI,R15
CALL 0x0011b31f
MOV RSI,qword ptr [RBX + 0x1a8]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0x170]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0x1b8]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0x230]
TEST RSI,RSI
JZ 0x0015aa92
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0013d488
LAB_0015aa92:
MOV EAX,dword ptr [RBX + 0x190]
TEST EAX,EAX
JLE 0x0015aae6
MOV R15D,0x8
XOR R12D,R12D
LAB_0015aaa5:
MOV RCX,qword ptr [RBX + 0x188]
MOV RDX,qword ptr [RCX + R15*0x1]
CMP EDX,-0x9
JC 0x0015aad7
MOV RSI,qword ptr [RCX + R15*0x1 + -0x8]
MOV RDI,qword ptr [R14 + 0x18]
MOV ECX,dword ptr [RSI]
LEA R8D,[RCX + -0x1]
MOV dword ptr [RSI],R8D
CMP ECX,0x1
JG 0x0015aad7
CALL 0x00120d90
MOV EAX,dword ptr [RBX + 0x190]
LAB_0015aad7:
INC R12
MOVSXD RCX,EAX
ADD R15,0x10
CMP R12,RCX
JL 0x0015aaa5
LAB_0015aae6:
MOV RSI,qword ptr [RBX + 0x188]
MOV RDI,R14
CALL 0x0011c845
MOV ESI,dword ptr [RBX + 0x88]
MOV RDI,R14
CALL 0x001202f5
CMP dword ptr [RBX + 0xa4],0x0
JLE 0x0015ab38
XOR R15D,R15D
XOR R12D,R12D
LAB_0015ab12:
MOV RAX,qword ptr [RBX + 0x90]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x001202f5
INC R12
MOVSXD RAX,dword ptr [RBX + 0xa4]
ADD R15,0x10
CMP R12,RAX
JL 0x0015ab12
LAB_0015ab38:
MOV RSI,qword ptr [RBX + 0x90]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0x98]
MOV RDI,R14
CALL 0x0011c845
CMP dword ptr [RBX + 0xb4],0x0
JLE 0x0015ab8b
XOR R15D,R15D
XOR R12D,R12D
LAB_0015ab65:
MOV RAX,qword ptr [RBX + 0xa8]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x001202f5
INC R12
MOVSXD RAX,dword ptr [RBX + 0xb4]
ADD R15,0x10
CMP R12,RAX
JL 0x0015ab65
LAB_0015ab8b:
MOV RSI,qword ptr [RBX + 0xa8]
MOV RDI,R14
CALL 0x0011c845
CMP dword ptr [RBX + 0x124],0x0
JLE 0x0015abd2
MOV R15D,0xc
XOR R12D,R12D
LAB_0015abac:
MOV RAX,qword ptr [RBX + 0x130]
MOV ESI,dword ptr [RAX + R15*0x1]
MOV RDI,R14
CALL 0x001202f5
INC R12
MOVSXD RAX,dword ptr [RBX + 0x124]
ADD R15,0x10
CMP R12,RAX
JL 0x0015abac
LAB_0015abd2:
MOV RSI,qword ptr [RBX + 0x130]
MOV RDI,R14
CALL 0x0011c845
CMP dword ptr [RBX + 0x198],0x0
JLE 0x0015ac10
XOR R15D,R15D
LAB_0015abed:
MOV RAX,qword ptr [RBX + 0x1a0]
MOV ESI,dword ptr [RAX + R15*0x8 + 0x4]
MOV RDI,R14
CALL 0x001202f5
INC R15
MOVSXD RAX,dword ptr [RBX + 0x198]
CMP R15,RAX
JL 0x0015abed
LAB_0015ac10:
MOV RSI,qword ptr [RBX + 0x1a0]
MOV RDI,R14
CALL 0x0011c845
MOV RSI,qword ptr [RBX + 0xf8]
LEA RAX,[RBX + 0x100]
CMP RSI,RAX
JZ 0x0015ac3a
MOV RDI,R14
CALL 0x0011c845
LAB_0015ac3a:
MOV ESI,dword ptr [RBX + 0x1d4]
MOV RDI,R14
CALL 0x001202f5
LEA RDI,[RBX + 0x1e0]
CALL 0x0011b31f
MOV RSI,qword ptr [RBX + 0x210]
MOV RDI,R14
CALL 0x0011c845
CMP qword ptr [RBX + 0x8],0x0
JZ 0x0015ac80
MOV RAX,qword ptr [RBX + 0x28]
MOV RCX,qword ptr [RBX + 0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x28],XMM0
LAB_0015ac80:
MOV RDI,R14
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x0011c845
|
void js_free_function_def(long param_1,long param_2)
{
int iVar1;
int *piVar2;
int8 uVar3;
long *plVar4;
int iVar5;
long lVar6;
long lVar7;
lVar6 = *(long *)(param_2 + 0x20);
while (lVar6 != param_2 + 0x18) {
lVar7 = *(long *)(lVar6 + 8);
js_free_function_def(param_1,lVar6 + -0x28);
lVar6 = lVar7;
}
free_bytecode_atoms(*(int8 *)(param_1 + 0x18),*(int8 *)(param_2 + 0x138),
*(int4 *)(param_2 + 0x140),*(int4 *)(param_2 + 0x16c));
dbuf_free(param_2 + 0x138);
js_free(param_1,*(int8 *)(param_2 + 0x1a8));
js_free(param_1,*(int8 *)(param_2 + 0x170));
js_free(param_1,*(int8 *)(param_2 + 0x1b8));
if (*(long *)(param_2 + 0x230) != 0) {
free_ic(*(int8 *)(param_1 + 0x18));
}
iVar5 = *(int *)(param_2 + 400);
if (0 < iVar5) {
lVar7 = 8;
lVar6 = 0;
do {
if (0xfffffff6 < (uint)*(int8 *)(*(long *)(param_2 + 0x188) + lVar7)) {
piVar2 = *(int **)(*(long *)(param_2 + 0x188) + -8 + lVar7);
uVar3 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar2;
*piVar2 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar3);
iVar5 = *(int *)(param_2 + 400);
}
}
lVar6 = lVar6 + 1;
lVar7 = lVar7 + 0x10;
} while (lVar6 < iVar5);
}
js_free(param_1,*(int8 *)(param_2 + 0x188));
JS_FreeAtom(param_1,*(int4 *)(param_2 + 0x88));
if (0 < *(int *)(param_2 + 0xa4)) {
lVar7 = 0;
lVar6 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x90) + lVar7));
lVar6 = lVar6 + 1;
lVar7 = lVar7 + 0x10;
} while (lVar6 < *(int *)(param_2 + 0xa4));
}
js_free(param_1,*(int8 *)(param_2 + 0x90));
js_free(param_1,*(int8 *)(param_2 + 0x98));
if (0 < *(int *)(param_2 + 0xb4)) {
lVar7 = 0;
lVar6 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0xa8) + lVar7));
lVar6 = lVar6 + 1;
lVar7 = lVar7 + 0x10;
} while (lVar6 < *(int *)(param_2 + 0xb4));
}
js_free(param_1,*(int8 *)(param_2 + 0xa8));
if (0 < *(int *)(param_2 + 0x124)) {
lVar7 = 0xc;
lVar6 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x130) + lVar7));
lVar6 = lVar6 + 1;
lVar7 = lVar7 + 0x10;
} while (lVar6 < *(int *)(param_2 + 0x124));
}
js_free(param_1,*(int8 *)(param_2 + 0x130));
if (0 < *(int *)(param_2 + 0x198)) {
lVar6 = 0;
do {
JS_FreeAtom(param_1,*(int4 *)(*(long *)(param_2 + 0x1a0) + 4 + lVar6 * 8));
lVar6 = lVar6 + 1;
} while (lVar6 < *(int *)(param_2 + 0x198));
}
js_free(param_1,*(int8 *)(param_2 + 0x1a0));
if (*(long *)(param_2 + 0xf8) != param_2 + 0x100) {
js_free(param_1);
}
JS_FreeAtom(param_1,*(int4 *)(param_2 + 0x1d4));
dbuf_free(param_2 + 0x1e0);
js_free(param_1,*(int8 *)(param_2 + 0x210));
if (*(long *)(param_2 + 8) != 0) {
lVar6 = *(long *)(param_2 + 0x28);
plVar4 = *(long **)(param_2 + 0x30);
*(long **)(lVar6 + 8) = plVar4;
*plVar4 = lVar6;
*(int8 *)(param_2 + 0x28) = 0;
*(int8 *)(param_2 + 0x30) = 0;
}
js_free(param_1,param_2);
return;
}
| |
39,417 | normalize_dirname | eloqsql/mysys/mf_pack.c | size_t normalize_dirname(char *to, const char *from)
{
size_t length;
char buff[FN_REFLEN + 1];
DBUG_ENTER("normalize_dirname");
/*
Despite the name, this actually converts the name to the system's
format (TODO: name this properly).
*/
(void) intern_filename(buff, from);
length= strlen(buff); /* Fix that '/' is last */
if (length &&
#ifdef FN_DEVCHAR
buff[length - 1] != FN_DEVCHAR &&
#endif
buff[length - 1] != FN_LIBCHAR && buff[length - 1] != '/')
{
/* we need reserve 2 bytes for the trailing slash and the zero */
if (length >= sizeof (buff) - 1)
length= sizeof (buff) - 2;
buff[length]= FN_LIBCHAR;
buff[length + 1]= '\0';
}
length=cleanup_dirname(to, buff);
DBUG_RETURN(length);
} | O3 | c | normalize_dirname:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq -0x220(%rbp), %r14
movq %r14, %rdi
callq 0x4cbc1
movq %r14, %rdi
callq 0x26150
testq %rax, %rax
je 0x4cf17
cmpb $0x2f, -0x1(%rax,%r14)
je 0x4cf17
movl $0x1ff, %ecx # imm = 0x1FF
cmpq %rcx, %rax
cmovbq %rax, %rcx
movw $0x2f, -0x220(%rbp,%rcx)
leaq -0x220(%rbp), %rsi
movq %rbx, %rdi
callq 0x4cc57
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x4cf41
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
callq 0x263b0
| normalize_dirname:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 210h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea r14, [rbp+var_220]
mov rdi, r14
call intern_filename
mov rdi, r14
call _strlen
test rax, rax
jz short loc_4CF17
cmp byte ptr [rax+r14-1], 2Fh ; '/'
jz short loc_4CF17
mov ecx, 1FFh
cmp rax, rcx
cmovb rcx, rax
mov [rbp+rcx+var_220], 2Fh ; '/'
loc_4CF17:
lea rsi, [rbp+var_220]
mov rdi, rbx
call cleanup_dirname
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_4CF41
add rsp, 210h
pop rbx
pop r14
pop rbp
retn
loc_4CF41:
call ___stack_chk_fail
| long long normalize_dirname(long long a1, _BYTE *a2)
{
unsigned long long v2; // rax
long long v3; // rcx
unsigned __int8 v5[520]; // [rsp+0h] [rbp-220h] BYREF
unsigned long long v6; // [rsp+208h] [rbp-18h]
v6 = __readfsqword(0x28u);
intern_filename((long long)v5, a2);
v2 = strlen(v5);
if ( v2 && v5[v2 - 1] != 47 )
{
v3 = 511LL;
if ( v2 < 0x1FF )
v3 = v2;
*(_WORD *)&v5[v3] = 47;
}
return cleanup_dirname(a1, v5);
}
| normalize_dirname:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x210
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA R14,[RBP + -0x220]
MOV RDI,R14
CALL 0x0014cbc1
MOV RDI,R14
CALL 0x00126150
TEST RAX,RAX
JZ 0x0014cf17
CMP byte ptr [RAX + R14*0x1 + -0x1],0x2f
JZ 0x0014cf17
MOV ECX,0x1ff
CMP RAX,RCX
CMOVC RCX,RAX
MOV word ptr [RBP + RCX*0x1 + -0x220],0x2f
LAB_0014cf17:
LEA RSI,[RBP + -0x220]
MOV RDI,RBX
CALL 0x0014cc57
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0014cf41
ADD RSP,0x210
POP RBX
POP R14
POP RBP
RET
LAB_0014cf41:
CALL 0x001263b0
|
void normalize_dirname(int8 param_1)
{
size_t sVar1;
size_t sVar2;
long in_FS_OFFSET;
int8 uStack_230;
char local_228 [520];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
uStack_230 = (code *)0x14ceec;
intern_filename(local_228);
uStack_230 = (code *)0x14cef4;
sVar1 = strlen(local_228);
if ((sVar1 != 0) && (local_228[sVar1 - 1] != '/')) {
sVar2 = 0x1ff;
if (sVar1 < 0x1ff) {
sVar2 = sVar1;
}
(local_228 + sVar2)[0] = '/';
(local_228 + sVar2)[1] = '\0';
}
uStack_230 = (code *)0x14cf26;
cleanup_dirname(param_1,local_228);
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return;
}
/* WARNING: Subroutine does not return */
uStack_230 = unpack_dirname;
__stack_chk_fail();
}
| |
39,418 | GASymbolTable::findSymbol(QString, bool) | goodasm/gasymboltable.cpp | GASymbol* GASymbolTable::findSymbol(QString name, bool autogen){
//Don't match on register names as if they were symbols.
assert(lang);
if(lang->regnames.contains(name))
return 0;
if(!table.contains(name)){
table[name]=new GASymbol(name);
table[name]->referenced=autogen; // Never used it.
table[name]->defined=false; // Never yet set.
}
return table[name];
} | O0 | cpp | GASymbolTable::findSymbol(QString, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x58(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, (%rax)
je 0x234be
jmp 0x234dd
leaq 0xee3eb(%rip), %rdi # 0x1118b0
leaq 0xed5c3(%rip), %rsi # 0x110a8f
movl $0x47, %edx
leaq 0xed63d(%rip), %rcx # 0x110b15
callq 0x70e0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rax
movq (%rax), %rdi
addq $0x48, %rdi
movl $0x1, %edx
callq 0x243f0
testb $0x1, %al
jne 0x234fc
jmp 0x23509
movq $0x0, -0x8(%rbp)
jmp 0x23609
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x24450
testb $0x1, %al
jne 0x235f1
movl $0x28, %edi
callq 0x74d0
movq -0x58(%rbp), %rsi
movq %rax, -0x68(%rbp)
movq %rax, -0x70(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xe8f0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x22fa0
jmp 0x23558
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movb $0x0, -0x45(%rbp)
addq $0x8, %rdi
callq 0x244d0
movq %rax, -0x78(%rbp)
jmp 0x23573
movq -0x78(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x38(%rbp), %rdi
callq 0xe770
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movb -0x19(%rbp), %al
movb %al, -0x79(%rbp)
addq $0x8, %rdi
callq 0x244d0
movb -0x79(%rbp), %cl
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rax), %rax
andb $0x1, %cl
movb %cl, 0x21(%rax)
addq $0x8, %rdi
callq 0x244d0
movq (%rax), %rax
movb $0x0, 0x20(%rax)
jmp 0x235f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe770
testb $0x1, -0x45(%rbp)
jne 0x235e1
jmp 0x235ef
movq -0x70(%rbp), %rdi
movl $0x28, %esi
callq 0x70a0
jmp 0x23616
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x244d0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7210
nop
| _ZN13GASymbolTable10findSymbolE7QStringb:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_58], rsi
mov al, dl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
and al, 1
mov [rbp+var_19], al
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
cmp qword ptr [rax], 0
jz short loc_234BE
jmp short loc_234DD
loc_234BE:
lea rdi, aGoodasmLang+9; "lang"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/goodas"...
mov edx, 47h ; 'G'
lea rcx, aGasymbolGasymb_0; "GASymbol *GASymbolTable::findSymbol(QSt"...
call ___assert_fail
loc_234DD:
mov rsi, [rbp+var_58]
mov rax, [rbp+var_50]
mov rdi, [rax]
add rdi, 48h ; 'H'
mov edx, 1
call _ZNK19QListSpecialMethodsI7QStringE8containsERKS0_N2Qt15CaseSensitivityE; QListSpecialMethods<QString>::contains(QString const&,Qt::CaseSensitivity)
test al, 1
jnz short loc_234FC
jmp short loc_23509
loc_234FC:
mov [rbp+var_8], 0
jmp loc_23609
loc_23509:
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_50]
add rdi, 8
call _ZNK4QMapI7QStringP8GASymbolE8containsERKS0_; QMap<QString,GASymbol *>::contains(QString const&)
test al, 1
jnz loc_235F1
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, [rbp+var_58]; QString *
mov [rbp+var_68], rax
mov [rbp+var_70], rax
mov [rbp+var_45], 1
lea rdi, [rbp+var_38]; this
mov [rbp+var_60], rdi
call _ZN7QStringC2ERKS_; QString::QString(QString const&)
mov rdi, [rbp+var_68]
mov rsi, [rbp+var_60]
call _ZN8GASymbolC2E7QString; GASymbol::GASymbol(QString)
jmp short $+2
loc_23558:
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_50]
mov [rbp+var_45], 0
add rdi, 8
call _ZN4QMapI7QStringP8GASymbolEixERKS0_; QMap<QString,GASymbol *>::operator[](QString const&)
mov [rbp+var_78], rax
jmp short $+2
loc_23573:
mov rax, [rbp+var_78]
mov rcx, [rbp+var_70]
mov [rax], rcx
lea rdi, [rbp+var_38]; this
call _ZN7QStringD2Ev; QString::~QString()
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_58]
mov al, [rbp+var_19]
mov [rbp+var_79], al
add rdi, 8
call _ZN4QMapI7QStringP8GASymbolEixERKS0_; QMap<QString,GASymbol *>::operator[](QString const&)
mov cl, [rbp+var_79]
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_58]
mov rax, [rax]
and cl, 1
mov [rax+21h], cl
add rdi, 8
call _ZN4QMapI7QStringP8GASymbolEixERKS0_; QMap<QString,GASymbol *>::operator[](QString const&)
mov rax, [rax]
mov byte ptr [rax+20h], 0
jmp short loc_235F1
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
lea rdi, [rbp+var_38]; this
call _ZN7QStringD2Ev; QString::~QString()
test [rbp+var_45], 1
jnz short loc_235E1
jmp short loc_235EF
loc_235E1:
mov rdi, [rbp+var_70]; void *
mov esi, 28h ; '('; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_235EF:
jmp short loc_23616
loc_235F1:
mov rsi, [rbp+var_58]
mov rdi, [rbp+var_50]
add rdi, 8
call _ZN4QMapI7QStringP8GASymbolEixERKS0_; QMap<QString,GASymbol *>::operator[](QString const&)
mov rax, [rax]
mov [rbp+var_8], rax
loc_23609:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
loc_23616:
mov rdi, [rbp+var_40]
call __Unwind_Resume
| long long GASymbolTable::findSymbol(_QWORD *a1, const QString *a2, char a3)
{
char v4; // [rsp+7h] [rbp-79h]
void *v5; // [rsp+10h] [rbp-70h]
_BYTE v6[31]; // [rsp+48h] [rbp-38h] BYREF
char v7; // [rsp+67h] [rbp-19h]
const QString *v8; // [rsp+68h] [rbp-18h]
_QWORD *v9; // [rsp+70h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3 & 1;
if ( !*a1 )
__assert_fail(
"lang",
"/workspace/llm4binary/github2025/goodasm/gasymboltable.cpp",
71LL,
"GASymbol *GASymbolTable::findSymbol(QString, bool)");
if ( (QListSpecialMethods<QString>::contains(*a1 + 72LL, a2, 1LL) & 1) != 0 )
return 0LL;
if ( (QMap<QString,GASymbol *>::contains(a1 + 1, a2) & 1) == 0 )
{
v5 = (void *)operator new(0x28uLL);
QString::QString((QString *)v6, a2);
GASymbol::GASymbol((long long)v5, (long long)v6);
*(_QWORD *)QMap<QString,GASymbol *>::operator[](a1 + 1, a2) = v5;
QString::~QString((QString *)v6);
v4 = v7;
*(_BYTE *)(*(_QWORD *)QMap<QString,GASymbol *>::operator[](a1 + 1, a2) + 33LL) = v4 & 1;
*(_BYTE *)(*(_QWORD *)QMap<QString,GASymbol *>::operator[](a1 + 1, a2) + 32LL) = 0;
}
return *(_QWORD *)QMap<QString,GASymbol *>::operator[](a1 + 1, a2);
}
| findSymbol:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x58],RSI
MOV AL,DL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RAX],0x0
JZ 0x001234be
JMP 0x001234dd
LAB_001234be:
LEA RDI,[0x2118b0]
LEA RSI,[0x210a8f]
MOV EDX,0x47
LEA RCX,[0x210b15]
CALL 0x001070e0
LAB_001234dd:
MOV RSI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RAX]
ADD RDI,0x48
MOV EDX,0x1
CALL 0x001243f0
TEST AL,0x1
JNZ 0x001234fc
JMP 0x00123509
LAB_001234fc:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00123609
LAB_00123509:
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x8
CALL 0x00124450
TEST AL,0x1
JNZ 0x001235f1
MOV EDI,0x28
CALL 0x001074d0
MOV RSI,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x68],RAX
MOV qword ptr [RBP + -0x70],RAX
MOV byte ptr [RBP + -0x45],0x1
LEA RDI,[RBP + -0x38]
MOV qword ptr [RBP + -0x60],RDI
CALL 0x0010e8f0
MOV RDI,qword ptr [RBP + -0x68]
MOV RSI,qword ptr [RBP + -0x60]
LAB_00123551:
CALL 0x00122fa0
JMP 0x00123558
LAB_00123558:
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0x45],0x0
ADD RDI,0x8
CALL 0x001244d0
LAB_0012356d:
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00123573
LAB_00123573:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x70]
MOV qword ptr [RAX],RCX
LEA RDI,[RBP + -0x38]
CALL 0x0010e770
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x58]
MOV AL,byte ptr [RBP + -0x19]
MOV byte ptr [RBP + -0x79],AL
ADD RDI,0x8
CALL 0x001244d0
MOV CL,byte ptr [RBP + -0x79]
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX]
AND CL,0x1
MOV byte ptr [RAX + 0x21],CL
ADD RDI,0x8
CALL 0x001244d0
MOV RAX,qword ptr [RAX]
MOV byte ptr [RAX + 0x20],0x0
JMP 0x001235f1
LAB_001235f1:
MOV RSI,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x8
CALL 0x001244d0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
LAB_00123609:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
/* GASymbolTable::findSymbol(QString, bool) */
int8 __thiscall GASymbolTable::findSymbol(GASymbolTable *this,QString *param_2,byte param_3)
{
byte bVar1;
ulong uVar2;
GASymbol *pGVar3;
int8 *puVar4;
long *plVar5;
QString local_40 [31];
byte local_21;
QString *local_20;
GASymbolTable *local_18;
int8 local_10;
local_21 = param_3 & 1;
local_20 = param_2;
local_18 = this;
if (*(long *)this != 0) {
uVar2 = QListSpecialMethods<QString>::contains
((QListSpecialMethods<QString> *)(*(long *)this + 0x48),param_2,1);
if ((uVar2 & 1) == 0) {
uVar2 = QMap<QString,GASymbol*>::contains((QMap<QString,GASymbol*> *)(this + 8),param_2);
if ((uVar2 & 1) == 0) {
pGVar3 = (GASymbol *)operator_new(0x28);
QString::QString(local_40,param_2);
/* try { // try from 00123551 to 0012356c has its CatchHandler @ 001235c4 */
GASymbol::GASymbol(pGVar3,local_40);
puVar4 = (int8 *)
QMap<QString,GASymbol*>::operator[]((QMap<QString,GASymbol*> *)(this + 8),param_2);
*puVar4 = pGVar3;
QString::~QString(local_40);
bVar1 = local_21;
plVar5 = (long *)QMap<QString,GASymbol*>::operator[]
((QMap<QString,GASymbol*> *)(this + 8),param_2);
*(byte *)(*plVar5 + 0x21) = bVar1 & 1;
plVar5 = (long *)QMap<QString,GASymbol*>::operator[]
((QMap<QString,GASymbol*> *)(this + 8),param_2);
*(int1 *)(*plVar5 + 0x20) = 0;
}
puVar4 = (int8 *)
QMap<QString,GASymbol*>::operator[]((QMap<QString,GASymbol*> *)(this + 8),param_2);
local_10 = *puVar4;
}
else {
local_10 = 0;
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("lang","/workspace/llm4binary/github2025/goodasm/gasymboltable.cpp",0x47,
"GASymbol *GASymbolTable::findSymbol(QString, bool)");
}
| |
39,419 | mariadb_stmt_execute_direct | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | int STDCALL mariadb_stmt_execute_direct(MYSQL_STMT *stmt,
const char *stmt_str,
size_t length)
{
MYSQL *mysql;
my_bool emulate_cmd;
my_bool clear_result= 0;
if (!stmt)
return 1;
mysql= stmt->mysql;
if (!mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return 1;
}
emulate_cmd= !(!(stmt->mysql->server_capabilities & CLIENT_MYSQL) &&
(stmt->mysql->extension->mariadb_server_capabilities &
(MARIADB_CLIENT_STMT_BULK_OPERATIONS >> 32))) || mysql->net.compress;
/* Server versions < 10.2 don't support execute_direct, so we need to
emulate it */
if (emulate_cmd)
{
int rc;
/* avoid sending close + prepare in 2 packets */
if ((rc= mysql_stmt_prepare(stmt, stmt_str, (unsigned long)length)))
return rc;
return mysql_stmt_execute(stmt);
}
if (ma_multi_command(mysql, COM_MULTI_ENABLED))
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return 1;
}
if (length == (size_t) -1)
length= strlen(stmt_str);
/* clear flags */
CLEAR_CLIENT_STMT_ERROR(stmt);
CLEAR_CLIENT_ERROR(stmt->mysql);
stmt->upsert_status.affected_rows= mysql->affected_rows= (unsigned long long) ~0;
/* check if we have to clear results */
if (stmt->state > MYSQL_STMT_INITTED)
{
/* We need to semi-close the prepared statement:
reset stmt and free all buffers and close the statement
on server side. Statement handle will get a new stmt_id */
char stmt_id[STMT_ID_LENGTH];
if (mysql_stmt_internal_reset(stmt, 1))
goto fail;
ma_free_root(&stmt->mem_root, MYF(MY_KEEP_PREALLOC));
ma_free_root(&((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root, MYF(0));
stmt->field_count= 0;
stmt->param_count= 0;
stmt->params= 0;
int4store(stmt_id, stmt->stmt_id);
if (mysql->methods->db_command(mysql, COM_STMT_CLOSE, stmt_id,
sizeof(stmt_id), 1, stmt))
goto fail;
}
stmt->stmt_id= -1;
if (mysql->methods->db_command(mysql, COM_STMT_PREPARE, stmt_str, length, 1, stmt))
goto fail;
/* in case prepare fails, we need to clear the result package from execute, which
is always an error packet (invalid statement id) */
clear_result= 1;
stmt->state= MYSQL_STMT_PREPARED;
/* Since we can't determine stmt_id here, we need to set it to -1, so server will know that the
* execute command belongs to previous prepare */
stmt->stmt_id= -1;
if (mysql_stmt_execute(stmt))
goto fail;
/* flush multi buffer */
if (ma_multi_command(mysql, COM_MULTI_END))
goto fail;
if (!mysql->options.extension->skip_read_response)
{
/* read prepare response */
if (mysql->methods->db_read_prepare_response &&
mysql->methods->db_read_prepare_response(stmt))
goto fail;
clear_result= 0;
/* read execute response packet */
return mthd_stmt_read_execute_response(stmt);
}
fail:
/* check if we need to set error message */
if (!mysql_stmt_errno(stmt))
UPDATE_STMT_ERROR(stmt);
if (clear_result) {
do {
stmt->mysql->methods->db_stmt_flush_unbuffered(stmt);
} while(mysql_stmt_more_results(stmt));
}
stmt->state= MYSQL_STMT_INITTED;
return 1;
} | O3 | c | mariadb_stmt_execute_direct:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl $0x1, %ebx
testq %rdi, %rdi
je 0x33d29
movq %rdi, %r14
movq 0x38(%rdi), %r15
testq %r15, %r15
je 0x33cd6
movq %rdx, %r13
movq %rsi, %r12
testb $0x1, 0x370(%r15)
jne 0x33c9b
movq 0x4f0(%r15), %rax
testb $0x4, 0x70(%rax)
je 0x33c9b
cmpb $0x0, 0x84(%r15)
je 0x33d4d
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3267c
testl %eax, %eax
jne 0x33d29
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x33fdb
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3324d
movl $0x7dd, 0x108(%r14) # imm = 0x7DD
leaq 0x30d(%r14), %rdi
leaq 0x2ed01(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
xorl %r15d, %r15d
movb %r15b, 0x312(%r14)
leaq 0x10c(%r14), %rdi
leaq 0x2ecec(%rip), %rax # 0x62a00
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14230
movb %r15b, 0x30b(%r14)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x33fdb
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movl $0x2, %esi
callq 0x27729
testl %eax, %eax
je 0x33da5
movl $0x7de, 0x108(%r14) # imm = 0x7DE
leaq 0x30d(%r14), %rdi
leaq 0x2ec79(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
xorl %r15d, %r15d
movb %r15b, 0x312(%r14)
leaq 0x10c(%r14), %rdi
leaq 0x2ec64(%rip), %rax # 0x62a00
movq 0x70(%rax), %rsi
jmp 0x33d18
cmpq $-0x1, %r13
jne 0x33db6
movq %r12, %rdi
callq 0x141c0
movq %rax, %r13
xorl %eax, %eax
movl %eax, 0x108(%r14)
movl $0x30303030, %ecx # imm = 0x30303030
movl %ecx, 0x30d(%r14)
movw $0x30, %dx
movw %dx, 0x311(%r14)
movb %al, 0x10c(%r14)
movq 0x38(%r14), %rsi
movl %eax, 0x90(%rsi)
movq 0x38(%r14), %rsi
movw %dx, 0x29b(%rsi)
movl %ecx, 0x297(%rsi)
movq 0x38(%r14), %rcx
movb %al, 0x97(%rcx)
movq 0x38(%r14), %rax
movq 0x2a0(%rax), %rax
testq %rax, %rax
je 0x33e1a
movl $0x0, 0x4(%rax)
movq $-0x1, %rax
movq %rax, 0x338(%r15)
movq %rax, 0xf8(%r14)
cmpl $0x0, 0x50(%r14)
je 0x33e9f
movq %r14, %rdi
movl $0x1, %esi
callq 0x313d0
testb %al, %al
jne 0x33e9a
movq %r14, %rdi
movl $0x1, %esi
callq 0x2f53b
movq 0x340(%r14), %rdi
xorl %esi, %esi
callq 0x2f53b
xorl %eax, %eax
movq %rax, 0x60(%r14)
movq %rax, 0x70(%r14)
movl 0x40(%r14), %eax
leaq -0x34(%rbp), %rdx
movl %eax, (%rdx)
movq 0x4d0(%r15), %rax
movl $0x4, %ecx
movq %r15, %rdi
movl $0x19, %esi
movl $0x1, %r8d
movq %r14, %r9
callq *0x10(%rax)
testl %eax, %eax
je 0x33e9f
movb $0x1, %r12b
jmp 0x33f13
movq $-0x1, 0x40(%r14)
movq 0x4d0(%r15), %rax
movq %r15, %rdi
movl $0x16, %esi
movq %r12, %rdx
movq %r13, %rcx
movl $0x1, %r8d
movq %r14, %r9
callq *0x10(%rax)
movb $0x1, %r12b
testl %eax, %eax
jne 0x33f13
movl $0x1, 0x50(%r14)
movq $-0x1, 0x40(%r14)
movq %r14, %rdi
callq 0x3324d
testl %eax, %eax
jne 0x33f10
movq %r15, %rdi
movl $0x4, %esi
callq 0x27729
testl %eax, %eax
jne 0x33f10
movq 0x480(%r15), %rax
cmpb $0x0, 0x148(%rax)
je 0x33faf
xorl %r12d, %r12d
cmpl $0x0, 0x108(%r14)
jne 0x33f74
leaq 0x30d(%r14), %rdi
leaq 0x10c(%r14), %r15
movq 0x38(%r14), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%r14)
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x14230
xorl %r13d, %r13d
movb %r13b, 0x312(%r14)
movl $0x97, %esi
addq 0x38(%r14), %rsi
movl $0x200, %edx # imm = 0x200
movq %r15, %rdi
callq 0x14230
movb %r13b, 0x30b(%r14)
testb %r12b, %r12b
jne 0x33fa2
movq 0x38(%r14), %rax
movq 0x4d0(%rax), %rax
movq %r14, %rdi
callq *0x78(%rax)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x33fa2
movzwl 0x380(%rax), %ecx
testl $0x1008, %ecx # imm = 0x1008
jne 0x33f7d
movl $0x0, 0x50(%r14)
jmp 0x33d29
movq 0x4d0(%r15), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x33fcc
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x33f10
movq %r14, %rdi
callq 0x32c4f
movl %eax, %ebx
jmp 0x33d29
callq 0x14520
| mariadb_stmt_execute_direct:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rbp+var_30], rax
mov ebx, 1
test rdi, rdi
jz loc_33D29
mov r14, rdi
mov r15, [rdi+38h]
test r15, r15
jz short loc_33CD6
mov r13, rdx
mov r12, rsi
test byte ptr [r15+370h], 1
jnz short loc_33C9B
mov rax, [r15+4F0h]
test byte ptr [rax+70h], 4
jz short loc_33C9B
cmp byte ptr [r15+84h], 0
jz loc_33D4D
loc_33C9B:
mov rdi, r14
mov rsi, r12
mov rdx, r13
call mysql_stmt_prepare
test eax, eax
jnz short loc_33D29
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_33FDB
mov rdi, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp mysql_stmt_execute
loc_33CD6:
mov dword ptr [r14+108h], 7DDh
lea rdi, [r14+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+312h], r15b
lea rdi, [r14+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
loc_33D18:
mov edx, 200h
call _strncpy
mov [r14+30Bh], r15b
loc_33D29:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_33FDB
mov eax, ebx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_33D4D:
mov rdi, r15
mov esi, 2
call ma_multi_command
test eax, eax
jz short loc_33DA5
mov dword ptr [r14+108h], 7DEh
lea rdi, [r14+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+312h], r15b
lea rdi, [r14+10Ch]
lea rax, client_errors
mov rsi, [rax+70h]
jmp loc_33D18
loc_33DA5:
cmp r13, 0FFFFFFFFFFFFFFFFh
jnz short loc_33DB6
mov rdi, r12
call _strlen
mov r13, rax
loc_33DB6:
xor eax, eax
mov [r14+108h], eax
mov ecx, 30303030h
mov [r14+30Dh], ecx
mov dx, 30h ; '0'
mov [r14+311h], dx
mov [r14+10Ch], al
mov rsi, [r14+38h]
mov [rsi+90h], eax
mov rsi, [r14+38h]
mov [rsi+29Bh], dx
mov [rsi+297h], ecx
mov rcx, [r14+38h]
mov [rcx+97h], al
mov rax, [r14+38h]
mov rax, [rax+2A0h]
test rax, rax
jz short loc_33E1A
mov dword ptr [rax+4], 0
loc_33E1A:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [r15+338h], rax
mov [r14+0F8h], rax
cmp dword ptr [r14+50h], 0
jz short loc_33E9F
mov rdi, r14
mov esi, 1
call mysql_stmt_internal_reset
test al, al
jnz short loc_33E9A
mov rdi, r14
mov esi, 1
call ma_free_root
mov rdi, [r14+340h]
xor esi, esi
call ma_free_root
xor eax, eax
mov [r14+60h], rax
mov [r14+70h], rax
mov eax, [r14+40h]
lea rdx, [rbp+var_34]
mov [rdx], eax
mov rax, [r15+4D0h]
mov ecx, 4
mov rdi, r15
mov esi, 19h
mov r8d, 1
mov r9, r14
call qword ptr [rax+10h]
test eax, eax
jz short loc_33E9F
loc_33E9A:
mov r12b, 1
jmp short loc_33F13
loc_33E9F:
mov qword ptr [r14+40h], 0FFFFFFFFFFFFFFFFh
mov rax, [r15+4D0h]
mov rdi, r15
mov esi, 16h
mov rdx, r12
mov rcx, r13
mov r8d, 1
mov r9, r14
call qword ptr [rax+10h]
mov r12b, 1
test eax, eax
jnz short loc_33F13
mov dword ptr [r14+50h], 1
mov qword ptr [r14+40h], 0FFFFFFFFFFFFFFFFh
mov rdi, r14
call mysql_stmt_execute
test eax, eax
jnz short loc_33F10
mov rdi, r15
mov esi, 4
call ma_multi_command
test eax, eax
jnz short loc_33F10
mov rax, [r15+480h]
cmp byte ptr [rax+148h], 0
jz loc_33FAF
loc_33F10:
xor r12d, r12d
loc_33F13:
cmp dword ptr [r14+108h], 0
jnz short loc_33F74
lea rdi, [r14+30Dh]
lea r15, [r14+10Ch]
mov rsi, [r14+38h]
mov eax, [rsi+90h]
mov [r14+108h], eax
add rsi, 297h
mov edx, 5
call _strncpy
xor r13d, r13d
mov [r14+312h], r13b
mov esi, 97h
add rsi, [r14+38h]
mov edx, 200h
mov rdi, r15
call _strncpy
mov [r14+30Bh], r13b
loc_33F74:
test r12b, r12b
jnz short loc_33FA2
mov rax, [r14+38h]
loc_33F7D:
mov rax, [rax+4D0h]
mov rdi, r14
call qword ptr [rax+78h]
mov rax, [r14+38h]
test rax, rax
jz short loc_33FA2
movzx ecx, word ptr [rax+380h]
test ecx, 1008h
jnz short loc_33F7D
loc_33FA2:
mov dword ptr [r14+50h], 0
jmp loc_33D29
loc_33FAF:
mov rax, [r15+4D0h]
mov rax, [rax+40h]
test rax, rax
jz short loc_33FCC
mov rdi, r14
call rax
test al, al
jnz loc_33F10
loc_33FCC:
mov rdi, r14
call mthd_stmt_read_execute_response
mov ebx, eax
jmp loc_33D29
loc_33FDB:
call ___stack_chk_fail
| long long mariadb_stmt_execute_direct(long long a1, long long a2, long long a3)
{
unsigned int v3; // ebx
long long v5; // r15
long long v6; // r13
long long v8; // rdi
char *v9; // rsi
long long v10; // rax
char v11; // r12
long long v12; // rsi
long long v13; // rax
unsigned __int8 ( *v14)(long long); // rax
int v15; // [rsp+Ch] [rbp-34h] BYREF
unsigned long long v16; // [rsp+10h] [rbp-30h]
v16 = __readfsqword(0x28u);
v3 = 1;
if ( !a1 )
return v3;
v5 = *(_QWORD *)(a1 + 56);
if ( !v5 )
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v8 = a1 + 268;
v9 = client_errors[13];
LABEL_9:
strncpy(v8, v9, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return v3;
}
v6 = a3;
if ( (*(_BYTE *)(v5 + 880) & 1) == 0 && (*(_BYTE *)(*(_QWORD *)(v5 + 1264) + 112LL) & 4) != 0 && !*(_BYTE *)(v5 + 132) )
{
if ( !(unsigned int)ma_multi_command(*(_QWORD *)(a1 + 56), 2) )
{
if ( v6 == -1 )
v6 = strlen(a2);
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v10 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v10 )
*(_DWORD *)(v10 + 4) = 0;
*(_QWORD *)(v5 + 824) = -1LL;
*(_QWORD *)(a1 + 248) = -1LL;
if ( *(_DWORD *)(a1 + 80)
&& ((unsigned __int8)mysql_stmt_internal_reset(a1, 1)
|| (ma_free_root(a1, 1),
ma_free_root(*(_QWORD *)(a1 + 832), 0),
*(_QWORD *)(a1 + 96) = 0LL,
*(_QWORD *)(a1 + 112) = 0LL,
v15 = *(_DWORD *)(a1 + 64),
(*(unsigned int ( **)(long long, long long, int *, long long, long long, long long))(*(_QWORD *)(v5 + 1232)
+ 16LL))(
v5,
25LL,
&v15,
4LL,
1LL,
a1))) )
{
v11 = 1;
}
else
{
*(_QWORD *)(a1 + 64) = -1LL;
v11 = 1;
if ( !(*(unsigned int ( **)(long long, long long, long long, long long, long long, long long))(*(_QWORD *)(v5 + 1232) + 16LL))(
v5,
22LL,
a2,
v6,
1LL,
a1) )
{
*(_DWORD *)(a1 + 80) = 1;
*(_QWORD *)(a1 + 64) = -1LL;
if ( !(unsigned int)mysql_stmt_execute(a1)
&& !(unsigned int)ma_multi_command(v5, 4)
&& !*(_BYTE *)(*(_QWORD *)(v5 + 1152) + 328LL) )
{
v14 = *(unsigned __int8 ( **)(long long))(*(_QWORD *)(v5 + 1232) + 64LL);
if ( !v14 || !v14(a1) )
return (unsigned int)mthd_stmt_read_execute_response(a1);
}
v11 = 0;
}
}
if ( !*(_DWORD *)(a1 + 264) )
{
v12 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v12 + 144);
strncpy(a1 + 781, v12 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
}
if ( !v11 )
{
v13 = *(_QWORD *)(a1 + 56);
do
{
(*(void ( **)(long long))(*(_QWORD *)(v13 + 1232) + 120LL))(a1);
v13 = *(_QWORD *)(a1 + 56);
}
while ( v13 && (*(_WORD *)(v13 + 896) & 0x1008) != 0 );
}
*(_DWORD *)(a1 + 80) = 0;
return v3;
}
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
v8 = a1 + 268;
v9 = client_errors[14];
goto LABEL_9;
}
if ( !(unsigned int)mysql_stmt_prepare(a1, a2, a3) )
return mysql_stmt_execute(a1);
return v3;
}
| mariadb_stmt_execute_direct:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV EBX,0x1
TEST RDI,RDI
JZ 0x00133d29
MOV R14,RDI
MOV R15,qword ptr [RDI + 0x38]
TEST R15,R15
JZ 0x00133cd6
MOV R13,RDX
MOV R12,RSI
TEST byte ptr [R15 + 0x370],0x1
JNZ 0x00133c9b
MOV RAX,qword ptr [R15 + 0x4f0]
TEST byte ptr [RAX + 0x70],0x4
JZ 0x00133c9b
CMP byte ptr [R15 + 0x84],0x0
JZ 0x00133d4d
LAB_00133c9b:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
CALL 0x0013267c
TEST EAX,EAX
JNZ 0x00133d29
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00133fdb
MOV RDI,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0013324d
LAB_00133cd6:
MOV dword ptr [R14 + 0x108],0x7dd
LEA RDI,[R14 + 0x30d]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
XOR R15D,R15D
MOV byte ptr [R14 + 0x312],R15B
LEA RDI,[R14 + 0x10c]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x68]
LAB_00133d18:
MOV EDX,0x200
CALL 0x00114230
MOV byte ptr [R14 + 0x30b],R15B
LAB_00133d29:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00133fdb
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00133d4d:
MOV RDI,R15
MOV ESI,0x2
CALL 0x00127729
TEST EAX,EAX
JZ 0x00133da5
MOV dword ptr [R14 + 0x108],0x7de
LEA RDI,[R14 + 0x30d]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
XOR R15D,R15D
MOV byte ptr [R14 + 0x312],R15B
LEA RDI,[R14 + 0x10c]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x70]
JMP 0x00133d18
LAB_00133da5:
CMP R13,-0x1
JNZ 0x00133db6
MOV RDI,R12
CALL 0x001141c0
MOV R13,RAX
LAB_00133db6:
XOR EAX,EAX
MOV dword ptr [R14 + 0x108],EAX
MOV ECX,0x30303030
MOV dword ptr [R14 + 0x30d],ECX
MOV DX,0x30
MOV word ptr [R14 + 0x311],DX
MOV byte ptr [R14 + 0x10c],AL
MOV RSI,qword ptr [R14 + 0x38]
MOV dword ptr [RSI + 0x90],EAX
MOV RSI,qword ptr [R14 + 0x38]
MOV word ptr [RSI + 0x29b],DX
MOV dword ptr [RSI + 0x297],ECX
MOV RCX,qword ptr [R14 + 0x38]
MOV byte ptr [RCX + 0x97],AL
MOV RAX,qword ptr [R14 + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
TEST RAX,RAX
JZ 0x00133e1a
MOV dword ptr [RAX + 0x4],0x0
LAB_00133e1a:
MOV RAX,-0x1
MOV qword ptr [R15 + 0x338],RAX
MOV qword ptr [R14 + 0xf8],RAX
CMP dword ptr [R14 + 0x50],0x0
JZ 0x00133e9f
MOV RDI,R14
MOV ESI,0x1
CALL 0x001313d0
TEST AL,AL
JNZ 0x00133e9a
MOV RDI,R14
MOV ESI,0x1
CALL 0x0012f53b
MOV RDI,qword ptr [R14 + 0x340]
XOR ESI,ESI
CALL 0x0012f53b
XOR EAX,EAX
MOV qword ptr [R14 + 0x60],RAX
MOV qword ptr [R14 + 0x70],RAX
MOV EAX,dword ptr [R14 + 0x40]
LEA RDX,[RBP + -0x34]
MOV dword ptr [RDX],EAX
MOV RAX,qword ptr [R15 + 0x4d0]
MOV ECX,0x4
MOV RDI,R15
MOV ESI,0x19
MOV R8D,0x1
MOV R9,R14
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x00133e9f
LAB_00133e9a:
MOV R12B,0x1
JMP 0x00133f13
LAB_00133e9f:
MOV qword ptr [R14 + 0x40],-0x1
MOV RAX,qword ptr [R15 + 0x4d0]
MOV RDI,R15
MOV ESI,0x16
MOV RDX,R12
MOV RCX,R13
MOV R8D,0x1
MOV R9,R14
CALL qword ptr [RAX + 0x10]
MOV R12B,0x1
TEST EAX,EAX
JNZ 0x00133f13
MOV dword ptr [R14 + 0x50],0x1
MOV qword ptr [R14 + 0x40],-0x1
MOV RDI,R14
CALL 0x0013324d
TEST EAX,EAX
JNZ 0x00133f10
MOV RDI,R15
MOV ESI,0x4
CALL 0x00127729
TEST EAX,EAX
JNZ 0x00133f10
MOV RAX,qword ptr [R15 + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JZ 0x00133faf
LAB_00133f10:
XOR R12D,R12D
LAB_00133f13:
CMP dword ptr [R14 + 0x108],0x0
JNZ 0x00133f74
LEA RDI,[R14 + 0x30d]
LEA R15,[R14 + 0x10c]
MOV RSI,qword ptr [R14 + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [R14 + 0x108],EAX
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00114230
XOR R13D,R13D
MOV byte ptr [R14 + 0x312],R13B
MOV ESI,0x97
ADD RSI,qword ptr [R14 + 0x38]
MOV EDX,0x200
MOV RDI,R15
CALL 0x00114230
MOV byte ptr [R14 + 0x30b],R13B
LAB_00133f74:
TEST R12B,R12B
JNZ 0x00133fa2
MOV RAX,qword ptr [R14 + 0x38]
LAB_00133f7d:
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RDI,R14
CALL qword ptr [RAX + 0x78]
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
JZ 0x00133fa2
MOVZX ECX,word ptr [RAX + 0x380]
TEST ECX,0x1008
JNZ 0x00133f7d
LAB_00133fa2:
MOV dword ptr [R14 + 0x50],0x0
JMP 0x00133d29
LAB_00133faf:
MOV RAX,qword ptr [R15 + 0x4d0]
MOV RAX,qword ptr [RAX + 0x40]
TEST RAX,RAX
JZ 0x00133fcc
MOV RDI,R14
CALL RAX
TEST AL,AL
JNZ 0x00133f10
LAB_00133fcc:
MOV RDI,R14
CALL 0x00132c4f
MOV EBX,EAX
JMP 0x00133d29
LAB_00133fdb:
CALL 0x00114520
|
ulong mariadb_stmt_execute_direct(long param_1,char *param_2,size_t param_3)
{
long lVar1;
code *pcVar2;
bool bVar3;
char cVar4;
int iVar5;
uint uVar6;
long lVar7;
ulong uVar8;
char *__src;
long in_FS_OFFSET;
int4 local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar8 = 1;
if (param_1 != 0) {
lVar7 = *(long *)(param_1 + 0x38);
if (lVar7 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Lost_connection_to_server_during_00162a68;
LAB_00133d18:
strncpy((char *)(param_1 + 0x10c),__src,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
}
else if ((((*(byte *)(lVar7 + 0x370) & 1) == 0) &&
((*(byte *)(*(long *)(lVar7 + 0x4f0) + 0x70) & 4) != 0)) &&
(*(char *)(lVar7 + 0x84) == '\0')) {
iVar5 = ma_multi_command(lVar7,2);
if (iVar5 != 0) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
__src = PTR_s_Commands_out_of_sync__you_can_t_r_00162a70;
goto LAB_00133d18;
}
if (param_3 == 0xffffffffffffffff) {
param_3 = strlen(param_2);
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar1 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar1 + 0x29b) = 0x30;
*(int4 *)(lVar1 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 4) = 0;
}
*(int8 *)(lVar7 + 0x338) = 0xffffffffffffffff;
*(int8 *)(param_1 + 0xf8) = 0xffffffffffffffff;
if (*(int *)(param_1 + 0x50) == 0) {
LAB_00133e9f:
*(int8 *)(param_1 + 0x40) = 0xffffffffffffffff;
iVar5 = (**(code **)(*(long *)(lVar7 + 0x4d0) + 0x10))(lVar7,0x16,param_2,param_3,1,param_1)
;
bVar3 = true;
if (iVar5 == 0) {
*(int4 *)(param_1 + 0x50) = 1;
*(int8 *)(param_1 + 0x40) = 0xffffffffffffffff;
iVar5 = mysql_stmt_execute(param_1);
if (iVar5 == 0) {
iVar5 = ma_multi_command(lVar7,4);
if ((iVar5 == 0) && (*(char *)(*(long *)(lVar7 + 0x480) + 0x148) == '\0')) {
pcVar2 = *(code **)(*(long *)(lVar7 + 0x4d0) + 0x40);
if (pcVar2 != (code *)0x0) {
cVar4 = (*pcVar2)(param_1);
if (cVar4 != '\0') goto LAB_00133f10;
}
uVar6 = mthd_stmt_read_execute_response(param_1);
uVar8 = (ulong)uVar6;
goto LAB_00133d29;
}
}
LAB_00133f10:
bVar3 = false;
}
}
else {
cVar4 = mysql_stmt_internal_reset(param_1,1);
if (cVar4 == '\0') {
ma_free_root(param_1,1);
ma_free_root(*(int8 *)(param_1 + 0x340),0);
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x70) = 0;
local_3c = *(int4 *)(param_1 + 0x40);
iVar5 = (**(code **)(*(long *)(lVar7 + 0x4d0) + 0x10))(lVar7,0x19,&local_3c,4,1,param_1);
if (iVar5 == 0) goto LAB_00133e9f;
}
bVar3 = true;
}
if (*(int *)(param_1 + 0x108) == 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),(char *)(*(long *)(param_1 + 0x38) + 0x97),0x200);
*(int1 *)(param_1 + 0x30b) = 0;
}
if (!bVar3) {
lVar7 = *(long *)(param_1 + 0x38);
do {
(**(code **)(*(long *)(lVar7 + 0x4d0) + 0x78))(param_1);
lVar7 = *(long *)(param_1 + 0x38);
if (lVar7 == 0) break;
} while ((*(ushort *)(lVar7 + 0x380) & 0x1008) != 0);
}
*(int4 *)(param_1 + 0x50) = 0;
}
else {
iVar5 = mysql_stmt_prepare(param_1,param_2,param_3);
if (iVar5 == 0) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar8 = mysql_stmt_execute(param_1);
return uVar8;
}
goto LAB_00133fdb;
}
}
}
LAB_00133d29:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar8;
}
LAB_00133fdb:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,420 | my_time_init | eloqsql/mysys/my_getsystime.c | void my_time_init()
{
#ifdef _WIN32
compile_time_assert(sizeof(LARGE_INTEGER) ==
sizeof(query_performance_frequency));
QueryPerformanceFrequency((LARGE_INTEGER *)&query_performance_frequency);
DBUG_ASSERT(query_performance_frequency);
#endif
} | O3 | c | my_time_init:
pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
| my_time_init:
push rbp
mov rbp, rsp
pop rbp
retn
| void my_time_init()
{
;
}
| my_time_init:
PUSH RBP
MOV RBP,RSP
POP RBP
RET
|
void my_time_init(void)
{
return;
}
| |
39,421 | maria_page_crc_check | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_check(uchar *page,
pgcache_page_no_t page_no,
MARIA_SHARE *share,
uint32 no_crc_val,
int data_length)
{
uint32 crc= uint4korr(page + share->block_size - CRC_SIZE), new_crc;
my_bool res;
DBUG_ENTER("maria_page_crc_check");
DBUG_ASSERT((uint)data_length <= share->block_size - CRC_SIZE);
/* we need this assert to get following comparison working */
compile_time_assert(MARIA_NO_CRC_BITMAP_PAGE ==
MARIA_NO_CRC_NORMAL_PAGE - 1 &&
MARIA_NO_CRC_NORMAL_PAGE == 0xffffffff);
/*
If crc is no_crc_val then
the page has no crc, so there is nothing to check.
*/
if (crc >= MARIA_NO_CRC_BITMAP_PAGE)
{
DBUG_PRINT("info", ("No crc: %lu crc: %lu page: %lu ",
(ulong) no_crc_val, (ulong) crc, (ulong) page_no));
if (crc != no_crc_val)
{
my_errno= HA_ERR_WRONG_CRC;
DBUG_PRINT("error", ("Wrong no CRC value"));
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
new_crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ASSERT(new_crc != no_crc_val);
res= MY_TEST(new_crc != crc);
if (res)
{
/*
Bitmap pages may be totally zero filled in some cases.
This happens when we get a crash after the pagecache has written
out a page that is on a newly created bitmap page and we get
a crash before the bitmap page is written out.
We handle this case with the following logic:
When reading, approve of bitmap pages where all bytes are zero
(This is after all a bitmap pages where no data is reserved and
the CRC will be corrected at next write)
*/
if (no_crc_val == MARIA_NO_CRC_BITMAP_PAGE &&
crc == 0 && _ma_check_if_zero(page, data_length))
{
DBUG_PRINT("warning", ("Found bitmap page that was not initialized"));
DBUG_RETURN(0);
}
DBUG_PRINT("error", ("Page: %lu crc: %lu calculated crc: %lu",
(ulong) page_no, (ulong) crc, (ulong) new_crc));
my_errno= HA_ERR_WRONG_CRC;
}
DBUG_RETURN(res);
} | O0 | c | maria_page_crc_check:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
movl -0x4(%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x365c2
jmp 0x365c4
jmp 0x365c6
cmpl $-0x2, -0x2c(%rbp)
jb 0x365f5
jmp 0x365ce
jmp 0x365d0
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x365ed
callq 0xc0d80
movl $0xb0, (%rax)
jmp 0x365e5
jmp 0x365e7
movb $0x1, -0x1(%rbp)
jmp 0x3666b
jmp 0x365ef
movb $0x0, -0x1(%rbp)
jmp 0x3666b
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x36680
movl %eax, -0x30(%rbp)
jmp 0x3660c
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
movb %al, -0x31(%rbp)
cmpb $0x0, -0x31(%rbp)
je 0x36663
cmpl $-0x2, -0x24(%rbp)
jne 0x36654
cmpl $0x0, -0x2c(%rbp)
jne 0x36654
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x3b210
movsbl %al, %eax
cmpl $0x0, %eax
je 0x36654
jmp 0x3664a
jmp 0x3664c
jmp 0x3664e
movb $0x0, -0x1(%rbp)
jmp 0x3666b
jmp 0x36656
jmp 0x36658
callq 0xc0d80
movl $0xb0, (%rax)
jmp 0x36665
movb -0x31(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| maria_page_crc_check:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
mov ecx, [rcx+7BCh]
mov eax, [rax+rcx-4]
mov [rbp+var_2C], eax
jmp short $+2
loc_365C2:
jmp short $+2
loc_365C4:
jmp short $+2
loc_365C6:
cmp [rbp+var_2C], 0FFFFFFFEh
jb short loc_365F5
jmp short $+2
loc_365CE:
jmp short $+2
loc_365D0:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_24]
jz short loc_365ED
call _my_thread_var
mov dword ptr [rax], 0B0h
jmp short $+2
loc_365E5:
jmp short $+2
loc_365E7:
mov [rbp+var_1], 1
jmp short loc_3666B
loc_365ED:
jmp short $+2
loc_365EF:
mov [rbp+var_1], 0
jmp short loc_3666B
loc_365F5:
mov rax, [rbp+var_18]
mov edi, eax
mov rsi, [rbp+var_10]
mov edx, [rbp+var_28]
call maria_page_crc
mov [rbp+var_30], eax
jmp short $+2
loc_3660C:
mov edx, [rbp+var_30]
mov esi, [rbp+var_2C]
xor eax, eax
mov ecx, 1
cmp edx, esi
cmovnz eax, ecx
mov [rbp+var_31], al
cmp [rbp+var_31], 0
jz short loc_36663
cmp [rbp+var_24], 0FFFFFFFEh
jnz short loc_36654
cmp [rbp+var_2C], 0
jnz short loc_36654
mov rdi, [rbp+var_10]
movsxd rsi, [rbp+var_28]
call _ma_check_if_zero
movsx eax, al
cmp eax, 0
jz short loc_36654
jmp short $+2
loc_3664A:
jmp short $+2
loc_3664C:
jmp short $+2
loc_3664E:
mov [rbp+var_1], 0
jmp short loc_3666B
loc_36654:
jmp short $+2
loc_36656:
jmp short $+2
loc_36658:
call _my_thread_var
mov dword ptr [rax], 0B0h
loc_36663:
jmp short $+2
loc_36665:
mov al, [rbp+var_31]
mov [rbp+var_1], al
loc_3666B:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char maria_page_crc_check(long long a1, unsigned int a2, long long a3, int a4, unsigned int a5)
{
bool v6; // [rsp+Fh] [rbp-31h]
unsigned int v7; // [rsp+14h] [rbp-2Ch]
v7 = *(_DWORD *)(a1 + *(unsigned int *)(a3 + 1980) - 4);
if ( v7 < 0xFFFFFFFE )
{
v6 = (unsigned int)maria_page_crc(a2, a1, a5) != v7;
if ( v6 )
{
if ( a4 == -2 && !v7 && (unsigned __int8)ma_check_if_zero(a1, (int)a5) )
return 0;
*(_DWORD *)my_thread_var() = 176;
}
return v6;
}
if ( v7 == a4 )
return 0;
*(_DWORD *)my_thread_var() = 176;
return 1;
}
| maria_page_crc_check:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RCX + 0x7bc]
MOV EAX,dword ptr [RAX + RCX*0x1 + -0x4]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001365c2
LAB_001365c2:
JMP 0x001365c4
LAB_001365c4:
JMP 0x001365c6
LAB_001365c6:
CMP dword ptr [RBP + -0x2c],-0x2
JC 0x001365f5
JMP 0x001365ce
LAB_001365ce:
JMP 0x001365d0
LAB_001365d0:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x24]
JZ 0x001365ed
CALL 0x001c0d80
MOV dword ptr [RAX],0xb0
JMP 0x001365e5
LAB_001365e5:
JMP 0x001365e7
LAB_001365e7:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013666b
LAB_001365ed:
JMP 0x001365ef
LAB_001365ef:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0013666b
LAB_001365f5:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x28]
CALL 0x00136680
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0013660c
LAB_0013660c:
MOV EDX,dword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x2c]
XOR EAX,EAX
MOV ECX,0x1
CMP EDX,ESI
CMOVNZ EAX,ECX
MOV byte ptr [RBP + -0x31],AL
CMP byte ptr [RBP + -0x31],0x0
JZ 0x00136663
CMP dword ptr [RBP + -0x24],-0x2
JNZ 0x00136654
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00136654
MOV RDI,qword ptr [RBP + -0x10]
MOVSXD RSI,dword ptr [RBP + -0x28]
CALL 0x0013b210
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00136654
JMP 0x0013664a
LAB_0013664a:
JMP 0x0013664c
LAB_0013664c:
JMP 0x0013664e
LAB_0013664e:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0013666b
LAB_00136654:
JMP 0x00136656
LAB_00136656:
JMP 0x00136658
LAB_00136658:
CALL 0x001c0d80
MOV dword ptr [RAX],0xb0
LAB_00136663:
JMP 0x00136665
LAB_00136665:
MOV AL,byte ptr [RBP + -0x31]
MOV byte ptr [RBP + -0x1],AL
LAB_0013666b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
bool maria_page_crc_check(long param_1,int4 param_2,long param_3,uint param_4,int param_5)
{
uint uVar1;
char cVar2;
uint uVar3;
int4 *puVar4;
bool local_9;
uVar1 = *(uint *)(param_1 + -4 + (ulong)*(uint *)(param_3 + 0x7bc));
if (uVar1 < 0xfffffffe) {
uVar3 = maria_page_crc(param_2,param_1,param_5);
local_9 = uVar3 != uVar1;
if (local_9) {
if (((param_4 == 0xfffffffe) && (uVar1 == 0)) &&
(cVar2 = _ma_check_if_zero(param_1,(long)param_5), cVar2 != '\0')) {
local_9 = false;
}
else {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0xb0;
}
}
}
else if (uVar1 == param_4) {
local_9 = false;
}
else {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0xb0;
local_9 = true;
}
return local_9;
}
| |
39,422 | my_context_yield | eloqsql/libmariadb/libmariadb/ma_context.c | int
my_context_yield(struct my_context *c)
{
uint64_t *save= &c->save[0];
__asm__ __volatile__
(
"movq (%[save]), %%rax\n\t"
"movq %%rsp, (%[save])\n\t"
"movq %%rax, %%rsp\n\t"
"movq 8(%[save]), %%rax\n\t"
"movq %%rbp, 8(%[save])\n\t"
"movq %%rax, %%rbp\n\t"
"movq 16(%[save]), %%rax\n\t"
"movq %%rbx, 16(%[save])\n\t"
"movq %%rax, %%rbx\n\t"
"movq 24(%[save]), %%rax\n\t"
"movq %%r12, 24(%[save])\n\t"
"movq %%rax, %%r12\n\t"
"movq 32(%[save]), %%rax\n\t"
"movq %%r13, 32(%[save])\n\t"
"movq %%rax, %%r13\n\t"
"movq 40(%[save]), %%rax\n\t"
"movq %%r14, 40(%[save])\n\t"
"movq %%rax, %%r14\n\t"
"movq 48(%[save]), %%rax\n\t"
"movq %%r15, 48(%[save])\n\t"
"movq %%rax, %%r15\n\t"
"movq 64(%[save]), %%rax\n\t"
"leaq 1f(%%rip), %%rcx\n\t"
"movq %%rcx, 64(%[save])\n\t"
"jmpq *%%rax\n"
"1:\n"
: [save] "+D" (save)
:
: "rax", "rcx", "rdx", "rsi", "r8", "r9", "r10", "r11", "memory", "cc"
);
return 0;
} | O3 | c | my_context_yield:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq %rsp, (%rdi)
movq %rax, %rsp
movq 0x8(%rdi), %rax
movq %rbp, 0x8(%rdi)
movq %rax, %rbp
movq 0x10(%rdi), %rax
movq %rbx, 0x10(%rdi)
movq %rax, %rbx
movq 0x18(%rdi), %rax
movq %r12, 0x18(%rdi)
movq %rax, %r12
movq 0x20(%rdi), %rax
movq %r13, 0x20(%rdi)
movq %rax, %r13
movq 0x28(%rdi), %rax
movq %r14, 0x28(%rdi)
movq %rax, %r14
movq 0x30(%rdi), %rax
movq %r15, 0x30(%rdi)
movq %rax, %r15
movq 0x40(%rdi), %rax
leaq 0x6(%rip), %rcx # 0x9e705
movq %rcx, 0x40(%rdi)
jmpq *%rax
xorl %eax, %eax
popq %rbp
retq
| my_context_yield:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov [rdi], rsp
mov rsp, rax
mov rax, [rdi+8]
mov [rdi+8], rbp
mov rbp, rax
mov rax, [rdi+10h]
mov [rdi+10h], rbx
mov rbx, rax
mov rax, [rdi+18h]
mov [rdi+18h], r12
mov r12, rax
mov rax, [rdi+20h]
mov [rdi+20h], r13
mov r13, rax
mov rax, [rdi+28h]
mov [rdi+28h], r14
mov r14, rax
mov rax, [rdi+30h]
mov [rdi+30h], r15
mov r15, rax
mov rax, [rdi+40h]
lea rcx, sub_9E705
mov [rdi+40h], rcx
jmp rax
| long long my_context_yield(_QWORD *a1)
{
long long v1; // rbx
long long v2; // r12
long long v3; // r13
long long v4; // r14
long long v5; // r15
long long (*v6)(void); // rax
long long savedregs; // [rsp+0h] [rbp+0h] BYREF
*a1 = &savedregs;
a1[1] = &savedregs;
a1[2] = v1;
a1[3] = v2;
a1[4] = v3;
a1[5] = v4;
a1[6] = v5;
v6 = (long long (*)(void))a1[8];
a1[8] = sub_9E705;
return v6();
}
| my_context_yield:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV qword ptr [RDI],RSP
MOV RSP,RAX
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [RDI + 0x8],RBP
MOV RBP,RAX
MOV RAX,qword ptr [RDI + 0x10]
MOV qword ptr [RDI + 0x10],RBX
MOV RBX,RAX
MOV RAX,qword ptr [RDI + 0x18]
MOV qword ptr [RDI + 0x18],R12
MOV R12,RAX
MOV RAX,qword ptr [RDI + 0x20]
MOV qword ptr [RDI + 0x20],R13
MOV R13,RAX
MOV RAX,qword ptr [RDI + 0x28]
MOV qword ptr [RDI + 0x28],R14
MOV R14,RAX
MOV RAX,qword ptr [RDI + 0x30]
MOV qword ptr [RDI + 0x30],R15
MOV R15,RAX
MOV RAX,qword ptr [RDI + 0x40]
LEA RCX,[0x19e705]
MOV qword ptr [RDI + 0x40],RCX
JMP RAX
|
void my_context_yield(long param_1)
{
code *UNRECOVERED_JUMPTABLE;
int8 unaff_RBX;
int8 unaff_R12;
int8 unaff_R13;
int8 unaff_R14;
int8 unaff_R15;
*(int1 **)param_1 = &stack0xfffffffffffffff8;
*(int1 **)(param_1 + 8) = &stack0xfffffffffffffff8;
*(int8 *)(param_1 + 0x10) = unaff_RBX;
*(int8 *)(param_1 + 0x18) = unaff_R12;
*(int8 *)(param_1 + 0x20) = unaff_R13;
*(int8 *)(param_1 + 0x28) = unaff_R14;
*(int8 *)(param_1 + 0x30) = unaff_R15;
UNRECOVERED_JUMPTABLE = *(code **)(param_1 + 0x40);
*(int1 **)(param_1 + 0x40) = &LAB_0019e705;
/* WARNING: Could not recover jumptable at 0x0019e703. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)();
return;
}
| |
39,423 | make_block_iq4_nlx4(block_iq4_nl*, unsigned int) | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp | static block_iq4_nlx4 make_block_iq4_nlx4(block_iq4_nl * in, unsigned int blck_size_interleave) {
block_iq4_nlx4 out;
for (int i = 0; i < 4; i++) {
out.d[i] = in[i].d;
}
const int end = QK4_NL * 2 / blck_size_interleave;
// TODO: this branch seems wrong
//if (blck_size_interleave == 8) {
// for (int i = 0; i < end; ++i) {
// int src_id = i % 4;
// int src_offset = (i / 4) * blck_size_interleave;
// int dst_offset = i * blck_size_interleave;
// // Using memcpy to avoid unaligned memory accesses
// memcpy(&out.qs[dst_offset], &in[src_id].qs[src_offset], sizeof(uint64_t));
// }
//} else
if (blck_size_interleave == 4) {
for (int i = 0; i < end; ++i) {
int src_id = i % 4;
int src_offset = (i / 4) * blck_size_interleave;
int dst_offset = i * blck_size_interleave;
memcpy(&out.qs[dst_offset], &in[src_id].qs[src_offset], sizeof(uint32_t));
}
} else {
GGML_ASSERT(false);
}
return out;
} | O0 | cpp | make_block_iq4_nlx4(block_iq4_nl*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x4f55d
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x12, %rdx, %rdx
addq %rdx, %rcx
movw (%rcx), %dx
movslq -0x10(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4f52e
movl $0x40, %eax
xorl %edx, %edx
divl -0xc(%rbp)
movl %eax, -0x14(%rbp)
cmpl $0x4, -0xc(%rbp)
jne 0x4f5db
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4f5d9
movl -0x18(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
imull -0xc(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movl -0x18(%rbp), %ecx
imull -0xc(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
movq -0x8(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
imulq $0x12, %rsi, %rsi
addq %rsi, %rdx
movslq -0x20(%rbp), %rsi
movl 0x2(%rdx,%rsi), %edx
movl %edx, 0x8(%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4f577
jmp 0x4f5fc
leaq 0x276b4(%rip), %rdi # 0x76c96
movl $0xeaa, %esi # imm = 0xEAA
leaq 0x245d3(%rip), %rdx # 0x73bc1
leaq 0x2601c(%rip), %rcx # 0x75611
movb $0x0, %al
callq 0xe270
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL19make_block_iq4_nlx4P12block_iq4_nlj:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_30], rdi
mov [rbp+var_8], rsi
mov [rbp+var_C], edx
mov [rbp+var_10], 0
loc_4F52E:
cmp [rbp+var_10], 4
jge short loc_4F55D
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
movsxd rdx, [rbp+var_10]
imul rdx, 12h
add rcx, rdx
mov dx, [rcx]
movsxd rcx, [rbp+var_10]
mov [rax+rcx*2], dx
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_4F52E
loc_4F55D:
mov eax, 40h ; '@'
xor edx, edx
div [rbp+var_C]
mov [rbp+var_14], eax
cmp [rbp+var_C], 4
jnz short loc_4F5DB
mov [rbp+var_18], 0
loc_4F577:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jge short loc_4F5D9
mov eax, [rbp+var_18]
mov ecx, 4
cdq
idiv ecx
mov [rbp+var_1C], edx
mov eax, [rbp+var_18]
mov ecx, 4
cdq
idiv ecx
mov ecx, eax
mov rax, [rbp+var_38]
imul ecx, [rbp+var_C]
mov [rbp+var_20], ecx
mov ecx, [rbp+var_18]
imul ecx, [rbp+var_C]
mov [rbp+var_24], ecx
movsxd rcx, [rbp+var_24]
mov rdx, [rbp+var_8]
movsxd rsi, [rbp+var_1C]
imul rsi, 12h
add rdx, rsi
movsxd rsi, [rbp+var_20]
mov edx, [rdx+rsi+2]
mov [rax+rcx+8], edx
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
jmp short loc_4F577
loc_4F5D9:
jmp short loc_4F5FC
loc_4F5DB:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0EAAh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalse; "false"
mov al, 0
call _ggml_abort
loc_4F5FC:
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
| long long make_block_iq4_nlx4(long long a1, long long a2, unsigned int a3)
{
signed int j; // [rsp+28h] [rbp-18h]
int i; // [rsp+30h] [rbp-10h]
for ( i = 0; i < 4; ++i )
*(_WORD *)(a1 + 2LL * i) = *(_WORD *)(18LL * i + a2);
if ( a3 == 4 )
{
for ( j = 0; j < (int)(0x40 / a3); ++j )
*(_DWORD *)(a1 + 4 * j + 8) = *(_DWORD *)(18LL * (j % 4) + a2 + 4 * (j / 4) + 2);
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp",
3754LL,
"GGML_ASSERT(%s) failed",
"false");
}
return a1;
}
| make_block_iq4_nlx4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV dword ptr [RBP + -0xc],EDX
MOV dword ptr [RBP + -0x10],0x0
LAB_0014f52e:
CMP dword ptr [RBP + -0x10],0x4
JGE 0x0014f55d
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0x10]
IMUL RDX,RDX,0x12
ADD RCX,RDX
MOV DX,word ptr [RCX]
MOVSXD RCX,dword ptr [RBP + -0x10]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0014f52e
LAB_0014f55d:
MOV EAX,0x40
XOR EDX,EDX
DIV dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0xc],0x4
JNZ 0x0014f5db
MOV dword ptr [RBP + -0x18],0x0
LAB_0014f577:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JGE 0x0014f5d9
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,0x4
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,0x4
CDQ
IDIV ECX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
IMUL ECX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],ECX
MOV ECX,dword ptr [RBP + -0x18]
IMUL ECX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x24],ECX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x8]
MOVSXD RSI,dword ptr [RBP + -0x1c]
IMUL RSI,RSI,0x12
ADD RDX,RSI
MOVSXD RSI,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RDX + RSI*0x1 + 0x2]
MOV dword ptr [RAX + RCX*0x1 + 0x8],EDX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x0014f577
LAB_0014f5d9:
JMP 0x0014f5fc
LAB_0014f5db:
LEA RDI,[0x176c96]
MOV ESI,0xeaa
LEA RDX,[0x173bc1]
LEA RCX,[0x175611]
MOV AL,0x0
CALL 0x0010e270
LAB_0014f5fc:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
/* make_block_iq4_nlx4(block_iq4_nl*, unsigned int) */
block_iq4_nl * make_block_iq4_nlx4(block_iq4_nl *param_1,uint param_2)
{
uint in_EDX;
int4 in_register_00000034;
int local_20;
int local_18;
for (local_18 = 0; local_18 < 4; local_18 = local_18 + 1) {
*(int2 *)(param_1 + (long)local_18 * 2) =
*(int2 *)(CONCAT44(in_register_00000034,param_2) + (long)local_18 * 0x12);
}
if (in_EDX == 4) {
for (local_20 = 0; local_20 < (int)(0x40 / (ulong)in_EDX); local_20 = local_20 + 1) {
*(int4 *)(param_1 + (long)(local_20 * 4) + 8) =
*(int4 *)
(CONCAT44(in_register_00000034,param_2) + (long)(local_20 % 4) * 0x12 + 2 +
(long)((local_20 / 4) * 4));
}
}
else {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp"
,0xeaa,"GGML_ASSERT(%s) failed","false");
}
return param_1;
}
| |
39,424 | Shell::addToHistory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | isaiah76[P]linux-shell/src/Shell.cpp | void Shell::addToHistory(const std::string& cmd){
if(cmd.empty() || (!commandHistory.empty() && cmd == commandHistory.back()))
return;
commandHistory.push_back(cmd);
add_history(cmd.c_str());
if(commandHistory.size() > MAX_HISTORY_SIZE)
commandHistory.erase(commandHistory.begin());
} | O0 | cpp | Shell::addToHistory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34e0
testb $0x1, %al
jne 0x422d
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x46d0
testb $0x1, %al
jne 0x422f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x47a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4710
testb $0x1, %al
jne 0x422d
jmp 0x422f
jmp 0x42a2
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
callq 0x45a0
movq -0x10(%rbp), %rdi
callq 0x3140
movq %rax, %rdi
callq 0x33f0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x4610
movq -0x30(%rbp), %rcx
cmpq 0x70(%rcx), %rax
jbe 0x42a2
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x40(%rbp)
addq $0x28, %rdi
callq 0x4850
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4880
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x47e0
movq %rax, -0x28(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN5Shell12addToHistoryERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_422D
mov rdi, [rbp+var_30]
add rdi, 28h ; '('
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5emptyEv; std::vector<std::string>::empty(void)
test al, 1
jnz short loc_422F
mov rdi, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
add rdi, 28h ; '('
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4backEv; std::vector<std::string>::back(void)
mov rdi, [rbp+var_38]
mov rsi, rax
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, 1
jnz short loc_422D
jmp short loc_422F
loc_422D:
jmp short loc_42A2
loc_422F:
mov rdi, [rbp+var_30]
add rdi, 28h ; '('
mov rsi, [rbp+var_10]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
mov rdi, [rbp+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
call _add_history
mov rdi, [rbp+var_30]
add rdi, 28h ; '('
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, [rbp+var_30]
cmp rax, [rcx+70h]
jbe short loc_42A2
mov rdi, [rbp+var_30]
mov rax, rdi
add rax, 28h ; '('
mov [rbp+var_40], rax
add rdi, 28h ; '('
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rbp+var_20], rax
lea rdi, [rbp+var_18]
lea rsi, [rbp+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEC2IPS6_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISF_SE_EE7__valueESB_E6__typeEEE
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_18]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5eraseEN9__gnu_cxx17__normal_iteratorIPKS5_S7_EE; std::vector<std::string>::erase(__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>)
mov [rbp+var_28], rax
loc_42A2:
add rsp, 40h
pop rbp
retn
| unsigned long long Shell::addToHistory(long long a1, long long a2)
{
unsigned long long result; // rax
long long v3; // rax
long long v4; // rax
long long v5; // [rsp+20h] [rbp-20h] BYREF
long long v6; // [rsp+28h] [rbp-18h] BYREF
long long v7; // [rsp+30h] [rbp-10h]
long long v8; // [rsp+38h] [rbp-8h]
v8 = a1;
v7 = a2;
result = std::string::empty(a2);
if ( (result & 1) == 0 )
{
if ( (std::vector<std::string>::empty(a1 + 40) & 1) != 0
|| (v3 = std::vector<std::string>::back(a1 + 40), result = std::operator==<char>(v7, v3), (result & 1) == 0) )
{
std::vector<std::string>::push_back(a1 + 40, v7);
v4 = std::string::c_str(v7);
add_history(v4);
result = std::vector<std::string>::size(a1 + 40);
if ( result > *(_QWORD *)(a1 + 112) )
{
v5 = std::vector<std::string>::begin(a1 + 40);
__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::__normal_iterator<std::string*>(
&v6,
&v5);
return std::vector<std::string>::erase(a1 + 40, v6);
}
}
}
return result;
}
| addToHistory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001034e0
TEST AL,0x1
JNZ 0x0010422d
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x28
CALL 0x001046d0
TEST AL,0x1
JNZ 0x0010422f
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
ADD RDI,0x28
CALL 0x001047a0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,RAX
CALL 0x00104710
TEST AL,0x1
JNZ 0x0010422d
JMP 0x0010422f
LAB_0010422d:
JMP 0x001042a2
LAB_0010422f:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x28
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001045a0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00103140
MOV RDI,RAX
CALL 0x001033f0
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x28
CALL 0x00104610
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RCX + 0x70]
JBE 0x001042a2
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,RDI
ADD RAX,0x28
MOV qword ptr [RBP + -0x40],RAX
ADD RDI,0x28
CALL 0x00104850
MOV qword ptr [RBP + -0x20],RAX
LEA RDI,[RBP + -0x18]
LEA RSI,[RBP + -0x20]
CALL 0x00104880
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001047e0
MOV qword ptr [RBP + -0x28],RAX
LAB_001042a2:
ADD RSP,0x40
POP RBP
RET
|
/* Shell::addToHistory(std::__cxx11::string const&) */
void __thiscall Shell::addToHistory(Shell *this,string *param_1)
{
string *psVar1;
ulong uVar2;
string *psVar3;
int8 uVar4;
int8 local_28;
int8 local_20;
string *local_18;
Shell *local_10;
local_18 = param_1;
local_10 = this;
uVar2 = std::__cxx11::string::empty();
if ((uVar2 & 1) == 0) {
uVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::empty
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x28));
psVar1 = local_18;
if ((uVar2 & 1) == 0) {
psVar3 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x28));
uVar2 = std::operator==(psVar1,psVar3);
if ((uVar2 & 1) != 0) {
return;
}
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x28),
local_18);
uVar4 = std::__cxx11::string::c_str();
add_history(uVar4);
uVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x28));
if (*(ulong *)(this + 0x70) < uVar2) {
local_28 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(this + 0x28));
__gnu_cxx::
__normal_iterator<std::__cxx11::string_const*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::__normal_iterator<std::__cxx11::string*>
((__normal_iterator<std::__cxx11::string_const*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_20,(__normal_iterator *)&local_28);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::erase
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x28),
local_20);
}
}
return;
}
| |
39,425 | ggml_easy::ctx::set_tensor_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<float (int, int, int, int)>) | ngxson[P]ggml-easy/ggml-easy.h | void set_tensor_data(const std::string & name, std::function<float(int, int, int, int)> data_fn) {
ggml_tensor * t = ggml_get_tensor(ctx_gf, name.c_str());
if (!t) {
throw std::runtime_error(string_format("tensor not found: %s", name.c_str()));
}
if (t->type != GGML_TYPE_F32) {
throw std::runtime_error(string_format("tensor type must be GGML_TYPE_F32: %s", name.c_str()));
}
std::vector<float> data(ggml_nelements(t));
for (int d3 = 0; d3 < t->ne[3]; ++d3) {
for (int d2 = 0; d2 < t->ne[2]; ++d2) {
for (int d1 = 0; d1 < t->ne[1]; ++d1) {
for (int d0 = 0; d0 < t->ne[0]; ++d0) {
int i = d3 * t->ne[2] + d2 * t->ne[1] + d1 * t->ne[0] + d0;
data[i] = data_fn(d0, d1, d2, d3);
}
}
}
}
ggml_backend_tensor_set(t, data.data(), 0, ggml_nbytes(t));
} | O0 | c | ggml_easy::ctx::set_tensor_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::function<float (int, int, int, int)>):
subq $0xf8, %rsp
movq %rdx, 0x40(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xf0(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x9170
movq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x9470
movq %rax, 0xd8(%rsp)
cmpq $0x0, 0xd8(%rsp)
jne 0xd900
movb $0x1, 0xab(%rsp)
movl $0x10, %edi
callq 0x91f0
movq %rax, 0x38(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x9170
movq %rax, %rdx
leaq 0x8aa1(%rip), %rsi # 0x16305
xorl %eax, %eax
leaq 0xb8(%rsp), %rdi
callq 0xac50
jmp 0xd875
movq 0x38(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x9540
jmp 0xd889
movq 0x38(%rsp), %rdi
movb $0x0, 0xab(%rsp)
movq 0x10753(%rip), %rsi # 0x1dff0
movq 0x1071c(%rip), %rdx # 0x1dfc0
callq 0x95d0
jmp 0xdbfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xd8e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x9270
testb $0x1, 0xab(%rsp)
jne 0xd8f1
jmp 0xd8fb
movq 0x38(%rsp), %rdi
callq 0x92e0
jmp 0xdbee
movq 0xd8(%rsp), %rax
cmpl $0x0, (%rax)
je 0xd9db
movb $0x1, 0x87(%rsp)
movl $0x10, %edi
callq 0x91f0
movq %rax, 0x30(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x9170
movq %rax, %rdx
leaq 0x89db(%rip), %rsi # 0x1631a
xorl %eax, %eax
leaq 0x88(%rsp), %rdi
callq 0xac50
jmp 0xd950
movq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x9540
jmp 0xd964
movq 0x30(%rsp), %rdi
movb $0x0, 0x87(%rsp)
movq 0x10678(%rip), %rsi # 0x1dff0
movq 0x10641(%rip), %rdx # 0x1dfc0
callq 0x95d0
jmp 0xdbfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
jmp 0xd9c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x9270
testb $0x1, 0x87(%rsp)
jne 0xd9cc
jmp 0xd9d6
movq 0x30(%rsp), %rdi
callq 0x92e0
jmp 0xdbee
movq 0xd8(%rsp), %rdi
callq 0x9390
movq %rax, 0x20(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x128f0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x12900
jmp 0xda12
leaq 0x67(%rsp), %rdi
callq 0x12980
movl $0x0, 0x60(%rsp)
movslq 0x60(%rsp), %rax
movq 0xd8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jge 0xdb94
movl $0x0, 0x5c(%rsp)
movslq 0x5c(%rsp), %rax
movq 0xd8(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jge 0xdb82
movl $0x0, 0x58(%rsp)
movslq 0x58(%rsp), %rax
movq 0xd8(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jge 0xdb70
movl $0x0, 0x54(%rsp)
movslq 0x54(%rsp), %rax
movq 0xd8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jge 0xdb5e
movq 0x40(%rsp), %rdi
movl 0x60(%rsp), %eax
movq 0xd8(%rsp), %rsi
movl 0x20(%rsi), %ecx
imull %ecx, %eax
movl 0x5c(%rsp), %ecx
movl 0x10(%rsi), %edx
movl 0x18(%rsi), %esi
imull %esi, %ecx
addl %ecx, %eax
movl 0x58(%rsp), %ecx
imull %edx, %ecx
addl %ecx, %eax
movl 0x54(%rsp), %ecx
addl %ecx, %eax
movl %eax, 0x50(%rsp)
movl 0x54(%rsp), %esi
movl 0x58(%rsp), %edx
movl 0x5c(%rsp), %ecx
movl 0x60(%rsp), %r8d
callq 0x12990
movss %xmm0, 0x1c(%rsp)
jmp 0xdaef
movslq 0x50(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x129f0
movss 0x1c(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0xda81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x12980
jmp 0xdbee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb0(%rsp)
movl %eax, 0xac(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x12a30
jmp 0xdbee
jmp 0xdb60
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0xda62
jmp 0xdb72
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xda43
jmp 0xdb84
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0xda24
movq 0xd8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x68(%rsp), %rdi
callq 0x12a10
movq %rax, 0x8(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x90a0
movq %rax, 0x10(%rsp)
jmp 0xdbc3
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x9210
jmp 0xdbdc
leaq 0x68(%rsp), %rdi
callq 0x12a30
addq $0xf8, %rsp
retq
movq 0xb0(%rsp), %rdi
callq 0x9610
nopl (%rax,%rax)
| _ZN9ggml_easy3ctx15set_tensor_dataERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFfiiiiEE:
sub rsp, 0F8h
mov [rsp+0F8h+var_B8], rdx
mov [rsp+0F8h+var_8], rdi
mov [rsp+0F8h+var_10], rsi
mov [rsp+0F8h+var_18], rdx
mov rax, [rsp+0F8h+var_8]
mov rax, [rax+48h]
mov [rsp+0F8h+var_B0], rax
mov rdi, [rsp+0F8h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, [rsp+0F8h+var_B0]
mov rsi, rax
call _ggml_get_tensor
mov [rsp+0F8h+var_20], rax
cmp [rsp+0F8h+var_20], 0
jnz loc_D900
mov [rsp+0F8h+var_4D], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+0F8h+var_C0], rax
mov rdi, [rsp+0F8h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdx, rax
lea rsi, aTensorNotFound; "tensor not found: %s"
xor eax, eax
lea rdi, [rsp+0F8h+var_40]
call _ZN9ggml_easy13string_formatB5cxx11EPKcz; ggml_easy::string_format(char const*,...)
jmp short $+2
loc_D875:
mov rdi, [rsp+0F8h+var_C0]
lea rsi, [rsp+0F8h+var_40]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D889:
mov rdi, [rsp+0F8h+var_C0]; void *
mov [rsp+0F8h+var_4D], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_DBFB
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp short loc_D8E5
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
lea rdi, [rsp+arg_B0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D8E5:
test [rsp+arg_A3], 1
jnz short loc_D8F1
jmp short loc_D8FB
loc_D8F1:
mov rdi, [rsp+arg_30]; void *
call ___cxa_free_exception
loc_D8FB:
jmp loc_DBEE
loc_D900:
mov rax, [rsp+0F8h+var_20]
cmp dword ptr [rax], 0
jz loc_D9DB
mov [rsp+0F8h+var_71], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+0F8h+var_C8], rax
mov rdi, [rsp+0F8h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdx, rax
lea rsi, aTensorTypeMust; "tensor type must be GGML_TYPE_F32: %s"
xor eax, eax
lea rdi, [rsp+0F8h+var_70]
call _ZN9ggml_easy13string_formatB5cxx11EPKcz; ggml_easy::string_format(char const*,...)
jmp short $+2
loc_D950:
mov rdi, [rsp+0F8h+var_C8]
lea rsi, [rsp+0F8h+var_70]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D964:
mov rdi, [rsp+0F8h+var_C8]; void *
mov [rsp+0F8h+var_71], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_DBFB
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
jmp short loc_D9C0
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
lea rdi, [rsp+arg_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_D9C0:
test [rsp+arg_7F], 1
jnz short loc_D9CC
jmp short loc_D9D6
loc_D9CC:
mov rdi, [rsp+arg_28]; void *
call ___cxa_free_exception
loc_D9D6:
jmp loc_DBEE
loc_D9DB:
mov rdi, [rsp+0F8h+var_20]
call _ggml_nelements
mov [rsp+0F8h+var_D8], rax
lea rdi, [rsp+0F8h+var_91]
mov [rsp+0F8h+var_D0], rdi
call _ZNSaIfEC2Ev; std::allocator<float>::allocator(void)
mov rsi, [rsp+0F8h+var_D8]
mov rdx, [rsp+0F8h+var_D0]
lea rdi, [rsp+0F8h+var_90]
call _ZNSt6vectorIfSaIfEEC2EmRKS0_; std::vector<float>::vector(ulong,std::allocator<float> const&)
jmp short $+2
loc_DA12:
lea rdi, [rsp+0F8h+var_91]
call _ZNSaIfED2Ev; std::allocator<float>::~allocator()
mov [rsp+0F8h+var_98], 0
loc_DA24:
movsxd rax, [rsp+0F8h+var_98]
mov rcx, [rsp+0F8h+var_20]
cmp rax, [rcx+28h]
jge loc_DB94
mov [rsp+0F8h+var_9C], 0
loc_DA43:
movsxd rax, [rsp+0F8h+var_9C]
mov rcx, [rsp+0F8h+var_20]
cmp rax, [rcx+20h]
jge loc_DB82
mov [rsp+0F8h+var_A0], 0
loc_DA62:
movsxd rax, [rsp+0F8h+var_A0]
mov rcx, [rsp+0F8h+var_20]
cmp rax, [rcx+18h]
jge loc_DB70
mov [rsp+0F8h+var_A4], 0
loc_DA81:
movsxd rax, [rsp+0F8h+var_A4]
mov rcx, [rsp+0F8h+var_20]
cmp rax, [rcx+10h]
jge loc_DB5E
mov rdi, [rsp+0F8h+var_B8]
mov eax, [rsp+0F8h+var_98]
mov rsi, [rsp+0F8h+var_20]
mov ecx, [rsi+20h]
imul eax, ecx
mov ecx, [rsp+0F8h+var_9C]
mov edx, [rsi+10h]
mov esi, [rsi+18h]
imul ecx, esi
add eax, ecx
mov ecx, [rsp+0F8h+var_A0]
imul ecx, edx
add eax, ecx
mov ecx, [rsp+0F8h+var_A4]
add eax, ecx
mov [rsp+0F8h+var_A8], eax
mov esi, [rsp+0F8h+var_A4]
mov edx, [rsp+0F8h+var_A0]
mov ecx, [rsp+0F8h+var_9C]
mov r8d, [rsp+0F8h+var_98]
call _ZNKSt8functionIFfiiiiEEclEiiii; std::function<float ()(int,int,int,int)>::operator()(int,int,int,int)
movss [rsp+0F8h+var_DC], xmm0
jmp short $+2
loc_DAEF:
movsxd rsi, [rsp+0F8h+var_A8]
lea rdi, [rsp+0F8h+var_90]
call _ZNSt6vectorIfSaIfEEixEm; std::vector<float>::operator[](ulong)
movss xmm0, [rsp+0F8h+var_DC]
movss dword ptr [rax], xmm0
mov eax, [rsp+0F8h+var_A4]
add eax, 1
mov [rsp+0F8h+var_A4], eax
jmp loc_DA81
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
lea rdi, [rsp+arg_5F]
call _ZNSaIfED2Ev; std::allocator<float>::~allocator()
jmp loc_DBEE
mov rcx, rax
mov eax, edx
mov [rsp+arg_A8], rcx
mov [rsp+arg_A4], eax
lea rdi, [rsp+arg_60]
call _ZNSt6vectorIfSaIfEED2Ev; std::vector<float>::~vector()
jmp loc_DBEE
loc_DB5E:
jmp short $+2
loc_DB60:
mov eax, [rsp+0F8h+var_A0]
add eax, 1
mov [rsp+0F8h+var_A0], eax
jmp loc_DA62
loc_DB70:
jmp short $+2
loc_DB72:
mov eax, [rsp+0F8h+var_9C]
add eax, 1
mov [rsp+0F8h+var_9C], eax
jmp loc_DA43
loc_DB82:
jmp short $+2
loc_DB84:
mov eax, [rsp+0F8h+var_98]
add eax, 1
mov [rsp+0F8h+var_98], eax
jmp loc_DA24
loc_DB94:
mov rax, [rsp+0F8h+var_20]
mov [rsp+0F8h+var_F8], rax
lea rdi, [rsp+0F8h+var_90]
call _ZNSt6vectorIfSaIfEE4dataEv; std::vector<float>::data(void)
mov [rsp+0F8h+var_F0], rax
mov rdi, [rsp+0F8h+var_20]
call _ggml_nbytes
mov [rsp+0F8h+var_E8], rax
jmp short $+2
loc_DBC3:
mov rcx, [rsp+0F8h+var_E8]
mov rsi, [rsp+0F8h+var_F0]
mov rdi, [rsp+0F8h+var_F8]
xor eax, eax
mov edx, eax
call _ggml_backend_tensor_set
jmp short $+2
loc_DBDC:
lea rdi, [rsp+0F8h+var_90]
call _ZNSt6vectorIfSaIfEED2Ev; std::vector<float>::~vector()
add rsp, 0F8h
retn
loc_DBEE:
mov rdi, [rsp+arg_A8]
call __Unwind_Resume
loc_DBFB:
nop dword ptr [rax+rax+00h]
| long long ggml_easy::ctx::set_tensor_data(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v11; // rsi
long long v12; // rax
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // rax
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
int v24; // ecx
int v25; // r8d
int v26; // r9d
char v28; // [rsp+0h] [rbp-F8h]
long long v29; // [rsp+0h] [rbp-F8h]
long long v30; // [rsp+8h] [rbp-F0h]
long long v31; // [rsp+10h] [rbp-E8h]
float v32; // [rsp+1Ch] [rbp-DCh]
int v33; // [rsp+20h] [rbp-D8h]
void *v34; // [rsp+30h] [rbp-C8h]
void *exception; // [rsp+38h] [rbp-C0h]
long long v37; // [rsp+48h] [rbp-B0h]
unsigned int v38; // [rsp+50h] [rbp-A8h]
unsigned int m; // [rsp+54h] [rbp-A4h]
unsigned int k; // [rsp+58h] [rbp-A0h]
unsigned int j; // [rsp+5Ch] [rbp-9Ch]
unsigned int i; // [rsp+60h] [rbp-98h]
char v43; // [rsp+67h] [rbp-91h] BYREF
_BYTE v44[32]; // [rsp+68h] [rbp-90h] BYREF
_BYTE v45[48]; // [rsp+88h] [rbp-70h] BYREF
_BYTE v46[32]; // [rsp+B8h] [rbp-40h] BYREF
long long tensor; // [rsp+D8h] [rbp-20h]
long long v48; // [rsp+E0h] [rbp-18h]
long long v49; // [rsp+E8h] [rbp-10h]
long long v50; // [rsp+F0h] [rbp-8h]
v50 = a1;
v49 = a2;
v48 = a3;
v37 = *(_QWORD *)(a1 + 72);
v11 = std::string::c_str(a2);
tensor = ggml_get_tensor(v37, v11);
if ( !tensor )
{
exception = __cxa_allocate_exception(0x10uLL);
v12 = std::string::c_str(v49);
ggml_easy::string_format[abi:cxx11](
(long long)v46,
(long long)"tensor not found: %s",
v12,
v13,
v14,
v15,
a4,
a5,
a6,
a7,
v16,
v17,
a10,
a11,
v28);
std::runtime_error::runtime_error(exception, v46);
v45[35] = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *(_DWORD *)tensor )
{
v34 = __cxa_allocate_exception(0x10uLL);
v18 = std::string::c_str(v49);
ggml_easy::string_format[abi:cxx11](
(long long)v45,
(long long)"tensor type must be GGML_TYPE_F32: %s",
v18,
v19,
v20,
v21,
a4,
a5,
a6,
a7,
v22,
v23,
a10,
a11,
v28);
std::runtime_error::runtime_error(v34, v45);
v44[31] = 0;
__cxa_throw(
v34,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v33 = ggml_nelements(tensor);
std::allocator<float>::allocator();
std::vector<float>::vector((unsigned int)v44, v33, (unsigned int)&v43, v24, v25, v26);
std::allocator<float>::~allocator(&v43);
for ( i = 0; (int)i < *(_QWORD *)(tensor + 40); ++i )
{
for ( j = 0; (int)j < *(_QWORD *)(tensor + 32); ++j )
{
for ( k = 0; (int)k < *(_QWORD *)(tensor + 24); ++k )
{
for ( m = 0; (int)m < *(_QWORD *)(tensor + 16); ++m )
{
v38 = m + *(_DWORD *)(tensor + 16) * k + *(_DWORD *)(tensor + 24) * j + *(_DWORD *)(tensor + 32) * i;
v32 = std::function<float ()(int,int,int,int)>::operator()(a3, m, k, j, i);
*(float *)std::vector<float>::operator[](v44, (int)v38) = v32;
}
}
}
}
v29 = tensor;
v30 = std::vector<float>::data(v44);
v31 = ggml_nbytes(tensor);
ggml_backend_tensor_set(v29, v30, 0LL, v31);
return std::vector<float>::~vector(v44);
}
| set_tensor_data:
SUB RSP,0xf8
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0xf0],RDI
MOV qword ptr [RSP + 0xe8],RSI
MOV qword ptr [RSP + 0xe0],RDX
MOV RAX,qword ptr [RSP + 0xf0]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x00109170
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,RAX
CALL 0x00109470
MOV qword ptr [RSP + 0xd8],RAX
CMP qword ptr [RSP + 0xd8],0x0
JNZ 0x0010d900
MOV byte ptr [RSP + 0xab],0x1
MOV EDI,0x10
CALL 0x001091f0
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x00109170
MOV RDX,RAX
LAB_0010d85d:
LEA RSI,[0x116305]
XOR EAX,EAX
LEA RDI,[RSP + 0xb8]
CALL 0x0010ac50
JMP 0x0010d875
LAB_0010d875:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0xb8]
CALL 0x00109540
JMP 0x0010d889
LAB_0010d889:
MOV RDI,qword ptr [RSP + 0x38]
MOV byte ptr [RSP + 0xab],0x0
MOV RSI,qword ptr [0x0011dff0]
MOV RDX,qword ptr [0x0011dfc0]
CALL 0x001095d0
LAB_0010d900:
MOV RAX,qword ptr [RSP + 0xd8]
CMP dword ptr [RAX],0x0
JZ 0x0010d9db
MOV byte ptr [RSP + 0x87],0x1
MOV EDI,0x10
CALL 0x001091f0
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0xe8]
CALL 0x00109170
MOV RDX,RAX
LAB_0010d938:
LEA RSI,[0x11631a]
XOR EAX,EAX
LEA RDI,[RSP + 0x88]
CALL 0x0010ac50
JMP 0x0010d950
LAB_0010d950:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[RSP + 0x88]
CALL 0x00109540
JMP 0x0010d964
LAB_0010d964:
MOV RDI,qword ptr [RSP + 0x30]
MOV byte ptr [RSP + 0x87],0x0
MOV RSI,qword ptr [0x0011dff0]
MOV RDX,qword ptr [0x0011dfc0]
CALL 0x001095d0
LAB_0010d9db:
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x00109390
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x67]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x001128f0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_0010da06:
LEA RDI,[RSP + 0x68]
CALL 0x00112900
JMP 0x0010da12
LAB_0010da12:
LEA RDI,[RSP + 0x67]
CALL 0x00112980
MOV dword ptr [RSP + 0x60],0x0
LAB_0010da24:
MOVSXD RAX,dword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0xd8]
CMP RAX,qword ptr [RCX + 0x28]
JGE 0x0010db94
MOV dword ptr [RSP + 0x5c],0x0
LAB_0010da43:
MOVSXD RAX,dword ptr [RSP + 0x5c]
MOV RCX,qword ptr [RSP + 0xd8]
CMP RAX,qword ptr [RCX + 0x20]
JGE 0x0010db82
MOV dword ptr [RSP + 0x58],0x0
LAB_0010da62:
MOVSXD RAX,dword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0xd8]
CMP RAX,qword ptr [RCX + 0x18]
JGE 0x0010db70
MOV dword ptr [RSP + 0x54],0x0
LAB_0010da81:
MOVSXD RAX,dword ptr [RSP + 0x54]
MOV RCX,qword ptr [RSP + 0xd8]
CMP RAX,qword ptr [RCX + 0x10]
JGE 0x0010db5e
MOV RDI,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0xd8]
MOV ECX,dword ptr [RSI + 0x20]
IMUL EAX,ECX
MOV ECX,dword ptr [RSP + 0x5c]
MOV EDX,dword ptr [RSI + 0x10]
MOV ESI,dword ptr [RSI + 0x18]
IMUL ECX,ESI
ADD EAX,ECX
MOV ECX,dword ptr [RSP + 0x58]
IMUL ECX,EDX
ADD EAX,ECX
MOV ECX,dword ptr [RSP + 0x54]
ADD EAX,ECX
MOV dword ptr [RSP + 0x50],EAX
MOV ESI,dword ptr [RSP + 0x54]
MOV EDX,dword ptr [RSP + 0x58]
MOV ECX,dword ptr [RSP + 0x5c]
MOV R8D,dword ptr [RSP + 0x60]
LAB_0010dae2:
CALL 0x00112990
MOVSS dword ptr [RSP + 0x1c],XMM0
JMP 0x0010daef
LAB_0010daef:
MOVSXD RSI,dword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x68]
CALL 0x001129f0
MOVSS XMM0,dword ptr [RSP + 0x1c]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,0x1
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0010da81
LAB_0010db5e:
JMP 0x0010db60
LAB_0010db60:
MOV EAX,dword ptr [RSP + 0x58]
ADD EAX,0x1
MOV dword ptr [RSP + 0x58],EAX
JMP 0x0010da62
LAB_0010db70:
JMP 0x0010db72
LAB_0010db72:
MOV EAX,dword ptr [RSP + 0x5c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x5c],EAX
JMP 0x0010da43
LAB_0010db82:
JMP 0x0010db84
LAB_0010db84:
MOV EAX,dword ptr [RSP + 0x60]
ADD EAX,0x1
MOV dword ptr [RSP + 0x60],EAX
JMP 0x0010da24
LAB_0010db94:
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x68]
CALL 0x00112a10
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x001090a0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0010dbc3
LAB_0010dbc3:
MOV RCX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00109210
LAB_0010dbda:
JMP 0x0010dbdc
LAB_0010dbdc:
LEA RDI,[RSP + 0x68]
CALL 0x00112a30
ADD RSP,0xf8
RET
|
/* ggml_easy::ctx::set_tensor_data(std::__cxx11::string const&, std::function<float (int, int, int,
int)>) */
void __thiscall
ggml_easy::ctx::set_tensor_data
(ctx *this,int8 param_1,function<float(int,int,int,int)> *param_3)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int8 uVar5;
runtime_error *prVar6;
int8 uVar7;
ulong uVar8;
int4 *puVar9;
int4 uVar10;
int local_a4;
int local_a0;
int local_9c;
int local_98;
allocator<float> local_91;
vector<float,std::allocator<float>> local_90 [31];
int1 local_71;
string local_70 [35];
int1 local_4d;
string local_40 [32];
int *local_20;
function<float(int,int,int,int)> *local_18;
int8 local_10;
ctx *local_8;
uVar7 = *(int8 *)(this + 0x48);
local_18 = param_3;
local_10 = param_1;
local_8 = this;
uVar5 = std::__cxx11::string::c_str();
local_20 = (int *)ggml_get_tensor(uVar7,uVar5);
if (local_20 == (int *)0x0) {
local_4d = 1;
prVar6 = (runtime_error *)__cxa_allocate_exception(0x10);
uVar7 = std::__cxx11::string::c_str();
/* try { // try from 0010d85d to 0010d872 has its CatchHandler @ 0010d8ae */
string_format_abi_cxx11_((char *)local_40,"tensor not found: %s",uVar7);
/* try { // try from 0010d875 to 0010d8a8 has its CatchHandler @ 0010d8c4 */
std::runtime_error::runtime_error(prVar6,local_40);
local_4d = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(prVar6,PTR_typeinfo_0011dff0,PTR__runtime_error_0011dfc0);
}
if (*local_20 != 0) {
local_71 = 1;
prVar6 = (runtime_error *)__cxa_allocate_exception(0x10);
uVar7 = std::__cxx11::string::c_str();
/* try { // try from 0010d938 to 0010d94d has its CatchHandler @ 0010d989 */
string_format_abi_cxx11_((char *)local_70,"tensor type must be GGML_TYPE_F32: %s",uVar7);
/* try { // try from 0010d950 to 0010d983 has its CatchHandler @ 0010d99f */
std::runtime_error::runtime_error(prVar6,local_70);
local_71 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(prVar6,PTR_typeinfo_0011dff0,PTR__runtime_error_0011dfc0);
}
uVar8 = ggml_nelements(local_20);
std::allocator<float>::allocator(&local_91);
/* try { // try from 0010da06 to 0010da0f has its CatchHandler @ 0010db18 */
std::vector<float,std::allocator<float>>::vector(local_90,uVar8,(allocator *)&local_91);
std::allocator<float>::~allocator(&local_91);
for (local_98 = 0; piVar4 = local_20, (long)local_98 < *(long *)(local_20 + 10);
local_98 = local_98 + 1) {
for (local_9c = 0; (long)local_9c < *(long *)(local_20 + 8); local_9c = local_9c + 1) {
for (local_a0 = 0; (long)local_a0 < *(long *)(local_20 + 6); local_a0 = local_a0 + 1) {
for (local_a4 = 0; (long)local_a4 < *(long *)(local_20 + 4); local_a4 = local_a4 + 1) {
iVar1 = local_20[8];
iVar2 = local_20[4];
iVar3 = local_20[6];
/* try { // try from 0010dae2 to 0010dbd9 has its CatchHandler @ 0010db3b */
uVar10 = std::function<float(int,int,int,int)>::operator()
(param_3,local_a4,local_a0,local_9c,local_98);
puVar9 = (int4 *)
std::vector<float,std::allocator<float>>::operator[]
(local_90,(long)(local_98 * iVar1 + local_9c * iVar3 + local_a0 * iVar2
+ local_a4));
*puVar9 = uVar10;
}
}
}
}
uVar7 = std::vector<float,std::allocator<float>>::data(local_90);
uVar5 = ggml_nbytes(local_20);
ggml_backend_tensor_set(piVar4,uVar7,0,uVar5);
std::vector<float,std::allocator<float>>::~vector(local_90);
return;
}
| |
39,426 | common_token_to_piece[abi:cxx11](llama_vocab const*, int, bool) | monkey531[P]llama/common/common.cpp | std::string common_token_to_piece(const struct llama_vocab * vocab, llama_token token, bool special) {
std::string piece;
piece.resize(piece.capacity()); // using string internal cache, 15 bytes + '\n'
const int n_chars = llama_token_to_piece(vocab, token, &piece[0], piece.size(), 0, special);
if (n_chars < 0) {
piece.resize(-n_chars);
int check = llama_token_to_piece(vocab, token, &piece[0], piece.size(), 0, special);
GGML_ASSERT(check == -n_chars);
}
else {
piece.resize(n_chars);
}
return piece;
} | O1 | cpp | common_token_to_piece[abi:cxx11](llama_vocab const*, int, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0xf, %esi
xorl %edx, %edx
callq 0x1b260
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
movzbl %r15b, %r15d
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
movl %r15d, %r9d
callq 0x1b820
movl %eax, %r12d
testl %eax, %eax
js 0x7aff6
movl %r12d, %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1b260
jmp 0x7b021
negl %r12d
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x1b260
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
movq %r14, %rdi
movl %ebp, %esi
xorl %r8d, %r8d
movl %r15d, %r9d
callq 0x1b820
cmpl %r12d, %eax
jne 0x7b033
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7bd4f(%rip), %rdi # 0xf6d89
leaq 0x72594(%rip), %rdx # 0xed5d5
leaq 0x7c3d4(%rip), %rcx # 0xf741c
movl $0x6cc, %esi # imm = 0x6CC
xorl %eax, %eax
callq 0x1bef0
jmp 0x7b058
jmp 0x7b058
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x7b06f
movq (%r13), %rsi
incq %rsi
callq 0x1b910
movq %r14, %rdi
callq 0x1bff0
| _Z21common_token_to_pieceB5cxx11PK11llama_vocabib:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, ecx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov esi, 0Fh
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rdx, [rbx]
mov ecx, [rbx+8]
movzx r15d, r15b
mov rdi, r14
mov esi, ebp
xor r8d, r8d
mov r9d, r15d
call _llama_token_to_piece
mov r12d, eax
test eax, eax
js short loc_7AFF6
mov esi, r12d
mov rdi, rbx
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
jmp short loc_7B021
loc_7AFF6:
neg r12d
mov rdi, rbx
mov rsi, r12
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rdx, [rbx]
mov ecx, [rbx+8]
mov rdi, r14
mov esi, ebp
xor r8d, r8d
mov r9d, r15d
call _llama_token_to_piece
cmp eax, r12d
jnz short loc_7B033
loc_7B021:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7B033:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCheckNChars; "check == -n_chars"
mov esi, 6CCh
xor eax, eax
call _ggml_abort
jmp short loc_7B058
jmp short $+2
loc_7B058:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_7B06F
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B06F:
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_token_to_piece[abi:cxx11](_QWORD *a1, long long a2, unsigned int a3, unsigned __int8 a4)
{
long long v4; // rax
_QWORD *v7; // r13
int v8; // eax
long long v9; // r12
long long v11; // r14
long long v12; // [rsp-8h] [rbp-38h]
long long v13; // [rsp-8h] [rbp-38h]
v12 = v4;
v7 = a1 + 2;
*a1 = a1 + 2;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
std::string::resize(a1, 15LL, 0LL);
v8 = llama_token_to_piece(a2, a3, *a1, *((unsigned int *)a1 + 2), 0LL, a4, v12);
if ( v8 < 0 )
{
v9 = (unsigned int)-v8;
std::string::resize(a1, v9, 0LL);
if ( (unsigned int)llama_token_to_piece(a2, a3, *a1, *((unsigned int *)a1 + 2), 0LL, a4, v13) != (_DWORD)v9 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1740LL,
"GGML_ASSERT(%s) failed",
"check == -n_chars");
if ( (_QWORD *)*a1 != v7 )
operator delete((void *)*a1, *v7 + 1LL);
_Unwind_Resume(v11);
}
}
else
{
std::string::resize(a1, (unsigned int)v8, 0LL);
}
return a1;
}
| common_token_to_piece[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,ECX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
MOV qword ptr [RDI],R13
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_0017afba:
MOV ESI,0xf
XOR EDX,EDX
CALL 0x0011b260
MOV RDX,qword ptr [RBX]
MOV ECX,dword ptr [RBX + 0x8]
LAB_0017afcc:
MOVZX R15D,R15B
MOV RDI,R14
MOV ESI,EBP
XOR R8D,R8D
MOV R9D,R15D
CALL 0x0011b820
MOV R12D,EAX
TEST EAX,EAX
JS 0x0017aff6
MOV ESI,R12D
MOV RDI,RBX
XOR EDX,EDX
CALL 0x0011b260
JMP 0x0017b021
LAB_0017aff6:
NEG R12D
MOV RDI,RBX
MOV RSI,R12
XOR EDX,EDX
CALL 0x0011b260
MOV RDX,qword ptr [RBX]
MOV ECX,dword ptr [RBX + 0x8]
LAB_0017b00c:
MOV RDI,R14
MOV ESI,EBP
XOR R8D,R8D
MOV R9D,R15D
CALL 0x0011b820
CMP EAX,R12D
JNZ 0x0017b033
LAB_0017b021:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017b033:
LEA RDI,[0x1f6d89]
LEA RDX,[0x1ed5d5]
LEA RCX,[0x1f741c]
MOV ESI,0x6cc
XOR EAX,EAX
CALL 0x0011bef0
|
/* common_token_to_piece[abi:cxx11](llama_vocab const*, int, bool) */
llama_vocab * common_token_to_piece_abi_cxx11_(llama_vocab *param_1,int param_2,bool param_3)
{
int iVar1;
int iVar2;
int1 in_CL;
int7 in_register_00000011;
int4 in_register_00000034;
*(llama_vocab **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (llama_vocab)0x0;
/* try { // try from 0017afba to 0017afc5 has its CatchHandler @ 0017b056 */
std::__cxx11::string::resize((ulong)param_1,'\x0f');
/* try { // try from 0017afcc to 0017b005 has its CatchHandler @ 0017b058 */
iVar1 = llama_token_to_piece
(CONCAT44(in_register_00000034,param_2),
CONCAT71(in_register_00000011,param_3) & 0xffffffff,*(int8 *)param_1,
*(int4 *)(param_1 + 8),0,in_CL);
if (iVar1 < 0) {
std::__cxx11::string::resize((ulong)param_1,(char)-iVar1);
/* try { // try from 0017b00c to 0017b053 has its CatchHandler @ 0017b054 */
iVar2 = llama_token_to_piece
(CONCAT44(in_register_00000034,param_2),
CONCAT71(in_register_00000011,param_3) & 0xffffffff,*(int8 *)param_1,
*(int4 *)(param_1 + 8),0,in_CL);
if (iVar2 != -iVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x6cc
,"GGML_ASSERT(%s) failed","check == -n_chars");
}
}
else {
std::__cxx11::string::resize((ulong)param_1,(char)iVar1);
}
return param_1;
}
| |
39,427 | ma_search_next | eloqsql/storage/maria/ma_search.c | int _ma_search_next(register MARIA_HA *info, MARIA_KEY *key,
uint32 nextflag, my_off_t pos)
{
int error;
uchar lastkey[MARIA_MAX_KEY_BUFF];
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_KEY tmp_key;
MARIA_PAGE page;
DBUG_ENTER("_ma_search_next");
DBUG_PRINT("enter",("nextflag: %u lastpos: %lu int_keypos:%p page_changed %d keyread_buff_used: %d",
nextflag, (ulong) info->cur_row.lastpos,
info->int_keypos,
info->page_changed, info->keyread_buff_used));
DBUG_EXECUTE("key", _ma_print_key(DBUG_FILE, key););
/*
Force full read if we are at last key or if we are not on a leaf
and the key tree has changed since we used it last time
Note that even if the key tree has changed since last read, we can use
the last read data from the leaf if we haven't used the buffer for
something else.
*/
if (((nextflag & SEARCH_BIGGER) && info->int_keypos >= info->int_maxpos) ||
info->page_changed ||
(info->int_keytree_version != keyinfo->version &&
(info->int_nod_flag || info->keyread_buff_used)))
DBUG_RETURN(_ma_search(info, key, nextflag | SEARCH_SAVE_BUFF,
pos));
if (info->keyread_buff_used)
{
if (_ma_fetch_keypage(&page, info, keyinfo, info->last_search_keypage,
PAGECACHE_LOCK_LEFT_UNLOCKED,
DFLT_INIT_HITS, info->keyread_buff, 0))
DBUG_RETURN(-1);
info->keyread_buff_used=0;
}
else
{
/* Last used buffer is in info->keyread_buff */
/* Todo: Add info->keyread_page to keep track of this */
_ma_page_setup(&page, info, keyinfo, 0, info->keyread_buff);
}
tmp_key.data= lastkey;
tmp_key.keyinfo= keyinfo;
if (nextflag & SEARCH_BIGGER) /* Next key */
{
if (page.node)
{
my_off_t tmp_pos= _ma_kpos(page.node, info->int_keypos);
if ((error= _ma_search(info, key, nextflag | SEARCH_SAVE_BUFF,
tmp_pos)) <=0)
DBUG_RETURN(error);
}
if (keyinfo->flag & (HA_PACK_KEY | HA_BINARY_PACK_KEY) &&
info->last_key.data != key->data)
memcpy(info->last_key.data, key->data,
key->data_length + key->ref_length);
if (!(*keyinfo->get_key)(&info->last_key, page.flag, page.node,
&info->int_keypos))
DBUG_RETURN(-1);
}
else /* Previous key */
{
/* Find start of previous key */
info->int_keypos= _ma_get_last_key(&tmp_key, &page, info->int_keypos);
if (!info->int_keypos)
DBUG_RETURN(-1);
if (info->int_keypos == info->keyread_buff + info->s->keypage_header)
{
/* Previous key was first key, read key before this one */
DBUG_RETURN(_ma_search(info, key, nextflag | SEARCH_SAVE_BUFF,
pos));
}
if (page.node &&
(error= _ma_search(info, key, nextflag | SEARCH_SAVE_BUFF,
_ma_kpos(page.node,info->int_keypos))) <= 0)
DBUG_RETURN(error);
/* QQ: We should be able to optimize away the following call */
if (! _ma_get_last_key(&info->last_key, &page, info->int_keypos))
DBUG_RETURN(-1);
}
info->cur_row.lastpos= _ma_row_pos_from_key(&info->last_key);
info->cur_row.trid= _ma_trid_from_key(&info->last_key);
DBUG_PRINT("exit",("found key at %lu",(ulong) info->cur_row.lastpos));
DBUG_RETURN(0);
} | O3 | c | ma_search_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa48, %rsp # imm = 0xA48
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rsi), %r12
testb $0x8, %r15b
je 0x6ea42
movq 0x3b0(%rbx), %rax
cmpq 0x3b8(%rbx), %rax
jae 0x6ea4b
cmpb $0x0, 0x684(%rbx)
je 0x6ea84
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6ecc6
orl $0x20, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r13, %rcx
addq $0xa48, %rsp # imm = 0xA48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6cacf
movl 0x3d4(%rbx), %eax
cmpl 0xb8(%r12), %eax
jne 0x6eae1
cmpb $0x0, 0x685(%rbx)
je 0x6eafb
movq 0x448(%rbx), %rcx
leaq -0xa48(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
movl $0x3, %r9d
pushq $0x0
pushq 0x380(%rbx)
callq 0x6faae
addq $0x10, %rsp
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testb %al, %al
jne 0x6eca3
movb $0x0, 0x685(%rbx)
jmp 0x6eb16
cmpl $0x0, 0x3d0(%rbx)
jne 0x6ea4b
cmpb $0x0, 0x685(%rbx)
jne 0x6ea4b
movq 0x380(%rbx), %r8
leaq -0xa48(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x6fa5c
leaq -0xa10(%rbp), %rax
movq %rax, -0xa68(%rbp)
movq %r12, -0xa60(%rbp)
testb $0x8, %r15b
jne 0x6ebdc
movq 0x3b0(%rbx), %rdx
leaq -0xa68(%rbp), %rdi
leaq -0xa48(%rbp), %rsi
callq 0x6e808
movq %rax, 0x3b0(%rbx)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x6eca3
movq (%rbx), %rcx
movl 0x744(%rcx), %ecx
addq 0x380(%rbx), %rcx
cmpq %rcx, %rax
je 0x6ec8c
movl -0xa20(%rbp), %edi
testl %edi, %edi
je 0x6ebb3
orl $0x20, %r15d
movq %rax, %rsi
callq 0x6dabf
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %rax, %rcx
callq 0x6cacf
testl %eax, %eax
jle 0x6eca1
movq 0x3b0(%rbx), %rax
leaq 0x200(%rbx), %rdi
leaq -0xa48(%rbp), %rsi
movq %rax, %rdx
callq 0x6e808
testq %rax, %rax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
jne 0x6ec5c
jmp 0x6eca3
movl -0xa20(%rbp), %edi
testl %edi, %edi
je 0x6ec0f
movq 0x3b0(%rbx), %rsi
callq 0x6dabf
orl $0x20, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %rax, %rcx
callq 0x6cacf
testl %eax, %eax
jle 0x6eca1
testb $0x22, 0xa2(%r12)
je 0x6ec36
movq 0x200(%rbx), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0x6ec36
movl 0x14(%r14), %edx
addl 0x10(%r14), %edx
callq 0x29080
leaq 0x200(%rbx), %rdi
movl -0xa20(%rbp), %edx
movl -0xa1c(%rbp), %esi
leaq 0x3b0(%rbx), %rcx
callq *0xe0(%r12)
testl %eax, %eax
je 0x6ec85
leaq 0x200(%rbx), %r14
movq %r14, %rdi
callq 0x6dc24
movq %rax, 0x98(%rbx)
movq %r14, %rdi
callq 0x6dcdc
movq %rax, 0xc0(%rbx)
xorl %ecx, %ecx
jmp 0x6eca3
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
jmp 0x6eca3
orl $0x20, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r13, %rcx
callq 0x6cacf
movl %eax, %ecx
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6ecc6
movl %ecx, %eax
addq $0xa48, %rsp # imm = 0xA48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29260
| _ma_search_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A48h
mov r13, rcx
mov r15d, edx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r12, [rsi+8]
test r15b, 8
jz short loc_6EA42
mov rax, [rbx+3B0h]
cmp rax, [rbx+3B8h]
jnb short loc_6EA4B
loc_6EA42:
cmp byte ptr [rbx+684h], 0
jz short loc_6EA84
loc_6EA4B:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_6ECC6
or r15d, 20h
mov rdi, rbx
mov rsi, r14
mov edx, r15d
mov rcx, r13
add rsp, 0A48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ma_search
loc_6EA84:
mov eax, [rbx+3D4h]
cmp eax, [r12+0B8h]
jnz short loc_6EAE1
cmp byte ptr [rbx+685h], 0
jz short loc_6EAFB
mov rcx, [rbx+448h]
lea rdi, [rbp+var_A48]
mov rsi, rbx
mov rdx, r12
xor r8d, r8d
mov r9d, 3
push 0
push qword ptr [rbx+380h]
call _ma_fetch_keypage
add rsp, 10h
mov ecx, 0FFFFFFFFh
test al, al
jnz loc_6ECA3
mov byte ptr [rbx+685h], 0
jmp short loc_6EB16
loc_6EAE1:
cmp dword ptr [rbx+3D0h], 0
jnz loc_6EA4B
cmp byte ptr [rbx+685h], 0
jnz loc_6EA4B
loc_6EAFB:
mov r8, [rbx+380h]
lea rdi, [rbp+var_A48]
mov rsi, rbx
mov rdx, r12
xor ecx, ecx
call _ma_page_setup
loc_6EB16:
lea rax, [rbp+var_A10]
mov [rbp+var_A68], rax
mov [rbp+var_A60], r12
test r15b, 8
jnz loc_6EBDC
mov rdx, [rbx+3B0h]
lea rdi, [rbp+var_A68]
lea rsi, [rbp+var_A48]
call _ma_get_last_key
mov [rbx+3B0h], rax
mov ecx, 0FFFFFFFFh
test rax, rax
jz loc_6ECA3
mov rcx, [rbx]
mov ecx, [rcx+744h]
add rcx, [rbx+380h]
cmp rax, rcx
jz loc_6EC8C
mov edi, [rbp+var_A20]
test edi, edi
jz short loc_6EBB3
or r15d, 20h
mov rsi, rax
call _ma_kpos
mov rdi, rbx
mov rsi, r14
mov edx, r15d
mov rcx, rax
call _ma_search
test eax, eax
jle loc_6ECA1
mov rax, [rbx+3B0h]
loc_6EBB3:
lea rdi, [rbx+200h]
lea rsi, [rbp+var_A48]
mov rdx, rax
call _ma_get_last_key
test rax, rax
mov ecx, 0FFFFFFFFh
jnz loc_6EC5C
jmp loc_6ECA3
loc_6EBDC:
mov edi, [rbp+var_A20]
test edi, edi
jz short loc_6EC0F
mov rsi, [rbx+3B0h]
call _ma_kpos
or r15d, 20h
mov rdi, rbx
mov rsi, r14
mov edx, r15d
mov rcx, rax
call _ma_search
test eax, eax
jle loc_6ECA1
loc_6EC0F:
test byte ptr [r12+0A2h], 22h
jz short loc_6EC36
mov rdi, [rbx+200h]
mov rsi, [r14]
cmp rdi, rsi
jz short loc_6EC36
mov edx, [r14+14h]
add edx, [r14+10h]
call _memcpy
loc_6EC36:
lea rdi, [rbx+200h]
mov edx, [rbp+var_A20]
mov esi, [rbp+var_A1C]
lea rcx, [rbx+3B0h]
call qword ptr [r12+0E0h]
test eax, eax
jz short loc_6EC85
loc_6EC5C:
lea r14, [rbx+200h]
mov rdi, r14
call _ma_row_pos_from_key
mov [rbx+98h], rax
mov rdi, r14
call _ma_trid_from_key
mov [rbx+0C0h], rax
xor ecx, ecx
jmp short loc_6ECA3
loc_6EC85:
mov ecx, 0FFFFFFFFh
jmp short loc_6ECA3
loc_6EC8C:
or r15d, 20h
mov rdi, rbx
mov rsi, r14
mov edx, r15d
mov rcx, r13
call _ma_search
loc_6ECA1:
mov ecx, eax
loc_6ECA3:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_6ECC6
mov eax, ecx
add rsp, 0A48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6ECC6:
call ___stack_chk_fail
| long long ma_search_next(long long a1, long long a2, int a3, long long a4)
{
long long v8; // r12
char keypage; // al
unsigned int v11; // ecx
unsigned long long last_key; // rax
long long v13; // rax
int v14; // eax
unsigned long long v15; // rax
long long v16; // rax
long long v17; // rdi
long long v18; // rsi
_QWORD v19[4]; // [rsp+8h] [rbp-A68h] BYREF
_BYTE v20[40]; // [rsp+28h] [rbp-A48h] BYREF
unsigned int v21; // [rsp+50h] [rbp-A20h]
unsigned int v22; // [rsp+54h] [rbp-A1Ch]
char v23; // [rsp+60h] [rbp-A10h] BYREF
unsigned long long v24; // [rsp+A40h] [rbp-30h]
v24 = __readfsqword(0x28u);
v8 = *(_QWORD *)(a2 + 8);
if ( (a3 & 8) != 0 && *(_QWORD *)(a1 + 944) >= *(_QWORD *)(a1 + 952) || *(_BYTE *)(a1 + 1668) )
return ma_search(a1, a2, a3 | 0x20u, a4);
if ( *(_DWORD *)(a1 + 980) != *(_DWORD *)(v8 + 184) )
{
if ( *(_DWORD *)(a1 + 976) || *(_BYTE *)(a1 + 1669) )
return ma_search(a1, a2, a3 | 0x20u, a4);
goto LABEL_11;
}
if ( !*(_BYTE *)(a1 + 1669) )
{
LABEL_11:
ma_page_setup(v20, a1, v8, 0LL, *(_QWORD *)(a1 + 896));
goto LABEL_12;
}
keypage = ma_fetch_keypage((unsigned int)v20, a1, v8, *(_QWORD *)(a1 + 1096), 0, 3, *(_QWORD *)(a1 + 896));
v11 = -1;
if ( keypage )
return v11;
*(_BYTE *)(a1 + 1669) = 0;
LABEL_12:
v19[0] = &v23;
v19[1] = v8;
if ( (a3 & 8) != 0 )
{
if ( !v21 || (v16 = ma_kpos(v21, *(_QWORD *)(a1 + 944)), v14 = ma_search(a1, a2, a3 | 0x20u, v16), v14 > 0) )
{
if ( (*(_BYTE *)(v8 + 162) & 0x22) != 0 )
{
v17 = *(_QWORD *)(a1 + 512);
v18 = *(_QWORD *)a2;
if ( v17 != *(_QWORD *)a2 )
memcpy(v17, v18, (unsigned int)(*(_DWORD *)(a2 + 16) + *(_DWORD *)(a2 + 20)));
}
if ( !(*(unsigned int ( **)(long long, _QWORD, _QWORD, long long))(v8 + 224))(a1 + 512, v22, v21, a1 + 944) )
return (unsigned int)-1;
goto LABEL_26;
}
return (unsigned int)v14;
}
last_key = ma_get_last_key((long long)v19, (long long)v20, *(_QWORD *)(a1 + 944));
*(_QWORD *)(a1 + 944) = last_key;
v11 = -1;
if ( last_key )
{
if ( last_key == *(_QWORD *)(a1 + 896) + *(unsigned int *)(*(_QWORD *)a1 + 1860LL) )
{
return (unsigned int)ma_search(a1, a2, a3 | 0x20u, a4);
}
else
{
if ( !v21 )
goto LABEL_18;
v13 = ma_kpos(v21, last_key);
v14 = ma_search(a1, a2, a3 | 0x20u, v13);
if ( v14 > 0 )
{
last_key = *(_QWORD *)(a1 + 944);
LABEL_18:
v15 = ma_get_last_key(a1 + 512, (long long)v20, last_key);
v11 = -1;
if ( !v15 )
return v11;
LABEL_26:
*(_QWORD *)(a1 + 152) = ma_row_pos_from_key((long long *)(a1 + 512));
*(_QWORD *)(a1 + 192) = ma_trid_from_key(a1 + 512);
return 0;
}
}
return (unsigned int)v14;
}
return v11;
}
| _ma_search_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa48
MOV R13,RCX
MOV R15D,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R12,qword ptr [RSI + 0x8]
TEST R15B,0x8
JZ 0x0016ea42
MOV RAX,qword ptr [RBX + 0x3b0]
CMP RAX,qword ptr [RBX + 0x3b8]
JNC 0x0016ea4b
LAB_0016ea42:
CMP byte ptr [RBX + 0x684],0x0
JZ 0x0016ea84
LAB_0016ea4b:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016ecc6
OR R15D,0x20
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R15D
MOV RCX,R13
ADD RSP,0xa48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0016cacf
LAB_0016ea84:
MOV EAX,dword ptr [RBX + 0x3d4]
CMP EAX,dword ptr [R12 + 0xb8]
JNZ 0x0016eae1
CMP byte ptr [RBX + 0x685],0x0
JZ 0x0016eafb
MOV RCX,qword ptr [RBX + 0x448]
LEA RDI,[RBP + -0xa48]
MOV RSI,RBX
MOV RDX,R12
XOR R8D,R8D
MOV R9D,0x3
PUSH 0x0
PUSH qword ptr [RBX + 0x380]
CALL 0x0016faae
ADD RSP,0x10
MOV ECX,0xffffffff
TEST AL,AL
JNZ 0x0016eca3
MOV byte ptr [RBX + 0x685],0x0
JMP 0x0016eb16
LAB_0016eae1:
CMP dword ptr [RBX + 0x3d0],0x0
JNZ 0x0016ea4b
CMP byte ptr [RBX + 0x685],0x0
JNZ 0x0016ea4b
LAB_0016eafb:
MOV R8,qword ptr [RBX + 0x380]
LEA RDI,[RBP + -0xa48]
MOV RSI,RBX
MOV RDX,R12
XOR ECX,ECX
CALL 0x0016fa5c
LAB_0016eb16:
LEA RAX,[RBP + -0xa10]
MOV qword ptr [RBP + -0xa68],RAX
MOV qword ptr [RBP + -0xa60],R12
TEST R15B,0x8
JNZ 0x0016ebdc
MOV RDX,qword ptr [RBX + 0x3b0]
LEA RDI,[RBP + -0xa68]
LEA RSI,[RBP + -0xa48]
CALL 0x0016e808
MOV qword ptr [RBX + 0x3b0],RAX
MOV ECX,0xffffffff
TEST RAX,RAX
JZ 0x0016eca3
MOV RCX,qword ptr [RBX]
MOV ECX,dword ptr [RCX + 0x744]
ADD RCX,qword ptr [RBX + 0x380]
CMP RAX,RCX
JZ 0x0016ec8c
MOV EDI,dword ptr [RBP + -0xa20]
TEST EDI,EDI
JZ 0x0016ebb3
OR R15D,0x20
MOV RSI,RAX
CALL 0x0016dabf
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R15D
MOV RCX,RAX
CALL 0x0016cacf
TEST EAX,EAX
JLE 0x0016eca1
MOV RAX,qword ptr [RBX + 0x3b0]
LAB_0016ebb3:
LEA RDI,[RBX + 0x200]
LEA RSI,[RBP + -0xa48]
MOV RDX,RAX
CALL 0x0016e808
TEST RAX,RAX
MOV ECX,0xffffffff
JNZ 0x0016ec5c
JMP 0x0016eca3
LAB_0016ebdc:
MOV EDI,dword ptr [RBP + -0xa20]
TEST EDI,EDI
JZ 0x0016ec0f
MOV RSI,qword ptr [RBX + 0x3b0]
CALL 0x0016dabf
OR R15D,0x20
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R15D
MOV RCX,RAX
CALL 0x0016cacf
TEST EAX,EAX
JLE 0x0016eca1
LAB_0016ec0f:
TEST byte ptr [R12 + 0xa2],0x22
JZ 0x0016ec36
MOV RDI,qword ptr [RBX + 0x200]
MOV RSI,qword ptr [R14]
CMP RDI,RSI
JZ 0x0016ec36
MOV EDX,dword ptr [R14 + 0x14]
ADD EDX,dword ptr [R14 + 0x10]
CALL 0x00129080
LAB_0016ec36:
LEA RDI,[RBX + 0x200]
MOV EDX,dword ptr [RBP + -0xa20]
MOV ESI,dword ptr [RBP + -0xa1c]
LEA RCX,[RBX + 0x3b0]
CALL qword ptr [R12 + 0xe0]
TEST EAX,EAX
JZ 0x0016ec85
LAB_0016ec5c:
LEA R14,[RBX + 0x200]
MOV RDI,R14
CALL 0x0016dc24
MOV qword ptr [RBX + 0x98],RAX
MOV RDI,R14
CALL 0x0016dcdc
MOV qword ptr [RBX + 0xc0],RAX
XOR ECX,ECX
JMP 0x0016eca3
LAB_0016ec85:
MOV ECX,0xffffffff
JMP 0x0016eca3
LAB_0016ec8c:
OR R15D,0x20
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R15D
MOV RCX,R13
CALL 0x0016cacf
LAB_0016eca1:
MOV ECX,EAX
LAB_0016eca3:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016ecc6
MOV EAX,ECX
ADD RSP,0xa48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016ecc6:
CALL 0x00129260
|
ulong _ma_search_next(long *param_1,int8 *param_2,uint param_3,int8 param_4)
{
char cVar1;
uint uVar2;
int iVar3;
ulong uVar4;
long lVar5;
int8 uVar6;
long in_FS_OFFSET;
int1 *local_a70;
long local_a68;
int1 local_a50 [40];
int local_a28;
int4 local_a24;
int1 local_a18 [2528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = param_2[1];
if ((((param_3 & 8) == 0) || ((ulong)param_1[0x76] < (ulong)param_1[0x77])) &&
(*(char *)((long)param_1 + 0x684) == '\0')) {
if (*(int *)((long)param_1 + 0x3d4) == *(int *)(lVar5 + 0xb8)) {
if (*(char *)((long)param_1 + 0x685) == '\0') goto LAB_0016eafb;
cVar1 = _ma_fetch_keypage(local_a50,param_1,lVar5,param_1[0x89],0,3,param_1[0x70],0);
uVar4 = 0xffffffff;
if (cVar1 == '\0') {
*(int1 *)((long)param_1 + 0x685) = 0;
goto LAB_0016eb16;
}
goto LAB_0016eca3;
}
if (((int)param_1[0x7a] == 0) && (*(char *)((long)param_1 + 0x685) == '\0')) {
LAB_0016eafb:
_ma_page_setup(local_a50,param_1,lVar5,0,param_1[0x70]);
LAB_0016eb16:
local_a70 = local_a18;
local_a68 = lVar5;
if ((param_3 & 8) == 0) {
lVar5 = _ma_get_last_key(&local_a70,local_a50,param_1[0x76]);
param_1[0x76] = lVar5;
uVar4 = 0xffffffff;
if (lVar5 != 0) {
if (lVar5 == (ulong)*(uint *)(*param_1 + 0x744) + param_1[0x70]) {
uVar2 = _ma_search(param_1,param_2,param_3 | 0x20,param_4);
LAB_0016eca1:
uVar4 = (ulong)uVar2;
}
else {
if (local_a28 != 0) {
uVar6 = _ma_kpos(local_a28,lVar5);
uVar2 = _ma_search(param_1,param_2,param_3 | 0x20,uVar6);
if ((int)uVar2 < 1) goto LAB_0016eca1;
lVar5 = param_1[0x76];
}
lVar5 = _ma_get_last_key(param_1 + 0x40,local_a50,lVar5);
uVar4 = 0xffffffff;
if (lVar5 != 0) goto LAB_0016ec5c;
}
}
}
else {
if (local_a28 != 0) {
uVar6 = _ma_kpos(local_a28,param_1[0x76]);
uVar2 = _ma_search(param_1,param_2,param_3 | 0x20,uVar6);
if ((int)uVar2 < 1) goto LAB_0016eca1;
}
if ((*(byte *)(lVar5 + 0xa2) & 0x22) != 0) {
if ((void *)param_1[0x40] != (void *)*param_2) {
memcpy((void *)param_1[0x40],(void *)*param_2,
(ulong)(uint)(*(int *)((long)param_2 + 0x14) + *(int *)(param_2 + 2)));
}
}
iVar3 = (**(code **)(lVar5 + 0xe0))(param_1 + 0x40,local_a24,local_a28,param_1 + 0x76);
if (iVar3 == 0) {
uVar4 = 0xffffffff;
}
else {
LAB_0016ec5c:
lVar5 = _ma_row_pos_from_key(param_1 + 0x40);
param_1[0x13] = lVar5;
lVar5 = _ma_trid_from_key(param_1 + 0x40);
param_1[0x18] = lVar5;
uVar4 = 0;
}
}
LAB_0016eca3:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar4;
}
goto LAB_0016ecc6;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar4 = _ma_search(param_1,param_2,param_3 | 0x20,param_4);
return uVar4;
}
LAB_0016ecc6:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,428 | glfwPlatformGetVideoModes | untodesu[P]riteg/build_O0/_deps/glfw-src/src/x11_monitor.c | GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
{
GLFWvidmode* result;
*count = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
int i, j;
XRRScreenResources* sr;
XRRCrtcInfo* ci;
XRROutputInfo* oi;
sr = XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
result = calloc(oi->nmode, sizeof(GLFWvidmode));
for (i = 0; i < oi->nmode; i++)
{
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
if (!modeIsGood(mi))
continue;
const GLFWvidmode mode = vidmodeFromModeInfo(mi, ci);
for (j = 0; j < *count; j++)
{
if (_glfwCompareVideoModes(result + j, &mode) == 0)
break;
}
// Skip duplicate modes
if (j < *count)
continue;
(*count)++;
result[*count - 1] = mode;
}
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
*count = 1;
result = calloc(1, sizeof(GLFWvidmode));
_glfwPlatformGetVideoMode(monitor, result);
}
return result;
} | O0 | c | glfwPlatformGetVideoModes:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
leaq 0xb1437(%rip), %rax # 0xe0c68
cmpl $0x0, 0x20570(%rax)
je 0x2fa22
leaq 0xb1423(%rip), %rax # 0xe0c68
cmpl $0x0, 0x20594(%rax)
jne 0x2fa22
leaq 0xb140f(%rip), %rax # 0xe0c68
movq 0x205e8(%rax), %rax
leaq 0xb1401(%rip), %rcx # 0xe0c68
movq 0x1fec0(%rcx), %rdi
leaq 0xb13f3(%rip), %rcx # 0xe0c68
movq 0x1fed0(%rcx), %rsi
callq *%rax
movq %rax, -0x28(%rbp)
leaq 0xb13df(%rip), %rax # 0xe0c68
movq 0x205d0(%rax), %rax
leaq 0xb13d1(%rip), %rcx # 0xe0c68
movq 0x1fec0(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rdx
callq *%rax
movq %rax, -0x30(%rbp)
leaq 0xb13ae(%rip), %rax # 0xe0c68
movq 0x205d8(%rax), %rax
leaq 0xb13a0(%rip), %rcx # 0xe0c68
movq 0x1fec0(%rcx), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0x88(%rcx), %rdx
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq 0x50(%rax), %rdi
movl $0x18, %esi
callq 0xc5b0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jge 0x2f9e4
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2f020
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2f090
cmpl $0x0, %eax
jne 0x2f941
jmp 0x2f9d6
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x2f0c0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2f990
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x58(%rbp), %rsi
callq 0x26910
cmpl $0x0, %eax
jne 0x2f983
jmp 0x2f990
jmp 0x2f985
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2f959
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2f99d
jmp 0x2f9d6
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2f901
leaq 0xb127d(%rip), %rax # 0xe0c68
movq 0x205b0(%rax), %rax
movq -0x38(%rbp), %rdi
callq *%rax
leaq 0xb1269(%rip), %rax # 0xe0c68
movq 0x205a0(%rax), %rax
movq -0x30(%rbp), %rdi
callq *%rax
leaq 0xb1255(%rip), %rax # 0xe0c68
movq 0x205b8(%rax), %rax
movq -0x28(%rbp), %rdi
callq *%rax
jmp 0x2fa4c
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x1, %edi
movl $0x18, %esi
callq 0xc5b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ee50
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _glfwPlatformGetVideoModes:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
lea rax, _glfw
cmp dword ptr ds:loc_20570[rax], 0
jz loc_2FA22
lea rax, _glfw
cmp dword ptr ds:loc_20594[rax], 0
jnz loc_2FA22
lea rax, _glfw
mov rax, [rax+205E8h]
lea rcx, _glfw
mov rdi, qword ptr ds:loc_1FEC0[rcx]
lea rcx, _glfw
mov rsi, [rcx+1FED0h]
call rax
mov [rbp+var_28], rax
lea rax, _glfw
mov rax, [rax+205D0h]
lea rcx, _glfw
mov rdi, qword ptr ds:loc_1FEC0[rcx]
mov rsi, [rbp+var_28]
mov rcx, [rbp+var_8]
mov rdx, [rcx+90h]
call rax
mov [rbp+var_30], rax
lea rax, _glfw
mov rax, [rax+205D8h]
lea rcx, _glfw
mov rdi, qword ptr ds:loc_1FEC0[rcx]
mov rsi, [rbp+var_28]
mov rcx, [rbp+var_8]
mov rdx, [rcx+88h]
call rax
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
movsxd rdi, dword ptr [rax+50h]
mov esi, 18h
call _calloc
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
loc_2F901:
mov eax, [rbp+var_1C]
mov rcx, [rbp+var_38]
cmp eax, [rcx+50h]
jge loc_2F9E4
mov rdi, [rbp+var_28]
mov rax, [rbp+var_38]
mov rax, [rax+58h]
movsxd rcx, [rbp+var_1C]
mov rsi, [rax+rcx*8]
call getModeInfo
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
call modeIsGood
cmp eax, 0
jnz short loc_2F941
jmp loc_2F9D6
loc_2F941:
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_30]
lea rdi, [rbp+var_58]
call vidmodeFromModeInfo
mov [rbp+var_20], 0
loc_2F959:
mov eax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp eax, [rcx]
jge short loc_2F990
mov rdi, [rbp+var_18]
movsxd rax, [rbp+var_20]
imul rax, 18h
add rdi, rax
lea rsi, [rbp+var_58]
call _glfwCompareVideoModes
cmp eax, 0
jnz short loc_2F983
jmp short loc_2F990
loc_2F983:
jmp short $+2
loc_2F985:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_2F959
loc_2F990:
mov eax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp eax, [rcx]
jge short loc_2F99D
jmp short loc_2F9D6
loc_2F99D:
mov rax, [rbp+var_10]
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov ecx, [rcx]
sub ecx, 1
movsxd rcx, ecx
imul rcx, 18h
add rax, rcx
mov rcx, [rbp+var_58]
mov [rax], rcx
mov rcx, [rbp+var_50]
mov [rax+8], rcx
mov rcx, [rbp+var_48]
mov [rax+10h], rcx
loc_2F9D6:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp loc_2F901
loc_2F9E4:
lea rax, _glfw
mov rax, qword ptr ds:loc_205B0[rax]
mov rdi, [rbp+var_38]
call rax
lea rax, _glfw
mov rax, qword ptr ds:loc_205A0[rax]
mov rdi, [rbp+var_30]
call rax
lea rax, _glfw
mov rax, [rax+205B8h]
mov rdi, [rbp+var_28]
call rax
jmp short loc_2FA4C
loc_2FA22:
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov edi, 1
mov esi, 18h
call _calloc
mov [rbp+var_18], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call _glfwPlatformGetVideoMode
loc_2FA4C:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
| _DWORD * glfwPlatformGetVideoModes(long long a1, _DWORD *a2)
{
_QWORD *v2; // rax
_QWORD v4[3]; // [rsp+8h] [rbp-58h] BYREF
long long ModeInfo; // [rsp+20h] [rbp-40h]
long long v6; // [rsp+28h] [rbp-38h]
long long v7; // [rsp+30h] [rbp-30h]
long long v8; // [rsp+38h] [rbp-28h]
int j; // [rsp+40h] [rbp-20h]
int i; // [rsp+44h] [rbp-1Ch]
_DWORD *v11; // [rsp+48h] [rbp-18h]
_DWORD *v12; // [rsp+50h] [rbp-10h]
long long v13; // [rsp+58h] [rbp-8h]
v13 = a1;
v12 = a2;
*a2 = 0;
if ( !*(_DWORD *)((char *)&loc_20570 + (_QWORD)glfw) || *(_DWORD *)((char *)&loc_20594 + (_QWORD)glfw) )
{
*v12 = 1;
v11 = (_DWORD *)calloc(1LL, 24LL);
glfwPlatformGetVideoMode(v13, v11);
}
else
{
v8 = (*(long long ( **)(_QWORD, _QWORD))&glfw[33146])(
*(_QWORD *)((char *)&loc_1FEC0 + (_QWORD)glfw),
*(_QWORD *)&glfw[32692]);
v7 = (*(long long ( **)(_QWORD, long long, _QWORD))&glfw[33140])(
*(_QWORD *)((char *)&loc_1FEC0 + (_QWORD)glfw),
v8,
*(_QWORD *)(v13 + 144));
v6 = (*(long long ( **)(_QWORD, long long, _QWORD))&glfw[33142])(
*(_QWORD *)((char *)&loc_1FEC0 + (_QWORD)glfw),
v8,
*(_QWORD *)(v13 + 136));
v11 = (_DWORD *)calloc(*(int *)(v6 + 80), 24LL);
for ( i = 0; i < *(_DWORD *)(v6 + 80); ++i )
{
ModeInfo = getModeInfo(v8, *(_QWORD *)(*(_QWORD *)(v6 + 88) + 8LL * i));
if ( modeIsGood(ModeInfo) )
{
vidmodeFromModeInfo((int *)v4, ModeInfo, v7);
for ( j = 0; j < *v12 && (unsigned int)glfwCompareVideoModes((long long)&v11[6 * j], (long long)v4); ++j )
;
if ( j >= *v12 )
{
v2 = &v11[6 * (*v12)++];
*v2 = v4[0];
v2[1] = v4[1];
v2[2] = v4[2];
}
}
}
(*(void ( **)(long long))((char *)&loc_205B0 + (_QWORD)glfw))(v6);
(*(void ( **)(long long))((char *)&loc_205A0 + (_QWORD)glfw))(v7);
(*(void ( **)(long long))&glfw[33134])(v8);
}
return v11;
}
| _glfwPlatformGetVideoModes:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
LEA RAX,[0x1e0c68]
CMP dword ptr [RAX + 0x20570],0x0
JZ 0x0012fa22
LEA RAX,[0x1e0c68]
CMP dword ptr [RAX + 0x20594],0x0
JNZ 0x0012fa22
LEA RAX,[0x1e0c68]
MOV RAX,qword ptr [RAX + 0x205e8]
LEA RCX,[0x1e0c68]
MOV RDI,qword ptr [RCX + 0x1fec0]
LEA RCX,[0x1e0c68]
MOV RSI,qword ptr [RCX + 0x1fed0]
CALL RAX
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[0x1e0c68]
MOV RAX,qword ptr [RAX + 0x205d0]
LEA RCX,[0x1e0c68]
MOV RDI,qword ptr [RCX + 0x1fec0]
MOV RSI,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RCX + 0x90]
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x1e0c68]
MOV RAX,qword ptr [RAX + 0x205d8]
LEA RCX,[0x1e0c68]
MOV RDI,qword ptr [RCX + 0x1fec0]
MOV RSI,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RCX + 0x88]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOVSXD RDI,dword ptr [RAX + 0x50]
MOV ESI,0x18
CALL 0x0010c5b0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_0012f901:
MOV EAX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x38]
CMP EAX,dword ptr [RCX + 0x50]
JGE 0x0012f9e4
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x58]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x0012f020
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x0012f090
CMP EAX,0x0
JNZ 0x0012f941
JMP 0x0012f9d6
LAB_0012f941:
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x30]
LEA RDI,[RBP + -0x58]
CALL 0x0012f0c0
MOV dword ptr [RBP + -0x20],0x0
LAB_0012f959:
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX]
JGE 0x0012f990
MOV RDI,qword ptr [RBP + -0x18]
MOVSXD RAX,dword ptr [RBP + -0x20]
IMUL RAX,RAX,0x18
ADD RDI,RAX
LEA RSI,[RBP + -0x58]
CALL 0x00126910
CMP EAX,0x0
JNZ 0x0012f983
JMP 0x0012f990
LAB_0012f983:
JMP 0x0012f985
LAB_0012f985:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0012f959
LAB_0012f990:
MOV EAX,dword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX]
JGE 0x0012f99d
JMP 0x0012f9d6
LAB_0012f99d:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX]
SUB ECX,0x1
MOVSXD RCX,ECX
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
LAB_0012f9d6:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0012f901
LAB_0012f9e4:
LEA RAX,[0x1e0c68]
MOV RAX,qword ptr [RAX + 0x205b0]
MOV RDI,qword ptr [RBP + -0x38]
CALL RAX
LEA RAX,[0x1e0c68]
MOV RAX,qword ptr [RAX + 0x205a0]
MOV RDI,qword ptr [RBP + -0x30]
CALL RAX
LEA RAX,[0x1e0c68]
MOV RAX,qword ptr [RAX + 0x205b8]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
JMP 0x0012fa4c
LAB_0012fa22:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV EDI,0x1
MOV ESI,0x18
CALL 0x0010c5b0
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012ee50
LAB_0012fa4c:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
void * _glfwPlatformGetVideoModes(long param_1,int *param_2)
{
int iVar1;
int8 *puVar2;
int8 local_60;
int8 local_58;
int8 local_50;
int8 local_48;
long local_40;
int8 local_38;
int8 local_30;
int local_28;
int local_24;
void *local_20;
int *local_18;
long local_10;
*param_2 = 0;
local_18 = param_2;
local_10 = param_1;
if ((DAT_002011d8 == 0) || (DAT_002011fc != 0)) {
*param_2 = 1;
local_20 = calloc(1,0x18);
_glfwPlatformGetVideoMode(local_10,local_20);
}
else {
local_30 = (*DAT_00201250)(DAT_00200b28,DAT_00200b38);
local_38 = (*DAT_00201238)(DAT_00200b28,local_30,*(int8 *)(local_10 + 0x90));
local_40 = (*DAT_00201240)(DAT_00200b28,local_30,*(int8 *)(local_10 + 0x88));
local_20 = calloc((long)*(int *)(local_40 + 0x50),0x18);
for (local_24 = 0; local_24 < *(int *)(local_40 + 0x50); local_24 = local_24 + 1) {
local_48 = getModeInfo(local_30,*(int8 *)
(*(long *)(local_40 + 0x58) + (long)local_24 * 8));
iVar1 = modeIsGood(local_48);
if (iVar1 != 0) {
vidmodeFromModeInfo(&local_60,local_48,local_38);
local_28 = 0;
while ((local_28 < *local_18 &&
(iVar1 = _glfwCompareVideoModes
((void *)((long)local_20 + (long)local_28 * 0x18),&local_60),
iVar1 != 0))) {
local_28 = local_28 + 1;
}
if (*local_18 <= local_28) {
*local_18 = *local_18 + 1;
puVar2 = (int8 *)((long)local_20 + (long)(*local_18 + -1) * 0x18);
*puVar2 = local_60;
puVar2[1] = local_58;
puVar2[2] = local_50;
}
}
}
(*DAT_00201218)(local_40);
(*DAT_00201208)(local_38);
(*DAT_00201220)(local_30);
}
return local_20;
}
| |
39,429 | ggml_compute_forward_flash_attn_ext | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_compute_forward_flash_attn_ext(
const struct ggml_compute_params * params,
const struct ggml_tensor * q,
const struct ggml_tensor * k,
const struct ggml_tensor * v,
const struct ggml_tensor * mask,
struct ggml_tensor * dst) {
switch (dst->op_params[3]) {
case GGML_PREC_DEFAULT:
case GGML_PREC_F32:
{
// uses F32 accumulators
ggml_compute_forward_flash_attn_ext_f16(params, q, k, v, mask, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O0 | c | ggml_compute_forward_flash_attn_ext:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x1, %eax
ja 0x18f4d
jmp 0x18f2e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x354d0
jmp 0x18f67
leaq 0x5ac0e(%rip), %rdi # 0x73b62
movl $0x2ade, %esi # imm = 0x2ADE
leaq 0x5ae5d(%rip), %rdx # 0x73dbd
movb $0x0, %al
callq 0xe270
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| ggml_compute_forward_flash_attn_ext:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_30]
mov eax, [rax+60h]
sub eax, 1
ja short loc_18F4D
jmp short $+2
loc_18F2E:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
call ggml_compute_forward_flash_attn_ext_f16
jmp short loc_18F67
loc_18F4D:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 2ADEh
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_18F67:
add rsp, 30h
pop rbp
retn
| double ggml_compute_forward_flash_attn_ext(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
double result; // xmm0_8
if ( *(_DWORD *)(a6 + 96) > 1u )
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
10974LL,
"fatal error");
ggml_compute_forward_flash_attn_ext_f16(a1, a2, a3, a4, a5, a6);
return result;
}
| ggml_compute_forward_flash_attn_ext:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x60]
SUB EAX,0x1
JA 0x00118f4d
JMP 0x00118f2e
LAB_00118f2e:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
MOV R9,qword ptr [RBP + -0x30]
CALL 0x001354d0
JMP 0x00118f67
LAB_00118f4d:
LEA RDI,[0x173b62]
MOV ESI,0x2ade
LEA RDX,[0x173dbd]
MOV AL,0x0
CALL 0x0010e270
LAB_00118f67:
ADD RSP,0x30
POP RBP
RET
|
void ggml_compute_forward_flash_attn_ext
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,long param_6)
{
if (*(uint *)(param_6 + 0x60) < 2) {
ggml_compute_forward_flash_attn_ext_f16(param_1,param_2,param_3,param_4,param_5,param_6);
}
else {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2ade,"fatal error");
}
return;
}
| |
39,430 | get_key_cache_statistics | eloqsql/mysys/mf_keycache.c | void get_key_cache_statistics(KEY_CACHE *keycache, uint partition_no,
KEY_CACHE_STATISTICS *key_cache_stats)
{
if (keycache->key_cache_inited)
{
pthread_mutex_lock(&keycache->op_lock);
keycache->interface_funcs->get_stats(keycache->keycache_cb,
partition_no, key_cache_stats);
pthread_mutex_unlock(&keycache->op_lock);
}
} | O0 | c | get_key_cache_statistics:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x48(%rax)
je 0xec934
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x291e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
callq 0x291c0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| get_key_cache_statistics:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
cmp byte ptr [rax+48h], 0
jz short loc_EC934
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_lock
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rax, [rax+48h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
call rax
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
call _pthread_mutex_unlock
loc_EC934:
add rsp, 20h
pop rbp
retn
| long long get_key_cache_statistics(long long a1, unsigned int a2, long long a3)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 72) )
{
pthread_mutex_lock(a1 + 88);
(*(void ( **)(_QWORD, _QWORD, long long))(*(_QWORD *)(a1 + 16) + 72LL))(*(_QWORD *)(a1 + 8), a2, a3);
return pthread_mutex_unlock(a1 + 88);
}
return result;
}
| get_key_cache_statistics:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x48],0x0
JZ 0x001ec934
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x001291e0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
CALL RAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
CALL 0x001291c0
LAB_001ec934:
ADD RSP,0x20
POP RBP
RET
|
void get_key_cache_statistics(long param_1,int4 param_2,int8 param_3)
{
if (*(char *)(param_1 + 0x48) != '\0') {
pthread_mutex_lock((pthread_mutex_t *)(param_1 + 0x58));
(**(code **)(*(long *)(param_1 + 0x10) + 0x48))(*(int8 *)(param_1 + 8),param_2,param_3);
pthread_mutex_unlock((pthread_mutex_t *)(param_1 + 0x58));
}
return;
}
| |
39,431 | minja::MacroTemplateToken::~MacroTemplateToken() | monkey531[P]llama/common/minja.hpp | MacroTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p)
: TemplateToken(Type::Macro, location, pre, post), name(std::move(n)), params(std::move(p)) {} | O3 | cpp | minja::MacroTemplateToken::~MacroTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x83401(%rip), %rax # 0xefdf8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0x4eeae
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x6ca15
callq 0x31b9a
leaq 0x827ac(%rip), %rax # 0xef1c8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x6ca32
popq %rbx
jmp 0x31b9a
popq %rbx
retq
| _ZN5minja18MacroTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja18MacroTemplateTokenE; `vtable for'minja::MacroTemplateToken
add rax, 10h
mov [rdi], rax
add rdi, 40h ; '@'
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EED2Ev; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::~vector()
mov rdi, [rbx+38h]
test rdi, rdi
jz short loc_6CA15
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6CA15:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_6CA32
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_6CA32:
pop rbx
retn
| void minja::MacroTemplateToken::~MacroTemplateToken(minja::MacroTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::MacroTemplateToken + 2;
std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::~vector((_QWORD *)this + 8);
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~MacroTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1efdf8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
ADD RDI,0x40
CALL 0x0014eeae
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JZ 0x0016ca15
CALL 0x00131b9a
LAB_0016ca15:
LEA RAX,[0x1ef1c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0016ca32
POP RBX
JMP 0x00131b9a
LAB_0016ca32:
POP RBX
RET
|
/* minja::MacroTemplateToken::~MacroTemplateToken() */
void __thiscall minja::MacroTemplateToken::~MacroTemplateToken(MacroTemplateToken *this)
{
*(int ***)this = &PTR__MacroTemplateToken_001efe08;
std::
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
::~vector((vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
*)(this + 0x40));
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_001ef1d8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
return;
}
return;
}
| |
39,432 | translog_walk_filenames | eloqsql/storage/maria/ma_loghandler.c | my_bool translog_walk_filenames(const char *directory,
my_bool (*callback)(const char *,
const char *))
{
MY_DIR *dirp;
uint i;
my_bool rc= FALSE;
/* Finds and removes transaction log files */
if (!(dirp = my_dir(directory, MYF(MY_DONT_SORT))))
return FALSE;
for (i= 0; i < dirp->number_of_files; i++)
{
char *file= dirp->dir_entry[i].name;
if (strncmp(file, "aria_log.", 10) == 0 &&
file[10] >= '0' && file[10] <= '9' &&
file[11] >= '0' && file[11] <= '9' &&
file[12] >= '0' && file[12] <= '9' &&
file[13] >= '0' && file[13] <= '9' &&
file[14] >= '0' && file[14] <= '9' &&
file[15] >= '0' && file[15] <= '9' &&
file[16] >= '0' && file[16] <= '9' &&
file[17] >= '0' && file[17] <= '9' &&
file[18] == '\0' && (*callback)(directory, file))
{
rc= TRUE;
break;
}
}
my_dirend(dirp);
return rc;
} | O3 | c | translog_walk_filenames:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xbed35
testq %rax, %rax
je 0x43891
movq %rax, %rbx
movl 0x8(%rax), %r12d
testl %r12d, %r12d
je 0x43886
movq %r15, -0x30(%rbp)
movq %r14, -0x38(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r14), %r13
movl $0xa, %edx
movq %r13, %rdi
leaq 0xb5433(%rip), %rsi # 0xf8c34
callq 0x2a1e0
testl %eax, %eax
jne 0x43873
movb 0xa(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0xb(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0xc(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0xd(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0xe(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0xf(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0x10(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
movb 0x11(%r13), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x43873
cmpb $0x0, 0x12(%r13)
jne 0x43873
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq *-0x38(%rbp)
testb %al, %al
jne 0x438a3
movl 0x8(%rbx), %r12d
incq %r15
movl %r12d, %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x437eb
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0xbed04
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %r12b
jmp 0x43889
| translog_walk_filenames:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rsi
mov r15, rdi
xor r12d, r12d
xor esi, esi
call my_dir
test rax, rax
jz loc_43891
mov rbx, rax
mov r12d, [rax+8]
test r12d, r12d
jz loc_43886
mov [rbp+var_30], r15
mov [rbp+var_38], r14
xor r14d, r14d
xor r15d, r15d
loc_437EB:
mov rax, [rbx]
mov r13, [rax+r14]
mov edx, 0Ah
mov rdi, r13
lea rsi, aMariaLog+1; "aria_log."
call _strncmp
test eax, eax
jnz short loc_43873
mov al, [r13+0Ah]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+0Bh]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+0Ch]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+0Dh]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+0Eh]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+0Fh]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+10h]
add al, 0D0h
cmp al, 9
ja short loc_43873
mov al, [r13+11h]
add al, 0D0h
cmp al, 9
ja short loc_43873
cmp byte ptr [r13+12h], 0
jnz short loc_43873
mov rdi, [rbp+var_30]
mov rsi, r13
call [rbp+var_38]
test al, al
jnz short loc_438A3
mov r12d, [rbx+8]
loc_43873:
inc r15
mov eax, r12d
add r14, 10h
cmp r15, rax
jb loc_437EB
loc_43886:
xor r12d, r12d
loc_43889:
mov rdi, rbx
call my_dirend
loc_43891:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_438A3:
mov r12b, 1
jmp short loc_43889
| long long translog_walk_filenames(long long a1, unsigned __int8 ( *a2)(long long, _BYTE *))
{
unsigned int v2; // r12d
long long v3; // rax
long long v4; // rcx
long long v5; // rbx
long long v6; // r14
unsigned long long v7; // r15
_BYTE *v8; // r13
v2 = 0;
v3 = my_dir(a1, 0LL);
if ( !v3 )
return v2;
v5 = v3;
v2 = *(_DWORD *)(v3 + 8);
if ( !v2 )
{
LABEL_17:
v2 = 0;
goto LABEL_18;
}
v6 = 0LL;
v7 = 0LL;
while ( 1 )
{
v8 = *(_BYTE **)(*(_QWORD *)v5 + v6);
if ( (unsigned int)strncmp(v8, "aria_log.", 10LL, v4)
|| (unsigned __int8)(v8[10] - 48) > 9u
|| (unsigned __int8)(v8[11] - 48) > 9u
|| (unsigned __int8)(v8[12] - 48) > 9u
|| (unsigned __int8)(v8[13] - 48) > 9u
|| (unsigned __int8)(v8[14] - 48) > 9u
|| (unsigned __int8)(v8[15] - 48) > 9u
|| (unsigned __int8)(v8[16] - 48) > 9u
|| (unsigned __int8)(v8[17] - 48) > 9u
|| v8[18] )
{
goto LABEL_16;
}
if ( a2(a1, v8) )
break;
v2 = *(_DWORD *)(v5 + 8);
LABEL_16:
++v7;
v6 += 16LL;
if ( v7 >= v2 )
goto LABEL_17;
}
LOBYTE(v2) = 1;
LABEL_18:
my_dirend(v5);
return v2;
}
| translog_walk_filenames:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV R15,RDI
XOR R12D,R12D
XOR ESI,ESI
CALL 0x001bed35
TEST RAX,RAX
JZ 0x00143891
MOV RBX,RAX
MOV R12D,dword ptr [RAX + 0x8]
TEST R12D,R12D
JZ 0x00143886
MOV qword ptr [RBP + -0x30],R15
MOV qword ptr [RBP + -0x38],R14
XOR R14D,R14D
XOR R15D,R15D
LAB_001437eb:
MOV RAX,qword ptr [RBX]
MOV R13,qword ptr [RAX + R14*0x1]
MOV EDX,0xa
MOV RDI,R13
LEA RSI,[0x1f8c34]
CALL 0x0012a1e0
TEST EAX,EAX
JNZ 0x00143873
MOV AL,byte ptr [R13 + 0xa]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0xb]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0xc]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0xd]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0xe]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0xf]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0x10]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
MOV AL,byte ptr [R13 + 0x11]
ADD AL,0xd0
CMP AL,0x9
JA 0x00143873
CMP byte ptr [R13 + 0x12],0x0
JNZ 0x00143873
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R13
CALL qword ptr [RBP + -0x38]
TEST AL,AL
JNZ 0x001438a3
MOV R12D,dword ptr [RBX + 0x8]
LAB_00143873:
INC R15
MOV EAX,R12D
ADD R14,0x10
CMP R15,RAX
JC 0x001437eb
LAB_00143886:
XOR R12D,R12D
LAB_00143889:
MOV RDI,RBX
CALL 0x001bed04
LAB_00143891:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001438a3:
MOV R12B,0x1
JMP 0x00143889
|
int8 translog_walk_filenames(int8 param_1,code *param_2)
{
char *__s1;
char cVar1;
int iVar2;
long *plVar3;
ulong uVar4;
int8 uVar5;
long lVar6;
ulong uVar7;
uVar5 = 0;
plVar3 = (long *)my_dir(param_1,0);
if (plVar3 != (long *)0x0) {
uVar4 = (ulong)*(uint *)(plVar3 + 1);
if (*(uint *)(plVar3 + 1) != 0) {
lVar6 = 0;
uVar7 = 0;
do {
__s1 = *(char **)(*plVar3 + lVar6);
iVar2 = strncmp(__s1,"aria_log.",10);
if ((((((iVar2 == 0) && ((byte)(__s1[10] - 0x30U) < 10)) && ((byte)(__s1[0xb] - 0x30U) < 10)
) && (((byte)(__s1[0xc] - 0x30U) < 10 && ((byte)(__s1[0xd] - 0x30U) < 10)))) &&
(((byte)(__s1[0xe] - 0x30U) < 10 &&
(((byte)(__s1[0xf] - 0x30U) < 10 && ((byte)(__s1[0x10] - 0x30U) < 10)))))) &&
(((byte)(__s1[0x11] - 0x30U) < 10 && (__s1[0x12] == '\0')))) {
cVar1 = (*param_2)(param_1,__s1);
if (cVar1 != '\0') {
uVar5 = CONCAT71((int7)(uVar4 >> 8),1);
goto LAB_00143889;
}
uVar4 = (ulong)*(uint *)(plVar3 + 1);
}
uVar7 = uVar7 + 1;
lVar6 = lVar6 + 0x10;
} while (uVar7 < uVar4);
}
uVar5 = 0;
LAB_00143889:
my_dirend(plVar3);
}
return uVar5;
}
| |
39,433 | my_rw_unlock | eloqsql/mysys/thr_rwlock.c | int my_rw_unlock(my_rw_lock_t *rwp)
{
DBUG_PRINT("rw_unlock",
("state: %d waiters: %d", rwp->state, rwp->waiters));
pthread_mutex_lock(&rwp->lock);
DBUG_ASSERT(rwp->state != 0);
if (rwp->state == -1) /* writer releasing */
{
my_rw_lock_assert_write_owner(rwp);
rwp->state= 0; /* mark as available */
#ifdef SAFE_MUTEX
rwp->write_thread= 0;
#endif
if ( rwp->waiters ) /* writers queued */
pthread_cond_signal( &rwp->writers );
else
pthread_cond_broadcast( &rwp->readers );
}
else
{
if ( --rwp->state == 0 && /* no more readers */
rwp->waiters)
pthread_cond_signal( &rwp->writers );
}
pthread_mutex_unlock( &rwp->lock );
return(0);
} | O3 | c | my_rw_unlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x244c0
movl 0x88(%rbx), %eax
cmpl $-0x1, %eax
je 0x2f3a8
decl %eax
movl %eax, 0x88(%rbx)
jne 0x2f3cf
cmpl $0x0, 0x8c(%rbx)
jne 0x2f3bb
jmp 0x2f3cf
movl $0x0, 0x88(%rbx)
cmpl $0x0, 0x8c(%rbx)
je 0x2f3c6
leaq 0x58(%rbx), %rdi
callq 0x24050
jmp 0x2f3cf
leaq 0x28(%rbx), %rdi
callq 0x24100
movq %rbx, %rdi
callq 0x24220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| my_rw_unlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
mov eax, [rbx+88h]
cmp eax, 0FFFFFFFFh
jz short loc_2F3A8
dec eax
mov [rbx+88h], eax
jnz short loc_2F3CF
cmp dword ptr [rbx+8Ch], 0
jnz short loc_2F3BB
jmp short loc_2F3CF
loc_2F3A8:
mov dword ptr [rbx+88h], 0
cmp dword ptr [rbx+8Ch], 0
jz short loc_2F3C6
loc_2F3BB:
lea rdi, [rbx+58h]
call _pthread_cond_signal
jmp short loc_2F3CF
loc_2F3C6:
lea rdi, [rbx+28h]
call _pthread_cond_broadcast
loc_2F3CF:
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long my_rw_unlock(long long a1)
{
int v1; // eax
int v2; // eax
pthread_mutex_lock(a1);
v1 = *(_DWORD *)(a1 + 136);
if ( v1 == -1 )
{
*(_DWORD *)(a1 + 136) = 0;
if ( !*(_DWORD *)(a1 + 140) )
{
pthread_cond_broadcast(a1 + 40);
goto LABEL_8;
}
goto LABEL_6;
}
v2 = v1 - 1;
*(_DWORD *)(a1 + 136) = v2;
if ( !v2 && *(_DWORD *)(a1 + 140) )
LABEL_6:
pthread_cond_signal(a1 + 88);
LABEL_8:
pthread_mutex_unlock(a1);
return 0LL;
}
| my_rw_unlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x001244c0
MOV EAX,dword ptr [RBX + 0x88]
CMP EAX,-0x1
JZ 0x0012f3a8
DEC EAX
MOV dword ptr [RBX + 0x88],EAX
JNZ 0x0012f3cf
CMP dword ptr [RBX + 0x8c],0x0
JNZ 0x0012f3bb
JMP 0x0012f3cf
LAB_0012f3a8:
MOV dword ptr [RBX + 0x88],0x0
CMP dword ptr [RBX + 0x8c],0x0
JZ 0x0012f3c6
LAB_0012f3bb:
LEA RDI,[RBX + 0x58]
CALL 0x00124050
JMP 0x0012f3cf
LAB_0012f3c6:
LEA RDI,[RBX + 0x28]
CALL 0x00124100
LAB_0012f3cf:
MOV RDI,RBX
CALL 0x00124220
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 my_rw_unlock(pthread_mutex_t *param_1)
{
int iVar1;
pthread_mutex_lock(param_1);
if (*(int *)((long)param_1 + 0x88) == -1) {
*(int4 *)((long)param_1 + 0x88) = 0;
if (*(int *)((long)param_1 + 0x8c) == 0) {
pthread_cond_broadcast((pthread_cond_t *)(param_1 + 1));
goto LAB_0012f3cf;
}
}
else {
iVar1 = *(int *)((long)param_1 + 0x88) + -1;
*(int *)((long)param_1 + 0x88) = iVar1;
if ((iVar1 != 0) || (*(int *)((long)param_1 + 0x8c) == 0)) goto LAB_0012f3cf;
}
pthread_cond_signal((pthread_cond_t *)((long)param_1 + 0x58));
LAB_0012f3cf:
pthread_mutex_unlock(param_1);
return 0;
}
| |
39,434 | nglog::(anonymous namespace)::MinimalFormatter::AppendString(char const*) | ng-log[P]ng-log/src/signalhandler.cc | void AppendString(const char* str) {
ptrdiff_t i = 0;
while (str[i] != '\0' && cursor_ + i < end_) {
cursor_[i] = str[i];
++i;
}
cursor_ += i;
} | O2 | cpp | nglog::(anonymous namespace)::MinimalFormatter::AppendString(char const*):
xorl %eax, %eax
movb (%rsi,%rax), %cl
movq 0x8(%rdi), %rdx
testb %cl, %cl
je 0x1c8c1
leaq (%rdx,%rax), %r8
cmpq 0x10(%rdi), %r8
jae 0x1c8c1
movb %cl, (%r8)
incq %rax
jmp 0x1c8a4
addq %rax, %rdx
movq %rdx, 0x8(%rdi)
retq
nop
| _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendStringEPKc:
xor eax, eax
loc_1C8A4:
mov cl, [rsi+rax]
mov rdx, [rdi+8]
test cl, cl
jz short loc_1C8C1
lea r8, [rdx+rax]
cmp r8, [rdi+10h]
jnb short loc_1C8C1
mov [r8], cl
inc rax
jmp short loc_1C8A4
loc_1C8C1:
add rdx, rax
mov [rdi+8], rdx
retn
| long long nglog::`anonymous namespace'::MinimalFormatter::AppendString(
nglog::_anonymous_namespace_::MinimalFormatter *this,
const char *a2)
{
long long result; // rax
char v3; // cl
long long v4; // rdx
for ( result = 0LL; ; ++result )
{
v3 = a2[result];
v4 = *((_QWORD *)this + 1);
if ( !v3 || (unsigned long long)(v4 + result) >= *((_QWORD *)this + 2) )
break;
*(_BYTE *)(v4 + result) = v3;
}
*((_QWORD *)this + 1) = result + v4;
return result;
}
| AppendString:
XOR EAX,EAX
LAB_0011c8a4:
MOV CL,byte ptr [RSI + RAX*0x1]
MOV RDX,qword ptr [RDI + 0x8]
TEST CL,CL
JZ 0x0011c8c1
LEA R8,[RDX + RAX*0x1]
CMP R8,qword ptr [RDI + 0x10]
JNC 0x0011c8c1
MOV byte ptr [R8],CL
INC RAX
JMP 0x0011c8a4
LAB_0011c8c1:
ADD RDX,RAX
MOV qword ptr [RDI + 0x8],RDX
RET
|
/* nglog::(anonymous namespace)::MinimalFormatter::AppendString(char const*) */
void __thiscall
nglog::(anonymous_namespace)::MinimalFormatter::AppendString(MinimalFormatter *this,char *param_1)
{
char *pcVar1;
long lVar2;
lVar2 = 0;
while( true ) {
if ((param_1[lVar2] == '\0') ||
(pcVar1 = (char *)(*(long *)(this + 8) + lVar2), *(char **)(this + 0x10) <= pcVar1)) break;
*pcVar1 = param_1[lVar2];
lVar2 = lVar2 + 1;
}
*(long *)(this + 8) = *(long *)(this + 8) + lVar2;
return;
}
| |
39,435 | inline_mysql_file_create | eloqsql/include/mysql/psi/mysql_file.h | static inline File
inline_mysql_file_create(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *filename, int create_flags, int access_flags, myf myFlags)
{
File file;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)(&state, key, PSI_FILE_CREATE, filename,
&locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_open_wait)(locker, src_file, src_line);
file= my_create(filename, create_flags, access_flags, myFlags);
PSI_FILE_CALL(end_file_open_wait_and_bind_to_descriptor)(locker, file);
return file;
}
#endif
file= my_create(filename, create_flags, access_flags, myFlags);
return file;
} | O0 | c | inline_mysql_file_create:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
leaq 0x266fec(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x148(%rax), %rax
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x80(%rbp), %rdi
xorl %edx, %edx
leaq -0x38(%rbp), %r8
callq *%rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x59163
leaq 0x266fa4(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x1f0(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0xef6b0
movl %eax, -0x2c(%rbp)
leaq 0x266f70(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x200(%rax), %rax
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq *%rax
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5917f
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0xef6b0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_file_create_0:
push rbp
mov rbp, rsp
sub rsp, 80h
mov rax, [rbp+arg_0]
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_28], r9d
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+148h]
mov esi, [rbp+var_8]
mov rcx, [rbp+var_20]
lea rdi, [rbp+var_80]
xor edx, edx
lea r8, [rbp+var_38]
call rax
mov [rbp+var_38], rax
cmp [rbp+var_38], 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_59163
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1F0h]
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov edx, [rbp+var_28]
mov rcx, [rbp+arg_0]
call my_create
mov [rbp+var_2C], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+200h]
mov rdi, [rbp+var_38]
mov esi, [rbp+var_2C]
call rax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
jmp short loc_5917F
loc_59163:
mov rdi, [rbp+var_20]
mov esi, [rbp+var_24]
mov edx, [rbp+var_28]
mov rcx, [rbp+arg_0]
call my_create
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_5917F:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_create_0(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
unsigned int a6,
long long a7)
{
_BYTE v8[72]; // [rsp+0h] [rbp-80h] BYREF
long long v9; // [rsp+48h] [rbp-38h] BYREF
unsigned int v10; // [rsp+54h] [rbp-2Ch]
unsigned int v11; // [rsp+58h] [rbp-28h]
unsigned int v12; // [rsp+5Ch] [rbp-24h]
long long v13; // [rsp+60h] [rbp-20h]
unsigned int v14; // [rsp+6Ch] [rbp-14h]
long long v15; // [rsp+70h] [rbp-10h]
unsigned int v16; // [rsp+78h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v11 = a6;
v9 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(v8, a1, 0LL, a4, &v9);
if ( v9 )
{
((void ( *)(long long, long long, _QWORD))PSI_server[62])(v9, v15, v14);
v10 = my_create(v13, v12, v11, a7);
((void ( *)(long long, _QWORD))PSI_server[64])(v9, v10);
}
else
{
return (unsigned int)my_create(v13, v12, v11, a7);
}
return v10;
}
| inline_mysql_file_create:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
MOV dword ptr [RBP + -0x28],R9D
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x148]
MOV ESI,dword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x80]
XOR EDX,EDX
LEA R8,[RBP + -0x38]
CALL RAX
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],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 0x00159163
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1f0]
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + 0x10]
CALL 0x001ef6b0
MOV dword ptr [RBP + -0x2c],EAX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x200]
MOV RDI,qword ptr [RBP + -0x38]
MOV ESI,dword ptr [RBP + -0x2c]
CALL RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0015917f
LAB_00159163:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x24]
MOV EDX,dword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + 0x10]
CALL 0x001ef6b0
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0015917f:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_create
(int4 param_1,int8 param_2,int4 param_3,int8 param_4,
int4 param_5,int4 param_6,int8 param_7)
{
int1 local_88 [72];
long local_40;
int4 local_34;
int4 local_30;
int4 local_2c;
int8 local_28;
int4 local_1c;
int8 local_18;
int4 local_10;
int4 local_c;
local_30 = param_6;
local_2c = param_5;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_40 = (**(code **)(PSI_server + 0x148))(local_88,param_1,0,param_4,&local_40);
if (local_40 == 0) {
local_c = my_create(local_28,local_2c,local_30,param_7);
}
else {
(**(code **)(PSI_server + 0x1f0))(local_40,local_18,local_1c);
local_34 = my_create(local_28,local_2c,local_30,param_7);
(**(code **)(PSI_server + 0x200))(local_40,local_34);
local_c = local_34;
}
return local_c;
}
| |
39,436 | common_tokenize(llama_vocab const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | monkey531[P]llama/common/common.cpp | std::vector<llama_token> common_tokenize(
const struct llama_vocab * vocab,
const std::string & text,
bool add_special,
bool parse_special) {
// upper limit for the number of tokens
int n_tokens = text.length() + 2 * add_special;
std::vector<llama_token> result(n_tokens);
n_tokens = llama_tokenize(vocab, text.data(), text.length(), result.data(), result.size(), add_special, parse_special);
if (n_tokens < 0) {
result.resize(-n_tokens);
int check = llama_tokenize(vocab, text.data(), text.length(), result.data(), result.size(), add_special, parse_special);
GGML_ASSERT(check == -n_tokens);
} else {
result.resize(n_tokens);
}
return result;
} | O2 | cpp | common_tokenize(llama_vocab const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leal (%r14,%r14), %eax
addl 0x8(%rdx), %eax
movslq %eax, %rsi
leaq 0x17(%rsp), %rdx
callq 0x55c04
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
subq %rcx, %r8
shrq $0x2, %r8
movl %ebp, (%rsp)
movq %r15, %rdi
movl %r14d, %r9d
callq 0x21c70
movl %eax, %r13d
testl %eax, %eax
js 0x53546
movl %r13d, %esi
movq %rbx, %rdi
callq 0x55c56
jmp 0x53583
negl %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x55c56
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
subq %rcx, %r8
shrq $0x2, %r8
movzbl %bpl, %eax
movl %eax, (%rsp)
movzbl %r14b, %r9d
movq %r15, %rdi
callq 0x21c70
cmpl %r13d, %eax
jne 0x53595
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x48955(%rip), %rdi # 0x9bef1
leaq 0x41827(%rip), %rdx # 0x94dca
leaq 0x48fca(%rip), %rcx # 0x9c574
movl $0x6b8, %esi # imm = 0x6B8
xorl %eax, %eax
callq 0x21b30
jmp 0x535b8
movq %rax, %r14
movq %rbx, %rdi
callq 0x8235c
movq %r14, %rdi
callq 0x21be0
| _Z15common_tokenizePK11llama_vocabRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r8d
mov r14d, ecx
mov r12, rdx
mov r15, rsi
mov rbx, rdi
lea eax, [r14+r14]
add eax, [rdx+8]
movsxd rsi, eax
lea rdx, [rsp+48h+var_31]
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
mov rsi, [r12]
mov edx, [r12+8]
mov rcx, [rbx]
mov r8, [rbx+8]
sub r8, rcx
shr r8, 2
mov [rsp+48h+var_48], ebp
mov rdi, r15
mov r9d, r14d
call _llama_tokenize
mov r13d, eax
test eax, eax
js short loc_53546
mov esi, r13d
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
jmp short loc_53583
loc_53546:
neg r13d
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rsi, [r12]
mov edx, [r12+8]
mov rcx, [rbx]
mov r8, [rbx+8]
sub r8, rcx
shr r8, 2
movzx eax, bpl
mov [rsp+48h+var_48], eax
movzx r9d, r14b
mov rdi, r15
call _llama_tokenize
cmp eax, r13d
jnz short loc_53595
loc_53583:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_53595:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCheckNTokens; "check == -n_tokens"
mov esi, 6B8h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_535B8:
mov r14, rax
mov rdi, rbx
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_tokenize(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4, int a5)
{
int v8; // eax
int v9; // r13d
long long v11; // r14
_BYTE v12[49]; // [rsp+17h] [rbp-31h] BYREF
std::vector<int>::vector(a1, (int)(*((_DWORD *)a3 + 2) + 2 * a4), v12);
v8 = llama_tokenize(a2, *a3, *((unsigned int *)a3 + 2), *a1, (a1[1] - *a1) >> 2, a4, a5);
if ( v8 < 0 )
{
v9 = -v8;
std::vector<int>::resize(a1, (unsigned int)-v8);
if ( (unsigned int)llama_tokenize(
a2,
*a3,
*((unsigned int *)a3 + 2),
*a1,
(a1[1] - *a1) >> 2,
(unsigned __int8)a4,
(unsigned __int8)a5) != v9 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1720LL,
"GGML_ASSERT(%s) failed",
"check == -n_tokens");
std::_Vector_base<int>::~_Vector_base(a1);
_Unwind_Resume(v11);
}
}
else
{
std::vector<int>::resize(a1, (unsigned int)v8);
}
return a1;
}
| common_tokenize:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R8D
MOV R14D,ECX
MOV R12,RDX
MOV R15,RSI
MOV RBX,RDI
LEA EAX,[R14 + R14*0x1]
ADD EAX,dword ptr [RDX + 0x8]
MOVSXD RSI,EAX
LEA RDX,[RSP + 0x17]
CALL 0x00155c04
MOV RSI,qword ptr [R12]
MOV EDX,dword ptr [R12 + 0x8]
MOV RCX,qword ptr [RBX]
MOV R8,qword ptr [RBX + 0x8]
SUB R8,RCX
SHR R8,0x2
LAB_00153524:
MOV dword ptr [RSP],EBP
MOV RDI,R15
MOV R9D,R14D
CALL 0x00121c70
MOV R13D,EAX
TEST EAX,EAX
JS 0x00153546
MOV ESI,R13D
MOV RDI,RBX
CALL 0x00155c56
JMP 0x00153583
LAB_00153546:
NEG R13D
MOV RDI,RBX
MOV RSI,R13
CALL 0x00155c56
MOV RSI,qword ptr [R12]
MOV EDX,dword ptr [R12 + 0x8]
MOV RCX,qword ptr [RBX]
MOV R8,qword ptr [RBX + 0x8]
SUB R8,RCX
SHR R8,0x2
LAB_0015356b:
MOVZX EAX,BPL
MOV dword ptr [RSP],EAX
MOVZX R9D,R14B
MOV RDI,R15
CALL 0x00121c70
CMP EAX,R13D
JNZ 0x00153595
LAB_00153583:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00153595:
LEA RDI,[0x19bef1]
LEA RDX,[0x194dca]
LEA RCX,[0x19c574]
MOV ESI,0x6b8
XOR EAX,EAX
CALL 0x00121b30
|
/* common_tokenize(llama_vocab const*, std::__cxx11::string const&, bool, bool) */
llama_vocab * common_tokenize(llama_vocab *param_1,string *param_2,bool param_3,bool param_4)
{
uint uVar1;
uint uVar2;
int7 in_register_00000009;
int7 in_register_00000011;
int8 *puVar3;
uint in_R8D;
allocator local_31;
puVar3 = (int8 *)CONCAT71(in_register_00000011,param_3);
std::vector<int,std::allocator<int>>::vector
((vector<int,std::allocator<int>> *)param_1,
(long)((int)CONCAT71(in_register_00000009,param_4) * 2 + *(int *)(puVar3 + 1)),
&local_31);
/* try { // try from 00153524 to 00153553 has its CatchHandler @ 001535b8 */
uVar1 = llama_tokenize(param_2,*puVar3,*(int4 *)(puVar3 + 1),*(long *)param_1,
(ulong)(*(long *)(param_1 + 8) - *(long *)param_1) >> 2,
CONCAT71(in_register_00000009,param_4) & 0xffffffff,in_R8D);
if ((int)uVar1 < 0) {
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)param_1,(ulong)-uVar1);
/* try { // try from 0015356b to 001535b5 has its CatchHandler @ 001535b6 */
uVar2 = llama_tokenize(param_2,*puVar3,*(int4 *)(puVar3 + 1),*(long *)param_1,
(ulong)(*(long *)(param_1 + 8) - *(long *)param_1) >> 2,param_4,
in_R8D & 0xff);
if (uVar2 != -uVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x6b8
,"GGML_ASSERT(%s) failed","check == -n_tokens");
}
}
else {
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)param_1,(ulong)uVar1);
}
return param_1;
}
| |
39,437 | get_envvars | eloqsql/libmariadb/unittest/libmariadb/my_test.h | void get_envvars() {
char *envvar;
if (!getenv("MYSQLTEST_VARDIR") &&
!getenv("MARIADB_CC_TEST"))
{
skip_all("Tests skipped.\nFor running unittest suite outside of MariaDB server tests,\nplease specify MARIADB_CC_TEST environment variable.");
exit(0);
}
if (getenv("TRAVIS_JOB_ID"))
travis_test= 1;
if (!hostname && (envvar= getenv("MYSQL_TEST_HOST")))
hostname= envvar;
if (!username)
{
if ((envvar= getenv("MYSQL_TEST_USER")))
username= envvar;
else
username= (char *)"root";
}
if (!password && (envvar= getenv("MYSQL_TEST_PASSWD")))
password= envvar;
if (!schema && (envvar= getenv("MYSQL_TEST_DB")))
schema= envvar;
if (!schema)
schema= "test";
if (!port)
{
if ((envvar= getenv("MYSQL_TEST_PORT")))
port= atoi(envvar);
else if ((envvar= getenv("MASTER_MYPORT")))
port= atoi(envvar);
diag("port: %d", port);
}
if (!ssl_port)
{
if ((envvar= getenv("MYSQL_TEST_SSL_PORT")))
ssl_port= atoi(envvar);
else
ssl_port = port;
diag("ssl_port: %d", ssl_port);
}
if (!force_tls && (envvar= getenv("MYSQL_TEST_TLS")))
force_tls= atoi(envvar);
if (!socketname)
{
if ((envvar= getenv("MYSQL_TEST_SOCKET")))
socketname= envvar;
else if ((envvar= getenv("MASTER_MYSOCK")))
socketname= envvar;
diag("socketname: %s", socketname);
}
if ((envvar= getenv("MYSQL_TEST_PLUGINDIR")))
plugindir= envvar;
if (IS_XPAND())
{
}
} | O3 | c | get_envvars:
pushq %rbp
movq %rsp, %rbp
leaq 0x22fd9(%rip), %rdi # 0x372b1
callq 0x135a0
testq %rax, %rax
jne 0x142f7
leaq 0x22fd9(%rip), %rdi # 0x372c2
callq 0x135a0
testq %rax, %rax
je 0x144ed
leaq 0x23054(%rip), %rdi # 0x37352
callq 0x135a0
cmpq $0x0, 0x39ea5(%rip) # 0x4e1b0
jne 0x14325
leaq 0x2304c(%rip), %rdi # 0x37360
callq 0x135a0
testq %rax, %rax
je 0x14325
movq %rax, 0x39e8b(%rip) # 0x4e1b0
cmpq $0x0, 0x39e8b(%rip) # 0x4e1b8
jne 0x14350
leaq 0x2303a(%rip), %rdi # 0x37370
callq 0x135a0
testq %rax, %rax
leaq 0x2303b(%rip), %rcx # 0x37380
cmovneq %rax, %rcx
movq %rcx, 0x39e68(%rip) # 0x4e1b8
cmpq $0x0, 0x39e68(%rip) # 0x4e1c0
jne 0x14372
leaq 0x23024(%rip), %rdi # 0x37385
callq 0x135a0
testq %rax, %rax
je 0x14372
movq %rax, 0x39e4e(%rip) # 0x4e1c0
cmpq $0x0, 0x39e4e(%rip) # 0x4e1c8
jne 0x1439d
leaq 0x23014(%rip), %rdi # 0x37397
callq 0x135a0
testq %rax, %rax
leaq 0x23013(%rip), %rcx # 0x373a5
cmovneq %rax, %rcx
movq %rcx, 0x39e2b(%rip) # 0x4e1c8
cmpl $0x0, 0x39e2c(%rip) # 0x4e1d0
jne 0x143ea
leaq 0x22ffd(%rip), %rdi # 0x373aa
callq 0x135a0
testq %rax, %rax
jne 0x143cc
leaq 0x22ffc(%rip), %rdi # 0x373ba
callq 0x135a0
testq %rax, %rax
je 0x144e2
movq %rax, %rdi
callq 0x13700
movl %eax, %esi
movl %eax, 0x39df4(%rip) # 0x4e1d0
leaq 0x22ffd(%rip), %rdi # 0x373e0
xorl %eax, %eax
callq 0x17b3b
cmpl $0x0, 0x39de3(%rip) # 0x4e1d4
jne 0x1442a
leaq 0x22fce(%rip), %rdi # 0x373c8
callq 0x135a0
testq %rax, %rax
je 0x14410
movq %rax, %rdi
callq 0x13700
movl %eax, %esi
jmp 0x14416
movl 0x39dba(%rip), %esi # 0x4e1d0
movl %esi, 0x39db8(%rip) # 0x4e1d4
leaq 0x22fb9(%rip), %rdi # 0x373dc
xorl %eax, %eax
callq 0x17b3b
cmpl $0x0, 0x39daf(%rip) # 0x4e1e0
jne 0x14452
leaq 0x22faf(%rip), %rdi # 0x373e9
callq 0x135a0
testq %rax, %rax
je 0x14452
movq %rax, %rdi
callq 0x13700
movl %eax, 0x39d8e(%rip) # 0x4e1e0
cmpq $0x0, 0x39d7e(%rip) # 0x4e1d8
jne 0x14496
leaq 0x22f95(%rip), %rdi # 0x373f8
callq 0x135a0
testq %rax, %rax
jne 0x1447e
leaq 0x22f96(%rip), %rdi # 0x3740a
callq 0x135a0
testq %rax, %rax
je 0x144e9
movq %rax, 0x39d53(%rip) # 0x4e1d8
leaq 0x22f8c(%rip), %rdi # 0x37418
movq %rax, %rsi
xorl %eax, %eax
callq 0x17b3b
leaq 0x22f8a(%rip), %rdi # 0x37427
callq 0x135a0
testq %rax, %rax
je 0x144ae
movq %rax, 0x39d3a(%rip) # 0x4e1e8
movq 0x39bbb(%rip), %rdi # 0x4e070
testq %rdi, %rdi
je 0x144d5
callq 0x1ea4e
leaq 0x22f76(%rip), %rsi # 0x3743c
movq %rax, %rdi
callq 0x13100
testq %rax, %rax
je 0x144d5
popq %rbp
retq
leaq 0x22f66(%rip), %rdi # 0x37442
popq %rbp
jmp 0x135a0
xorl %esi, %esi
jmp 0x143dc
xorl %eax, %eax
jmp 0x14485
leaq 0x22dde(%rip), %rdi # 0x372d2
xorl %eax, %eax
callq 0x17cbe
| get_envvars:
push rbp
mov rbp, rsp
lea rdi, aMysqltestVardi; "MYSQLTEST_VARDIR"
call _getenv
test rax, rax
jnz short loc_142F7
lea rdi, aMariadbCcTest; "MARIADB_CC_TEST"
call _getenv
test rax, rax
jz loc_144ED
loc_142F7:
lea rdi, aTravisJobId; "TRAVIS_JOB_ID"
call _getenv
cmp cs:hostname, 0
jnz short loc_14325
lea rdi, aMysqlTestHost; "MYSQL_TEST_HOST"
call _getenv
test rax, rax
jz short loc_14325
mov cs:hostname, rax
loc_14325:
cmp cs:username, 0
jnz short loc_14350
lea rdi, aMysqlTestUser; "MYSQL_TEST_USER"
call _getenv
test rax, rax
lea rcx, aRoot; "root"
cmovnz rcx, rax
mov cs:username, rcx
loc_14350:
cmp cs:password, 0
jnz short loc_14372
lea rdi, aMysqlTestPassw; "MYSQL_TEST_PASSWD"
call _getenv
test rax, rax
jz short loc_14372
mov cs:password, rax
loc_14372:
cmp cs:schema, 0
jnz short loc_1439D
lea rdi, aMysqlTestDb; "MYSQL_TEST_DB"
call _getenv
test rax, rax
lea rcx, aTest; "test"
cmovnz rcx, rax
mov cs:schema, rcx
loc_1439D:
cmp cs:port, 0
jnz short loc_143EA
lea rdi, aMysqlTestPort; "MYSQL_TEST_PORT"
call _getenv
test rax, rax
jnz short loc_143CC
lea rdi, aMasterMyport; "MASTER_MYPORT"
call _getenv
test rax, rax
jz loc_144E2
loc_143CC:
mov rdi, rax
call _atoi
mov esi, eax
mov cs:port, eax
loc_143DC:
lea rdi, aSslPortD+4; "port: %d"
xor eax, eax
call diag
loc_143EA:
cmp cs:ssl_port, 0
jnz short loc_1442A
lea rdi, aMysqlTestSslPo; "MYSQL_TEST_SSL_PORT"
call _getenv
test rax, rax
jz short loc_14410
mov rdi, rax
call _atoi
mov esi, eax
jmp short loc_14416
loc_14410:
mov esi, cs:port
loc_14416:
mov cs:ssl_port, esi
lea rdi, aSslPortD; "ssl_port: %d"
xor eax, eax
call diag
loc_1442A:
cmp cs:force_tls, 0
jnz short loc_14452
lea rdi, aMysqlTestTls; "MYSQL_TEST_TLS"
call _getenv
test rax, rax
jz short loc_14452
mov rdi, rax
call _atoi
mov cs:force_tls, eax
loc_14452:
cmp cs:socketname, 0
jnz short loc_14496
lea rdi, aMysqlTestSocke; "MYSQL_TEST_SOCKET"
call _getenv
test rax, rax
jnz short loc_1447E
lea rdi, aMasterMysock; "MASTER_MYSOCK"
call _getenv
test rax, rax
jz short loc_144E9
loc_1447E:
mov cs:socketname, rax
loc_14485:
lea rdi, aSocketnameS; "socketname: %s"
mov rsi, rax
xor eax, eax
call diag
loc_14496:
lea rdi, aMysqlTestPlugi; "MYSQL_TEST_PLUGINDIR"
call _getenv
test rax, rax
jz short loc_144AE
mov cs:plugindir, rax
loc_144AE:
mov rdi, cs:mysql_default
test rdi, rdi
jz short loc_144D5
call mysql_get_server_info
lea rsi, aXpand; "Xpand"
mov rdi, rax
call _strstr
test rax, rax
jz short loc_144D5
pop rbp
retn
loc_144D5:
lea rdi, aSrv; "srv"
pop rbp
jmp _getenv
loc_144E2:
xor esi, esi
jmp loc_143DC
loc_144E9:
xor eax, eax
jmp short loc_14485
loc_144ED:
lea rdi, aTestsSkippedFo; "Tests skipped.\nFor running unittest su"...
xor eax, eax
call skip_all
| long long get_envvars(long long a1, int a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
long long v6; // rax
long long v7; // rax
const char *v8; // rcx
long long v9; // rax
long long v10; // rax
const char *v11; // rcx
long long v12; // rax
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // esi
long long v18; // rax
int v19; // edx
int v20; // ecx
int v21; // r8d
int v22; // r9d
int v23; // esi
long long v24; // rax
long long v25; // rax
int v26; // edx
int v27; // ecx
int v28; // r8d
int v29; // r9d
long long v30; // rax
long long server_info; // rax
long long result; // rax
if ( !getenv("MYSQLTEST_VARDIR") && !getenv("MARIADB_CC_TEST") )
skip_all(
(unsigned int)"Tests skipped.\n"
"For running unittest suite outside of MariaDB server tests,\n"
"please specify MARIADB_CC_TEST environment variable.",
a2,
v2,
v3,
v4,
v5);
getenv("TRAVIS_JOB_ID");
if ( !hostname )
{
v6 = getenv("MYSQL_TEST_HOST");
if ( v6 )
hostname = v6;
}
if ( !username )
{
v7 = getenv("MYSQL_TEST_USER");
v8 = "root";
if ( v7 )
v8 = (const char *)v7;
username = (long long)v8;
}
if ( !password )
{
v9 = getenv("MYSQL_TEST_PASSWD");
if ( v9 )
password = v9;
}
if ( !schema )
{
v10 = getenv("MYSQL_TEST_DB");
v11 = "test";
if ( v10 )
v11 = (const char *)v10;
schema = (long long)v11;
}
if ( !port )
{
v12 = getenv("MYSQL_TEST_PORT");
if ( v12 || (v12 = getenv("MASTER_MYPORT")) != 0 )
{
v17 = atoi(v12);
port = v17;
}
else
{
v17 = 0;
}
diag((unsigned int)"port: %d", v17, v13, v14, v15, v16);
}
if ( !ssl_port )
{
v18 = getenv("MYSQL_TEST_SSL_PORT");
if ( v18 )
v23 = atoi(v18);
else
v23 = port;
ssl_port = v23;
diag((unsigned int)"ssl_port: %d", v23, v19, v20, v21, v22);
}
if ( !force_tls )
{
v24 = getenv("MYSQL_TEST_TLS");
if ( v24 )
force_tls = atoi(v24);
}
if ( !socketname )
{
v25 = getenv("MYSQL_TEST_SOCKET");
if ( v25 || (v25 = getenv("MASTER_MYSOCK")) != 0 )
socketname = v25;
else
LODWORD(v25) = 0;
diag((unsigned int)"socketname: %s", v25, v26, v27, v28, v29);
}
v30 = getenv("MYSQL_TEST_PLUGINDIR");
if ( v30 )
plugindir = v30;
if ( !mysql_default )
return getenv("srv");
server_info = mysql_get_server_info();
result = strstr(server_info, "Xpand");
if ( !result )
return getenv("srv");
return result;
}
| get_envvars:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x1372b1]
CALL 0x001135a0
TEST RAX,RAX
JNZ 0x001142f7
LEA RDI,[0x1372c2]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x001144ed
LAB_001142f7:
LEA RDI,[0x137352]
CALL 0x001135a0
CMP qword ptr [0x0014e1b0],0x0
JNZ 0x00114325
LEA RDI,[0x137360]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x00114325
MOV qword ptr [0x0014e1b0],RAX
LAB_00114325:
CMP qword ptr [0x0014e1b8],0x0
JNZ 0x00114350
LEA RDI,[0x137370]
CALL 0x001135a0
TEST RAX,RAX
LEA RCX,[0x137380]
CMOVNZ RCX,RAX
MOV qword ptr [0x0014e1b8],RCX
LAB_00114350:
CMP qword ptr [0x0014e1c0],0x0
JNZ 0x00114372
LEA RDI,[0x137385]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x00114372
MOV qword ptr [0x0014e1c0],RAX
LAB_00114372:
CMP qword ptr [0x0014e1c8],0x0
JNZ 0x0011439d
LEA RDI,[0x137397]
CALL 0x001135a0
TEST RAX,RAX
LEA RCX,[0x1373a5]
CMOVNZ RCX,RAX
MOV qword ptr [0x0014e1c8],RCX
LAB_0011439d:
CMP dword ptr [0x0014e1d0],0x0
JNZ 0x001143ea
LEA RDI,[0x1373aa]
CALL 0x001135a0
TEST RAX,RAX
JNZ 0x001143cc
LEA RDI,[0x1373ba]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x001144e2
LAB_001143cc:
MOV RDI,RAX
CALL 0x00113700
MOV ESI,EAX
MOV dword ptr [0x0014e1d0],EAX
LAB_001143dc:
LEA RDI,[0x1373e0]
XOR EAX,EAX
CALL 0x00117b3b
LAB_001143ea:
CMP dword ptr [0x0014e1d4],0x0
JNZ 0x0011442a
LEA RDI,[0x1373c8]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x00114410
MOV RDI,RAX
CALL 0x00113700
MOV ESI,EAX
JMP 0x00114416
LAB_00114410:
MOV ESI,dword ptr [0x0014e1d0]
LAB_00114416:
MOV dword ptr [0x0014e1d4],ESI
LEA RDI,[0x1373dc]
XOR EAX,EAX
CALL 0x00117b3b
LAB_0011442a:
CMP dword ptr [0x0014e1e0],0x0
JNZ 0x00114452
LEA RDI,[0x1373e9]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x00114452
MOV RDI,RAX
CALL 0x00113700
MOV dword ptr [0x0014e1e0],EAX
LAB_00114452:
CMP qword ptr [0x0014e1d8],0x0
JNZ 0x00114496
LEA RDI,[0x1373f8]
CALL 0x001135a0
TEST RAX,RAX
JNZ 0x0011447e
LEA RDI,[0x13740a]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x001144e9
LAB_0011447e:
MOV qword ptr [0x0014e1d8],RAX
LAB_00114485:
LEA RDI,[0x137418]
MOV RSI,RAX
XOR EAX,EAX
CALL 0x00117b3b
LAB_00114496:
LEA RDI,[0x137427]
CALL 0x001135a0
TEST RAX,RAX
JZ 0x001144ae
MOV qword ptr [0x0014e1e8],RAX
LAB_001144ae:
MOV RDI,qword ptr [0x0014e070]
TEST RDI,RDI
JZ 0x001144d5
CALL 0x0011ea4e
LEA RSI,[0x13743c]
MOV RDI,RAX
CALL 0x00113100
TEST RAX,RAX
JZ 0x001144d5
POP RBP
RET
LAB_001144d5:
LEA RDI,[0x137442]
POP RBP
JMP 0x001135a0
LAB_001144e2:
XOR ESI,ESI
JMP 0x001143dc
LAB_001144e9:
XOR EAX,EAX
JMP 0x00114485
LAB_001144ed:
LEA RDI,[0x1372d2]
XOR EAX,EAX
CALL 0x00117cbe
|
void get_envvars(void)
{
char cVar1;
int iVar2;
uint uVar3;
int4 uVar4;
char *pcVar5;
char *pcVar6;
int8 uVar7;
long *plVar8;
int8 uVar9;
long lVar10;
int8 *puVar11;
long lVar12;
ulong uVar13;
pcVar5 = getenv("MYSQLTEST_VARDIR");
if ((pcVar5 != (char *)0x0) || (pcVar5 = getenv("MARIADB_CC_TEST"), pcVar5 != (char *)0x0)) {
getenv("TRAVIS_JOB_ID");
if ((hostname == (char *)0x0) && (pcVar5 = getenv("MYSQL_TEST_HOST"), pcVar5 != (char *)0x0)) {
hostname = pcVar5;
}
if (username == (char *)0x0) {
pcVar5 = getenv("MYSQL_TEST_USER");
username = "root";
if (pcVar5 != (char *)0x0) {
username = pcVar5;
}
}
if ((password == (char *)0x0) && (pcVar5 = getenv("MYSQL_TEST_PASSWD"), pcVar5 != (char *)0x0))
{
password = pcVar5;
}
if (schema == (char *)0x0) {
pcVar5 = getenv("MYSQL_TEST_DB");
schema = "test";
if (pcVar5 != (char *)0x0) {
schema = pcVar5;
}
}
if (port == 0) {
pcVar5 = getenv("MYSQL_TEST_PORT");
if ((pcVar5 == (char *)0x0) && (pcVar5 = getenv("MASTER_MYPORT"), pcVar5 == (char *)0x0)) {
iVar2 = 0;
}
else {
port = atoi(pcVar5);
iVar2 = port;
}
diag("port: %d",iVar2);
}
if (ssl_port == 0) {
pcVar5 = getenv("MYSQL_TEST_SSL_PORT");
iVar2 = port;
if (pcVar5 != (char *)0x0) {
iVar2 = atoi(pcVar5);
}
ssl_port = iVar2;
diag("ssl_port: %d");
}
if ((force_tls == 0) && (pcVar5 = getenv("MYSQL_TEST_TLS"), pcVar5 != (char *)0x0)) {
force_tls = atoi(pcVar5);
}
if (socketname == (char *)0x0) {
pcVar6 = getenv("MYSQL_TEST_SOCKET");
pcVar5 = pcVar6;
if ((pcVar6 == (char *)0x0) &&
(pcVar6 = getenv("MASTER_MYSOCK"), pcVar5 = pcVar6, pcVar6 == (char *)0x0)) {
pcVar6 = (char *)0x0;
pcVar5 = socketname;
}
socketname = pcVar5;
diag("socketname: %s",pcVar6);
}
pcVar5 = getenv("MYSQL_TEST_PLUGINDIR");
if (pcVar5 != (char *)0x0) {
plugindir = pcVar5;
}
if (mysql_default != 0) {
pcVar5 = (char *)mysql_get_server_info();
pcVar5 = strstr(pcVar5,"Xpand");
if (pcVar5 != (char *)0x0) {
return;
}
}
getenv("srv");
return;
}
pcVar5 =
"Tests skipped.\nFor running unittest suite outside of MariaDB server tests,\nplease specify MARIADB_CC_TEST environment variable."
;
uVar7 = skip_all();
plVar8 = (long *)((long)pcVar5 + 8);
uVar13 = 0xffffffffffffffff;
do {
uVar13 = uVar13 + 1;
lVar10 = *plVar8;
plVar8 = plVar8 + 6;
} while (lVar10 != 0);
plan(uVar13 & 0xffffffff);
uVar9 = mysql_init(0);
mysql_ssl_set(uVar9,0,0,0,0,0,uVar7);
lVar10 = mysql_real_connect(uVar9,hostname,username,password,schema,port,socketname,0);
if (lVar10 == 0) {
pcVar5 = "Can\'t establish TLS connection to server.";
}
else {
iVar2 = mysql_query(uVar9,"SHOW VARIABLES LIKE \'%ssl%\'");
if (iVar2 == 0) {
diag("TLS server variables");
diag("--------------------");
uVar7 = mysql_store_result(uVar9);
puVar11 = (int8 *)mysql_fetch_row(uVar7);
while (puVar11 != (int8 *)0x0) {
diag("%s: %s",*puVar11,puVar11[1]);
puVar11 = (int8 *)mysql_fetch_row(uVar7);
}
mysql_free_result(uVar7);
uVar7 = mysql_get_ssl_cipher(uVar9);
diag("Cipher in use: %s",uVar7);
diag("--------------------");
}
mysql_close(uVar9);
mysql_default = test_connect(0);
if (mysql_default != 0) {
uVar7 = mysql_get_server_info(mysql_default);
diag("Testing against MySQL Server %s",uVar7);
uVar7 = mysql_get_host_info(mysql_default);
diag("Host: %s",uVar7);
uVar7 = mysql_get_client_info();
diag("Client library: %s",uVar7);
is_mariadb = mariadb_connection(mysql_default);
lVar10 = mysql_default;
do {
mysql_default = lVar10;
if (uVar13 == 0) {
if (this_host != (void *)0x0) {
free(this_host);
}
if (mysql_default != 0) {
diag("close default");
mysql_close(mysql_default);
return;
}
return;
}
if ((lVar10 == 0) && ((*(byte *)((long)pcVar5 + 0x10) & 1) != 0)) {
diag("MySQL server not running");
lVar12 = *(long *)pcVar5;
LAB_0011472d:
skip(1,"%s",lVar12);
}
else {
lVar12 = *(long *)((long)pcVar5 + 0x28);
if (lVar12 != 0) goto LAB_0011472d;
uVar3 = *(uint *)((long)pcVar5 + 0x10);
if ((uVar3 & 4) != 0) {
lVar10 = test_connect(pcVar5);
uVar3 = *(uint *)((long)pcVar5 + 0x10);
}
if ((uVar3 & 2) != 0) {
lVar10 = 0;
}
iVar2 = (**(code **)((long)pcVar5 + 8))(lVar10);
if (iVar2 == -1) {
skip(1,"%s",*(long *)pcVar5);
LAB_00114760:
iVar2 = mysql_errno(mysql_default);
if (iVar2 != 0) goto LAB_00114770;
LAB_00114776:
if ((mysql_default == 0) || ((*(byte *)((long)pcVar5 + 0x10) & 1) == 0)) {
if ((lVar10 != 0) && ((*(byte *)((long)pcVar5 + 0x10) & 8) == 0)) {
mysql_close(lVar10);
}
}
else {
if (is_mariadb == '\0') {
LAB_001147dc:
iVar2 = mysql_reset_connection(lVar10);
}
else {
pcVar6 = (char *)mysql_get_server_info();
pcVar6 = strstr(pcVar6,"maxScale");
if ((pcVar6 != (char *)0x0) ||
((pcVar6 = getenv("srv"), pcVar6 != (char *)0x0 &&
((iVar2 = strcmp(pcVar6,"maxscale"), iVar2 == 0 ||
(iVar2 = strcmp(pcVar6,"skysql-ha"), iVar2 == 0)))))) goto LAB_001147dc;
cVar1 = mysql_change_user(lVar10,username,password,schema);
iVar2 = (int)cVar1;
}
if (iVar2 != 0) {
uVar7 = mysql_error(lVar10);
uVar4 = mysql_errno(lVar10);
uVar9 = 0x238;
LAB_0011491e:
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar7,uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/my_test.h"
,uVar9);
return;
}
iVar2 = mysql_query(lVar10,"SET sql_mode=\'\'");
if (iVar2 != 0) {
uVar7 = mysql_error(lVar10);
uVar4 = mysql_errno(lVar10);
uVar9 = 0x23a;
goto LAB_0011491e;
}
}
}
else {
ok(iVar2 == 0,"%s",*(long *)pcVar5);
if (iVar2 != 1) goto LAB_00114760;
LAB_00114770:
if ((*(byte *)((long)pcVar5 + 0x10) & 1) == 0) goto LAB_00114776;
mysql_close(mysql_default);
mysql_default = test_connect(pcVar5);
}
}
pcVar5 = (char *)((long)pcVar5 + 0x30);
uVar13 = uVar13 - 1;
lVar10 = mysql_default;
} while( true );
}
pcVar5 = "Can\'t connect to a server. Aborting....";
mysql_default = 0;
}
/* WARNING: Subroutine does not return */
BAIL_OUT(pcVar5);
}
| |
39,438 | string_view::operator==(string_view const&) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | bool operator==(const string_view & other) const {
std::string this_str = *this;
std::string other_str = other;
return this_str == other_str;
} | O1 | cpp | string_view::operator==(string_view const&) const:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rcx
subq %rdx, %rcx
movq %rsp, %rdi
callq 0x1b900
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x10(%rbx), %rcx
subq %rdx, %rcx
leaq 0x20(%rsp), %rdi
callq 0x1b900
movq 0x8(%rsp), %rdx
cmpq 0x28(%rsp), %rdx
jne 0xcb840
testq %rdx, %rdx
je 0xcb844
movq 0x20(%rsp), %rsi
movq (%rsp), %rdi
callq 0x1b8f0
testl %eax, %eax
sete %bl
jmp 0xcb846
xorl %ebx, %ebx
jmp 0xcb846
movb $0x1, %bl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcb861
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8b0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcb87c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcb8a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rdi
callq 0x1bf70
| _ZNK11string_vieweqERKS_:
push rbx
sub rsp, 40h
mov rbx, rsi
mov rsi, [rdi]
mov rdx, [rdi+8]
mov rcx, [rdi+10h]
sub rcx, rdx
mov rdi, rsp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rsi, [rbx]
mov rdx, [rbx+8]
mov rcx, [rbx+10h]
sub rcx, rdx
lea rdi, [rsp+48h+var_28]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdx, [rsp+48h+var_40]
cmp rdx, [rsp+48h+var_20]
jnz short loc_CB840
test rdx, rdx
jz short loc_CB844
mov rsi, [rsp+48h+var_28]
mov rdi, [rsp+48h+var_48]
call _bcmp
test eax, eax
setz bl
jmp short loc_CB846
loc_CB840:
xor ebx, ebx
jmp short loc_CB846
loc_CB844:
mov bl, 1
loc_CB846:
lea rax, [rsp+48h+var_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CB861
mov rsi, [rsp+48h+var_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CB861:
lea rax, [rsp+48h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CB87C
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CB87C:
mov eax, ebx
add rsp, 40h
pop rbx
retn
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CB8A2
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CB8A2:
mov rdi, rbx
call __Unwind_Resume
| long long string_view::operator==(_QWORD *a1, _QWORD *a2)
{
long long *v4; // [rsp+0h] [rbp-48h] BYREF
void *v5; // [rsp+8h] [rbp-40h]
long long v6; // [rsp+10h] [rbp-38h] BYREF
void *v7[2]; // [rsp+20h] [rbp-28h] BYREF
long long v8; // [rsp+30h] [rbp-18h] BYREF
std::string::substr(&v4, *a1, a1[1], a1[2] - a1[1]);
std::string::substr(v7, *a2, a2[1], a2[2] - a2[1]);
if ( v5 == v7[1] )
{
if ( v5 )
LOBYTE(a2) = (unsigned int)bcmp(v4, v7[0]) == 0;
else
LOBYTE(a2) = 1;
}
else
{
LODWORD(a2) = 0;
}
if ( v7[0] != &v8 )
operator delete(v7[0], v8 + 1);
if ( v4 != &v6 )
operator delete(v4, v6 + 1);
return (unsigned int)a2;
}
| operator==:
PUSH RBX
SUB RSP,0x40
MOV RBX,RSI
MOV RSI,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
SUB RCX,RDX
MOV RDI,RSP
CALL 0x0011b900
MOV RSI,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX + 0x10]
SUB RCX,RDX
LAB_001cb810:
LEA RDI,[RSP + 0x20]
CALL 0x0011b900
LAB_001cb81a:
MOV RDX,qword ptr [RSP + 0x8]
CMP RDX,qword ptr [RSP + 0x28]
JNZ 0x001cb840
TEST RDX,RDX
JZ 0x001cb844
MOV RSI,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RSP]
CALL 0x0011b8f0
TEST EAX,EAX
SETZ BL
JMP 0x001cb846
LAB_001cb840:
XOR EBX,EBX
JMP 0x001cb846
LAB_001cb844:
MOV BL,0x1
LAB_001cb846:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001cb861
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011b8b0
LAB_001cb861:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001cb87c
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011b8b0
LAB_001cb87c:
MOV EAX,EBX
ADD RSP,0x40
POP RBX
RET
|
/* string_view::TEMPNAMEPLACEHOLDERVALUE(string_view const&) const */
ulong __thiscall string_view::operator==(string_view *this,string_view *param_1)
{
int iVar1;
int7 uVar3;
ulong uVar2;
long *local_48;
size_t local_40;
long local_38 [2];
long *local_28;
size_t local_20;
long local_18 [2];
std::__cxx11::string::substr((ulong)&local_48,*(ulong *)this);
/* try { // try from 001cb810 to 001cb819 has its CatchHandler @ 001cb884 */
std::__cxx11::string::substr((ulong)&local_28,*(ulong *)param_1);
if (local_40 == local_20) {
uVar3 = (int7)((ulong)param_1 >> 8);
if (local_40 == 0) {
uVar2 = CONCAT71(uVar3,1);
}
else {
iVar1 = bcmp(local_48,local_28,local_40);
uVar2 = CONCAT71(uVar3,iVar1 == 0);
}
}
else {
uVar2 = 0;
}
if (local_28 != local_18) {
operator_delete(local_28,local_18[0] + 1);
}
if (local_48 != local_38) {
operator_delete(local_48,local_38[0] + 1);
}
return uVar2 & 0xffffffff;
}
| |
39,439 | ma_get_host_list | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void ma_get_host_list(char *host_list, struct st_host *host_info, int default_port)
{
char *token, *start, *save;
int host_nr= 0;
start= host_list;
while ((token= strtok_r(start, ",", &save)))
{
char *p;
/* ipv6 hostname */
if ((p= strchr(token, ']')))
{
host_info[host_nr].host= token + 1;
*p++= 0;
token= p;
}
else
host_info[host_nr].host= token;
/* check if port was specified */
if ((p= strchr(token, ':')))
{
*p++= 0;
host_info[host_nr].port= atoi(p);
}
else
host_info[host_nr].port= default_port;
host_nr++;
start= NULL;
}
return;
} | O0 | c | ma_get_host_list:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x3004e(%rip), %rsi # 0x50ccb
leaq -0x30(%rbp), %rdx
callq 0x13790
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x20d6c
movq -0x20(%rbp), %rdi
movl $0x5d, %esi
callq 0x13170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x20ce2
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x20cf8
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0x13170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x20d41
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0x136c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x20d56
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x20c72
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_get_host_list:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_34], 0
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
loc_20C72:
mov rdi, [rbp+var_28]
lea rsi, asc_50CCB; ","
lea rdx, [rbp+var_30]
call _strtok_r
mov [rbp+var_20], rax
cmp rax, 0
jz loc_20D6C
mov rdi, [rbp+var_20]
mov esi, 5Dh ; ']'
call _strchr
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_20CE2
mov rcx, [rbp+var_20]
add rcx, 1
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax], rcx
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
mov [rbp+var_20], rax
jmp short loc_20CF8
loc_20CE2:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax], rcx
loc_20CF8:
mov rdi, [rbp+var_20]
mov esi, 3Ah ; ':'
call _strchr
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_20D41
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rdi, [rbp+var_40]
call _atoi
mov ecx, eax
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp short loc_20D56
loc_20D41:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
loc_20D56:
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
mov [rbp+var_28], 0
jmp loc_20C72
loc_20D6C:
add rsp, 40h
pop rbp
retn
| long long ma_get_host_list(long long a1, long long a2, int a3)
{
long long result; // rax
int v4; // eax
_BYTE *v5; // [rsp+0h] [rbp-40h]
_BYTE *v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+Ch] [rbp-34h]
_BYTE v8[8]; // [rsp+10h] [rbp-30h] BYREF
long long i; // [rsp+18h] [rbp-28h]
_BYTE *v10; // [rsp+20h] [rbp-20h]
int v11; // [rsp+2Ch] [rbp-14h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v7 = 0;
for ( i = a1; ; i = 0LL )
{
result = strtok_r(i, ",", v8);
v10 = (_BYTE *)result;
if ( !result )
break;
v5 = (_BYTE *)strchr(v10, 93LL);
if ( v5 )
{
*(_QWORD *)(16LL * v7 + v12) = v10 + 1;
*v5 = 0;
v10 = v5 + 1;
}
else
{
*(_QWORD *)(16LL * v7 + v12) = v10;
}
v6 = (_BYTE *)strchr(v10, 58LL);
if ( v6 )
{
*v6 = 0;
v4 = atoi(v6 + 1);
*(_DWORD *)(16LL * v7 + v12 + 8) = v4;
}
else
{
*(_DWORD *)(16LL * v7 + v12 + 8) = v11;
}
++v7;
}
return result;
}
| ma_get_host_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_00120c72:
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[0x150ccb]
LEA RDX,[RBP + -0x30]
CALL 0x00113790
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x00120d6c
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x5d
CALL 0x00113170
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x00120ce2
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00120cf8
LAB_00120ce2:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LAB_00120cf8:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x3a
CALL 0x00113170
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x00120d41
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001136c0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x00120d56
LAB_00120d41:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
LAB_00120d56:
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
MOV qword ptr [RBP + -0x28],0x0
JMP 0x00120c72
LAB_00120d6c:
ADD RSP,0x40
POP RBP
RET
|
void ma_get_host_list(char *param_1,long param_2,int4 param_3)
{
int iVar1;
char *pcVar2;
int local_3c;
char *local_38;
char *local_30;
char *local_28;
int4 local_1c;
long local_18;
char *local_10;
local_3c = 0;
local_30 = param_1;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
local_28 = strtok_r(local_30,",",&local_38);
if (local_28 == (char *)0x0) break;
pcVar2 = strchr(local_28,0x5d);
if (pcVar2 == (char *)0x0) {
*(char **)(local_18 + (long)local_3c * 0x10) = local_28;
}
else {
*(char **)(local_18 + (long)local_3c * 0x10) = local_28 + 1;
local_28 = pcVar2 + 1;
*pcVar2 = '\0';
}
pcVar2 = strchr(local_28,0x3a);
if (pcVar2 == (char *)0x0) {
*(int4 *)(local_18 + (long)local_3c * 0x10 + 8) = local_1c;
}
else {
*pcVar2 = '\0';
iVar1 = atoi(pcVar2 + 1);
*(int *)(local_18 + (long)local_3c * 0x10 + 8) = iVar1;
}
local_3c = local_3c + 1;
local_30 = (char *)0x0;
}
return;
}
| |
39,440 | init_default_directories | eloqsql/mysys/my_default.c | static const char **init_default_directories(MEM_ROOT *alloc)
{
const char **dirs;
char *env;
int errors= 0;
DBUG_ENTER("init_default_directories");
dirs= (const char **)alloc_root(alloc, DEFAULT_DIRS_SIZE * sizeof(char *));
if (dirs == NULL)
DBUG_RETURN(NULL);
bzero((char *) dirs, DEFAULT_DIRS_SIZE * sizeof(char *));
#ifdef _WIN32
{
char fname_buffer[FN_REFLEN];
if (GetSystemWindowsDirectory(fname_buffer, sizeof(fname_buffer)))
errors += add_directory(alloc, fname_buffer, dirs);
if (GetWindowsDirectory(fname_buffer, sizeof(fname_buffer)))
errors += add_directory(alloc, fname_buffer, dirs);
errors += add_directory(alloc, "C:/", dirs);
if (my_get_module_parent(fname_buffer, sizeof(fname_buffer)) != NULL)
{
errors += add_directory(alloc, fname_buffer, dirs);
strcat_s(fname_buffer, sizeof(fname_buffer), "/data");
errors += add_directory(alloc, fname_buffer, dirs);
}
}
#else
#if defined(DEFAULT_SYSCONFDIR)
if (DEFAULT_SYSCONFDIR[0])
errors += add_directory(alloc, DEFAULT_SYSCONFDIR, dirs);
#else
errors += add_directory(alloc, "/etc/", dirs);
errors += add_directory(alloc, "/etc/mysql/", dirs);
#endif /* DEFAULT_SYSCONFDIR */
#endif
/*
If value of $MARIADB_HOME environment variable name is NULL, check
for $MYSQL_HOME
*/
if ((env= getenv("MARIADB_HOME")))
errors += add_directory(alloc, env, dirs);
else
{
if ((env= getenv("MYSQL_HOME")))
errors += add_directory(alloc, env, dirs);
}
/* Placeholder for --defaults-extra-file=<path> */
errors += add_directory(alloc, "", dirs);
#if !defined(_WIN32)
errors += add_directory(alloc, "~/", dirs);
#endif
DBUG_RETURN(errors > 0 ? NULL : dirs);
} | O0 | c | init_default_directories:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0x28b20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2539b
jmp 0x2538e
movq $0x0, -0x8(%rbp)
jmp 0x2548f
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x24180
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5a68e(%rip), %rsi # 0x7fa48
callq 0x270a0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5a67a(%rip), %rsi # 0x7fa4e
callq 0x270a0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
leaq 0x5a674(%rip), %rdi # 0x7fa5a
callq 0x243a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2540e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x270a0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2543d
leaq 0x5a652(%rip), %rdi # 0x7fa67
callq 0x243a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2543b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x270a0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2543d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5e758(%rip), %rsi # 0x83ba4
callq 0x270a0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x5a60c(%rip), %rsi # 0x7fa72
callq 0x270a0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x2547f
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x25487
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| init_default_directories:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_24], 0
mov rdi, [rbp+var_10]
mov esi, 40h ; '@'
call alloc_root
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jnz short loc_2539B
jmp short $+2
loc_2538E:
mov [rbp+var_8], 0
jmp loc_2548F
loc_2539B:
mov rdi, [rbp+var_18]
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, aEtc; "/etc/"
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, aEtcMysql; "/etc/mysql/"
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
lea rdi, aMariadbHome; "MARIADB_HOME"
call _getenv
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_2540E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
jmp short loc_2543D
loc_2540E:
lea rdi, aMysqlHome; "MYSQL_HOME"
call _getenv
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_2543B
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
loc_2543B:
jmp short $+2
loc_2543D:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, asc_83BA0+4; ""
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
lea rsi, asc_7FA72; "~/"
call add_directory
add eax, [rbp+var_24]
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jle short loc_2547F
xor eax, eax
mov [rbp+var_30], rax
jmp short loc_25487
loc_2547F:
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_25487:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_2548F:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long init_default_directories(long long a1)
{
int v3; // [rsp+Ch] [rbp-24h]
int v4; // [rsp+Ch] [rbp-24h]
int v5; // [rsp+Ch] [rbp-24h]
long long v6; // [rsp+10h] [rbp-20h]
long long v7; // [rsp+18h] [rbp-18h]
v7 = alloc_root(a1, 64LL);
if ( !v7 )
return 0LL;
memset(v7, 0LL, 64LL);
v3 = add_directory(a1, "/etc/", v7);
v4 = v3 + add_directory(a1, "/etc/mysql/", v7);
v6 = getenv("MARIADB_HOME");
if ( v6 || (v6 = getenv("MYSQL_HOME")) != 0 )
v4 += add_directory(a1, v6, v7);
v5 = v4 + add_directory(a1, "", v7);
if ( (int)(v5 + add_directory(a1, "~/", v7)) <= 0 )
return v7;
else
return 0LL;
}
| init_default_directories:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x24],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x40
CALL 0x00128b20
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0012539b
JMP 0x0012538e
LAB_0012538e:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012548f
LAB_0012539b:
MOV RDI,qword ptr [RBP + -0x18]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x00124180
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x17fa48]
CALL 0x001270a0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x17fa4e]
CALL 0x001270a0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
LEA RDI,[0x17fa5a]
CALL 0x001243a0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0012540e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001270a0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0012543d
LAB_0012540e:
LEA RDI,[0x17fa67]
CALL 0x001243a0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0012543b
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001270a0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
LAB_0012543b:
JMP 0x0012543d
LAB_0012543d:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x183ba4]
CALL 0x001270a0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x17fa72]
CALL 0x001270a0
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JLE 0x0012547f
XOR EAX,EAX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00125487
LAB_0012547f:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_00125487:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012548f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
void * init_default_directories(int8 param_1)
{
int iVar1;
int iVar2;
char *pcVar3;
void *local_38;
int local_2c;
void *local_10;
local_38 = (void *)alloc_root(param_1);
if (local_38 == (void *)0x0) {
local_10 = (void *)0x0;
}
else {
memset(local_38,0,0x40);
iVar1 = add_directory(param_1,"/etc/",local_38);
local_2c = add_directory(param_1,"/etc/mysql/",local_38);
local_2c = local_2c + iVar1;
pcVar3 = getenv("MARIADB_HOME");
if (pcVar3 == (char *)0x0) {
pcVar3 = getenv("MYSQL_HOME");
if (pcVar3 != (char *)0x0) {
iVar1 = add_directory(param_1,pcVar3,local_38);
local_2c = iVar1 + local_2c;
}
}
else {
iVar1 = add_directory(param_1,pcVar3,local_38);
local_2c = iVar1 + local_2c;
}
iVar1 = add_directory(param_1,&DAT_00183ba4,local_38);
iVar2 = add_directory(param_1,&DAT_0017fa72,local_38);
if (0 < iVar2 + iVar1 + local_2c) {
local_38 = (void *)0x0;
}
local_10 = local_38;
}
return local_10;
}
| |
39,441 | start_timer | bluesky950520[P]quickjs/tests/test_conv.c | static clock_t start_timer(void) {
clock_t t0, t;
t0 = clock();
// wait for next transition
while ((t = clock()) == t0)
continue;
return t;
} | O2 | c | start_timer:
pushq %rbx
callq 0x2060
movq %rax, %rbx
callq 0x2060
cmpq %rbx, %rax
je 0x5388
popq %rbx
retq
| start_timer:
push rbx
call _clock
mov rbx, rax
loc_5388:
call _clock
cmp rax, rbx
jz short loc_5388
pop rbx
retn
| long long start_timer()
{
long long v0; // rbx
long long result; // rax
v0 = clock();
do
result = clock();
while ( result == v0 );
return result;
}
| start_timer:
PUSH RBX
CALL 0x00102060
MOV RBX,RAX
LAB_00105388:
CALL 0x00102060
CMP RAX,RBX
JZ 0x00105388
POP RBX
RET
|
void start_timer(void)
{
clock_t cVar1;
clock_t cVar2;
cVar1 = clock();
do {
cVar2 = clock();
} while (cVar2 == cVar1);
return;
}
| |
39,442 | my_b_cache_read_r | eloqsql/mysys/mf_iocache.c | static int _my_b_cache_read_r(IO_CACHE *cache, uchar *Buffer, size_t Count)
{
my_off_t pos_in_file;
size_t length, diff_length, left_length= 0;
IO_CACHE_SHARE *cshare= cache->share;
DBUG_ENTER("_my_b_cache_read_r");
DBUG_ASSERT(!(cache->myflags & MY_ENCRYPT));
while (Count)
{
size_t cnt, len;
pos_in_file= cache->pos_in_file + (cache->read_end - cache->buffer);
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
length=IO_ROUND_UP(Count+diff_length)-diff_length;
length= ((length <= cache->read_length) ?
length + IO_ROUND_DN(cache->read_length - length) :
length - IO_ROUND_UP(length - cache->read_length));
if (cache->type != READ_FIFO &&
(length > (cache->end_of_file - pos_in_file)))
length= (size_t) (cache->end_of_file - pos_in_file);
if (length == 0)
{
cache->error= (int) left_length;
DBUG_RETURN(1);
}
if (lock_io_cache(cache, pos_in_file))
{
/* With a synchronized write/read cache we won't come here... */
DBUG_ASSERT(!cshare->source_cache);
/*
... unless the writer has gone before this thread entered the
lock. Simulate EOF in this case. It can be distinguished by
cache->file.
*/
if (cache->file < 0)
len= 0;
else
{
/*
Whenever a function which operates on IO_CACHE flushes/writes
some part of the IO_CACHE to disk it will set the property
"seek_not_done" to indicate this to other functions operating
on the IO_CACHE.
*/
if (cache->seek_not_done)
{
if (mysql_file_seek(cache->file, pos_in_file, MY_SEEK_SET, MYF(0))
== MY_FILEPOS_ERROR)
{
cache->error= -1;
unlock_io_cache(cache);
DBUG_RETURN(1);
}
}
len= mysql_file_read(cache->file, cache->buffer, length, cache->myflags);
}
DBUG_PRINT("io_cache_share", ("read %lu bytes", (ulong) len));
cache->read_end= cache->buffer + (len == (size_t) -1 ? 0 : len);
cache->error= (len == length ? 0 : (int) len);
cache->pos_in_file= pos_in_file;
/* Copy important values to the share. */
cshare->error= cache->error;
cshare->read_end= cache->read_end;
cshare->pos_in_file= pos_in_file;
/* Mark all threads as running and wake them. */
unlock_io_cache(cache);
}
else
{
/*
With a synchronized write/read cache readers always come here.
Copy important values from the share.
*/
cache->error= cshare->error;
cache->read_end= cshare->read_end;
cache->pos_in_file= cshare->pos_in_file;
len= ((cache->error == -1) ? (size_t) -1 :
(size_t) (cache->read_end - cache->buffer));
}
cache->read_pos= cache->buffer;
cache->seek_not_done= 0;
if (len == 0 || len == (size_t) -1)
{
DBUG_PRINT("io_cache_share", ("reader error. len %lu left %lu",
(ulong) len, (ulong) left_length));
cache->error= (int) left_length;
DBUG_RETURN(1);
}
cnt= (len > Count) ? Count : len;
if (cnt)
memcpy(Buffer, cache->read_pos, cnt);
Count -= cnt;
Buffer+= cnt;
left_length+= cnt;
cache->read_pos+= cnt;
}
DBUG_RETURN(0);
} | O0 | c | my_b_cache_read_r:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xe2960
jmp 0xe2962
cmpq $0x0, -0x20(%rbp)
je 0xe2d43
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
addq -0x38(%rbp), %rax
addq $0x1000, %rax # imm = 0x1000
subq $0x1, %rax
movabsq $0xfffff000, %rcx # imm = 0xFFFFF000
andq %rcx, %rax
subq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0xf0(%rcx), %rax
ja 0xe29fd
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xf0(%rcx), %rcx
subq -0x30(%rbp), %rcx
movabsq $0xfffff000, %rdx # imm = 0xFFFFF000
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0xe2a2f
movq -0x30(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq 0xf0(%rdx), %rcx
addq $0x1000, %rcx # imm = 0x1000
subq $0x1, %rcx
movabsq $0xfffff000, %rdx # imm = 0xFFFFF000
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, 0xb0(%rax)
je 0xe2a69
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xe2a69
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xe2a8c
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xe2d4c
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe4510
cmpl $0x0, %eax
je 0xe2c00
jmp 0xe2aa4
jmp 0xe2aa6
movq -0x10(%rbp), %rax
cmpl $0x0, 0xd4(%rax)
jge 0xe2ac0
movq $0x0, -0x58(%rbp)
jmp 0xe2b55
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0xe2b1f
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x28(%rbp), %rcx
leaq 0x72c2c(%rip), %rdi # 0x15570e
movl $0x4cb, %esi # imm = 0x4CB
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xe1990
cmpq $-0x1, %rax
jne 0xe2b1d
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
callq 0xe4770
movl $0x1, -0x4(%rbp)
jmp 0xe2d4c
jmp 0xe2b1f
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x72bc7(%rip), %rdi # 0x15570e
movl $0x4d3, %esi # imm = 0x4D3
callq 0xe43a0
movq %rax, -0x58(%rbp)
jmp 0xe2b57
jmp 0xe2b59
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $-0x1, -0x58(%rbp)
jne 0xe2b74
xorl %eax, %eax
movq %rax, -0x70(%rbp)
jmp 0xe2b7c
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x58(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xe2ba0
xorl %eax, %eax
movl %eax, -0x74(%rbp)
jmp 0xe2ba7
movq -0x58(%rbp), %rax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0xe4(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rdi
callq 0xe4770
jmp 0xe2c72
movq -0x48(%rbp), %rax
movl 0xe0(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x48(%rbp), %rax
movq 0xd0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xe4(%rax)
jne 0xe2c53
movq $-0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xe2c6a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
cmpq $0x0, -0x58(%rbp)
je 0xe2c9e
cmpq $-0x1, -0x58(%rbp)
jne 0xe2cbe
jmp 0xe2ca0
jmp 0xe2ca2
movq -0x40(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xe2d4c
movq -0x58(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xe2cd5
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0xe2ce0
movq -0x58(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xe2d07
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x50(%rbp), %rdx
callq 0x2a090
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0xe2962
jmp 0xe2d45
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _my_b_cache_read_r:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_40], 0
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_48], rax
jmp short $+2
loc_E2960:
jmp short $+2
loc_E2962:
cmp [rbp+var_20], 0
jz loc_E2D43
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_10]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
and rax, 0FFFh
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_38]
add rax, 1000h
sub rax, 1
mov rcx, 0FFFFF000h
and rax, rcx
sub rax, [rbp+var_38]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
cmp rax, [rcx+0F0h]
ja short loc_E29FD
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+0F0h]
sub rcx, [rbp+var_30]
mov rdx, 0FFFFF000h
and rcx, rdx
add rax, rcx
mov [rbp+var_60], rax
jmp short loc_E2A2F
loc_E29FD:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_30]
mov rdx, [rbp+var_10]
sub rcx, [rdx+0F0h]
add rcx, 1000h
sub rcx, 1
mov rdx, 0FFFFF000h
and rcx, rdx
sub rax, rcx
mov [rbp+var_60], rax
loc_E2A2F:
mov rax, [rbp+var_60]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 4
jz short loc_E2A69
mov rax, [rbp+var_30]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rcx, [rbp+var_28]
cmp rax, rcx
jbe short loc_E2A69
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rax, [rbp+var_28]
mov [rbp+var_30], rax
loc_E2A69:
cmp [rbp+var_30], 0
jnz short loc_E2A8C
mov rax, [rbp+var_40]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov [rbp+var_4], 1
jmp loc_E2D4C
loc_E2A8C:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call lock_io_cache
cmp eax, 0
jz loc_E2C00
jmp short $+2
loc_E2AA4:
jmp short $+2
loc_E2AA6:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0D4h], 0
jge short loc_E2AC0
mov [rbp+var_58], 0
jmp loc_E2B55
loc_E2AC0:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0E0h], 0
jz short loc_E2B1F
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_28]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4CBh
xor r8d, r8d
xor eax, eax
mov r9d, eax
call inline_mysql_file_seek_6
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E2B1D
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
call unlock_io_cache
mov [rbp+var_4], 1
jmp loc_E2D4C
loc_E2B1D:
jmp short $+2
loc_E2B1F:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov r8, [rbp+var_30]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4D3h
call inline_mysql_file_read_5
mov [rbp+var_58], rax
loc_E2B55:
jmp short $+2
loc_E2B57:
jmp short $+2
loc_E2B59:
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_68], rax
cmp [rbp+var_58], 0FFFFFFFFFFFFFFFFh
jnz short loc_E2B74
xor eax, eax
mov [rbp+var_70], rax
jmp short loc_E2B7C
loc_E2B74:
mov rax, [rbp+var_58]
mov [rbp+var_70], rax
loc_E2B7C:
mov rcx, [rbp+var_68]
mov rax, [rbp+var_70]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_58]
cmp rax, [rbp+var_30]
jnz short loc_E2BA0
xor eax, eax
mov [rbp+var_74], eax
jmp short loc_E2BA7
loc_E2BA0:
mov rax, [rbp+var_58]
mov [rbp+var_74], eax
loc_E2BA7:
mov ecx, [rbp+var_74]
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+0E4h]
mov rax, [rbp+var_48]
mov [rax+0E0h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
mov rax, [rbp+var_48]
mov [rax+0D0h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_48]
mov [rax+0B8h], rcx
mov rdi, [rbp+var_10]
call unlock_io_cache
jmp short loc_E2C72
loc_E2C00:
mov rax, [rbp+var_48]
mov ecx, [rax+0E0h]
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov rax, [rbp+var_48]
mov rcx, [rax+0D0h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_48]
mov rcx, [rax+0B8h]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+0E4h], 0FFFFFFFFh
jnz short loc_E2C53
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rax
jmp short loc_E2C6A
loc_E2C53:
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, rcx
mov [rbp+var_80], rax
loc_E2C6A:
mov rax, [rbp+var_80]
mov [rbp+var_58], rax
loc_E2C72:
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
cmp [rbp+var_58], 0
jz short loc_E2C9E
cmp [rbp+var_58], 0FFFFFFFFFFFFFFFFh
jnz short loc_E2CBE
loc_E2C9E:
jmp short $+2
loc_E2CA0:
jmp short $+2
loc_E2CA2:
mov rax, [rbp+var_40]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
mov [rbp+var_4], 1
jmp loc_E2D4C
loc_E2CBE:
mov rax, [rbp+var_58]
cmp rax, [rbp+var_20]
jbe short loc_E2CD5
mov rax, [rbp+var_20]
mov [rbp+var_88], rax
jmp short loc_E2CE0
loc_E2CD5:
mov rax, [rbp+var_58]
mov [rbp+var_88], rax
loc_E2CE0:
mov rax, [rbp+var_88]
mov [rbp+var_50], rax
cmp [rbp+var_50], 0
jz short loc_E2D07
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rdx, [rbp+var_50]
call _memcpy
loc_E2D07:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rcx, [rbp+var_50]
mov rax, [rbp+var_10]
add rcx, [rax+10h]
mov [rax+10h], rcx
jmp loc_E2962
loc_E2D43:
jmp short $+2
loc_E2D45:
mov [rbp+var_4], 0
loc_E2D4C:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long my_b_cache_read_r(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+8h] [rbp-88h]
long long v5; // [rsp+10h] [rbp-80h]
int v6; // [rsp+1Ch] [rbp-74h]
unsigned long long v7; // [rsp+20h] [rbp-70h]
unsigned long long v8; // [rsp+30h] [rbp-60h]
unsigned long long v9; // [rsp+38h] [rbp-58h]
long long v10; // [rsp+48h] [rbp-48h]
int v11; // [rsp+50h] [rbp-40h]
unsigned long long v12; // [rsp+60h] [rbp-30h]
long long v13; // [rsp+60h] [rbp-30h]
long long v14; // [rsp+68h] [rbp-28h]
v11 = 0;
v10 = *(_QWORD *)(a1 + 152);
while ( a3 )
{
v14 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1;
v12 = (((v14 & 0xFFF) + a3 + 4095) & 0xFFFFF000) - (v14 & 0xFFF);
if ( v12 > *(_QWORD *)(a1 + 240) )
v8 = v12 - ((v12 - *(_QWORD *)(a1 + 240) + 4095) & 0xFFFFF000);
else
v8 = ((*(_QWORD *)(a1 + 240) - v12) & 0xFFFFF000) + v12;
v13 = v8;
if ( *(_DWORD *)(a1 + 176) != 4 && v8 > *(_QWORD *)(a1 + 8) - v14 )
v13 = *(_QWORD *)(a1 + 8) - v14;
if ( !v13 )
{
*(_DWORD *)(a1 + 228) = v11;
return 1;
}
if ( (unsigned int)lock_io_cache(a1, v14) )
{
if ( *(int *)(a1 + 212) >= 0 )
{
if ( *(_DWORD *)(a1 + 224)
&& inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x4CBu,
*(_DWORD *)(a1 + 212),
v14,
0,
0LL) == -1 )
{
*(_DWORD *)(a1 + 228) = -1;
unlock_io_cache(a1);
return 1;
}
v9 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1235LL,
*(unsigned int *)(a1 + 212),
*(_QWORD *)(a1 + 32),
v13,
*(_QWORD *)(a1 + 248));
}
else
{
v9 = 0LL;
}
if ( v9 == -1LL )
v7 = 0LL;
else
v7 = v9;
*(_QWORD *)(a1 + 24) = v7 + *(_QWORD *)(a1 + 32);
if ( v9 == v13 )
v6 = 0;
else
v6 = v9;
*(_DWORD *)(a1 + 228) = v6;
*(_QWORD *)a1 = v14;
*(_DWORD *)(v10 + 224) = *(_DWORD *)(a1 + 228);
*(_QWORD *)(v10 + 208) = *(_QWORD *)(a1 + 24);
*(_QWORD *)(v10 + 184) = v14;
unlock_io_cache(a1);
}
else
{
*(_DWORD *)(a1 + 228) = *(_DWORD *)(v10 + 224);
*(_QWORD *)(a1 + 24) = *(_QWORD *)(v10 + 208);
*(_QWORD *)a1 = *(_QWORD *)(v10 + 184);
if ( *(_DWORD *)(a1 + 228) == -1 )
v5 = -1LL;
else
v5 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32);
v9 = v5;
}
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
*(_DWORD *)(a1 + 224) = 0;
if ( !v9 || v9 == -1LL )
{
*(_DWORD *)(a1 + 228) = v11;
return 1;
}
if ( v9 <= a3 )
v4 = v9;
else
v4 = a3;
memcpy(a2, *(_QWORD *)(a1 + 16), v4);
a3 -= v4;
a2 += v4;
v11 += v4;
*(_QWORD *)(a1 + 16) += v4;
}
return 0;
}
| _my_b_cache_read_r:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x40],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e2960
LAB_001e2960:
JMP 0x001e2962
LAB_001e2962:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e2d43
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0xfff
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1000
SUB RAX,0x1
MOV RCX,0xfffff000
AND RAX,RCX
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0xf0]
JA 0x001e29fd
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0xf0]
SUB RCX,qword ptr [RBP + -0x30]
MOV RDX,0xfffff000
AND RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001e2a2f
LAB_001e29fd:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
SUB RCX,qword ptr [RDX + 0xf0]
ADD RCX,0x1000
SUB RCX,0x1
MOV RDX,0xfffff000
AND RCX,RDX
SUB RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
LAB_001e2a2f:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x4
JZ 0x001e2a69
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,qword ptr [RBP + -0x28]
CMP RAX,RCX
JBE 0x001e2a69
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
LAB_001e2a69:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001e2a8c
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e2d4c
LAB_001e2a8c:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001e4510
CMP EAX,0x0
JZ 0x001e2c00
JMP 0x001e2aa4
LAB_001e2aa4:
JMP 0x001e2aa6
LAB_001e2aa6:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xd4],0x0
JGE 0x001e2ac0
MOV qword ptr [RBP + -0x58],0x0
JMP 0x001e2b55
LAB_001e2ac0:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xe0],0x0
JZ 0x001e2b1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x28]
LEA RDI,[0x25570e]
MOV ESI,0x4cb
XOR R8D,R8D
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001e1990
CMP RAX,-0x1
JNZ 0x001e2b1d
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e4770
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e2d4c
LAB_001e2b1d:
JMP 0x001e2b1f
LAB_001e2b1f:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x25570e]
MOV ESI,0x4d3
CALL 0x001e43a0
MOV qword ptr [RBP + -0x58],RAX
LAB_001e2b55:
JMP 0x001e2b57
LAB_001e2b57:
JMP 0x001e2b59
LAB_001e2b59:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x68],RAX
CMP qword ptr [RBP + -0x58],-0x1
JNZ 0x001e2b74
XOR EAX,EAX
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001e2b7c
LAB_001e2b74:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x70],RAX
LAB_001e2b7c:
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x70]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001e2ba0
XOR EAX,EAX
MOV dword ptr [RBP + -0x74],EAX
JMP 0x001e2ba7
LAB_001e2ba0:
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x74],EAX
LAB_001e2ba7:
MOV ECX,dword ptr [RBP + -0x74]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0xe4]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0xe0],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0xd0],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0xb8],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e4770
JMP 0x001e2c72
LAB_001e2c00:
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0xe0]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0xd0]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xe4],-0x1
JNZ 0x001e2c53
MOV RAX,-0x1
MOV qword ptr [RBP + -0x80],RAX
JMP 0x001e2c6a
LAB_001e2c53:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x80],RAX
LAB_001e2c6a:
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x58],RAX
LAB_001e2c72:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
CMP qword ptr [RBP + -0x58],0x0
JZ 0x001e2c9e
CMP qword ptr [RBP + -0x58],-0x1
JNZ 0x001e2cbe
LAB_001e2c9e:
JMP 0x001e2ca0
LAB_001e2ca0:
JMP 0x001e2ca2
LAB_001e2ca2:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e2d4c
LAB_001e2cbe:
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001e2cd5
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x001e2ce0
LAB_001e2cd5:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x88],RAX
LAB_001e2ce0:
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001e2d07
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x0012a090
LAB_001e2d07:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001e2962
LAB_001e2d43:
JMP 0x001e2d45
LAB_001e2d45:
MOV dword ptr [RBP + -0x4],0x0
LAB_001e2d4c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
int4 _my_b_cache_read_r(ulong *param_1,void *param_2,ulong param_3)
{
ulong uVar1;
int iVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
size_t local_90;
ulong local_88;
int4 local_7c;
ulong local_78;
ulong local_68;
ulong local_60;
long local_48;
ulong local_38;
ulong local_28;
void *local_20;
local_48 = 0;
uVar1 = param_1[0x13];
local_28 = param_3;
local_20 = param_2;
while( true ) {
if (local_28 == 0) {
return 0;
}
uVar3 = *param_1 + (param_1[3] - param_1[4]);
local_68 = (local_28 + (uVar3 & 0xfff) + 0xfff & 0xfffff000) - (uVar3 & 0xfff);
if (param_1[0x1e] < local_68) {
uVar5 = -((local_68 - param_1[0x1e]) + 0xfff & 0xfffff000);
}
else {
uVar5 = param_1[0x1e] - local_68 & 0xfffff000;
}
local_68 = local_68 + uVar5;
local_38 = local_68;
if (((int)param_1[0x16] != 4) && (param_1[1] - uVar3 < local_68)) {
local_38 = param_1[1] - uVar3;
}
if (local_38 == 0) {
*(int *)((long)param_1 + 0xe4) = (int)local_48;
return 1;
}
iVar2 = lock_io_cache(param_1,uVar3);
if (iVar2 == 0) {
*(int4 *)((long)param_1 + 0xe4) = *(int4 *)(uVar1 + 0xe0);
param_1[3] = *(ulong *)(uVar1 + 0xd0);
*param_1 = *(ulong *)(uVar1 + 0xb8);
if (*(int *)((long)param_1 + 0xe4) == -1) {
local_88 = 0xffffffffffffffff;
}
else {
local_88 = param_1[3] - param_1[4];
}
local_60 = local_88;
}
else {
if (*(int *)((long)param_1 + 0xd4) < 0) {
local_60 = 0;
}
else {
if (((int)param_1[0x1c] != 0) &&
(lVar4 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x4cb,
*(int4 *)((long)param_1 + 0xd4),uVar3,0,0), lVar4 == -1)) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
unlock_io_cache(param_1);
return 1;
}
local_60 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x4d3,
*(int4 *)((long)param_1 + 0xd4),param_1[4],local_38,
param_1[0x1f]);
}
if (local_60 == 0xffffffffffffffff) {
local_78 = 0;
}
else {
local_78 = local_60;
}
param_1[3] = param_1[4] + local_78;
if (local_60 == local_38) {
local_7c = 0;
}
else {
local_7c = (int4)local_60;
}
*(int4 *)((long)param_1 + 0xe4) = local_7c;
*param_1 = uVar3;
*(int4 *)(uVar1 + 0xe0) = *(int4 *)((long)param_1 + 0xe4);
*(ulong *)(uVar1 + 0xd0) = param_1[3];
*(ulong *)(uVar1 + 0xb8) = uVar3;
unlock_io_cache(param_1);
}
param_1[2] = param_1[4];
*(int4 *)(param_1 + 0x1c) = 0;
if ((local_60 == 0) || (local_60 == 0xffffffffffffffff)) break;
if (local_28 < local_60) {
local_90 = local_28;
}
else {
local_90 = local_60;
}
if (local_90 != 0) {
memcpy(local_20,(void *)param_1[2],local_90);
}
local_28 = local_28 - local_90;
local_20 = (void *)(local_90 + (long)local_20);
local_48 = local_90 + local_48;
param_1[2] = local_90 + param_1[2];
}
*(int *)((long)param_1 + 0xe4) = (int)local_48;
return 1;
}
| |
39,443 | mi_restore_status | eloqsql/storage/myisam/mi_locking.c | void mi_restore_status(void *param)
{
MI_INFO *info= (MI_INFO*) param;
DBUG_ENTER("mi_restore_status");
DBUG_PRINT("info",("key_file: %ld data_file: %ld",
(long) info->s->state.state.key_file_length,
(long) info->s->state.state.data_file_length));
info->state= &info->s->state.state;
info->append_insert_at_end= 0;
DBUG_VOID_RETURN;
} | O3 | c | mi_restore_status:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
addq $0x18, %rax
movq %rax, 0x8(%rdi)
movb $0x0, 0x33a(%rdi)
popq %rbp
retq
| mi_restore_status:
push rbp
mov rbp, rsp
mov rax, [rdi]
add rax, 18h
mov [rdi+8], rax
mov byte ptr [rdi+33Ah], 0
pop rbp
retn
| long long mi_restore_status(long long a1)
{
long long result; // rax
result = *(_QWORD *)a1 + 24LL;
*(_QWORD *)(a1 + 8) = result;
*(_BYTE *)(a1 + 826) = 0;
return result;
}
| mi_restore_status:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
ADD RAX,0x18
MOV qword ptr [RDI + 0x8],RAX
MOV byte ptr [RDI + 0x33a],0x0
POP RBP
RET
|
void mi_restore_status(long *param_1)
{
param_1[1] = *param_1 + 0x18;
*(int1 *)((long)param_1 + 0x33a) = 0;
return;
}
| |
39,444 | rw_pr_rdlock | eloqsql/mysys/thr_rwlock.c | int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
} | O3 | c | rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x29220
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x291e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| rw_pr_rdlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
inc dword ptr [rbx+58h]
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
| long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
| rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00129220
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x001291e0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
| |
39,445 | 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::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array() | llama.cpp/common/json.hpp | bool end_array()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_array());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
} | O3 | cpp | 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::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array():
pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x8eb2a
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x8eb46
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x8cec9(%rip), %rdi # 0x11b9fa
leaq 0x8cefd(%rip), %rdx # 0x11ba35
leaq 0x8deae(%rip), %rcx # 0x11c9ed
movl $0x1b01, %esi # imm = 0x1B01
jmp 0x8eb60
leaq 0x8cead(%rip), %rdi # 0x11b9fa
leaq 0x8cee1(%rip), %rdx # 0x11ba35
leaq 0x8e143(%rip), %rcx # 0x11cc9e
movl $0x1b02, %esi # imm = 0x1B02
xorl %eax, %eax
callq 0x21fc0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
push rax
mov rax, [rdi+10h]
cmp [rdi+8], rax
jz short loc_8EB2A
mov rcx, [rax-8]
cmp byte ptr [rcx], 2
jnz short loc_8EB46
add rax, 0FFFFFFFFFFFFFFF8h
mov [rdi+10h], rax
mov al, 1
pop rcx
retn
loc_8EB2A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1B01h
jmp short loc_8EB60
loc_8EB46:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs_0; "ref_stack.back()->is_array()"
mov esi, 1B02h
loc_8EB60:
xor eax, eax
call _ggml_abort
nop
| char 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>>::end_array(
long long a1)
{
long long v1; // rax
long long v3; // rsi
long long v4; // rdx
long long v5; // rcx
v1 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v1 )
{
v3 = 6913LL;
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
6913LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
}
else
{
if ( **(_BYTE **)(v1 - 8) == 2 )
{
*(_QWORD *)(a1 + 16) = v1 - 8;
return 1;
}
v3 = 6914LL;
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
6914LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_array()");
}
return 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::out_of_range>(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
v3,
v4,
v5);
}
| end_array:
PUSH RAX
MOV RAX,qword ptr [RDI + 0x10]
CMP qword ptr [RDI + 0x8],RAX
JZ 0x0018eb2a
MOV RCX,qword ptr [RAX + -0x8]
CMP byte ptr [RCX],0x2
JNZ 0x0018eb46
ADD RAX,-0x8
MOV qword ptr [RDI + 0x10],RAX
MOV AL,0x1
POP RCX
RET
LAB_0018eb2a:
LEA RDI,[0x21b9fa]
LEA RDX,[0x21ba35]
LEA RCX,[0x21c9ed]
MOV ESI,0x1b01
JMP 0x0018eb60
LAB_0018eb46:
LEA RDI,[0x21b9fa]
LEA RDX,[0x21ba35]
LEA RCX,[0x21cc9e]
MOV ESI,0x1b02
LAB_0018eb60:
XOR EAX,EAX
CALL 0x00121fc0
|
/* 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> >::end_array() */
int8 __thiscall
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>>
::end_array(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)
{
long lVar1;
char *pcVar2;
int8 uVar3;
lVar1 = *(long *)(this + 0x10);
if (*(long *)(this + 8) == lVar1) {
pcVar2 = "!ref_stack.empty()";
uVar3 = 0x1b01;
}
else {
if (**(char **)(lVar1 + -8) == '\x02') {
*(long *)(this + 0x10) = lVar1 + -8;
return CONCAT71((int7)((ulong)(lVar1 + -8) >> 8),1);
}
pcVar2 = "ref_stack.back()->is_array()";
uVar3 = 0x1b02;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
39,446 | add_cfg_dir | eloqsql/libmariadb/libmariadb/ma_default.c | static int add_cfg_dir(char **cfg_dirs, const char *directory)
{
int i;
for (i = 0; i < MAX_CONFIG_DIRS && cfg_dirs[i]; i++)
if (!strcmp(cfg_dirs[i], directory)) /* already present */
return 0;
if (i < MAX_CONFIG_DIRS) {
cfg_dirs[i]= strdup(directory);
return 0;
}
return 1;
} | O0 | c | add_cfg_dir:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x6, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0x4b695
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x4b69e
jmp 0x4b6ce
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x13600
cmpl $0x0, %eax
jne 0x4b6c1
movl $0x0, -0x4(%rbp)
jmp 0x4b6fc
jmp 0x4b6c3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4b677
cmpl $0x6, -0x1c(%rbp)
jge 0x4b6f5
movq -0x18(%rbp), %rdi
callq 0x137b0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
jmp 0x4b6fc
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| add_cfg_dir:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], 0
loc_4B677:
xor eax, eax
cmp [rbp+var_1C], 6
mov [rbp+var_1D], al
jge short loc_4B695
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
cmp qword ptr [rax+rcx*8], 0
setnz al
mov [rbp+var_1D], al
loc_4B695:
mov al, [rbp+var_1D]
test al, 1
jnz short loc_4B69E
jmp short loc_4B6CE
loc_4B69E:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rdi, [rax+rcx*8]
mov rsi, [rbp+var_18]
call _strcmp
cmp eax, 0
jnz short loc_4B6C1
mov [rbp+var_4], 0
jmp short loc_4B6FC
loc_4B6C1:
jmp short $+2
loc_4B6C3:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_4B677
loc_4B6CE:
cmp [rbp+var_1C], 6
jge short loc_4B6F5
mov rdi, [rbp+var_18]
call _strdup
mov rdx, rax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov [rax+rcx*8], rdx
mov [rbp+var_4], 0
jmp short loc_4B6FC
loc_4B6F5:
mov [rbp+var_4], 1
loc_4B6FC:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long add_cfg_dir(long long a1, long long a2)
{
bool v3; // [rsp+3h] [rbp-1Dh]
int i; // [rsp+4h] [rbp-1Ch]
for ( i = 0; ; ++i )
{
v3 = 0;
if ( i < 6 )
v3 = *(_QWORD *)(a1 + 8LL * i) != 0LL;
if ( !v3 )
break;
if ( !(unsigned int)strcmp(*(_QWORD *)(a1 + 8LL * i), a2) )
return 0;
}
if ( i >= 6 )
{
return 1;
}
else
{
*(_QWORD *)(a1 + 8LL * i) = strdup(a2);
return 0;
}
}
| add_cfg_dir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],0x0
LAB_0014b677:
XOR EAX,EAX
CMP dword ptr [RBP + -0x1c],0x6
MOV byte ptr [RBP + -0x1d],AL
JGE 0x0014b695
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
CMP qword ptr [RAX + RCX*0x8],0x0
SETNZ AL
MOV byte ptr [RBP + -0x1d],AL
LAB_0014b695:
MOV AL,byte ptr [RBP + -0x1d]
TEST AL,0x1
JNZ 0x0014b69e
JMP 0x0014b6ce
LAB_0014b69e:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00113600
CMP EAX,0x0
JNZ 0x0014b6c1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014b6fc
LAB_0014b6c1:
JMP 0x0014b6c3
LAB_0014b6c3:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0014b677
LAB_0014b6ce:
CMP dword ptr [RBP + -0x1c],0x6
JGE 0x0014b6f5
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001137b0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014b6fc
LAB_0014b6f5:
MOV dword ptr [RBP + -0x4],0x1
LAB_0014b6fc:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 add_cfg_dir(long param_1,char *param_2)
{
int iVar1;
char *pcVar2;
bool bVar3;
int local_24;
local_24 = 0;
while( true ) {
bVar3 = false;
if (local_24 < 6) {
bVar3 = *(long *)(param_1 + (long)local_24 * 8) != 0;
}
if (!bVar3) break;
iVar1 = strcmp(*(char **)(param_1 + (long)local_24 * 8),param_2);
if (iVar1 == 0) {
return 0;
}
local_24 = local_24 + 1;
}
if (local_24 < 6) {
pcVar2 = strdup(param_2);
*(char **)(param_1 + (long)local_24 * 8) = pcVar2;
return 0;
}
return 1;
}
| |
39,447 | lf_alloc_new | eloqsql/mysys/lf_alloc-pin.c | void *lf_alloc_new(LF_PINS *pins)
{
LF_ALLOCATOR *allocator= (LF_ALLOCATOR *)(pins->pinbox->free_func_arg);
uchar *node;
for (;;)
{
do
{
node= allocator->top;
lf_pin(pins, 0, node);
} while (node != allocator->top && LF_BACKOFF());
if (!node)
{
node= (void *)my_malloc(key_memory_lf_node, allocator->element_size,
MYF(MY_WME));
if (allocator->constructor)
allocator->constructor(node);
#ifdef MY_LF_EXTRA_DEBUG
if (likely(node != 0))
my_atomic_add32(&allocator->mallocs, 1);
#endif
break;
}
if (my_atomic_casptr((void **)(char *)&allocator->top,
(void *)&node, anext_node(node)))
break;
}
lf_unpin(pins, 0);
return node;
} | O3 | c | lf_alloc_new:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x30(%rax), %r15
leaq 0x2e3ced(%rip), %rcx # 0x390ee0
movq 0x48(%r15), %r14
movq %r14, %rax
xchgq %rax, (%rbx)
cmpq 0x48(%r15), %r14
je 0xad211
movl (%rcx), %eax
testl %eax, %eax
je 0xad1f3
pause
decl %eax
jne 0xad209
jmp 0xad1f3
testq %r14, %r14
je 0xad22b
movl 0x38(%r15), %eax
movq (%r14,%rax), %rdx
movq %r14, %rax
lock
cmpxchgq %rdx, 0x48(%r15)
jne 0xad1f3
jmp 0xad253
leaq 0xb675ce(%rip), %rax # 0xc14800
movl (%rax), %edi
movl 0x50(%r15), %esi
movl $0x10, %edx
callq 0xa6f99
movq %rax, %r14
movq 0x58(%r15), %rax
testq %rax, %rax
je 0xad253
movq %r14, %rdi
callq *%rax
xorl %eax, %eax
xchgq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| lf_alloc_new:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov rax, [rdi+20h]
mov r15, [rax+30h]
lea rcx, my_cpu_relax_multiplier
loc_AD1F3:
mov r14, [r15+48h]
mov rax, r14
xchg rax, [rbx]
cmp r14, [r15+48h]
jz short loc_AD211
mov eax, [rcx]
test eax, eax
jz short loc_AD1F3
loc_AD209:
pause
dec eax
jnz short loc_AD209
jmp short loc_AD1F3
loc_AD211:
test r14, r14
jz short loc_AD22B
mov eax, [r15+38h]
mov rdx, [r14+rax]
mov rax, r14
lock cmpxchg [r15+48h], rdx
jnz short loc_AD1F3
jmp short loc_AD253
loc_AD22B:
lea rax, key_memory_lf_node
mov edi, [rax]
mov esi, [r15+50h]
mov edx, 10h
call my_malloc
mov r14, rax
mov rax, [r15+58h]
test rax, rax
jz short loc_AD253
mov rdi, r14
call rax
loc_AD253:
xor eax, eax
xchg rax, [rbx]
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long lf_alloc_new(long long a1)
{
long long v1; // r15
long long v2; // r14
int i; // eax
void ( *v4)(long long); // rax
v1 = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 48LL);
while ( 1 )
{
while ( 1 )
{
v2 = *(_QWORD *)(v1 + 72);
_InterlockedExchange64((volatile long long *)a1, v2);
if ( v2 == *(_QWORD *)(v1 + 72) )
break;
for ( i = my_cpu_relax_multiplier; i; --i )
_mm_pause();
}
if ( !v2 )
break;
if ( v2 == _InterlockedCompareExchange64(
(volatile signed long long *)(v1 + 72),
*(_QWORD *)(v2 + *(unsigned int *)(v1 + 56)),
v2) )
goto LABEL_11;
}
v2 = my_malloc(key_memory_lf_node, (const char *)*(unsigned int *)(v1 + 80), 16);
v4 = *(void ( **)(long long))(v1 + 88);
if ( v4 )
v4(v2);
LABEL_11:
_InterlockedExchange64((volatile long long *)a1, 0LL);
return v2;
}
| lf_alloc_new:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x20]
MOV R15,qword ptr [RAX + 0x30]
LEA RCX,[0x490ee0]
LAB_001ad1f3:
MOV R14,qword ptr [R15 + 0x48]
MOV RAX,R14
XCHG qword ptr [RBX],RAX
CMP R14,qword ptr [R15 + 0x48]
JZ 0x001ad211
MOV EAX,dword ptr [RCX]
TEST EAX,EAX
JZ 0x001ad1f3
LAB_001ad209:
PAUSE
DEC EAX
JNZ 0x001ad209
JMP 0x001ad1f3
LAB_001ad211:
TEST R14,R14
JZ 0x001ad22b
MOV EAX,dword ptr [R15 + 0x38]
MOV RDX,qword ptr [R14 + RAX*0x1]
MOV RAX,R14
CMPXCHG.LOCK qword ptr [R15 + 0x48],RDX
JNZ 0x001ad1f3
JMP 0x001ad253
LAB_001ad22b:
LEA RAX,[0xd14800]
MOV EDI,dword ptr [RAX]
MOV ESI,dword ptr [R15 + 0x50]
MOV EDX,0x10
CALL 0x001a6f99
MOV R14,RAX
MOV RAX,qword ptr [R15 + 0x58]
TEST RAX,RAX
JZ 0x001ad253
MOV RDI,R14
CALL RAX
LAB_001ad253:
XOR EAX,EAX
XCHG qword ptr [RBX],RAX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
long lf_alloc_new(long *param_1)
{
long lVar1;
int iVar2;
long lVar3;
bool bVar4;
lVar1 = *(long *)(param_1[4] + 0x30);
do {
while( true ) {
lVar3 = *(long *)(lVar1 + 0x48);
LOCK();
*param_1 = lVar3;
UNLOCK();
iVar2 = my_cpu_relax_multiplier;
if (lVar3 == *(long *)(lVar1 + 0x48)) break;
for (; iVar2 != 0; iVar2 = iVar2 + -1) {
}
}
if (lVar3 == 0) {
lVar3 = my_malloc(key_memory_lf_node,*(int4 *)(lVar1 + 0x50),0x10);
if (*(code **)(lVar1 + 0x58) != (code *)0x0) {
(**(code **)(lVar1 + 0x58))(lVar3);
}
break;
}
LOCK();
bVar4 = lVar3 == *(long *)(lVar1 + 0x48);
if (bVar4) {
*(long *)(lVar1 + 0x48) = *(long *)(lVar3 + (ulong)*(uint *)(lVar1 + 0x38));
}
UNLOCK();
} while (!bVar4);
LOCK();
*param_1 = 0;
UNLOCK();
return lVar3;
}
| |
39,448 | my_sync_dir | eloqsql/mysys/my_sync.c | int my_sync_dir(const char *dir_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
static const char cur_dir_name[]= {FN_CURLIB, 0};
File dir_fd;
int res= 0;
const char *correct_dir_name;
DBUG_ENTER("my_sync_dir");
DBUG_PRINT("my",("Dir: '%s' my_flags: %lu", dir_name, my_flags));
/* Sometimes the path does not contain an explicit directory */
correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;
/*
Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.
EIO on the other hand is very important. Hence MY_IGNORE_BADFD.
*/
if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)
{
if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))
res= 2;
if (my_close(dir_fd, MYF(my_flags)))
res= 3;
}
else
res= 1;
DBUG_RETURN(res);
#else
return 0;
#endif
} | O3 | c | my_sync_dir:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
movq %rsi, %rbx
leaq 0x4085c(%rip), %rax # 0xe1e48
cmoveq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xa03e0
testl %eax, %eax
js 0xa1633
movl %eax, %r14d
movq %rbx, %rsi
orq $0x20, %rsi
movl %eax, %edi
callq 0xa14a4
xorl %r15d, %r15d
testl %eax, %eax
setne %r15b
addl %r15d, %r15d
movl %r14d, %edi
movq %rbx, %rsi
callq 0xa0585
testl %eax, %eax
movl $0x3, %eax
cmovel %r15d, %eax
jmp 0xa1638
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_sync_dir:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp byte ptr [rdi], 0
mov rbx, rsi
lea rax, my_sync_dir_cur_dir_name
cmovz rdi, rax
xor esi, esi
mov rdx, rbx
call my_open
test eax, eax
js short loc_A1633
mov r14d, eax
mov rsi, rbx
or rsi, 20h
mov edi, eax
call my_sync
xor r15d, r15d
test eax, eax
setnz r15b
add r15d, r15d
mov edi, r14d
mov rsi, rbx
call my_close
test eax, eax
mov eax, 3
cmovz eax, r15d
jmp short loc_A1638
loc_A1633:
mov eax, 1
loc_A1638:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_sync_dir(_BYTE *a1, long long a2)
{
int v2; // eax
unsigned int v3; // r14d
unsigned int v4; // r15d
bool v5; // zf
long long result; // rax
if ( !*a1 )
a1 = &my_sync_dir_cur_dir_name;
v2 = my_open((long long)a1, 0, a2);
if ( v2 < 0 )
return 1LL;
v3 = v2;
v4 = 2 * ((unsigned int)my_sync((unsigned int)v2, (const char *)(a2 | 0x20)) != 0);
v5 = (unsigned int)my_close(v3, (const char *)a2) == 0;
result = 3LL;
if ( v5 )
return v4;
return result;
}
| my_sync_dir:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP byte ptr [RDI],0x0
MOV RBX,RSI
LEA RAX,[0x1e1e48]
CMOVZ RDI,RAX
XOR ESI,ESI
MOV RDX,RBX
CALL 0x001a03e0
TEST EAX,EAX
JS 0x001a1633
MOV R14D,EAX
MOV RSI,RBX
OR RSI,0x20
MOV EDI,EAX
CALL 0x001a14a4
XOR R15D,R15D
TEST EAX,EAX
SETNZ R15B
ADD R15D,R15D
MOV EDI,R14D
MOV RSI,RBX
CALL 0x001a0585
TEST EAX,EAX
MOV EAX,0x3
CMOVZ EAX,R15D
JMP 0x001a1638
LAB_001a1633:
MOV EAX,0x1
LAB_001a1638:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char my_sync_dir(char *param_1,ulong param_2)
{
char cVar1;
int iVar2;
int iVar3;
if (*param_1 == '\0') {
param_1 = ".";
}
iVar2 = my_open(param_1,0,param_2);
if (iVar2 < 0) {
cVar1 = '\x01';
}
else {
iVar3 = my_sync(iVar2,param_2 | 0x20);
iVar2 = my_close(iVar2,param_2);
cVar1 = '\x03';
if (iVar2 == 0) {
cVar1 = (iVar3 != 0) * '\x02';
}
}
return cVar1;
}
| |
39,449 | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_float(double) | monkey531[P]llama/common/json.hpp | void dump_float(number_float_t x)
{
// NaN / inf
if (!std::isfinite(x))
{
o->write_characters("null", 4);
return;
}
// If number_float_t is an IEEE-754 single or double precision number,
// use the Grisu2 algorithm to produce short numbers which are
// guaranteed to round-trip, using strtof and strtod, resp.
//
// NB: The test below works if <long double> == <double>.
static constexpr bool is_ieee_single_or_double
= (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
(std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_float(double):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jl 0xb6f01
movq (%rbx), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq 0x396a4(%rip), %rsi # 0xf0597
movl $0x4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x10(%rbx), %r14
leaq 0x50(%rbx), %rsi
movq %r14, %rdi
callq 0xb7145
movq (%rbx), %rdi
subq %r14, %rax
movq (%rdi), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10dump_floatEd:
push r14
push rbx
push rax
mov rbx, rdi
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jl short loc_B6F01
mov rdi, [rbx]
mov rax, [rdi]
mov rax, [rax+8]
lea rsi, aOnNull_0+5; "null"
mov edx, 4
add rsp, 8
pop rbx
pop r14
jmp rax
loc_B6F01:
lea r14, [rbx+10h]
lea rsi, [rbx+50h]
mov rdi, r14; this
call _ZN8nlohmann16json_abi_v3_11_36detail8to_charsIdEEPcS3_PKcT_; nlohmann::json_abi_v3_11_3::detail::to_chars<double>(char *,char const*,double)
mov rdi, [rbx]
sub rax, r14
mov rcx, [rdi]
mov rcx, [rcx+8]
mov rsi, r14
mov rdx, rax
add rsp, 8
pop rbx
pop r14
jmp rcx
| long long nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::dump_float(
_QWORD *a1,
double a2)
{
long long v3; // rax
if ( (*(_QWORD *)&a2 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
return (*(long long ( **)(_QWORD, char *, long long))(*(_QWORD *)*a1 + 8LL))(*a1, "null", 4LL);
v3 = nlohmann::json_abi_v3_11_3::detail::to_chars<double>((nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)(a1 + 2));
return (*(long long ( **)(_QWORD, _QWORD *, long long))(*(_QWORD *)*a1 + 8LL))(
*a1,
a1 + 2,
v3 - (_QWORD)(a1 + 2));
}
| dump_float:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JL 0x001b6f01
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
LEA RSI,[0x1f0597]
MOV EDX,0x4
ADD RSP,0x8
POP RBX
POP R14
JMP RAX
LAB_001b6f01:
LEA R14,[RBX + 0x10]
LEA RSI,[RBX + 0x50]
MOV RDI,R14
CALL 0x001b7145
MOV RDI,qword ptr [RBX]
SUB RAX,R14
MOV RCX,qword ptr [RDI]
MOV RCX,qword ptr [RCX + 0x8]
MOV RSI,R14
MOV RDX,RAX
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::dump_float(double) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::dump_float(serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,double param_1)
{
serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*psVar1;
code *UNRECOVERED_JUMPTABLE;
char *pcVar2;
if (0x7fefffffffffffff < (ulong)ABS(param_1)) {
/* WARNING: Could not recover jumptable at 0x001b6eff. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)this + 8))(*(long **)this,"null",4);
return;
}
psVar1 = this + 0x10;
pcVar2 = to_chars<double>((char *)psVar1,(char *)(this + 0x50),param_1);
UNRECOVERED_JUMPTABLE = *(code **)(**(long **)this + 8);
/* WARNING: Could not recover jumptable at 0x001b6f2b. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(*(long **)this,psVar1,(long)pcVar2 - (long)psVar1,UNRECOVERED_JUMPTABLE);
return;
}
| |
39,450 | JS_EvalFunctionInternal | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
JSValue this_obj,
JSVarRef **var_refs, JSStackFrame *sf)
{
JSValue ret_val;
uint32_t tag;
tag = JS_VALUE_GET_TAG(fun_obj);
if (tag == JS_TAG_FUNCTION_BYTECODE) {
fun_obj = js_closure(ctx, fun_obj, var_refs, sf);
ret_val = JS_CallFree(ctx, fun_obj, this_obj, 0, NULL);
} else if (tag == JS_TAG_MODULE) {
JSModuleDef *m;
m = JS_VALUE_GET_PTR(fun_obj);
/* the module refcount should be >= 2 */
JS_FreeValue(ctx, fun_obj);
if (js_create_module_function(ctx, m) < 0)
goto fail;
if (js_link_module(ctx, m) < 0)
goto fail;
ret_val = js_evaluate_module(ctx, m);
if (JS_IsException(ret_val)) {
fail:
return JS_EXCEPTION;
}
} else {
JS_FreeValue(ctx, fun_obj);
ret_val = JS_ThrowTypeError(ctx, "bytecode function expected");
}
return ret_val;
} | O0 | c | JS_EvalFunctionInternal:
subq $0xa8, %rsp
movq 0xb0(%rsp), %rax
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x78(%rsp)
movq %r8, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq 0x90(%rsp), %rax
movl %eax, 0x54(%rsp)
cmpl $-0x2, 0x54(%rsp)
jne 0x50d5f
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rcx
movq 0xb0(%rsp), %r8
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x6a300
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x70(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x34570
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x50e68
cmpl $-0x3, 0x54(%rsp)
jne 0x50e1b
movq 0x88(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x29f80
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7b5e0
cmpl $0x0, %eax
jge 0x50da7
jmp 0x50e00
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7b770
cmpl $0x0, %eax
jge 0x50dbd
jmp 0x50e00
movq 0x70(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x7b800
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x50e19
jmp 0x50e00
movl $0x0, 0x98(%rsp)
movq $0x6, 0xa0(%rsp)
jmp 0x50e82
jmp 0x50e66
movq 0x70(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x29f80
movq 0x70(%rsp), %rdi
leaq 0xc3c20(%rip), %rsi # 0x114a61
movb $0x0, %al
callq 0x335f0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x50e68
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq 0xa0(%rsp), %rdx
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
| JS_EvalFunctionInternal:
sub rsp, 0A8h
mov rax, [rsp+0A8h+arg_0]
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_18], rdx
mov [rsp+0A8h+var_30], rcx
mov [rsp+0A8h+var_28], r8
mov [rsp+0A8h+var_38], rdi
mov [rsp+0A8h+var_40], r9
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_54], eax
cmp [rsp+0A8h+var_54], 0FFFFFFFEh
jnz loc_50D5F
mov rdi, [rsp+0A8h+var_38]
mov rcx, [rsp+0A8h+var_40]
mov r8, [rsp+0A8h+arg_0]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call js_closure
mov [rsp+0A8h+var_68], rax
mov [rsp+0A8h+var_60], rdx
mov rax, [rsp+0A8h+var_68]
mov [rsp+0A8h+var_20], rax
mov rax, [rsp+0A8h+var_60]
mov [rsp+0A8h+var_18], rax
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
mov rcx, [rsp+0A8h+var_30]
mov r8, [rsp+0A8h+var_28]
xor r9d, r9d
xor eax, eax
mov [rsp+0A8h+var_A8], 0
call JS_CallFree
mov [rsp+0A8h+var_78], rax
mov [rsp+0A8h+var_70], rdx
mov rax, [rsp+0A8h+var_78]
mov [rsp+0A8h+var_50], rax
mov rax, [rsp+0A8h+var_70]
mov [rsp+0A8h+var_48], rax
jmp loc_50E68
loc_50D5F:
cmp [rsp+0A8h+var_54], 0FFFFFFFDh
jnz loc_50E1B
mov rax, [rsp+0A8h+var_20]
mov [rsp+0A8h+var_80], rax
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call JS_FreeValue
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_80]
call js_create_module_function
cmp eax, 0
jge short loc_50DA7
jmp short loc_50E00
loc_50DA7:
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_80]
call js_link_module
cmp eax, 0
jge short loc_50DBD
jmp short loc_50E00
loc_50DBD:
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_80]
call js_evaluate_module
mov [rsp+0A8h+var_90], rax
mov [rsp+0A8h+var_88], rdx
mov rax, [rsp+0A8h+var_90]
mov [rsp+0A8h+var_50], rax
mov rax, [rsp+0A8h+var_88]
mov [rsp+0A8h+var_48], rax
mov rdi, [rsp+0A8h+var_50]
mov rsi, [rsp+0A8h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_50E19
jmp short $+2
loc_50E00:
mov dword ptr [rsp+0A8h+var_10], 0
mov [rsp+0A8h+var_8], 6
jmp short loc_50E82
loc_50E19:
jmp short loc_50E66
loc_50E1B:
mov rdi, [rsp+0A8h+var_38]
mov rsi, [rsp+0A8h+var_20]
mov rdx, [rsp+0A8h+var_18]
call JS_FreeValue
mov rdi, [rsp+0A8h+var_38]
lea rsi, aBytecodeFuncti_0; "bytecode function expected"
mov al, 0
call JS_ThrowTypeError
mov [rsp+0A8h+var_A0], rax
mov [rsp+0A8h+var_98], rdx
mov rax, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_50], rax
mov rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_48], rax
loc_50E66:
jmp short $+2
loc_50E68:
mov rax, [rsp+0A8h+var_50]
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_48]
mov [rsp+0A8h+var_8], rax
loc_50E82:
mov rax, [rsp+0A8h+var_10]
mov rdx, [rsp+0A8h+var_8]
add rsp, 0A8h
retn
| long long JS_EvalFunctionInternal(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15)
{
long long v15; // rdx
int v16; // edx
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
__m128 v21; // xmm4
__m128 v22; // xmm5
char v24; // [rsp+0h] [rbp-A8h]
long long v25; // [rsp+40h] [rbp-68h]
long long v26; // [rsp+58h] [rbp-50h]
long long v29; // [rsp+98h] [rbp-10h]
if ( (_DWORD)a3 == -2 )
{
v25 = js_closure(a1, a2, a3, a6, a15, *(double *)a7.m128_u64);
return JS_CallFree(a1, v25, v15, a4, a5, 0, 0LL);
}
if ( (_DWORD)a3 != -3 )
{
JS_FreeValue(a1, a2, a3);
return JS_ThrowTypeError(
a1,
(long long)"bytecode function expected",
v17,
v18,
v19,
v20,
a7,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
v24);
}
JS_FreeValue(a1, a2, a3);
if ( (int)js_create_module_function(a1, a2) >= 0 && (int)js_link_module(a1, a2) >= 0 )
{
v26 = js_evaluate_module(a1, a2);
if ( !JS_IsException_1(v26, v16) )
return v26;
}
LODWORD(v29) = 0;
return v29;
}
| JS_EvalFunctionInternal:
SUB RSP,0xa8
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],R8
MOV qword ptr [RSP + 0x70],RDI
MOV qword ptr [RSP + 0x68],R9
MOV RAX,qword ptr [RSP + 0x90]
MOV dword ptr [RSP + 0x54],EAX
CMP dword ptr [RSP + 0x54],-0x2
JNZ 0x00150d5f
MOV RDI,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x0016a300
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x90],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RSP + 0x78]
MOV R8,qword ptr [RSP + 0x80]
XOR R9D,R9D
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x00134570
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x60],RAX
JMP 0x00150e68
LAB_00150d5f:
CMP dword ptr [RSP + 0x54],-0x3
JNZ 0x00150e1b
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0017b5e0
CMP EAX,0x0
JGE 0x00150da7
JMP 0x00150e00
LAB_00150da7:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0017b770
CMP EAX,0x0
JGE 0x00150dbd
JMP 0x00150e00
LAB_00150dbd:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0017b800
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x00150e19
JMP 0x00150e00
LAB_00150e00:
MOV dword ptr [RSP + 0x98],0x0
MOV qword ptr [RSP + 0xa0],0x6
JMP 0x00150e82
LAB_00150e19:
JMP 0x00150e66
LAB_00150e1b:
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[0x214a61]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x60],RAX
LAB_00150e66:
JMP 0x00150e68
LAB_00150e68:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xa0],RAX
LAB_00150e82:
MOV RAX,qword ptr [RSP + 0x98]
MOV RDX,qword ptr [RSP + 0xa0]
ADD RSP,0xa8
RET
|
int1 [16]
JS_EvalFunctionInternal
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7)
{
int iVar1;
int1 auVar2 [16];
int8 local_48;
int4 local_10;
int4 uStack_c;
int8 local_8;
if ((int)param_3 == -2) {
auVar2 = js_closure(param_1,param_2,param_3,param_6,param_7);
auVar2 = JS_CallFree(param_1,auVar2._0_8_,auVar2._8_8_,param_4,param_5,0,0);
}
else {
if ((int)param_3 == -3) {
JS_FreeValue(param_1,param_2,param_3);
iVar1 = js_create_module_function(param_1,param_2);
if ((-1 < iVar1) && (iVar1 = js_link_module(param_1,param_2), -1 < iVar1)) {
auVar2 = js_evaluate_module(param_1,param_2);
iVar1 = JS_IsException(auVar2._0_8_,auVar2._8_8_);
if (iVar1 == 0) goto LAB_00150e68;
}
local_10 = 0;
local_8 = 6;
goto LAB_00150e82;
}
JS_FreeValue(param_1,param_2,param_3);
auVar2 = JS_ThrowTypeError(param_1,"bytecode function expected");
}
LAB_00150e68:
local_48 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
local_8 = local_48;
LAB_00150e82:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
39,451 | JS_EvalFunctionInternal | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
JSValue this_obj,
JSVarRef **var_refs, JSStackFrame *sf)
{
JSValue ret_val;
uint32_t tag;
tag = JS_VALUE_GET_TAG(fun_obj);
if (tag == JS_TAG_FUNCTION_BYTECODE) {
fun_obj = js_closure(ctx, fun_obj, var_refs, sf);
ret_val = JS_CallFree(ctx, fun_obj, this_obj, 0, NULL);
} else if (tag == JS_TAG_MODULE) {
JSModuleDef *m;
m = JS_VALUE_GET_PTR(fun_obj);
/* the module refcount should be >= 2 */
JS_FreeValue(ctx, fun_obj);
if (js_create_module_function(ctx, m) < 0)
goto fail;
if (js_link_module(ctx, m) < 0)
goto fail;
ret_val = js_evaluate_module(ctx, m);
if (JS_IsException(ret_val)) {
fail:
return JS_EXCEPTION;
}
} else {
JS_FreeValue(ctx, fun_obj);
ret_val = JS_ThrowTypeError(ctx, "bytecode function expected");
}
return ret_val;
} | O1 | c | JS_EvalFunctionInternal:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq %rsi, 0x30(%rsp)
cmpl $-0x3, %edx
je 0x352cd
cmpl $-0x2, %edx
jne 0x35328
movq %r8, %r14
movq %rcx, %r15
movq 0x80(%rsp), %r8
movq %rbx, %rdi
movq %r9, %rcx
callq 0x4303a
movq %rax, 0x30(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x26cf9
movq %rax, %r14
jmp 0x3554e
movq 0x30(%rsp), %r14
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x21922
movq %rbx, %rdi
movq %r14, %rsi
callq 0x484a7
testl %eax, %eax
js 0x35427
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x48679
testl %eax, %eax
jns 0x35357
movq 0x20(%rsp), %rcx
testq %rcx, %rcx
je 0x3534f
movb $0x0, 0x83(%rcx)
movq 0x90(%rcx), %rcx
jmp 0x35313
movq 0x18(%rbx), %rdi
callq 0x21922
leaq 0x6e73d(%rip), %rsi # 0xa3a75
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x265c3
movl $0x6, %edx
jmp 0x3554e
testl %eax, %eax
js 0x35427
movl $0xfe000000, %eax # imm = 0xFE000000
andl 0x80(%r14), %eax
cmpl $0x4000000, %eax # imm = 0x4000000
jne 0x35371
movq 0xb8(%r14), %r14
movq 0xc8(%r14), %rax
cmpl $0x3, %eax
jne 0x3542e
leaq 0xd0(%r14), %rsi
xorl %r15d, %r15d
movl $0x3, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3a312
movq %rax, 0xc0(%r14)
movq %rdx, 0xc8(%r14)
movl $0x6, %eax
movl $0x0, %esi
cmpl $0x6, %edx
je 0x35530
leaq 0x38(%rsp), %rcx
movq $0x0, (%rcx)
leaq 0x40(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x48ad7
testl %eax, %eax
js 0x3543a
cmpl $0x0, 0xac(%r14)
jne 0x35504
xorl %eax, %eax
leaq 0x50(%rsp), %rcx
movl %eax, (%rcx)
movl $0x3, %edi
movq %rdi, 0x8(%rcx)
movq 0xd0(%r14), %rsi
movq 0xd8(%r14), %rdx
movl %eax, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rcx, 0x10(%rsp)
jmp 0x354da
xorl %edx, %edx
jmp 0x3553c
movq 0xc0(%r14), %r15
jmp 0x35512
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x3548e
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
movb $0x5, 0x83(%rax)
movb $0x1, 0xf0(%rax)
movq %rcx, 0x20(%rsp)
cmpl $-0x9, %edx
jb 0x3546d
movq 0x20(%rsp), %rsi
incl (%rsi)
movq %rcx, 0xf8(%rax)
movq %rdx, 0x100(%rax)
movq %r14, 0xb8(%rax)
movq 0x90(%rax), %rax
testq %rax, %rax
jne 0x3544e
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x21922
leaq 0xf8(%r14), %rax
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x2c526
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x21922
movq 0xc0(%r14), %r15
movq 0xc8(%r14), %rax
movq %r15, 0x20(%rsp)
cmpl $-0x9, %eax
jb 0x35523
movq 0x20(%rsp), %rcx
incl (%rcx)
movabsq $-0x100000000, %rsi # imm = 0xFFFFFFFF00000000
andq %r15, %rsi
movl %r15d, %ecx
orq %rsi, %rcx
cmpl $0x6, %eax
setne %dl
xorl %r14d, %r14d
testb %dl, %dl
movl $0x6, %edx
cmovneq %rax, %rdx
cmovneq %rcx, %r14
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
| JS_EvalFunctionInternal:
push r15
push r14
push rbx
sub rsp, 60h
mov rbx, rdi
mov [rsp+78h+var_48], rsi
cmp edx, 0FFFFFFFDh
jz short loc_352CD
cmp edx, 0FFFFFFFEh
jnz loc_35328
mov r14, r8
mov r15, rcx
mov r8, [rsp+78h+arg_0]
mov rdi, rbx
mov rcx, r9
call js_closure
mov [rsp+78h+var_48], rax
mov qword ptr [rsp+78h+var_78], 0
mov rdi, rbx
mov rsi, rax
mov rcx, r15
mov r8, r14
xor r9d, r9d
call JS_CallFree
mov r14, rax
jmp loc_3554E
loc_352CD:
mov r14, [rsp+78h+var_48]
mov rdi, [rbx+18h]
mov rsi, r14
call JS_FreeValueRT
mov rdi, rbx
mov rsi, r14
call js_create_module_function
test eax, eax
js loc_35427
lea rdx, [rsp+78h+var_58]
mov qword ptr [rdx], 0
mov rdi, rbx
mov rsi, r14
xor ecx, ecx
call js_inner_module_linking
test eax, eax
jns short loc_35357
mov rcx, qword ptr [rsp+78h+var_58]
loc_35313:
test rcx, rcx
jz short loc_3534F
mov byte ptr [rcx+83h], 0
mov rcx, [rcx+90h]
jmp short loc_35313
loc_35328:
mov rdi, [rbx+18h]
call JS_FreeValueRT
lea rsi, aBytecodeFuncti_0; "bytecode function expected"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp loc_3554E
loc_3534F:
test eax, eax
js loc_35427
loc_35357:
mov eax, 0FE000000h
and eax, [r14+80h]
cmp eax, 4000000h
jnz short loc_35371
mov r14, [r14+0B8h]
loc_35371:
mov rax, [r14+0C8h]
cmp eax, 3
jnz loc_3542E
lea rsi, [r14+0D0h]
xor r15d, r15d
mov ecx, 3
mov rdi, rbx
xor edx, edx
call js_new_promise_capability
mov [r14+0C0h], rax
mov [r14+0C8h], rdx
mov eax, 6
mov esi, 0
cmp edx, 6
jz loc_35530
lea rcx, [rsp+78h+var_40]
mov qword ptr [rcx], 0
lea r8, [rsp+78h+var_38]
mov rdi, rbx
mov rsi, r14
xor edx, edx
call js_inner_module_evaluation
test eax, eax
js short loc_3543A
cmp dword ptr [r14+0ACh], 0
jnz loc_35504
xor eax, eax
lea rcx, [rsp+78h+var_28]
mov [rcx], eax
mov edi, 3
mov [rcx+8], rdi
mov rsi, [r14+0D0h]
mov rdx, [r14+0D8h]
mov dword ptr [rsp+78h+var_58], eax
mov qword ptr [rsp+78h+var_58+8], rdi
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
mov [rsp+78h+var_68], rcx
jmp loc_354DA
loc_35427:
xor edx, edx
jmp loc_3553C
loc_3542E:
mov r15, [r14+0C0h]
jmp loc_35512
loc_3543A:
mov rax, [rsp+78h+var_40]
test rax, rax
jz short loc_3548E
mov rcx, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
loc_3544E:
mov byte ptr [rax+83h], 5
mov byte ptr [rax+0F0h], 1
mov qword ptr [rsp+78h+var_58], rcx
cmp edx, 0FFFFFFF7h
jb short loc_3546D
mov rsi, qword ptr [rsp+78h+var_58]
inc dword ptr [rsi]
loc_3546D:
mov [rax+0F8h], rcx
mov [rax+100h], rdx
mov [rax+0B8h], r14
mov rax, [rax+90h]
test rax, rax
jnz short loc_3544E
loc_3548E:
mov [rsp+78h+var_40], rax
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
mov rdi, [rbx+18h]
call JS_FreeValueRT
lea rax, [r14+0F8h]
mov rsi, [r14+0E0h]
mov rdx, [r14+0E8h]
mov dword ptr [rsp+78h+var_58], 0
mov qword ptr [rsp+78h+var_58+8], 3
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
mov [rsp+78h+var_68], rax
loc_354DA:
mov [rsp+78h+var_60], 2
mov r8d, 3
mov rdi, rbx
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov rdi, [rbx+18h]
mov rsi, rax
call JS_FreeValueRT
loc_35504:
mov r15, [r14+0C0h]
mov rax, [r14+0C8h]
loc_35512:
mov qword ptr [rsp+78h+var_58], r15
cmp eax, 0FFFFFFF7h
jb short loc_35523
mov rcx, qword ptr [rsp+78h+var_58]
inc dword ptr [rcx]
loc_35523:
mov rsi, 0FFFFFFFF00000000h
and rsi, r15
loc_35530:
mov ecx, r15d
or rcx, rsi
cmp eax, 6
setnz dl
loc_3553C:
xor r14d, r14d
test dl, dl
mov edx, 6
cmovnz rdx, rax
cmovnz r14, rcx
loc_3554E:
mov rax, r14
add rsp, 60h
pop rbx
pop r14
pop r15
retn
| long long JS_EvalFunctionInternal(
long long a1,
_DWORD *a2,
long long a3,
int a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15)
{
long long v17; // rdx
long long v18; // r14
_DWORD *v19; // r14
unsigned long long i; // rcx
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; // rax
unsigned long long v28; // r15
long long v29; // rdx
unsigned long long v30; // rsi
__m128 v31; // xmm4
__m128 v32; // xmm5
long long v33; // rsi
long long v34; // rdx
_DWORD *v35; // rax
long long v36; // rdx
bool v37; // dl
long long v38; // rax
_DWORD *v39; // rcx
long long v40; // rdx
long long v41; // rsi
long long v42; // rdx
__m128 v43; // xmm4
__m128 v44; // xmm5
char v46; // [rsp+0h] [rbp-78h]
__m128 v47; // [rsp+20h] [rbp-58h] BYREF
_DWORD *v48; // [rsp+30h] [rbp-48h]
long long v49; // [rsp+38h] [rbp-40h] BYREF
_DWORD *v50; // [rsp+40h] [rbp-38h] BYREF
long long v51; // [rsp+48h] [rbp-30h]
int v52; // [rsp+50h] [rbp-28h] BYREF
long long v53; // [rsp+58h] [rbp-20h]
v48 = a2;
if ( (_DWORD)a3 != -3 )
{
if ( (_DWORD)a3 == -2 )
{
v48 = (_DWORD *)js_closure(a1, a2, a3, a6, a15);
return JS_CallFree(a1, v48, v17, a4, a5, 0, 0LL);
}
else
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a2, a3);
v18 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"bytecode function expected",
v21,
v22,
v23,
v24,
a7,
a8,
a9,
a10,
v25,
v26,
a13,
a14,
v46);
}
return v18;
}
v19 = v48;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v48, a3);
if ( (int)js_create_module_function(a1, v48) < 0 )
goto LABEL_18;
v47.m128_u64[0] = 0LL;
if ( (int)js_inner_module_linking(a1, v48, &v47, 0LL) < 0 )
{
for ( i = v47.m128_u64[0]; i; i = *(_QWORD *)(i + 144) )
*(_BYTE *)(i + 131) = 0;
LABEL_18:
v37 = 0;
goto LABEL_32;
}
if ( (v19[32] & 0xFE000000) == 0x4000000 )
v19 = (_DWORD *)*((_QWORD *)v19 + 23);
v27 = *((_QWORD *)v19 + 25);
if ( (_DWORD)v27 != 3 )
{
v28 = *((_QWORD *)v19 + 24);
LABEL_28:
v47.m128_u64[0] = v28;
if ( (unsigned int)v27 >= 0xFFFFFFF7 )
++*(_DWORD *)v47.m128_u64[0];
v30 = v28 & 0xFFFFFFFF00000000LL;
goto LABEL_31;
}
LODWORD(v28) = 0;
*((_QWORD *)v19 + 24) = js_new_promise_capability(a1, v19 + 52, 0LL);
*((_QWORD *)v19 + 25) = v29;
LODWORD(v27) = 6;
v30 = 0LL;
if ( (_DWORD)v29 != 6 )
{
v49 = 0LL;
if ( (int)js_inner_module_evaluation(a1, v19, 0LL, &v49, &v50) < 0 )
{
v38 = v49;
if ( v49 )
{
v39 = v50;
v40 = v51;
do
{
*(_BYTE *)(v38 + 131) = 5;
*(_BYTE *)(v38 + 240) = 1;
v47.m128_u64[0] = (unsigned long long)v39;
if ( (unsigned int)v40 >= 0xFFFFFFF7 )
++*(_DWORD *)v47.m128_u64[0];
*(_QWORD *)(v38 + 248) = v39;
*(_QWORD *)(v38 + 256) = v40;
*(_QWORD *)(v38 + 184) = v19;
v38 = *(_QWORD *)(v38 + 144);
}
while ( v38 );
}
v49 = v38;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v50, v51);
v41 = *((_QWORD *)v19 + 28);
v42 = *((_QWORD *)v19 + 29);
v47.m128_i32[0] = 0;
v47.m128_u64[1] = 3LL;
v35 = (_DWORD *)JS_CallInternal(
a1,
v41,
v42,
0LL,
3LL,
1LL,
v47,
a8,
a9,
a10,
v43,
v44,
a13,
a14,
0,
3,
(long long)(v19 + 62),
2u);
}
else
{
if ( v19[43] )
{
LABEL_27:
v28 = *((_QWORD *)v19 + 24);
v27 = *((_QWORD *)v19 + 25);
goto LABEL_28;
}
v52 = 0;
v53 = 3LL;
v33 = *((_QWORD *)v19 + 26);
v34 = *((_QWORD *)v19 + 27);
v47.m128_i32[0] = 0;
v47.m128_u64[1] = 3LL;
v35 = (_DWORD *)JS_CallInternal(
a1,
v33,
v34,
0LL,
3LL,
1LL,
v47,
a8,
a9,
a10,
v31,
v32,
a13,
a14,
0,
3,
(long long)&v52,
2u);
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v35, v36);
goto LABEL_27;
}
LABEL_31:
i = v30 | (unsigned int)v28;
v37 = (_DWORD)v27 != 6;
LABEL_32:
v18 = 0LL;
if ( v37 )
return i;
return v18;
}
| JS_EvalFunctionInternal:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RDI
MOV qword ptr [RSP + 0x30],RSI
CMP EDX,-0x3
JZ 0x001352cd
CMP EDX,-0x2
JNZ 0x00135328
MOV R14,R8
MOV R15,RCX
MOV R8,qword ptr [RSP + 0x80]
MOV RDI,RBX
MOV RCX,R9
CALL 0x0014303a
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP],0x0
MOV RDI,RBX
MOV RSI,RAX
MOV RCX,R15
MOV R8,R14
XOR R9D,R9D
CALL 0x00126cf9
MOV R14,RAX
JMP 0x0013554e
LAB_001352cd:
MOV R14,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
CALL 0x00121922
MOV RDI,RBX
MOV RSI,R14
CALL 0x001484a7
TEST EAX,EAX
JS 0x00135427
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],0x0
MOV RDI,RBX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00148679
TEST EAX,EAX
JNS 0x00135357
MOV RCX,qword ptr [RSP + 0x20]
LAB_00135313:
TEST RCX,RCX
JZ 0x0013534f
MOV byte ptr [RCX + 0x83],0x0
MOV RCX,qword ptr [RCX + 0x90]
JMP 0x00135313
LAB_00135328:
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x00121922
LEA RSI,[0x1a3a75]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001265c3
MOV EDX,0x6
JMP 0x0013554e
LAB_0013534f:
TEST EAX,EAX
JS 0x00135427
LAB_00135357:
MOV EAX,0xfe000000
AND EAX,dword ptr [R14 + 0x80]
CMP EAX,0x4000000
JNZ 0x00135371
MOV R14,qword ptr [R14 + 0xb8]
LAB_00135371:
MOV RAX,qword ptr [R14 + 0xc8]
CMP EAX,0x3
JNZ 0x0013542e
LEA RSI,[R14 + 0xd0]
XOR R15D,R15D
MOV ECX,0x3
MOV RDI,RBX
XOR EDX,EDX
CALL 0x0013a312
MOV qword ptr [R14 + 0xc0],RAX
MOV qword ptr [R14 + 0xc8],RDX
MOV EAX,0x6
MOV ESI,0x0
CMP EDX,0x6
JZ 0x00135530
LEA RCX,[RSP + 0x38]
MOV qword ptr [RCX],0x0
LEA R8,[RSP + 0x40]
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00148ad7
TEST EAX,EAX
JS 0x0013543a
CMP dword ptr [R14 + 0xac],0x0
JNZ 0x00135504
XOR EAX,EAX
LEA RCX,[RSP + 0x50]
MOV dword ptr [RCX],EAX
MOV EDI,0x3
MOV qword ptr [RCX + 0x8],RDI
MOV RSI,qword ptr [R14 + 0xd0]
MOV RDX,qword ptr [R14 + 0xd8]
MOV dword ptr [RSP + 0x20],EAX
MOV qword ptr [RSP + 0x28],RDI
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],RCX
JMP 0x001354da
LAB_00135427:
XOR EDX,EDX
JMP 0x0013553c
LAB_0013542e:
MOV R15,qword ptr [R14 + 0xc0]
JMP 0x00135512
LAB_0013543a:
MOV RAX,qword ptr [RSP + 0x38]
TEST RAX,RAX
JZ 0x0013548e
MOV RCX,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
LAB_0013544e:
MOV byte ptr [RAX + 0x83],0x5
MOV byte ptr [RAX + 0xf0],0x1
MOV qword ptr [RSP + 0x20],RCX
CMP EDX,-0x9
JC 0x0013546d
MOV RSI,qword ptr [RSP + 0x20]
INC dword ptr [RSI]
LAB_0013546d:
MOV qword ptr [RAX + 0xf8],RCX
MOV qword ptr [RAX + 0x100],RDX
MOV qword ptr [RAX + 0xb8],R14
MOV RAX,qword ptr [RAX + 0x90]
TEST RAX,RAX
JNZ 0x0013544e
LAB_0013548e:
MOV qword ptr [RSP + 0x38],RAX
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x00121922
LEA RAX,[R14 + 0xf8]
MOV RSI,qword ptr [R14 + 0xe0]
MOV RDX,qword ptr [R14 + 0xe8]
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],RAX
LAB_001354da:
MOV dword ptr [RSP + 0x18],0x2
MOV R8D,0x3
MOV RDI,RBX
XOR ECX,ECX
MOV R9D,0x1
CALL 0x0012c526
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,RAX
CALL 0x00121922
LAB_00135504:
MOV R15,qword ptr [R14 + 0xc0]
MOV RAX,qword ptr [R14 + 0xc8]
LAB_00135512:
MOV qword ptr [RSP + 0x20],R15
CMP EAX,-0x9
JC 0x00135523
MOV RCX,qword ptr [RSP + 0x20]
INC dword ptr [RCX]
LAB_00135523:
MOV RSI,-0x100000000
AND RSI,R15
LAB_00135530:
MOV ECX,R15D
OR RCX,RSI
CMP EAX,0x6
SETNZ DL
LAB_0013553c:
XOR R14D,R14D
TEST DL,DL
MOV EDX,0x6
CMOVNZ RDX,RAX
CMOVNZ R14,RCX
LAB_0013554e:
MOV RAX,R14
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
ulong JS_EvalFunctionInternal
(long param_1,long param_2,int8 param_3,ulong param_4,int8 param_5,
int8 param_6,int8 param_7)
{
int iVar1;
uint uVar2;
ulong uVar3;
int8 uVar4;
int *piVar5;
int8 uVar6;
bool bVar7;
int1 auVar8 [16];
int4 *puVar9;
int *local_58;
int8 uStack_50;
long local_48;
long local_40;
int *local_38;
int8 local_30;
int4 local_28 [2];
int8 local_20;
local_48 = param_2;
if ((int)param_3 != -3) {
if ((int)param_3 == -2) {
auVar8 = js_closure(param_1,param_2,param_3,param_6,param_7);
local_48 = auVar8._0_8_;
uVar3 = JS_CallFree(param_1,local_48,auVar8._8_8_,param_4,param_5,0,0);
return uVar3;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18));
JS_ThrowTypeError(param_1,"bytecode function expected");
return 0;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),param_2);
iVar1 = js_create_module_function(param_1,param_2);
if (iVar1 < 0) {
LAB_00135427:
bVar7 = false;
goto LAB_0013553c;
}
local_58 = (int *)0x0;
iVar1 = js_inner_module_linking(param_1,param_2,&local_58,0);
piVar5 = local_58;
if (iVar1 < 0) {
for (; piVar5 != (int *)0x0; piVar5 = *(int **)(piVar5 + 0x24)) {
*(int1 *)((long)piVar5 + 0x83) = 0;
}
param_4 = 0;
if (iVar1 < 0) goto LAB_00135427;
}
if ((*(uint *)(param_2 + 0x80) & 0xfe000000) == 0x4000000) {
param_2 = *(long *)(param_2 + 0xb8);
}
uVar2 = (uint)*(int8 *)(param_2 + 200);
if (uVar2 == 3) {
piVar5 = (int *)0x0;
auVar8 = js_new_promise_capability(param_1,param_2 + 0xd0,0,3);
*(int1 (*) [16])(param_2 + 0xc0) = auVar8;
uVar2 = 6;
param_4 = 0;
if (auVar8._8_4_ != 6) {
local_40 = 0;
iVar1 = js_inner_module_evaluation(param_1,param_2,0,&local_40,&local_38);
if (iVar1 < 0) {
for (; local_40 != 0; local_40 = *(long *)(local_40 + 0x90)) {
*(int1 *)(local_40 + 0x83) = 5;
*(int1 *)(local_40 + 0xf0) = 1;
if (0xfffffff6 < (uint)local_30) {
*local_38 = *local_38 + 1;
}
*(int **)(local_40 + 0xf8) = local_38;
*(int8 *)(local_40 + 0x100) = local_30;
*(long *)(local_40 + 0xb8) = param_2;
local_58 = local_38;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_38,local_30);
puVar9 = (int4 *)(param_2 + 0xf8);
uVar4 = *(int8 *)(param_2 + 0xe0);
uVar6 = *(int8 *)(param_2 + 0xe8);
piVar5 = local_58;
LAB_001354da:
local_58 = (int *)((ulong)piVar5 & 0xffffffff00000000);
uStack_50 = 3;
uVar4 = JS_CallInternal(param_1,uVar4,uVar6,0,3,1,(ulong)piVar5 & 0xffffffff00000000,3,
puVar9,2);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar4);
}
else if (*(int *)(param_2 + 0xac) == 0) {
puVar9 = local_28;
local_28[0] = 0;
local_20 = 3;
uVar4 = *(int8 *)(param_2 + 0xd0);
uVar6 = *(int8 *)(param_2 + 0xd8);
piVar5 = local_58;
goto LAB_001354da;
}
piVar5 = *(int **)(param_2 + 0xc0);
uVar2 = (uint)*(int8 *)(param_2 + 200);
goto LAB_00135512;
}
}
else {
piVar5 = *(int **)(param_2 + 0xc0);
LAB_00135512:
if (0xfffffff6 < uVar2) {
*piVar5 = *piVar5 + 1;
}
param_4 = (ulong)piVar5 & 0xffffffff00000000;
}
param_4 = (ulong)piVar5 & 0xffffffff | param_4;
bVar7 = uVar2 != 6;
LAB_0013553c:
uVar3 = 0;
if (bVar7) {
uVar3 = param_4;
}
return uVar3;
}
| |
39,452 | JS_EvalFunctionInternal | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_EvalFunctionInternal(JSContext *ctx, JSValue fun_obj,
JSValue this_obj,
JSVarRef **var_refs, JSStackFrame *sf)
{
JSValue ret_val;
uint32_t tag;
tag = JS_VALUE_GET_TAG(fun_obj);
if (tag == JS_TAG_FUNCTION_BYTECODE) {
fun_obj = js_closure(ctx, fun_obj, var_refs, sf);
ret_val = JS_CallFree(ctx, fun_obj, this_obj, 0, NULL);
} else if (tag == JS_TAG_MODULE) {
JSModuleDef *m;
m = JS_VALUE_GET_PTR(fun_obj);
/* the module refcount should be >= 2 */
JS_FreeValue(ctx, fun_obj);
if (js_create_module_function(ctx, m) < 0)
goto fail;
if (js_link_module(ctx, m) < 0)
goto fail;
ret_val = js_evaluate_module(ctx, m);
if (JS_IsException(ret_val)) {
fail:
return JS_EXCEPTION;
}
} else {
JS_FreeValue(ctx, fun_obj);
ret_val = JS_ThrowTypeError(ctx, "bytecode function expected");
}
return ret_val;
} | O2 | c | JS_EvalFunctionInternal:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x3, %edx
je 0x2d363
cmpl $-0x2, %edx
jne 0x2d418
movq %r8, %r15
movq %rcx, %r12
movq 0x60(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
movq %r9, %rcx
callq 0x3afe3
andq $0x0, (%rsp)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x2093e
movq %rax, %r14
movq %rdx, %r15
jmp 0x2d55a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bbce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fb53
pushq $0x6
popq %r15
testl %eax, %eax
js 0x2d410
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x3fd52
testl %eax, %eax
js 0x2d407
movl $0xfe000000, %eax # imm = 0xFE000000
andl 0x80(%r14), %eax
cmpl $0x4000000, %eax # imm = 0x4000000
jne 0x2d3bd
movq 0xb8(%r14), %r14
movq 0xc8(%r14), %rax
cmpl $0x3, %eax
jne 0x2d440
leaq 0xd0(%r14), %rsi
movq %rbx, %rdi
callq 0x2d11d
movq %rax, 0xc0(%r14)
movq %rdx, 0xc8(%r14)
cmpl $0x6, %edx
jne 0x2d44c
pushq $0x6
popq %rax
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x2d543
movb $0x0, 0x83(%r12)
addq $0x90, %r12
movq (%r12), %r12
testq %r12, %r12
jne 0x2d3f7
xorl %r14d, %r14d
jmp 0x2d55a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bbce
leaq 0x5c59b(%rip), %rsi # 0x899c5
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x201fd
pushq $0x6
popq %r15
jmp 0x2d55a
movq 0xc0(%r14), %rcx
jmp 0x2d52f
leaq 0x20(%rsp), %r15
andq $0x0, (%r15)
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x40104
testl %eax, %eax
js 0x2d49c
cmpl $0x0, 0xac(%r14)
jne 0x2d521
leaq 0x28(%rsp), %rax
andl $0x0, (%rax)
movq $0x3, 0x8(%rax)
movq 0xd0(%r14), %rsi
movq 0xd8(%r14), %rdx
jmp 0x2d500
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%r15), %r15
testq %r15, %r15
je 0x2d4e3
movb $0x5, 0x83(%r15)
movb $0x1, 0xf0(%r15)
cmpl $-0x9, %edx
jb 0x2d4c5
incl (%rsi)
movq %rsi, 0xf8(%r15)
movq %rdx, 0x100(%r15)
movq %r14, 0xb8(%r15)
addq $0x90, %r15
jmp 0x2d4a6
movq %rbx, %rdi
callq 0x1bbce
leaq 0xf8(%r14), %rax
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
movq %rax, (%rsp)
pushq $0x3
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x25a66
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1bbce
movq 0xc0(%r14), %rcx
movq 0xc8(%r14), %rax
cmpl $-0x9, %eax
jb 0x2d536
incl (%rcx)
movabsq $-0x100000000, %rdx # imm = 0xFFFFFFFF00000000
andq %rcx, %rdx
movl %ecx, %ecx
orq %rdx, %rcx
xorl %r14d, %r14d
cmpl $0x6, %eax
pushq $0x6
popq %r15
cmovneq %rax, %r15
cmovneq %rcx, %r14
movq %r14, %rax
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| JS_EvalFunctionInternal:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov r14, rsi
mov rbx, rdi
cmp edx, 0FFFFFFFDh
jz short loc_2D363
cmp edx, 0FFFFFFFEh
jnz loc_2D418
mov r15, r8
mov r12, rcx
mov r8, [rsp+58h+arg_0]
mov rdi, rbx
mov rsi, r14
mov rcx, r9
call js_closure
and [rsp+58h+var_58], 0
mov rdi, rbx
mov rsi, rax
mov rcx, r12
mov r8, r15
xor r9d, r9d
call JS_CallFree
mov r14, rax
mov r15, rdx
jmp loc_2D55A
loc_2D363:
mov rdi, rbx
mov rsi, r14
call JS_FreeValue
mov rdi, rbx
mov rsi, r14
call js_create_module_function
push 6
pop r15
test eax, eax
js loc_2D410
lea r12, [rsp+58h+var_48]
and qword ptr [r12], 0
mov rdi, rbx
mov rsi, r14
mov rdx, r12
xor ecx, ecx
call js_inner_module_linking
test eax, eax
js short loc_2D407
mov eax, 0FE000000h
and eax, [r14+80h]
cmp eax, 4000000h
jnz short loc_2D3BD
mov r14, [r14+0B8h]
loc_2D3BD:
mov rax, [r14+0C8h]
cmp eax, 3
jnz short loc_2D440
lea rsi, [r14+0D0h]
mov rdi, rbx
call JS_NewPromiseCapability
mov [r14+0C0h], rax
mov [r14+0C8h], rdx
cmp edx, 6
jnz short loc_2D44C
push 6
pop rax
xor ecx, ecx
xor edx, edx
jmp loc_2D543
loc_2D3F7:
mov byte ptr [r12+83h], 0
add r12, 90h
loc_2D407:
mov r12, [r12]
test r12, r12
jnz short loc_2D3F7
loc_2D410:
xor r14d, r14d
jmp loc_2D55A
loc_2D418:
mov rdi, rbx
mov rsi, r14
call JS_FreeValue
lea rsi, aBytecodeFuncti_0; "bytecode function expected"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop r15
jmp loc_2D55A
loc_2D440:
mov rcx, [r14+0C0h]
jmp loc_2D52F
loc_2D44C:
lea r15, [rsp+58h+var_38]
and qword ptr [r15], 0
lea r8, [rsp+58h+var_48]
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, r15
call js_inner_module_evaluation
test eax, eax
js short loc_2D49C
cmp dword ptr [r14+0ACh], 0
jnz loc_2D521
lea rax, [rsp+58h+var_30]
and dword ptr [rax], 0
mov qword ptr [rax+8], 3
mov rsi, [r14+0D0h]
mov rdx, [r14+0D8h]
jmp short loc_2D500
loc_2D49C:
mov rsi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_40]
loc_2D4A6:
mov r15, [r15]
test r15, r15
jz short loc_2D4E3
mov byte ptr [r15+83h], 5
mov byte ptr [r15+0F0h], 1
cmp edx, 0FFFFFFF7h
jb short loc_2D4C5
inc dword ptr [rsi]
loc_2D4C5:
mov [r15+0F8h], rsi
mov [r15+100h], rdx
mov [r15+0B8h], r14
add r15, 90h
jmp short loc_2D4A6
loc_2D4E3:
mov rdi, rbx
call JS_FreeValue
lea rax, [r14+0F8h]
mov rsi, [r14+0E0h]
mov rdx, [r14+0E8h]
loc_2D500:
mov [rsp+58h+var_58], rax
push 3
pop r8
push 1
pop r9
mov rdi, rbx
xor ecx, ecx
call JS_Call
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
loc_2D521:
mov rcx, [r14+0C0h]
mov rax, [r14+0C8h]
loc_2D52F:
cmp eax, 0FFFFFFF7h
jb short loc_2D536
inc dword ptr [rcx]
loc_2D536:
mov rdx, 0FFFFFFFF00000000h
and rdx, rcx
loc_2D543:
mov ecx, ecx
or rcx, rdx
xor r14d, r14d
cmp eax, 6
push 6
pop r15
cmovnz r15, rax
cmovnz r14, rcx
loc_2D55A:
mov rax, r14
mov rdx, r15
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
| long long JS_EvalFunctionInternal(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15)
{
long long v15; // r14
long long v18; // rax
long long v19; // rdx
long long v20; // r14
long long *v21; // r12
long long v22; // rax
long long v23; // rdx
unsigned long long v24; // rcx
unsigned long long v25; // rdx
long long v26; // r12
long long v27; // rdx
long long v28; // rcx
long long v29; // r8
long long v30; // r9
__m128 v31; // xmm4
__m128 v32; // xmm5
long long *v33; // r15
int *v34; // rax
long long v35; // rsi
long long v36; // rdx
_DWORD *v37; // rsi
long long v38; // rdx
long long v39; // r15
long long v40; // rax
long long v41; // rdx
unsigned long long v42; // rcx
char v44; // [rsp+0h] [rbp-58h]
_QWORD v45[2]; // [rsp+10h] [rbp-48h] BYREF
long long v46; // [rsp+20h] [rbp-38h] BYREF
int v47; // [rsp+28h] [rbp-30h] BYREF
long long v48; // [rsp+30h] [rbp-28h]
v15 = a2;
if ( (_DWORD)a3 != -3 )
{
if ( (_DWORD)a3 == -2 )
{
v18 = js_closure(a1, a2, a3, a6, a15);
return JS_CallFree(a1, v18, v19, a4, a5, 0, 0LL);
}
else
{
JS_FreeValue(a1, a2, a3);
v20 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"bytecode function expected",
v27,
v28,
v29,
v30,
a7,
a8,
a9,
a10,
v31,
v32,
a13,
a14,
v44);
}
return v20;
}
JS_FreeValue(a1, a2, a3);
if ( (int)js_create_module_function(a1, a2) < 0 )
return 0LL;
v21 = v45;
v45[0] = 0LL;
if ( (int)js_inner_module_linking(a1, a2, v45, 0LL) < 0 )
{
while ( 1 )
{
v26 = *v21;
if ( !v26 )
break;
*(_BYTE *)(v26 + 131) = 0;
v21 = (long long *)(v26 + 144);
}
return 0LL;
}
if ( (*(_DWORD *)(a2 + 128) & 0xFE000000) == 0x4000000 )
v15 = *(_QWORD *)(a2 + 184);
v22 = *(_QWORD *)(v15 + 200);
if ( (_DWORD)v22 != 3 )
{
v24 = *(_QWORD *)(v15 + 192);
LABEL_27:
if ( (unsigned int)v22 >= 0xFFFFFFF7 )
++*(_DWORD *)v24;
v25 = v24 & 0xFFFFFFFF00000000LL;
goto LABEL_30;
}
*(_QWORD *)(v15 + 192) = JS_NewPromiseCapability(a1, v15 + 208);
*(_QWORD *)(v15 + 200) = v23;
if ( (_DWORD)v23 != 6 )
{
v33 = &v46;
v46 = 0LL;
if ( (int)js_inner_module_evaluation(a1, v15, 0LL, &v46, v45) < 0 )
{
v37 = (_DWORD *)v45[0];
v38 = v45[1];
while ( 1 )
{
v39 = *v33;
if ( !v39 )
break;
*(_BYTE *)(v39 + 131) = 5;
*(_BYTE *)(v39 + 240) = 1;
if ( (unsigned int)v38 >= 0xFFFFFFF7 )
++*v37;
*(_QWORD *)(v39 + 248) = v37;
*(_QWORD *)(v39 + 256) = v38;
*(_QWORD *)(v39 + 184) = v15;
v33 = (long long *)(v39 + 144);
}
JS_FreeValue(a1, (long long)v37, v38);
v34 = (int *)(v15 + 248);
v35 = *(_QWORD *)(v15 + 224);
v36 = *(_QWORD *)(v15 + 232);
}
else
{
if ( *(_DWORD *)(v15 + 172) )
{
LABEL_26:
v24 = *(_QWORD *)(v15 + 192);
v22 = *(_QWORD *)(v15 + 200);
goto LABEL_27;
}
v34 = &v47;
v47 = 0;
v48 = 3LL;
v35 = *(_QWORD *)(v15 + 208);
v36 = *(_QWORD *)(v15 + 216);
}
v40 = JS_Call(a1, v35, v36, 0, 3, 1, (long long)v34);
JS_FreeValue(a1, v40, v41);
goto LABEL_26;
}
LODWORD(v22) = 6;
LODWORD(v24) = 0;
v25 = 0LL;
LABEL_30:
v42 = v25 | (unsigned int)v24;
v20 = 0LL;
if ( (_DWORD)v22 != 6 )
return v42;
return v20;
}
| JS_EvalFunctionInternal:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,RSI
MOV RBX,RDI
CMP EDX,-0x3
JZ 0x0012d363
CMP EDX,-0x2
JNZ 0x0012d418
MOV R15,R8
MOV R12,RCX
MOV R8,qword ptr [RSP + 0x60]
MOV RDI,RBX
MOV RSI,R14
MOV RCX,R9
CALL 0x0013afe3
AND qword ptr [RSP],0x0
MOV RDI,RBX
MOV RSI,RAX
MOV RCX,R12
MOV R8,R15
XOR R9D,R9D
CALL 0x0012093e
MOV R14,RAX
MOV R15,RDX
JMP 0x0012d55a
LAB_0012d363:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011bbce
MOV RDI,RBX
MOV RSI,R14
CALL 0x0013fb53
PUSH 0x6
POP R15
TEST EAX,EAX
JS 0x0012d410
LEA R12,[RSP + 0x10]
AND qword ptr [R12],0x0
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
XOR ECX,ECX
CALL 0x0013fd52
TEST EAX,EAX
JS 0x0012d407
MOV EAX,0xfe000000
AND EAX,dword ptr [R14 + 0x80]
CMP EAX,0x4000000
JNZ 0x0012d3bd
MOV R14,qword ptr [R14 + 0xb8]
LAB_0012d3bd:
MOV RAX,qword ptr [R14 + 0xc8]
CMP EAX,0x3
JNZ 0x0012d440
LEA RSI,[R14 + 0xd0]
MOV RDI,RBX
CALL 0x0012d11d
MOV qword ptr [R14 + 0xc0],RAX
MOV qword ptr [R14 + 0xc8],RDX
CMP EDX,0x6
JNZ 0x0012d44c
PUSH 0x6
POP RAX
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0012d543
LAB_0012d3f7:
MOV byte ptr [R12 + 0x83],0x0
ADD R12,0x90
LAB_0012d407:
MOV R12,qword ptr [R12]
TEST R12,R12
JNZ 0x0012d3f7
LAB_0012d410:
XOR R14D,R14D
JMP 0x0012d55a
LAB_0012d418:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011bbce
LEA RSI,[0x1899c5]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001201fd
PUSH 0x6
POP R15
JMP 0x0012d55a
LAB_0012d440:
MOV RCX,qword ptr [R14 + 0xc0]
JMP 0x0012d52f
LAB_0012d44c:
LEA R15,[RSP + 0x20]
AND qword ptr [R15],0x0
LEA R8,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
MOV RCX,R15
CALL 0x00140104
TEST EAX,EAX
JS 0x0012d49c
CMP dword ptr [R14 + 0xac],0x0
JNZ 0x0012d521
LEA RAX,[RSP + 0x28]
AND dword ptr [RAX],0x0
MOV qword ptr [RAX + 0x8],0x3
MOV RSI,qword ptr [R14 + 0xd0]
MOV RDX,qword ptr [R14 + 0xd8]
JMP 0x0012d500
LAB_0012d49c:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
LAB_0012d4a6:
MOV R15,qword ptr [R15]
TEST R15,R15
JZ 0x0012d4e3
MOV byte ptr [R15 + 0x83],0x5
MOV byte ptr [R15 + 0xf0],0x1
CMP EDX,-0x9
JC 0x0012d4c5
INC dword ptr [RSI]
LAB_0012d4c5:
MOV qword ptr [R15 + 0xf8],RSI
MOV qword ptr [R15 + 0x100],RDX
MOV qword ptr [R15 + 0xb8],R14
ADD R15,0x90
JMP 0x0012d4a6
LAB_0012d4e3:
MOV RDI,RBX
CALL 0x0011bbce
LEA RAX,[R14 + 0xf8]
MOV RSI,qword ptr [R14 + 0xe0]
MOV RDX,qword ptr [R14 + 0xe8]
LAB_0012d500:
MOV qword ptr [RSP],RAX
PUSH 0x3
POP R8
PUSH 0x1
POP R9
MOV RDI,RBX
XOR ECX,ECX
CALL 0x00125a66
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011bbce
LAB_0012d521:
MOV RCX,qword ptr [R14 + 0xc0]
MOV RAX,qword ptr [R14 + 0xc8]
LAB_0012d52f:
CMP EAX,-0x9
JC 0x0012d536
INC dword ptr [RCX]
LAB_0012d536:
MOV RDX,-0x100000000
AND RDX,RCX
LAB_0012d543:
MOV ECX,ECX
OR RCX,RDX
XOR R14D,R14D
CMP EAX,0x6
PUSH 0x6
POP R15
CMOVNZ R15,RAX
CMOVNZ R14,RCX
LAB_0012d55a:
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16]
JS_EvalFunctionInternal
(int8 param_1,long param_2,int8 param_3,int8 param_4,int8 param_5,
int8 param_6,int8 param_7)
{
long lVar1;
int iVar2;
int4 *puVar3;
int8 uVar4;
int *piVar5;
int8 uVar6;
ulong uVar7;
int **ppiVar8;
long *plVar9;
int1 auVar10 [16];
int *local_48;
int8 local_40;
long local_38;
int4 local_30 [2];
int8 local_28;
if ((int)param_3 != -3) {
if ((int)param_3 == -2) {
auVar10 = js_closure(param_1,param_2,param_3,param_6,param_7);
auVar10 = JS_CallFree(param_1,auVar10._0_8_,auVar10._8_8_,param_4,param_5,0,0);
return auVar10;
}
JS_FreeValue(param_1,param_2);
JS_ThrowTypeError(param_1,"bytecode function expected");
return ZEXT816(6) << 0x40;
}
JS_FreeValue(param_1,param_2);
iVar2 = js_create_module_function(param_1,param_2);
if (iVar2 < 0) {
LAB_0012d410:
return ZEXT816(6) << 0x40;
}
ppiVar8 = &local_48;
local_48 = (int *)0x0;
iVar2 = js_inner_module_linking(param_1,param_2,ppiVar8,0);
if (iVar2 < 0) {
while (piVar5 = *ppiVar8, piVar5 != (int *)0x0) {
*(int1 *)((long)piVar5 + 0x83) = 0;
ppiVar8 = (int **)(piVar5 + 0x24);
}
goto LAB_0012d410;
}
if ((*(uint *)(param_2 + 0x80) & 0xfe000000) == 0x4000000) {
param_2 = *(long *)(param_2 + 0xb8);
}
uVar4 = *(int8 *)(param_2 + 200);
if ((int)uVar4 == 3) {
auVar10 = JS_NewPromiseCapability(param_1,param_2 + 0xd0);
*(int1 (*) [16])(param_2 + 0xc0) = auVar10;
if (auVar10._8_4_ == 6) {
uVar4 = 6;
piVar5 = (int *)0x0;
uVar7 = 0;
goto LAB_0012d543;
}
plVar9 = &local_38;
local_38 = 0;
iVar2 = js_inner_module_evaluation(param_1,param_2,0,plVar9,&local_48);
if (iVar2 < 0) {
while (lVar1 = *plVar9, lVar1 != 0) {
*(int1 *)(lVar1 + 0x83) = 5;
*(int1 *)(lVar1 + 0xf0) = 1;
if (0xfffffff6 < (uint)local_40) {
*local_48 = *local_48 + 1;
}
*(int **)(lVar1 + 0xf8) = local_48;
*(int8 *)(lVar1 + 0x100) = local_40;
*(long *)(lVar1 + 0xb8) = param_2;
plVar9 = (long *)(lVar1 + 0x90);
}
JS_FreeValue(param_1);
puVar3 = (int4 *)(param_2 + 0xf8);
uVar4 = *(int8 *)(param_2 + 0xe0);
uVar6 = *(int8 *)(param_2 + 0xe8);
LAB_0012d500:
uVar4 = JS_Call(param_1,uVar4,uVar6,0,3,1,puVar3);
JS_FreeValue(param_1,uVar4);
}
else if (*(int *)(param_2 + 0xac) == 0) {
puVar3 = local_30;
local_30[0] = 0;
local_28 = 3;
uVar4 = *(int8 *)(param_2 + 0xd0);
uVar6 = *(int8 *)(param_2 + 0xd8);
goto LAB_0012d500;
}
piVar5 = *(int **)(param_2 + 0xc0);
uVar4 = *(int8 *)(param_2 + 200);
}
else {
piVar5 = *(int **)(param_2 + 0xc0);
}
if (0xfffffff6 < (uint)uVar4) {
*piVar5 = *piVar5 + 1;
}
uVar7 = (ulong)piVar5 & 0xffffffff00000000;
LAB_0012d543:
auVar10._8_8_ = uVar4;
auVar10._0_8_ = (ulong)piVar5 & 0xffffffff | uVar7;
if ((int)uVar4 == 6) {
return ZEXT816(6) << 0x40;
}
return auVar10;
}
| |
39,453 | LefDefParser::lefwMinfeature(double, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwMinfeature(double minFeatureX,
double minFeatureY)
{
lefwObsoleteNum = LEFW_MINFEATURE;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_INIT && lefwState < LEFW_END)
return LEFW_BAD_ORDER;
if (versionNum >= 5.4)
return LEFW_OBSOLETE;
if (lefwSynArray[LEFW_MINFEATURE])
return LEFW_ALREADY_DEFINED;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "MINFEATURE %.11g %.11g ;\n",
minFeatureX, minFeatureY);
else
fprintf(lefwFile, "MINFEATURE %.11g %.11g ;\n", minFeatureX, minFeatureY);
lefwSynArray[LEFW_MINFEATURE] = 1;
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwMinfeature(double, double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
movl $0x3a, 0xacb1f(%rip) # 0xc4f18
leaq 0xace50(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x18413
movl $0x1, 0x14(%rsp)
jmp 0x1850d
leaq 0xad08a(%rip), %rax # 0xc54a4
cmpl $0x0, (%rax)
jne 0x1842c
movl $0x2, 0x14(%rsp)
jmp 0x1850d
leaq 0xad06d(%rip), %rax # 0xc54a0
cmpl $0x1, (%rax)
je 0x18451
leaq 0xad061(%rip), %rax # 0xc54a0
cmpl $0x4f, (%rax)
jge 0x18451
movl $0x2, 0x14(%rsp)
jmp 0x1850d
movsd 0xacab7(%rip), %xmm0 # 0xc4f10
movsd 0x8a7df(%rip), %xmm1 # 0xa2c40
ucomisd %xmm1, %xmm0
jb 0x18474
movl $0x7, 0x14(%rsp)
jmp 0x1850d
leaq 0xacde5(%rip), %rax # 0xc5260
cmpl $0x0, 0xe8(%rax)
je 0x1848e
movl $0x4, 0x14(%rsp)
jmp 0x1850d
cmpl $0x0, 0xad0a7(%rip) # 0xc553c
je 0x184bc
leaq 0xacdb2(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x7a313(%rip), %rsi # 0x927c6
movb $0x2, %al
callq 0x8bf50
jmp 0x184df
leaq 0xacd8d(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x7a2ee(%rip), %rsi # 0x927c6
movb $0x2, %al
callq 0x2370
leaq 0xacd7a(%rip), %rax # 0xc5260
movl $0x1, 0xe8(%rax)
leaq 0xacfa5(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xacf99(%rip), %rax # 0xc549c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser14lefwMinfeatureEdd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
movsd [rsp+18h+var_18], xmm1
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 3Ah ; ':'; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_18413
mov [rsp+18h+var_4], 1
jmp loc_1850D
loc_18413:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_1842C
mov [rsp+18h+var_4], 2
jmp loc_1850D
loc_1842C:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1
jz short loc_18451
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 4Fh ; 'O'
jge short loc_18451
mov [rsp+18h+var_4], 2
jmp loc_1850D
loc_18451:
movsd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
movsd xmm1, cs:qword_A2C40
ucomisd xmm0, xmm1
jb short loc_18474
mov [rsp+18h+var_4], 7
jmp loc_1850D
loc_18474:
lea rax, _ZN12LefDefParser12lefwSynArrayE; LefDefParser::lefwSynArray
cmp dword ptr [rax+0E8h], 0
jz short loc_1848E
mov [rsp+18h+var_4], 4
jmp short loc_1850D
loc_1848E:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_184BC
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aMinfeature11g1; "MINFEATURE %.11g %.11g ;\n"
mov al, 2
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_184DF
loc_184BC:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
movsd xmm1, [rsp+18h+var_18]
lea rsi, aMinfeature11g1; "MINFEATURE %.11g %.11g ;\n"
mov al, 2
call _fprintf
loc_184DF:
lea rax, _ZN12LefDefParser12lefwSynArrayE; LefDefParser::lefwSynArray
mov dword ptr [rax+0E8h], 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_1850D:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwMinfeature(
LefDefParser *this,
double a2,
double a3,
long long a4,
int a5,
int a6,
int a7,
int a8)
{
LefDefParser::lefwObsoleteNum = 58;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwState == 1 || LefDefParser::lefwState >= 79 )
{
if ( *(double *)&LefDefParser::versionNum < 5.4 )
{
if ( LefDefParser::lefwSynArray[58] )
{
return 4;
}
else
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"MINFEATURE %.11g %.11g ;\n", a5, a6, a7, a8);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "MINFEATURE %.11g %.11g ;\n", a2, a3);
LefDefParser::lefwSynArray[58] = 1;
++LefDefParser::lefwLines;
return 0;
}
}
else
{
return 7;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwMinfeature:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD qword ptr [RSP],XMM1
MOV dword ptr [0x001c4f18],0x3a
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x00118413
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0011850d
LAB_00118413:
LEA RAX,[0x1c54a4]
CMP dword ptr [RAX],0x0
JNZ 0x0011842c
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0011850d
LAB_0011842c:
LEA RAX,[0x1c54a0]
CMP dword ptr [RAX],0x1
JZ 0x00118451
LEA RAX,[0x1c54a0]
CMP dword ptr [RAX],0x4f
JGE 0x00118451
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0011850d
LAB_00118451:
MOVSD XMM0,qword ptr [0x001c4f10]
MOVSD XMM1,qword ptr [0x001a2c40]
UCOMISD XMM0,XMM1
JC 0x00118474
MOV dword ptr [RSP + 0x14],0x7
JMP 0x0011850d
LAB_00118474:
LEA RAX,[0x1c5260]
CMP dword ptr [RAX + 0xe8],0x0
JZ 0x0011848e
MOV dword ptr [RSP + 0x14],0x4
JMP 0x0011850d
LAB_0011848e:
CMP dword ptr [0x001c553c],0x0
JZ 0x001184bc
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x1927c6]
MOV AL,0x2
CALL 0x0018bf50
JMP 0x001184df
LAB_001184bc:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP]
LEA RSI,[0x1927c6]
MOV AL,0x2
CALL 0x00102370
LAB_001184df:
LEA RAX,[0x1c5260]
MOV dword ptr [RAX + 0xe8],0x1
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_0011850d:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMinfeature(double, double) */
int4 LefDefParser::lefwMinfeature(double param_1,double param_2)
{
int4 local_4;
lefwObsoleteNum = 0x3a;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if ((lefwState == 1) || (0x4e < lefwState)) {
if (versionNum < DAT_001a2c40) {
if (lefwSynArray._232_4_ == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile,"MINFEATURE %.11g %.11g ;\n",param_1,param_2);
}
else {
encPrint(lefwFile,"MINFEATURE %.11g %.11g ;\n",param_1,param_2);
}
lefwSynArray._232_4_ = 1;
lefwLines = lefwLines + 1;
local_4 = 0;
}
else {
local_4 = 4;
}
}
else {
local_4 = 7;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
39,454 | list_cons | eloqsql/mysys/list.c | LIST *list_cons(void *data, LIST *list)
{
LIST *new_charset=(LIST*) my_malloc(key_memory_LIST, sizeof(LIST),MYF(MY_FAE));
if (!new_charset)
return 0;
new_charset->data=data;
return list_add(list,new_charset);
} | O3 | c | list_cons:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb72f09(%rip), %rax # 0xc0706c
movl (%rax), %edi
movl $0x18, %esi
movl $0x8, %edx
callq 0x9f6e1
testq %rax, %rax
je 0x941a8
movq %r14, 0x10(%rax)
testq %rbx, %rbx
je 0x94193
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x9419c
movq %rax, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x9419e
movq $0x0, (%rax)
jmp 0x941a4
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| list_cons:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
lea rax, key_memory_LIST
mov edi, [rax]
mov esi, 18h
mov edx, 8
call my_malloc
test rax, rax
jz short loc_941A8
mov [rax+10h], r14
test rbx, rbx
jz short loc_94193
mov rcx, [rbx]
test rcx, rcx
jz short loc_9419C
mov [rcx+8], rax
mov rcx, [rbx]
jmp short loc_9419E
loc_94193:
mov qword ptr [rax], 0
jmp short loc_941A4
loc_9419C:
xor ecx, ecx
loc_9419E:
mov [rax], rcx
mov [rbx], rax
loc_941A4:
mov [rax+8], rbx
loc_941A8:
pop rbx
pop r14
pop rbp
retn
| _QWORD * list_cons(long long a1, long long *a2)
{
_QWORD *result; // rax
long long v3; // rcx
result = (_QWORD *)my_malloc(key_memory_LIST, 24LL, 8LL);
if ( result )
{
result[2] = a1;
if ( a2 )
{
if ( *a2 )
{
*(_QWORD *)(*a2 + 8) = result;
v3 = *a2;
}
else
{
v3 = 0LL;
}
*result = v3;
*a2 = (long long)result;
}
else
{
*result = 0LL;
}
result[1] = a2;
}
return result;
}
| list_cons:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
LEA RAX,[0xd0706c]
MOV EDI,dword ptr [RAX]
MOV ESI,0x18
MOV EDX,0x8
CALL 0x0019f6e1
TEST RAX,RAX
JZ 0x001941a8
MOV qword ptr [RAX + 0x10],R14
TEST RBX,RBX
JZ 0x00194193
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JZ 0x0019419c
MOV qword ptr [RCX + 0x8],RAX
MOV RCX,qword ptr [RBX]
JMP 0x0019419e
LAB_00194193:
MOV qword ptr [RAX],0x0
JMP 0x001941a4
LAB_0019419c:
XOR ECX,ECX
LAB_0019419e:
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX],RAX
LAB_001941a4:
MOV qword ptr [RAX + 0x8],RBX
LAB_001941a8:
POP RBX
POP R14
POP RBP
RET
|
void list_cons(long param_1,long *param_2)
{
long *plVar1;
long lVar2;
plVar1 = (long *)my_malloc(key_memory_LIST,0x18,8);
if (plVar1 != (long *)0x0) {
plVar1[2] = param_1;
if (param_2 == (long *)0x0) {
*plVar1 = 0;
}
else {
if (*param_2 == 0) {
lVar2 = 0;
}
else {
*(long **)(*param_2 + 8) = plVar1;
lVar2 = *param_2;
}
*plVar1 = lVar2;
*param_2 = (long)plVar1;
}
plVar1[1] = (long)param_2;
}
return;
}
| |
39,455 | multadd | eloqsql/strings/dtoa.c | static Bigint *multadd(Bigint *b, int m, int a, Stack_alloc *alloc)
{
int i, wds;
ULong *x;
ULLong carry, y;
Bigint *b1;
wds= b->wds;
x= b->p.x;
i= 0;
carry= a;
do
{
y= *x * (ULLong)m + carry;
carry= y >> 32;
*x++= (ULong)(y & FFFFFFFF);
}
while (++i < wds);
if (carry)
{
if (wds >= b->maxwds)
{
b1= Balloc(b->k+1, alloc);
Bcopy(b1, b);
Bfree(b, alloc);
b= b1;
}
b->p.x[wds++]= (ULong) carry;
b->wds= wds;
}
return b;
} | O3 | c | multadd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
movslq 0x14(%rdi), %r12
movq (%rdi), %rax
movslq %edx, %r13
movslq %esi, %rcx
cmpl $0x2, %r12d
movl $0x1, %edx
cmovgel %r12d, %edx
xorl %esi, %esi
movl (%rax,%rsi,4), %edi
imulq %rcx, %rdi
addq %r13, %rdi
movq %rdi, %r13
shrq $0x20, %r13
movl %edi, (%rax,%rsi,4)
incq %rsi
cmpl %esi, %edx
jne 0x58872
shrq $0x20, %rdi
je 0x588df
cmpl 0xc(%rbx), %r12d
jl 0x588d0
movl 0x8(%rbx), %edi
incl %edi
movq %r14, %rsi
callq 0x58218
movq %rax, %r15
leaq 0x10(%rax), %rdi
leaq 0x10(%rbx), %rsi
movslq 0x14(%rbx), %rax
leaq 0x8(,%rax,4), %rdx
callq 0x24220
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58611
movq %r15, %rbx
movq (%rbx), %rax
leal 0x1(%r12), %ecx
movl %r13d, (%rax,%r12,4)
movl %ecx, 0x14(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| multadd:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rcx
mov rbx, rdi
movsxd r12, dword ptr [rdi+14h]
mov rax, [rdi]
movsxd r13, edx
movsxd rcx, esi
cmp r12d, 2
mov edx, 1
cmovge edx, r12d
xor esi, esi
loc_58872:
mov edi, [rax+rsi*4]
imul rdi, rcx
add rdi, r13
mov r13, rdi
shr r13, 20h
mov [rax+rsi*4], edi
inc rsi
cmp edx, esi
jnz short loc_58872
shr rdi, 20h
jz short loc_588DF
cmp r12d, [rbx+0Ch]
jl short loc_588D0
mov edi, [rbx+8]
inc edi
mov rsi, r14
call Balloc
mov r15, rax
lea rdi, [rax+10h]
lea rsi, [rbx+10h]
movsxd rax, dword ptr [rbx+14h]
lea rdx, ds:8[rax*4]
call _memcpy
mov rdi, rbx
mov rsi, r14
call Bfree
mov rbx, r15
loc_588D0:
mov rax, [rbx]
lea ecx, [r12+1]
mov [rax+r12*4], r13d
mov [rbx+14h], ecx
loc_588DF:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long multadd(unsigned long long a1, int a2, int a3, unsigned long long *a4)
{
unsigned long long v5; // rbx
long long v6; // r12
long long v7; // rax
unsigned long long v8; // r13
long long v9; // rcx
int v10; // edx
long long v11; // rsi
unsigned long long v12; // rdi
long long v13; // r15
v5 = a1;
v6 = *(int *)(a1 + 20);
v7 = *(_QWORD *)a1;
v8 = a3;
v9 = a2;
v10 = 1;
if ( (int)v6 >= 2 )
v10 = *(_DWORD *)(a1 + 20);
v11 = 0LL;
do
{
v12 = v8 + v9 * *(unsigned int *)(v7 + 4 * v11);
v8 = HIDWORD(v12);
*(_DWORD *)(v7 + 4 * v11++) = v12;
}
while ( v10 != (_DWORD)v11 );
if ( HIDWORD(v12) )
{
if ( (int)v6 >= *(_DWORD *)(v5 + 12) )
{
v13 = Balloc(*(_DWORD *)(v5 + 8) + 1, (long long)a4);
memcpy(v13 + 16, v5 + 16, 4LL * *(int *)(v5 + 20) + 8);
Bfree(v5, a4);
v5 = v13;
}
*(_DWORD *)(*(_QWORD *)v5 + 4 * v6) = HIDWORD(v12);
*(_DWORD *)(v5 + 20) = v6 + 1;
}
return v5;
}
| multadd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDI
MOVSXD R12,dword ptr [RDI + 0x14]
MOV RAX,qword ptr [RDI]
MOVSXD R13,EDX
MOVSXD RCX,ESI
CMP R12D,0x2
MOV EDX,0x1
CMOVGE EDX,R12D
XOR ESI,ESI
LAB_00158872:
MOV EDI,dword ptr [RAX + RSI*0x4]
IMUL RDI,RCX
ADD RDI,R13
MOV R13,RDI
SHR R13,0x20
MOV dword ptr [RAX + RSI*0x4],EDI
INC RSI
CMP EDX,ESI
JNZ 0x00158872
SHR RDI,0x20
JZ 0x001588df
CMP R12D,dword ptr [RBX + 0xc]
JL 0x001588d0
MOV EDI,dword ptr [RBX + 0x8]
INC EDI
MOV RSI,R14
CALL 0x00158218
MOV R15,RAX
LEA RDI,[RAX + 0x10]
LEA RSI,[RBX + 0x10]
MOVSXD RAX,dword ptr [RBX + 0x14]
LEA RDX,[0x8 + RAX*0x4]
CALL 0x00124220
MOV RDI,RBX
MOV RSI,R14
CALL 0x00158611
MOV RBX,R15
LAB_001588d0:
MOV RAX,qword ptr [RBX]
LEA ECX,[R12 + 0x1]
MOV dword ptr [RAX + R12*0x4],R13D
MOV dword ptr [RBX + 0x14],ECX
LAB_001588df:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long * multadd(long *param_1,int param_2,int param_3,int8 param_4)
{
int iVar1;
long lVar2;
long *plVar3;
int iVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
iVar1 = *(int *)((long)param_1 + 0x14);
lVar2 = *param_1;
uVar7 = (ulong)param_3;
iVar4 = 1;
if (1 < iVar1) {
iVar4 = iVar1;
}
lVar5 = 0;
do {
uVar6 = (ulong)*(uint *)(lVar2 + lVar5 * 4) * (long)param_2 + uVar7;
uVar7 = uVar6 >> 0x20;
*(int *)(lVar2 + lVar5 * 4) = (int)uVar6;
lVar5 = lVar5 + 1;
} while (iVar4 != (int)lVar5);
plVar3 = param_1;
if (uVar6 >> 0x20 != 0) {
if (*(int *)((long)param_1 + 0xc) <= iVar1) {
plVar3 = (long *)Balloc((int)param_1[1] + 1,param_4);
memcpy(plVar3 + 2,param_1 + 2,(long)*(int *)((long)param_1 + 0x14) * 4 + 8);
Bfree(param_1,param_4);
}
*(int *)(*plVar3 + (long)iVar1 * 4) = (int)(uVar6 >> 0x20);
*(int *)((long)plVar3 + 0x14) = iVar1 + 1;
}
return plVar3;
}
| |
39,456 | stbi__convert_8_to_16(unsigned char*, int, int, int) | SDL3Lite/dependencies/stb_image.h | static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
{
int i;
int img_len = w * h * channels;
stbi__uint16 *enlarged;
enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
for (i = 0; i < img_len; ++i)
enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
STBI_FREE(orig);
return enlarged;
} | O0 | c | stbi__convert_8_to_16(unsigned char*, int, int, int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movslq %eax, %rdi
callq 0x32a50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x32af8
leaq 0x8c5d(%rip), %rdi # 0x3b73f
callq 0x2f390
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, -0x8(%rbp)
jmp 0x32b4f
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x32b3e
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, %dx
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x32aff
movq -0x10(%rbp), %rdi
callq 0x21c70
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL21stbi__convert_8_to_16Phiii:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov eax, [rbp+var_14]
imul eax, [rbp+var_18]
imul eax, [rbp+var_1C]
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
shl eax, 1
movsxd rdi, eax; unsigned __int64
call _ZL12stbi__mallocm; stbi__malloc(ulong)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_32AF8
lea rdi, aOutofmem; "outofmem"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov ecx, eax
xor eax, eax
cmp ecx, 0
cmovnz rax, rax
mov [rbp+var_8], rax
jmp short loc_32B4F
loc_32AF8:
mov [rbp+var_20], 0
loc_32AFF:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jge short loc_32B3E
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_20]
movzx eax, byte ptr [rax+rcx]
shl eax, 8
mov rcx, [rbp+var_10]
movsxd rdx, [rbp+var_20]
movzx ecx, byte ptr [rcx+rdx]
add eax, ecx
mov dx, ax
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_20]
mov [rax+rcx*2], dx
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_32AFF
loc_32B3E:
mov rdi, [rbp+var_10]
call _free
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_32B4F:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long stbi__convert_8_to_16(unsigned __int8 *a1, int a2, int a3, int a4)
{
long long v5; // [rsp+0h] [rbp-30h]
int v6; // [rsp+Ch] [rbp-24h]
int i; // [rsp+10h] [rbp-20h]
v6 = a4 * a3 * a2;
v5 = stbi__malloc(2 * v6);
if ( v5 )
{
for ( i = 0; i < v6; ++i )
*(_WORD *)(v5 + 2LL * i) = 257 * a1[i];
free(a1);
return v5;
}
else
{
stbi__err("outofmem");
return 0LL;
}
}
| stbi__convert_8_to_16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,dword ptr [RBP + -0x18]
IMUL EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x1
MOVSXD RDI,EAX
CALL 0x00132a50
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00132af8
LEA RDI,[0x13b73f]
CALL 0x0012f390
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ RAX,RAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00132b4f
LAB_00132af8:
MOV dword ptr [RBP + -0x20],0x0
LAB_00132aff:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x00132b3e
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
ADD EAX,ECX
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x00132aff
LAB_00132b3e:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00121c70
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_00132b4f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
/* stbi__convert_8_to_16(unsigned char*, int, int, int) */
long stbi__convert_8_to_16(uchar *param_1,int param_2,int param_3,int param_4)
{
int iVar1;
int local_28;
long local_10;
iVar1 = param_2 * param_3 * param_4;
local_10 = stbi__malloc((long)(iVar1 * 2));
if (local_10 == 0) {
stbi__err("outofmem");
local_10 = 0;
}
else {
for (local_28 = 0; local_28 < iVar1; local_28 = local_28 + 1) {
*(ushort *)(local_10 + (long)local_28 * 2) =
(ushort)param_1[local_28] * 0x100 + (ushort)param_1[local_28];
}
free(param_1);
}
return local_10;
}
| |
39,457 | stbi__convert_8_to_16(unsigned char*, int, int, int) | SDL3Lite/dependencies/stb_image.h | static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels)
{
int i;
int img_len = w * h * channels;
stbi__uint16 *enlarged;
enlarged = (stbi__uint16 *) stbi__malloc(img_len*2);
if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory");
for (i = 0; i < img_len; ++i)
enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff
STBI_FREE(orig);
return enlarged;
} | O3 | c | stbi__convert_8_to_16(unsigned char*, int, int, int):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x24(%rsp), %eax
imull 0x20(%rsp), %eax
imull 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
shll %eax
movslq %eax, %rdi
callq 0x33290
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x33330
leaq 0x8426(%rip), %rdi # 0x3b73f
callq 0x2f5a0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x30(%rsp)
jmp 0x33395
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x33381
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq 0x28(%rsp), %rcx
movslq 0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movw %ax, %dx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movw %dx, (%rax,%rcx,2)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x33338
movq 0x28(%rsp), %rdi
callq 0x21c70
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
| _ZL21stbi__convert_8_to_16Phiii:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_14], esi
mov [rsp+38h+var_18], edx
mov [rsp+38h+var_1C], ecx
mov eax, [rsp+38h+var_14]
imul eax, [rsp+38h+var_18]
imul eax, [rsp+38h+var_1C]
mov [rsp+38h+var_24], eax
mov eax, [rsp+38h+var_24]
shl eax, 1
movsxd rdi, eax; unsigned __int64
call _ZL12stbi__mallocm; stbi__malloc(ulong)
mov [rsp+38h+var_30], rax
cmp [rsp+38h+var_30], 0
jnz short loc_33330
lea rdi, aOutofmem; "outofmem"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov ecx, eax
xor eax, eax
cmp ecx, 0
cmovnz rax, rax
mov [rsp+38h+var_8], rax
jmp short loc_33395
loc_33330:
mov [rsp+38h+var_20], 0
loc_33338:
mov eax, [rsp+38h+var_20]
cmp eax, [rsp+38h+var_24]
jge short loc_33381
mov rax, [rsp+38h+var_10]
movsxd rcx, [rsp+38h+var_20]
movzx eax, byte ptr [rax+rcx]
shl eax, 8
mov rcx, [rsp+38h+var_10]
movsxd rdx, [rsp+38h+var_20]
movzx ecx, byte ptr [rcx+rdx]
add eax, ecx
mov dx, ax
mov rax, [rsp+38h+var_30]
movsxd rcx, [rsp+38h+var_20]
mov [rax+rcx*2], dx
mov eax, [rsp+38h+var_20]
add eax, 1
mov [rsp+38h+var_20], eax
jmp short loc_33338
loc_33381:
mov rdi, [rsp+38h+var_10]
call _free
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_8], rax
loc_33395:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long stbi__convert_8_to_16(unsigned __int8 *a1, int a2, int a3, int a4)
{
long long v5; // [rsp+8h] [rbp-30h]
int v6; // [rsp+14h] [rbp-24h]
int i; // [rsp+18h] [rbp-20h]
v6 = a4 * a3 * a2;
v5 = stbi__malloc(2 * v6);
if ( v5 )
{
for ( i = 0; i < v6; ++i )
*(_WORD *)(v5 + 2LL * i) = 257 * a1[i];
free(a1);
return v5;
}
else
{
stbi__err("outofmem");
return 0LL;
}
}
| stbi__convert_8_to_16:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV dword ptr [RSP + 0x24],ESI
MOV dword ptr [RSP + 0x20],EDX
MOV dword ptr [RSP + 0x1c],ECX
MOV EAX,dword ptr [RSP + 0x24]
IMUL EAX,dword ptr [RSP + 0x20]
IMUL EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x14],EAX
MOV EAX,dword ptr [RSP + 0x14]
SHL EAX,0x1
MOVSXD RDI,EAX
CALL 0x00133290
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00133330
LEA RDI,[0x13b73f]
CALL 0x0012f5a0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ RAX,RAX
MOV qword ptr [RSP + 0x30],RAX
JMP 0x00133395
LAB_00133330:
MOV dword ptr [RSP + 0x18],0x0
LAB_00133338:
MOV EAX,dword ptr [RSP + 0x18]
CMP EAX,dword ptr [RSP + 0x14]
JGE 0x00133381
MOV RAX,qword ptr [RSP + 0x28]
MOVSXD RCX,dword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x8
MOV RCX,qword ptr [RSP + 0x28]
MOVSXD RDX,dword ptr [RSP + 0x18]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
ADD EAX,ECX
MOV DX,AX
MOV RAX,qword ptr [RSP + 0x8]
MOVSXD RCX,dword ptr [RSP + 0x18]
MOV word ptr [RAX + RCX*0x2],DX
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,0x1
MOV dword ptr [RSP + 0x18],EAX
JMP 0x00133338
LAB_00133381:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00121c70
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RAX
LAB_00133395:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0x38
RET
|
/* stbi__convert_8_to_16(unsigned char*, int, int, int) */
long stbi__convert_8_to_16(uchar *param_1,int param_2,int param_3,int param_4)
{
int iVar1;
int local_20;
long local_8;
iVar1 = param_2 * param_3 * param_4;
local_8 = stbi__malloc((long)(iVar1 * 2));
if (local_8 == 0) {
stbi__err("outofmem");
local_8 = 0;
}
else {
for (local_20 = 0; local_20 < iVar1; local_20 = local_20 + 1) {
*(ushort *)(local_8 + (long)local_20 * 2) =
(ushort)param_1[local_20] * 0x100 + (ushort)param_1[local_20];
}
free(param_1);
}
return local_8;
}
| |
39,458 | minja::Parser::parseStringConcat() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseStringConcat() {
auto left = parseMathPow();
if (!left) throw std::runtime_error("Expected left side of 'string concat' expression");
static std::regex concat_tok(R"(~(?!\}))");
if (!consumeToken(concat_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'string concat' expression");
left = std::make_shared<BinaryOpExpr>(get_location(), std::move(left), std::move(right), BinaryOpExpr::Op::StrConcat);
}
return left;
} | O2 | cpp | minja::Parser::parseStringConcat():
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x68652
cmpq $0x0, (%rbx)
je 0x684e3
leaq 0x9d04f(%rip), %rax # 0x105480
movb (%rax), %al
testb %al, %al
je 0x68518
leaq 0x9d01e(%rip), %rdx # 0x105460
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x64cda
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x25288
testq %r15, %r15
je 0x684d6
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6632c
cmpq $0x0, 0x8(%rsp)
je 0x6856d
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x648b6
leaq 0x1c(%rsp), %r8
andl $0x0, (%r8)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdx
callq 0x68803
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x7566c
leaq 0x28(%rsp), %rdi
callq 0x53f50
leaq 0x38(%rsp), %rdi
callq 0x53f50
leaq 0x10(%rsp), %rdi
callq 0x53f50
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x24480
movq %rax, %r15
leaq 0x4fe11(%rip), %rsi # 0xb8306
movq %rax, %rdi
callq 0x24340
movq 0x9aaec(%rip), %rsi # 0x102ff0
movq 0x9aa4d(%rip), %rdx # 0x102f58
movq %r15, %rdi
callq 0x24fa0
jmp 0x6859d
leaq 0x9cf61(%rip), %rdi # 0x105480
callq 0x250a0
testl %eax, %eax
je 0x6843b
leaq 0x9cf2d(%rip), %rdi # 0x105460
leaq 0x4fdfd(%rip), %rsi # 0xb8337
pushq $0x10
popq %rdx
callq 0x4aade
leaq -0x1d845(%rip), %rdi # 0x4ad04
leaq 0x9cf10(%rip), %rsi # 0x105460
leaq 0x9b3f1(%rip), %rdx # 0x103948
callq 0x24800
leaq 0x9cf1d(%rip), %rdi # 0x105480
callq 0x24600
jmp 0x6843b
pushq $0x10
popq %rdi
callq 0x24480
movq %rax, %r15
leaq 0x4fdc0(%rip), %rsi # 0xb833f
movq %rax, %rdi
callq 0x24340
movq 0x9aa62(%rip), %rsi # 0x102ff0
movq 0x9a9c3(%rip), %rdx # 0x102f58
movq %r15, %rdi
callq 0x24fa0
movq %rax, %r14
leaq 0x9ced9(%rip), %rdi # 0x105480
callq 0x245f0
jmp 0x685ef
jmp 0x685db
movq %rax, %r14
movq %r15, %rdi
callq 0x246c0
jmp 0x685de
jmp 0x685ec
movq %rax, %r14
movq %r15, %rdi
callq 0x246c0
jmp 0x685ef
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x53f50
jmp 0x685de
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x53f50
jmp 0x685ef
jmp 0x685ec
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x53f50
movq %r14, %rdi
callq 0x25020
| _ZN5minja6Parser17parseStringConcatEv:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
call _ZN5minja6Parser12parseMathPowEv; minja::Parser::parseMathPow(void)
cmp qword ptr [rbx], 0
jz loc_684E3
lea rax, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; `guard variable for'minja::Parser::parseStringConcat(void)::concat_tok
mov al, [rax]
test al, al
jz loc_68518
loc_6843B:
lea rdx, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; minja::Parser::parseStringConcat(void)::concat_tok
lea rdi, [rsp+68h+var_38]
push 1
pop rcx
mov rsi, r14
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rdi, [rsp+68h+var_38]; void *
mov r15, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_684D6
lea rdi, [rsp+68h+var_60]; this
mov rsi, r14
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
cmp [rsp+68h+var_60], 0
jz loc_6856D
lea rdi, [rsp+68h+var_38]; this
mov rsi, r14
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
lea r8, [rsp+68h+var_4C]
and dword ptr [r8], 0
lea rdi, [rsp+68h+var_48]
lea rsi, [rsp+68h+var_38]
lea rcx, [rsp+68h+var_60]
mov rdx, rbx
call _ZSt11make_sharedIN5minja12BinaryOpExprEJNS0_8LocationESt10shared_ptrINS0_10ExpressionEES5_NS1_2OpEEES3_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
lea rsi, [rsp+68h+var_48]
mov rdi, rbx
call _ZNSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr20__sp_compatible_withIPT_PS1_EE5valueERS4_E4typeEOS_IS8_LS3_2EE
lea rdi, [rsp+68h+var_40]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+68h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_684D6:
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop r15
retn
loc_684E3:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedLeftSi_2; "Expected left side of 'string concat' e"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp loc_6859D
loc_68518:
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_6843B
lea rdi, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; minja::Parser::parseStringConcat(void)::concat_tok
lea rsi, asc_B8337; "~(?!\\})"
push 10h
pop rdx
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_6843B
loc_6856D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedRightS_2; "Expected right side of 'string concat' "...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_6859D:
mov r14, rax
lea rdi, _ZGVZN5minja6Parser17parseStringConcatEvE10concat_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_685EF
jmp short loc_685DB
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_685DE
jmp short loc_685EC
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_685EF
mov r14, rax
lea rdi, [rsp+68h+var_30]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_685DE
loc_685DB:
mov r14, rax
loc_685DE:
lea rdi, [rsp+68h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_685EF
jmp short $+2
loc_685EC:
mov r14, rax
loc_685EF:
add rbx, 8
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseStringConcat(minja::Parser *this, _QWORD *a2)
{
long long v2; // r15
std::runtime_error *exception; // r15
std::runtime_error *v5; // r15
long long v6; // [rsp+8h] [rbp-60h] BYREF
long long v7; // [rsp+10h] [rbp-58h] BYREF
int v8; // [rsp+1Ch] [rbp-4Ch] BYREF
_BYTE v9[8]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+28h] [rbp-40h] BYREF
long long v11; // [rsp+30h] [rbp-38h] BYREF
_QWORD v12[6]; // [rsp+38h] [rbp-30h] BYREF
minja::Parser::parseMathPow(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'string concat' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
(long long)"~(?!\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
&v11,
(long long)a2,
(long long)&minja::Parser::parseStringConcat(void)::concat_tok[abi:cxx11],
1u);
v2 = v12[0];
std::string::~string(&v11);
if ( v2 )
{
minja::Parser::parseLogicalAnd((minja::Parser *)&v6, a2);
if ( !v6 )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected right side of 'string concat' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Parser::get_location((minja::Parser *)&v11, a2);
v8 = 0;
std::make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
v9,
&v11,
this,
&v6,
&v8);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=<minja::BinaryOpExpr>(this, v9);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v12);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v7);
}
return this;
}
| parseStringConcat:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
CALL 0x00168652
CMP qword ptr [RBX],0x0
JZ 0x001684e3
LEA RAX,[0x205480]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00168518
LAB_0016843b:
LEA RDX,[0x205460]
LEA RDI,[RSP + 0x30]
PUSH 0x1
POP RCX
MOV RSI,R14
CALL 0x00164cda
LEA RDI,[RSP + 0x30]
MOV R15,qword ptr [RDI + 0x8]
CALL 0x00125288
TEST R15,R15
JZ 0x001684d6
LAB_00168465:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0016632c
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0016856d
LAB_0016847e:
LEA RDI,[RSP + 0x30]
MOV RSI,R14
CALL 0x001648b6
LEA R8,[RSP + 0x1c]
AND dword ptr [R8],0x0
LAB_00168494:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x30]
LEA RCX,[RSP + 0x8]
MOV RDX,RBX
CALL 0x00168803
LAB_001684ab:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0017566c
LEA RDI,[RSP + 0x28]
CALL 0x00153f50
LEA RDI,[RSP + 0x38]
CALL 0x00153f50
LEA RDI,[RSP + 0x10]
CALL 0x00153f50
LAB_001684d6:
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
LAB_001684e3:
PUSH 0x10
POP RDI
CALL 0x00124480
MOV R15,RAX
LAB_001684ee:
LEA RSI,[0x1b8306]
MOV RDI,RAX
CALL 0x00124340
LAB_001684fd:
MOV RSI,qword ptr [0x00202ff0]
MOV RDX,qword ptr [0x00202f58]
MOV RDI,R15
CALL 0x00124fa0
LAB_00168518:
LEA RDI,[0x205480]
CALL 0x001250a0
TEST EAX,EAX
JZ 0x0016843b
LAB_0016852c:
LEA RDI,[0x205460]
LEA RSI,[0x1b8337]
PUSH 0x10
POP RDX
CALL 0x0014aade
LAB_00168542:
LEA RDI,[0x14ad04]
LEA RSI,[0x205460]
LEA RDX,[0x203948]
CALL 0x00124800
LEA RDI,[0x205480]
CALL 0x00124600
JMP 0x0016843b
LAB_0016856d:
PUSH 0x10
POP RDI
CALL 0x00124480
MOV R15,RAX
LAB_00168578:
LEA RSI,[0x1b833f]
MOV RDI,RAX
CALL 0x00124340
LAB_00168587:
MOV RSI,qword ptr [0x00202ff0]
MOV RDX,qword ptr [0x00202f58]
MOV RDI,R15
CALL 0x00124fa0
|
/* minja::Parser::parseStringConcat() */
void minja::Parser::parseStringConcat(void)
{
int iVar1;
runtime_error *prVar2;
__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2> *in_RDI;
long local_60;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [12];
int4 local_4c;
Location local_48 [8];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_40 [8];
string local_38 [8];
long local_30 [3];
parseMathPow();
if (*(long *)in_RDI == 0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001684ee to 001684fc has its CatchHandler @ 001685bf */
std::runtime_error::runtime_error(prVar2,"Expected left side of \'string concat\' expression");
/* try { // try from 001684fd to 00168512 has its CatchHandler @ 001685bd */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00202ff0,PTR__runtime_error_00202f58);
}
if (parseStringConcat()::concat_tok_abi_cxx11_ == '\0') {
iVar1 = __cxa_guard_acquire(&parseStringConcat()::concat_tok_abi_cxx11_);
if (iVar1 != 0) {
/* try { // try from 0016852c to 00168541 has its CatchHandler @ 0016859d */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseStringConcat()::concat_tok_abi_cxx11_,"~(?!\\})",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseStringConcat()::concat_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseStringConcat()::concat_tok_abi_cxx11_);
}
}
/* try { // try from 0016843b to 00168451 has its CatchHandler @ 001685ec */
consumeToken(local_38);
std::__cxx11::string::~string(local_38);
if (local_30[0] != 0) {
/* try { // try from 00168465 to 00168471 has its CatchHandler @ 001685ea */
parseLogicalAnd();
if (local_60 == 0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00168578 to 00168586 has its CatchHandler @ 001685b0 */
std::runtime_error::runtime_error
(prVar2,"Expected right side of \'string concat\' expression");
/* try { // try from 00168587 to 0016859c has its CatchHandler @ 001685ae */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_00202ff0,PTR__runtime_error_00202f58);
}
/* try { // try from 0016847e to 0016848a has its CatchHandler @ 001685db */
get_location();
local_4c = 0;
/* try { // try from 00168494 to 001684aa has its CatchHandler @ 001685cc */
std::
make_shared<minja::BinaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_48,local_38,in_RDI,(Op *)&local_60);
std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator=
(in_RDI,(__shared_ptr *)local_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)local_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
}
return;
}
| |
39,459 | append_json_point(String*, unsigned int, char const*) | eloqsql/sql/spatial.cc | static void append_json_point(String *txt, uint max_dec, const char *data)
{
double x,y;
get_point(&x, &y, data);
if (max_dec < FLOATING_POINT_DECIMALS)
{
x= my_double_round(x, max_dec, FALSE, FALSE);
y= my_double_round(y, max_dec, FALSE, FALSE);
}
txt->qs_append('[');
txt->qs_append(x);
txt->qs_append(", ", 2);
txt->qs_append(y);
txt->qs_append(']');
} | O0 | cpp | append_json_point(String*, unsigned int, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa70000
cmpl $0x1f, -0xc(%rbp)
jae 0xa7068a
movsd -0x20(%rbp), %xmm0
movl -0xc(%rbp), %eax
movl %eax, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x95c520
movsd %xmm0, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
movl -0xc(%rbp), %eax
movl %eax, %edi
xorl %edx, %edx
movl %edx, %esi
callq 0x95c520
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x5b, %esi
callq 0x4b41f0
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movsd -0x20(%rbp), %xmm0
callq 0x492160
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x35701c(%rip), %rsi # 0xdc76d9
movl $0x2, %edx
callq 0x492110
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x492160
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x5d, %esi
callq 0x4b41f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL17append_json_pointP6StringjPKc:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_C+4], rdi
mov dword ptr [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rdx, [rbp+var_18]; char *
lea rdi, [rbp+var_20]; double *
lea rsi, [rbp+var_28]; double *
call _ZL9get_pointPdS_PKc; get_point(double *,double *,char const*)
cmp dword ptr [rbp+var_C], 1Fh
jnb short loc_A7068A
movsd xmm0, [rbp+var_20]; double
mov eax, dword ptr [rbp+var_C]
mov edi, eax; __int64
xor edx, edx; bool
mov esi, edx; bool
call _Z15my_double_rounddxbb; my_double_round(double,long long,bool,bool)
movsd [rbp+var_20], xmm0
movsd xmm0, [rbp+var_28]; double
mov eax, dword ptr [rbp+var_C]
mov edi, eax; __int64
xor edx, edx; bool
mov esi, edx; bool
call _Z15my_double_rounddxbb; my_double_round(double,long long,bool,bool)
movsd [rbp+var_28], xmm0
loc_A7068A:
mov rdi, [rbp+var_C+4]
add rdi, 8; this
mov esi, 5Bh ; '['; char
call _ZN13Binary_string9qs_appendEc; Binary_string::qs_append(char)
mov rdi, [rbp+var_C+4]
add rdi, 8; this
movsd xmm0, [rbp+var_20]; double
call _ZN13Binary_string9qs_appendEd; Binary_string::qs_append(double)
mov rdi, [rbp+var_C+4]
add rdi, 8; this
lea rsi, asc_DC76D7+2; char *
mov edx, 2; unsigned __int64
call _ZN13Binary_string9qs_appendEPKcm; Binary_string::qs_append(char const*,ulong)
mov rdi, [rbp+var_C+4]
add rdi, 8; this
movsd xmm0, [rbp+var_28]; double
call _ZN13Binary_string9qs_appendEd; Binary_string::qs_append(double)
mov rdi, [rbp+var_C+4]
add rdi, 8; this
mov esi, 5Dh ; ']'; char
call _ZN13Binary_string9qs_appendEc; Binary_string::qs_append(char)
add rsp, 30h
pop rbp
retn
| Binary_string * append_json_point(String *a1, int a2, double *a3)
{
double v4; // [rsp+8h] [rbp-28h] BYREF
double v5[2]; // [rsp+10h] [rbp-20h] BYREF
_DWORD v6[3]; // [rsp+24h] [rbp-Ch]
*(_QWORD *)&v6[1] = a1;
v6[0] = a2;
*(_QWORD *)&v5[1] = a3;
get_point(v5, &v4, a3);
if ( v6[0] < 0x1Fu )
{
v5[0] = my_double_round(v5[0], v6[0], 0, 0);
v4 = my_double_round(v4, v6[0], 0, 0);
}
Binary_string::qs_append((Binary_string *)(*(_QWORD *)&v6[1] + 8LL), 91);
Binary_string::qs_append((Binary_string *)(*(_QWORD *)&v6[1] + 8LL), v5[0]);
Binary_string::qs_append((Binary_string *)(*(_QWORD *)&v6[1] + 8LL), ", ", 2LL);
Binary_string::qs_append((Binary_string *)(*(_QWORD *)&v6[1] + 8LL), v4);
return Binary_string::qs_append((Binary_string *)(*(_QWORD *)&v6[1] + 8LL), 93);
}
| limit_index_condition_pushdown_processor:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV AL,0x1
AND AL,0x1
POP RBP
RET
|
/* Item_func_sp::limit_index_condition_pushdown_processor(void*) */
int1 Item_func_sp::limit_index_condition_pushdown_processor(void *param_1)
{
return 1;
}
| |
39,460 | google::protobuf::internal::DynamicMapField::Clear() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/map_field.cc | void DynamicMapField::Clear() {
Map<MapKey, MapValueRef>* map = &const_cast<DynamicMapField*>(this)->map_;
if (MapFieldBase::arena_ == nullptr) {
for (Map<MapKey, MapValueRef>::iterator iter = map->begin();
iter != map->end(); ++iter) {
iter->second.DeleteData();
}
}
map->clear();
if (MapFieldBase::repeated_field_ != nullptr) {
MapFieldBase::repeated_field_->Clear();
}
// Data in map and repeated field are both empty, but we can't set status
// CLEAN which will invalidate previous reference to map.
MapFieldBase::SetMapDirty();
} | O0 | cpp | google::protobuf::internal::DynamicMapField::Clear():
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rcx
addq $0x48, %rcx
movq %rcx, 0x38(%rsp)
cmpq $0x0, 0x8(%rax)
jne 0x32d0ac
movq 0x38(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x332820
movq 0x38(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x332860
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3328a0
testb $0x1, %al
jne 0x32d088
jmp 0x32d0aa
leaq 0x20(%rsp), %rdi
callq 0x332ae0
movq %rax, %rdi
addq $0x28, %rdi
callq 0x3328e0
leaq 0x20(%rsp), %rdi
callq 0x332a80
jmp 0x32d064
jmp 0x32d0ac
movq 0x38(%rsp), %rdi
callq 0x332ab0
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x32d0ce
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x332af0
movq (%rsp), %rdi
callq 0x32ca80
addq $0x48, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf8internal15DynamicMapField5ClearEv:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_48], rax
mov rcx, rax
add rcx, 48h ; 'H'
mov [rsp+48h+var_10], rcx
cmp qword ptr [rax+8], 0
jnz short loc_32D0AC
mov rsi, [rsp+48h+var_10]
lea rdi, [rsp+48h+var_28]
call _ZN6google8protobuf3MapINS0_6MapKeyENS0_11MapValueRefEE5beginEv; google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::begin(void)
loc_32D064:
mov rsi, [rsp+48h+var_10]
lea rdi, [rsp+48h+var_40]
call _ZN6google8protobuf3MapINS0_6MapKeyENS0_11MapValueRefEE3endEv; google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::end(void)
lea rdi, [rsp+48h+var_28]
lea rsi, [rsp+48h+var_40]
call _ZN6google8protobufneERKNS0_3MapINS0_6MapKeyENS0_11MapValueRefEE8iteratorES7_; google::protobuf::operator!=(google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::iterator const&,google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::iterator const&)
test al, 1
jnz short loc_32D088
jmp short loc_32D0AA
loc_32D088:
lea rdi, [rsp+48h+var_28]
call _ZNK6google8protobuf3MapINS0_6MapKeyENS0_11MapValueRefEE8iteratorptEv; google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::iterator::operator->(void)
mov rdi, rax
add rdi, 28h ; '('; this
call _ZN6google8protobuf11MapValueRef10DeleteDataEv; google::protobuf::MapValueRef::DeleteData(void)
lea rdi, [rsp+48h+var_28]
call _ZN6google8protobuf3MapINS0_6MapKeyENS0_11MapValueRefEE8iteratorppEv; google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::iterator::operator++(void)
jmp short loc_32D064
loc_32D0AA:
jmp short $+2
loc_32D0AC:
mov rdi, [rsp+48h+var_10]
call _ZN6google8protobuf3MapINS0_6MapKeyENS0_11MapValueRefEE5clearEv; google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::clear(void)
mov rax, [rsp+48h+var_48]
cmp qword ptr [rax+10h], 0
jz short loc_32D0CE
mov rax, [rsp+48h+var_48]
mov rdi, [rax+10h]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_7MessageEE5ClearEv; google::protobuf::RepeatedPtrField<google::protobuf::Message>::Clear(void)
loc_32D0CE:
mov rdi, [rsp+48h+var_48]; this
call _ZN6google8protobuf8internal12MapFieldBase11SetMapDirtyEv; google::protobuf::internal::MapFieldBase::SetMapDirty(void)
add rsp, 48h
retn
| long long google::protobuf::internal::DynamicMapField::Clear(
google::protobuf::internal::DynamicMapField *this)
{
long long v1; // rax
_BYTE v3[24]; // [rsp+8h] [rbp-40h] BYREF
_BYTE v4[24]; // [rsp+20h] [rbp-28h] BYREF
char *v5; // [rsp+38h] [rbp-10h]
google::protobuf::internal::DynamicMapField *v6; // [rsp+40h] [rbp-8h]
v6 = this;
v5 = (char *)this + 72;
if ( !*((_QWORD *)this + 1) )
{
google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::begin(v4, v5);
while ( 1 )
{
google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::end(v3, v5);
if ( (google::protobuf::operator!=(v4, v3) & 1) == 0 )
break;
v1 = google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::iterator::operator->(v4);
google::protobuf::MapValueRef::DeleteData((google::protobuf::MapValueRef *)(v1 + 40));
google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::iterator::operator++(v4);
}
}
google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::clear(v5);
if ( *((_QWORD *)this + 2) )
google::protobuf::RepeatedPtrField<google::protobuf::Message>::Clear(*((_QWORD *)this + 2));
return google::protobuf::internal::MapFieldBase::SetMapDirty(this);
}
| ZigZagEncode64:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
SHL RAX,0x1
MOV RCX,qword ptr [RSP + -0x8]
SAR RCX,0x3f
XOR RAX,RCX
RET
|
/* google::protobuf::internal::WireFormatLite::ZigZagEncode64(long) */
ulong google::protobuf::internal::WireFormatLite::ZigZagEncode64(long param_1)
{
return param_1 << 1 ^ param_1 >> 0x3f;
}
| |
39,461 | 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> const>>::~iteration_proxy_value() | monkey531[P]llama/common/json.hpp | ~iteration_proxy_value() = default; | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>>::~iteration_proxy_value():
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x74270
movq (%rax), %rsi
incq %rsi
callq 0x1a740
movq 0x30(%rbx), %rdi
addq $0x40, %rbx
cmpq %rbx, %rdi
je 0x74289
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x1a740
popq %rbx
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEED2Ev:
push rbx
mov rbx, rdi
mov rdi, [rdi+50h]; void *
lea rax, [rbx+60h]
cmp rdi, rax
jz short loc_74270
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_74270:
mov rdi, [rbx+30h]; void *
add rbx, 40h ; '@'
cmp rdi, rbx
jz short loc_74289
mov rsi, [rbx]
inc rsi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_74289:
pop rbx
retn
| void nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>>::~iteration_proxy_value(
_QWORD *a1)
{
_QWORD *v2; // rdi
_QWORD *v3; // rdi
_QWORD *v4; // rbx
v2 = (_QWORD *)a1[10];
if ( v2 != a1 + 12 )
operator delete(v2, a1[12] + 1LL);
v3 = (_QWORD *)a1[6];
v4 = a1 + 8;
if ( v3 != v4 )
operator delete(v3, *v4 + 1LL);
}
| ~iteration_proxy_value:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x50]
LEA RAX,[RBX + 0x60]
CMP RDI,RAX
JZ 0x00174270
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011a740
LAB_00174270:
MOV RDI,qword ptr [RBX + 0x30]
ADD RBX,0x40
CMP RDI,RBX
JZ 0x00174289
MOV RSI,qword ptr [RBX]
INC RSI
POP RBX
JMP 0x0011a740
LAB_00174289:
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const> >::~iteration_proxy_value() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
::~iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
*this)
{
if (*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x50) != this + 0x60) {
operator_delete(*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x50),*(long *)(this + 0x60) + 1);
}
if (*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x30) != this + 0x40) {
operator_delete(*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>>
**)(this + 0x30),*(long *)(this + 0x40) + 1);
return;
}
return;
}
| |
39,462 | safe_lexcstrdup_root | eloqsql/mysys/my_alloc.c | LEX_CSTRING safe_lexcstrdup_root(MEM_ROOT *root, const LEX_CSTRING str)
{
LEX_CSTRING res;
if (str.length)
res.str= strmake_root(root, str.str, str.length);
else
res.str= (const char *)"";
res.length= str.length;
return res;
} | O0 | c | safe_lexcstrdup_root:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x336e2
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x33600
movq %rax, -0x10(%rbp)
jmp 0x336ed
leaq 0x4946b(%rip), %rax # 0x7cb54
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| safe_lexcstrdup_root:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_20], rsi
mov [rbp+var_18], rdx
mov [rbp+var_28], rdi
cmp [rbp+var_18], 0
jz short loc_336E2
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call strmake_root
mov [rbp+var_10], rax
jmp short loc_336ED
loc_336E2:
lea rax, asc_7CB50+4; ""
mov [rbp+var_10], rax
loc_336ED:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| char * safe_lexcstrdup_root(_QWORD **a1, long long a2, long long a3)
{
if ( a3 )
return strmake_root(a1, a2, a3);
else
return "";
}
| safe_lexcstrdup_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x28],RDI
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001336e2
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00133600
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001336ed
LAB_001336e2:
LEA RAX,[0x17cb54]
MOV qword ptr [RBP + -0x10],RAX
LAB_001336ed:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] safe_lexcstrdup_root(int8 param_1,int8 param_2,long param_3)
{
int1 auVar1 [16];
int *local_18;
if (param_3 == 0) {
local_18 = &DAT_0017cb54;
}
else {
local_18 = (int *)strmake_root(param_1,param_2,param_3);
}
auVar1._8_8_ = param_3;
auVar1._0_8_ = local_18;
return auVar1;
}
| |
39,463 | my_fdopen | eloqsql/mysys/my_fopen.c | FILE *my_fdopen(File Filedes, const char *name, int Flags, myf MyFlags)
{
FILE *fd;
char type[5];
DBUG_ENTER("my_fdopen");
DBUG_PRINT("my",("fd: %d Flags: %d MyFlags: %lu",
Filedes, Flags, MyFlags));
make_ftype(type,Flags);
#ifdef _WIN32
fd= my_win_fdopen(Filedes, type);
#else
fd= fdopen(Filedes, type);
#endif
if (!fd)
{
my_errno=errno;
if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_CANT_OPEN_STREAM, MYF(ME_BELL), errno);
}
else
{
statistic_increment(my_stream_opened, &THR_LOCK_open);
if ((uint) Filedes < (uint) my_file_limit)
{
if (my_file_info[Filedes].type != UNOPEN)
{
/* File is opened with my_open ! */
my_atomic_add32_explicit(&my_file_opened, -1, MY_MEMORY_ORDER_RELAXED);
}
else
{
my_file_info[Filedes].name= my_strdup(key_memory_my_file_info,
name, MyFlags);
}
my_file_info[Filedes].type= STREAM_BY_FDOPEN;
}
}
DBUG_PRINT("exit",("stream: %p", fd));
DBUG_RETURN(fd);
} | O0 | c | my_fdopen:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
jmp 0x76a35
leaq -0xd(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x76780
movl -0x14(%rbp), %edi
leaq -0xd(%rbp), %rsi
callq 0x36080
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x76a97
callq 0x369e0
movl (%rax), %eax
movl %eax, -0x44(%rbp)
callq 0x7d4a0
movl -0x44(%rbp), %ecx
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0x76a92
callq 0x369e0
movl (%rax), %edx
movl $0xf, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x760a0
jmp 0x76b45
leaq 0x37c8c2(%rip), %rax # 0x3f3360
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x37c8b4(%rip), %rax # 0x3f3360
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
leaq 0x1bae17(%rip), %rcx # 0x2318d0
cmpl (%rcx), %eax
jae 0x76b43
leaq 0x1bae10(%rip), %rax # 0x2318d8
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x76af6
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movl -0x3c(%rbp), %eax
leaq 0x37c897(%rip), %rcx # 0x3f3384
lock
xaddl %eax, (%rcx)
movl %eax, -0x40(%rbp)
jmp 0x76b27
leaq 0x37cdb7(%rip), %rax # 0x3f38b4
movl (%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7be00
movq %rax, %rcx
leaq 0x1badc2(%rip), %rax # 0x2318d8
movq (%rax), %rax
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
leaq 0x1badaa(%rip), %rax # 0x2318d8
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x4, 0x8(%rax)
jmp 0x76b45
jmp 0x76b47
jmp 0x76b49
jmp 0x76b4b
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x76b6f
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x362b0
nopw %cs:(%rax,%rax)
nop
| my_fdopen:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
jmp short $+2
loc_76A35:
lea rdi, [rbp+var_D]
mov esi, [rbp+var_24]
call make_ftype
mov edi, [rbp+var_14]
lea rsi, [rbp+var_D]
call _fdopen
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz short loc_76A97
call ___errno_location
mov eax, [rax]
mov [rbp+var_44], eax
call _my_thread_var
mov ecx, [rbp+var_44]
mov [rax], ecx
mov rax, [rbp+var_30]
and rax, 18h
cmp rax, 0
jz short loc_76A92
call ___errno_location
mov edx, [rax]
mov edi, 0Fh
mov esi, 4
mov al, 0
call my_error
loc_76A92:
jmp loc_76B45
loc_76A97:
lea rax, my_stream_opened
mov rcx, [rax]
add rcx, 1
lea rax, my_stream_opened
mov [rax], rcx
mov eax, [rbp+var_14]
lea rcx, my_file_limit
cmp eax, [rcx]
jnb loc_76B43
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_14]
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+8], 0
jz short loc_76AF6
mov [rbp+var_3C], 0FFFFFFFFh
mov eax, [rbp+var_3C]
lea rcx, my_file_opened
lock xadd [rcx], eax
mov [rbp+var_40], eax
jmp short loc_76B27
loc_76AF6:
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_30]
call my_strdup
mov rcx, rax
lea rax, my_file_info
mov rax, [rax]
movsxd rdx, [rbp+var_14]
shl rdx, 4
add rax, rdx
mov [rax], rcx
loc_76B27:
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_14]
shl rcx, 4
add rax, rcx
mov dword ptr [rax+8], 4
loc_76B43:
jmp short $+2
loc_76B45:
jmp short $+2
loc_76B47:
jmp short $+2
loc_76B49:
jmp short $+2
loc_76B4B:
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_76B6F
mov rax, [rbp+var_50]
add rsp, 50h
pop rbp
retn
loc_76B6F:
call ___stack_chk_fail
| long long my_fdopen(unsigned int a1, long long a2, __int16 a3, long long a4)
{
unsigned int *v4; // rax
int v6; // [rsp+Ch] [rbp-44h]
long long v7; // [rsp+18h] [rbp-38h]
char v9[5]; // [rsp+43h] [rbp-Dh] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
make_ftype(v9, a3);
v7 = fdopen(a1, v9);
if ( v7 )
{
++my_stream_opened;
if ( a1 < my_file_limit )
{
if ( *((_DWORD *)my_file_info + 4 * (int)a1 + 2) )
_InterlockedExchangeAdd(my_file_opened, 0xFFFFFFFF);
else
*((_QWORD *)my_file_info + 2 * (int)a1) = my_strdup(key_memory_my_file_info, a2, a4);
*((_DWORD *)my_file_info + 4 * (int)a1 + 2) = 4;
}
}
else
{
v6 = *(_DWORD *)__errno_location(a1);
*(_DWORD *)my_thread_var() = v6;
if ( (a4 & 0x18) != 0 )
{
v4 = (unsigned int *)__errno_location(a1);
my_error(0xFu, 4LL, *v4);
}
}
return v7;
}
| my_fdopen:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
JMP 0x00176a35
LAB_00176a35:
LEA RDI,[RBP + -0xd]
MOV ESI,dword ptr [RBP + -0x24]
CALL 0x00176780
MOV EDI,dword ptr [RBP + -0x14]
LEA RSI,[RBP + -0xd]
CALL 0x00136080
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00176a97
CALL 0x001369e0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
CALL 0x0017d4a0
MOV ECX,dword ptr [RBP + -0x44]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x18
CMP RAX,0x0
JZ 0x00176a92
CALL 0x001369e0
MOV EDX,dword ptr [RAX]
MOV EDI,0xf
MOV ESI,0x4
MOV AL,0x0
CALL 0x001760a0
LAB_00176a92:
JMP 0x00176b45
LAB_00176a97:
LEA RAX,[0x4f3360]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x4f3360]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x14]
LEA RCX,[0x3318d0]
CMP EAX,dword ptr [RCX]
JNC 0x00176b43
LEA RAX,[0x3318d8]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x14]
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00176af6
MOV dword ptr [RBP + -0x3c],0xffffffff
MOV EAX,dword ptr [RBP + -0x3c]
LEA RCX,[0x4f3384]
XADD.LOCK dword ptr [RCX],EAX
MOV dword ptr [RBP + -0x40],EAX
JMP 0x00176b27
LAB_00176af6:
LEA RAX,[0x4f38b4]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0017be00
MOV RCX,RAX
LEA RAX,[0x3318d8]
MOV RAX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RBP + -0x14]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LAB_00176b27:
LEA RAX,[0x3318d8]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x14]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RAX + 0x8],0x4
LAB_00176b43:
JMP 0x00176b45
LAB_00176b45:
JMP 0x00176b47
LAB_00176b47:
JMP 0x00176b49
LAB_00176b49:
JMP 0x00176b4b
LAB_00176b4b:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00176b6f
MOV RAX,qword ptr [RBP + -0x50]
ADD RSP,0x50
POP RBP
RET
LAB_00176b6f:
CALL 0x001362b0
|
FILE * my_fdopen(uint param_1,int8 param_2,int4 param_3,ulong param_4)
{
int iVar1;
FILE *pFVar2;
int *piVar3;
int8 uVar4;
long in_FS_OFFSET;
char local_15 [5];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
make_ftype(local_15,param_3);
pFVar2 = fdopen(param_1,local_15);
if (pFVar2 == (FILE *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_4 & 0x18) != 0) {
piVar3 = __errno_location();
my_error(0xf,4,*piVar3);
}
}
else {
my_stream_opened = my_stream_opened + 1;
if (param_1 < my_file_limit) {
if (*(int *)(my_file_info + (long)(int)param_1 * 0x10 + 8) == 0) {
uVar4 = my_strdup(key_memory_my_file_info,param_2,param_4);
*(int8 *)(my_file_info + (long)(int)param_1 * 0x10) = uVar4;
}
else {
LOCK();
my_file_opened = my_file_opened + -1;
UNLOCK();
}
*(int4 *)(my_file_info + (long)(int)param_1 * 0x10 + 8) = 4;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pFVar2;
}
| |
39,464 | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp | void
set_data( const char* raw_data, Elf_Word size )
{
if ( get_type() != SHT_NOBITS ) {
delete [] data;
try {
data = new char[size];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
size = 0;
}
if ( 0 != data && 0 != raw_data ) {
data_size = size;
std::copy( raw_data, raw_data + size, data );
}
}
set_size( size );
} | O0 | cpp | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0x1a4b9
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1a409
movq 0x8(%rsp), %rdi
callq 0x152a0
movl 0x34(%rsp), %eax
movl %eax, %edi
callq 0x15030
movq %rax, (%rsp)
jmp 0x1a41a
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x60(%rax)
jmp 0x1a47b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1a4d2
movq 0x28(%rsp), %rdi
callq 0x150b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq $0x0, 0x60(%rax)
movl $0x0, 0x68(%rax)
movl $0x0, 0x34(%rsp)
callq 0x15370
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x60(%rcx), %rax
je 0x1a4b7
xorl %eax, %eax
cmpq 0x38(%rsp), %rax
je 0x1a4b7
movq 0x10(%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x68(%rax)
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x34(%rsp), %ecx
addq %rcx, %rsi
movq 0x60(%rax), %rdx
callq 0x19b20
jmp 0x1a4b9
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %esi
movq (%rdi), %rax
callq *0xa0(%rax)
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x153a0
nopl (%rax)
| _ZN5ELFIO12section_implINS_10Elf32_ShdrEE8set_dataEPKcj:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_14+4], rsi
mov dword ptr [rsp+48h+var_14], edx
mov rdi, [rsp+48h+var_8]
mov [rsp+48h+var_38], rdi
mov rax, [rdi]
call qword ptr [rax+28h]
cmp eax, 8
jz loc_1A4B9
mov rax, [rsp+48h+var_38]
mov rax, [rax+60h]
mov [rsp+48h+var_40], rax
cmp rax, 0
jz short loc_1A409
mov rdi, [rsp+48h+var_40]; void *
call __ZdaPv; operator delete[](void *)
loc_1A409:
mov eax, dword ptr [rsp+48h+var_14]
mov edi, eax; unsigned __int64
call __Znam; operator new[](ulong)
mov [rsp+48h+var_48], rax
jmp short $+2
loc_1A41A:
mov rax, [rsp+48h+var_38]
mov rcx, [rsp+48h+var_48]
mov [rax+60h], rcx
jmp short loc_1A47B
mov rcx, rax
mov eax, edx
mov [rsp+48h+var_20], rcx
mov [rsp+48h+var_24], eax
mov eax, [rsp+48h+var_24]
mov ecx, 1
cmp eax, ecx
jnz loc_1A4D2
mov rdi, [rsp+48h+var_20]; void *
call ___cxa_begin_catch
mov rcx, rax
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_30], rcx
mov qword ptr [rax+60h], 0
mov dword ptr [rax+68h], 0
mov dword ptr [rsp+48h+var_14], 0
call ___cxa_end_catch
loc_1A47B:
mov rcx, [rsp+48h+var_38]
xor eax, eax
cmp rax, [rcx+60h]
jz short loc_1A4B7
xor eax, eax
cmp rax, [rsp+48h+var_14+4]
jz short loc_1A4B7
mov rax, [rsp+48h+var_38]
mov ecx, dword ptr [rsp+48h+var_14]
mov [rax+68h], ecx
mov rdi, [rsp+48h+var_14+4]
mov rsi, [rsp+48h+var_14+4]
mov ecx, dword ptr [rsp+48h+var_14]
add rsi, rcx
mov rdx, [rax+60h]
call _ZSt4copyIPKcPcET0_T_S4_S3_; std::copy<char const*,char *>(char const*,char const*,char *)
loc_1A4B7:
jmp short $+2
loc_1A4B9:
mov rdi, [rsp+48h+var_38]
mov eax, dword ptr [rsp+48h+var_14]
mov esi, eax
mov rax, [rdi]
call qword ptr [rax+0A0h]
add rsp, 48h
retn
loc_1A4D2:
mov rdi, [rsp+48h+var_20]
call __Unwind_Resume
| long long ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data(long long a1, long long a2, unsigned int a3)
{
void *v4; // [rsp+8h] [rbp-40h]
if ( (*(unsigned int ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1) != 8 )
{
v4 = *(void **)(a1 + 96);
if ( v4 )
operator delete[](v4);
*(_QWORD *)(a1 + 96) = operator new[](a3);
if ( *(_QWORD *)(a1 + 96) && a2 )
{
*(_DWORD *)(a1 + 104) = a3;
std::copy<char const*,char *>(a2, a3 + a2, *(_QWORD *)(a1 + 96));
}
}
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a1 + 160LL))(a1, a3);
}
| set_data:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV dword ptr [RSP + 0x34],EDX
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0011a4b9
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,0x0
JZ 0x0011a409
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001152a0
LAB_0011a409:
MOV EAX,dword ptr [RSP + 0x34]
MOV EDI,EAX
LAB_0011a40f:
CALL 0x00115030
LAB_0011a414:
MOV qword ptr [RSP],RAX
JMP 0x0011a41a
LAB_0011a41a:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX + 0x60],RCX
JMP 0x0011a47b
LAB_0011a47b:
MOV RCX,qword ptr [RSP + 0x10]
XOR EAX,EAX
CMP RAX,qword ptr [RCX + 0x60]
JZ 0x0011a4b7
XOR EAX,EAX
CMP RAX,qword ptr [RSP + 0x38]
JZ 0x0011a4b7
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RSP + 0x34]
MOV dword ptr [RAX + 0x68],ECX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x38]
MOV ECX,dword ptr [RSP + 0x34]
ADD RSI,RCX
MOV RDX,qword ptr [RAX + 0x60]
CALL 0x00119b20
LAB_0011a4b7:
JMP 0x0011a4b9
LAB_0011a4b9:
MOV RDI,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0x34]
MOV ESI,EAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0xa0]
ADD RSP,0x48
RET
|
/* ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data(char const*, unsigned int) */
void __thiscall
ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data
(section_impl<ELFIO::Elf32_Shdr> *this,char *param_1,uint param_2)
{
int iVar1;
void *pvVar2;
iVar1 = (**(code **)(*(long *)this + 0x28))();
if (iVar1 != 8) {
if (*(void **)(this + 0x60) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x60));
}
/* try { // try from 0011a40f to 0011a413 has its CatchHandler @ 0011a429 */
pvVar2 = operator_new__((ulong)param_2);
*(void **)(this + 0x60) = pvVar2;
if ((*(long *)(this + 0x60) != 0) && (param_1 != (char *)0x0)) {
*(uint *)(this + 0x68) = param_2;
std::copy<char_const*,char*>(param_1,param_1 + param_2,*(char **)(this + 0x60));
}
}
(**(code **)(*(long *)this + 0xa0))(this,param_2);
return;
}
| |
39,465 | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp | void
set_data( const char* raw_data, Elf_Word size )
{
if ( get_type() != SHT_NOBITS ) {
delete [] data;
try {
data = new char[size];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
size = 0;
}
if ( 0 != data && 0 != raw_data ) {
data_size = size;
std::copy( raw_data, raw_data + size, data );
}
}
set_size( size );
} | O1 | cpp | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int):
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0xcf04
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xced1
callq 0xb280
movl %ebp, %edi
callq 0xb030
movq %rax, 0x78(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0xcf04
movl %ebp, 0x80(%rbx)
testl %ebp, %ebp
je 0xcf04
movl %ebp, %edx
movq %r14, %rsi
callq 0xb330
movl %ebp, %esi
movq (%rbx), %rax
movq 0xa0(%rax), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq %rax, %rdi
callq 0xb0d0
movq $0x0, 0x78(%rbx)
movl $0x0, 0x80(%rbx)
callq 0xb340
xorl %ebp, %ebp
jmp 0xcedc
| _ZN5ELFIO12section_implINS_10Elf64_ShdrEE8set_dataEPKcj:
push rbp
push r14
push rbx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
call qword ptr [rax+28h]
cmp eax, 8
jz short loc_CF04
mov rdi, [rbx+78h]; void *
test rdi, rdi
jz short loc_CED1
call __ZdaPv; operator delete[](void *)
loc_CED1:
mov edi, ebp; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+78h], rax
loc_CEDC:
mov rdi, [rbx+78h]
test rdi, rdi
setz al
test r14, r14
setz cl
or cl, al
jnz short loc_CF04
mov [rbx+80h], ebp
test ebp, ebp
jz short loc_CF04
mov edx, ebp
mov rsi, r14
call _memmove
loc_CF04:
mov esi, ebp
mov rax, [rbx]
mov rax, [rax+0A0h]
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp rax
mov rdi, rax; void *
call ___cxa_begin_catch
mov qword ptr [rbx+78h], 0
mov dword ptr [rbx+80h], 0
call ___cxa_end_catch
xor ebp, ebp
jmp short loc_CEDC
| long long ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(long long a1, long long a2, unsigned int a3)
{
void *v5; // rdi
long long v6; // rdi
if ( (*(unsigned int ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1) != 8 )
{
v5 = *(void **)(a1 + 120);
if ( v5 )
operator delete[](v5);
*(_QWORD *)(a1 + 120) = operator new[](a3);
v6 = *(_QWORD *)(a1 + 120);
if ( v6 != 0 && a2 != 0 )
{
*(_DWORD *)(a1 + 128) = a3;
if ( a3 )
memmove(v6, a2, a3);
}
}
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a1 + 160LL))(a1, a3);
}
| set_data:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0010cf04
MOV RDI,qword ptr [RBX + 0x78]
TEST RDI,RDI
JZ 0x0010ced1
CALL 0x0010b280
LAB_0010ced1:
MOV EDI,EBP
LAB_0010ced3:
CALL 0x0010b030
LAB_0010ced8:
MOV qword ptr [RBX + 0x78],RAX
LAB_0010cedc:
MOV RDI,qword ptr [RBX + 0x78]
TEST RDI,RDI
SETZ AL
TEST R14,R14
SETZ CL
OR CL,AL
JNZ 0x0010cf04
MOV dword ptr [RBX + 0x80],EBP
TEST EBP,EBP
JZ 0x0010cf04
MOV EDX,EBP
MOV RSI,R14
CALL 0x0010b330
LAB_0010cf04:
MOV ESI,EBP
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP RAX
|
/* ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int) */
void __thiscall
ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data
(section_impl<ELFIO::Elf64_Shdr> *this,char *param_1,uint param_2)
{
int iVar1;
void *pvVar2;
iVar1 = (**(code **)(*(long *)this + 0x28))();
if (iVar1 != 8) {
if (*(void **)(this + 0x78) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x78));
}
/* try { // try from 0010ced3 to 0010ced7 has its CatchHandler @ 0010cf19 */
pvVar2 = operator_new__((ulong)param_2);
*(void **)(this + 0x78) = pvVar2;
if ((param_1 != (char *)0x0 && *(void **)(this + 0x78) != (void *)0x0) &&
(*(uint *)(this + 0x80) = param_2, param_2 != 0)) {
memmove(*(void **)(this + 0x78),param_1,(ulong)param_2);
}
}
/* WARNING: Could not recover jumptable at 0x0010cf17. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*(long *)this + 0xa0))(this,param_2);
return;
}
| |
39,466 | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp | void
set_data( const char* raw_data, Elf_Word size )
{
if ( get_type() != SHT_NOBITS ) {
delete [] data;
try {
data = new char[size];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
size = 0;
}
if ( 0 != data && 0 != raw_data ) {
data_size = size;
std::copy( raw_data, raw_data + size, data );
}
}
set_size( size );
} | O2 | cpp | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int):
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0xdc29
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0xdbf3
callq 0xc250
movl %ebp, %edi
callq 0xc030
movq %rax, 0x78(%rbx)
testq %rax, %rax
sete %cl
testq %r14, %r14
sete %dl
orb %cl, %dl
jne 0xdc29
movl %ebp, 0x80(%rbx)
testl %ebp, %ebp
je 0xdc27
movl %ebp, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0xc310
jmp 0xdc29
xorl %ebp, %ebp
movl %ebp, %esi
movq (%rbx), %rax
movq 0xa0(%rax), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq %rax, %rdi
callq 0xc0b0
andq $0x0, 0x78(%rbx)
andl $0x0, 0x80(%rbx)
callq 0xc320
movq 0x78(%rbx), %rax
xorl %ebp, %ebp
jmp 0xdbfe
nop
| _ZN5ELFIO12section_implINS_10Elf64_ShdrEE8set_dataEPKcj:
push rbp
push r14
push rbx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
call qword ptr [rax+28h]
cmp eax, 8
jz short loc_DC29
mov rdi, [rbx+78h]; void *
test rdi, rdi
jz short loc_DBF3
call __ZdaPv; operator delete[](void *)
loc_DBF3:
mov edi, ebp; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+78h], rax
loc_DBFE:
test rax, rax
setz cl
test r14, r14
setz dl
or dl, cl
jnz short loc_DC29
mov [rbx+80h], ebp
test ebp, ebp
jz short loc_DC27
mov edx, ebp
mov rdi, rax
mov rsi, r14
call _memmove
jmp short loc_DC29
loc_DC27:
xor ebp, ebp
loc_DC29:
mov esi, ebp
mov rax, [rbx]
mov rax, [rax+0A0h]
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp rax
mov rdi, rax; void *
call ___cxa_begin_catch
and qword ptr [rbx+78h], 0
and dword ptr [rbx+80h], 0
call ___cxa_end_catch
mov rax, [rbx+78h]
xor ebp, ebp
jmp short loc_DBFE
| long long ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(long long a1, long long a2, unsigned int a3)
{
void *v5; // rdi
long long v6; // rax
if ( (*(unsigned int ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1) != 8 )
{
v5 = *(void **)(a1 + 120);
if ( v5 )
operator delete[](v5);
v6 = operator new[](a3);
*(_QWORD *)(a1 + 120) = v6;
if ( v6 != 0 && a2 != 0 )
{
*(_DWORD *)(a1 + 128) = a3;
if ( a3 )
memmove(v6, a2, a3);
else
a3 = 0;
}
}
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a1 + 160LL))(a1, a3);
}
| set_data:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0010dc29
MOV RDI,qword ptr [RBX + 0x78]
TEST RDI,RDI
JZ 0x0010dbf3
CALL 0x0010c250
LAB_0010dbf3:
MOV EDI,EBP
LAB_0010dbf5:
CALL 0x0010c030
LAB_0010dbfa:
MOV qword ptr [RBX + 0x78],RAX
LAB_0010dbfe:
TEST RAX,RAX
SETZ CL
TEST R14,R14
SETZ DL
OR DL,CL
JNZ 0x0010dc29
MOV dword ptr [RBX + 0x80],EBP
TEST EBP,EBP
JZ 0x0010dc27
MOV EDX,EBP
MOV RDI,RAX
MOV RSI,R14
CALL 0x0010c310
JMP 0x0010dc29
LAB_0010dc27:
XOR EBP,EBP
LAB_0010dc29:
MOV ESI,EBP
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP RAX
|
/* ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int) */
void __thiscall
ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data
(section_impl<ELFIO::Elf64_Shdr> *this,char *param_1,uint param_2)
{
int iVar1;
void *__dest;
iVar1 = (**(code **)(*(long *)this + 0x28))();
if (iVar1 != 8) {
if (*(void **)(this + 0x78) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x78));
}
/* try { // try from 0010dbf5 to 0010dbf9 has its CatchHandler @ 0010dc3e */
__dest = operator_new__((ulong)param_2);
*(void **)(this + 0x78) = __dest;
if (param_1 != (char *)0x0 && __dest != (void *)0x0) {
*(uint *)(this + 0x80) = param_2;
if (param_2 == 0) {
param_2 = 0;
}
else {
memmove(__dest,param_1,(ulong)param_2);
}
}
}
/* WARNING: Could not recover jumptable at 0x0010dc3c. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*(long *)this + 0xa0))(this,param_2);
return;
}
| |
39,467 | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio_section.hpp | void
set_data( const char* raw_data, Elf_Word size )
{
if ( get_type() != SHT_NOBITS ) {
delete [] data;
try {
data = new char[size];
} catch (const std::bad_alloc&) {
data = 0;
data_size = 0;
size = 0;
}
if ( 0 != data && 0 != raw_data ) {
data_size = size;
std::copy( raw_data, raw_data + size, data );
}
}
set_size( size );
} | O3 | cpp | ELFIO::section_impl<ELFIO::Elf64_Shdr>::set_data(char const*, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x8, %eax
je 0xd569
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xd53c
callq 0xb280
movl %ebp, %r15d
movq %r15, %rdi
callq 0xb030
movq %rax, 0x60(%rbx)
testq %r14, %r14
je 0xd569
movl %ebp, 0x68(%rbx)
testl %ebp, %ebp
je 0xd567
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb170
jmp 0xd569
xorl %ebp, %ebp
movl %ebp, %esi
movq (%rbx), %rax
movq 0xa0(%rax), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rax, %rdi
callq 0xb0d0
movq $0x0, 0x60(%rbx)
movl $0x0, 0x68(%rbx)
callq 0xb340
xorl %ebp, %ebp
testq %r14, %r14
je 0xd569
cmpq $0x0, 0x60(%rbx)
je 0xd569
movl $0x0, 0x68(%rbx)
jmp 0xd569
nop
| _ZN5ELFIO12section_implINS_10Elf32_ShdrEE8set_dataEPKcj:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi]
call qword ptr [rax+28h]
cmp eax, 8
jz short loc_D569
mov rdi, [rbx+60h]; void *
test rdi, rdi
jz short loc_D53C
call __ZdaPv; operator delete[](void *)
loc_D53C:
mov r15d, ebp
mov rdi, r15; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+60h], rax
test r14, r14
jz short loc_D569
mov [rbx+68h], ebp
test ebp, ebp
jz short loc_D567
mov rdi, rax
mov rsi, r14
mov rdx, r15
call _memcpy
jmp short loc_D569
loc_D567:
xor ebp, ebp
loc_D569:
mov esi, ebp
mov rax, [rbx]
mov rax, [rax+0A0h]
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp rax
mov rdi, rax; void *
call ___cxa_begin_catch
mov qword ptr [rbx+60h], 0
mov dword ptr [rbx+68h], 0
call ___cxa_end_catch
xor ebp, ebp
test r14, r14
jz short loc_D569
cmp qword ptr [rbx+60h], 0
jz short loc_D569
mov dword ptr [rbx+68h], 0
jmp short loc_D569
| long long ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data(long long a1, long long a2, unsigned int a3)
{
void *v5; // rdi
long long v6; // rax
if ( (*(unsigned int ( **)(long long))(*(_QWORD *)a1 + 40LL))(a1) != 8 )
{
v5 = *(void **)(a1 + 96);
if ( v5 )
operator delete[](v5);
v6 = operator new[](a3);
*(_QWORD *)(a1 + 96) = v6;
if ( a2 )
{
*(_DWORD *)(a1 + 104) = a3;
if ( a3 )
memcpy(v6, a2, a3);
else
a3 = 0;
}
}
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)a1 + 160LL))(a1, a3);
}
| set_data:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x28]
CMP EAX,0x8
JZ 0x0010d569
MOV RDI,qword ptr [RBX + 0x60]
TEST RDI,RDI
JZ 0x0010d53c
CALL 0x0010b280
LAB_0010d53c:
MOV R15D,EBP
LAB_0010d53f:
MOV RDI,R15
CALL 0x0010b030
LAB_0010d547:
MOV qword ptr [RBX + 0x60],RAX
TEST R14,R14
JZ 0x0010d569
MOV dword ptr [RBX + 0x68],EBP
TEST EBP,EBP
JZ 0x0010d567
MOV RDI,RAX
MOV RSI,R14
MOV RDX,R15
CALL 0x0010b170
JMP 0x0010d569
LAB_0010d567:
XOR EBP,EBP
LAB_0010d569:
MOV ESI,EBP
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0xa0]
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP RAX
|
/* ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data(char const*, unsigned int) */
void __thiscall
ELFIO::section_impl<ELFIO::Elf32_Shdr>::set_data
(section_impl<ELFIO::Elf32_Shdr> *this,char *param_1,uint param_2)
{
int iVar1;
void *__dest;
iVar1 = (**(code **)(*(long *)this + 0x28))();
if (iVar1 != 8) {
if (*(void **)(this + 0x60) != (void *)0x0) {
operator_delete__(*(void **)(this + 0x60));
}
/* try { // try from 0010d53f to 0010d546 has its CatchHandler @ 0010d584 */
__dest = operator_new__((ulong)param_2);
*(void **)(this + 0x60) = __dest;
if (param_1 != (char *)0x0) {
*(uint *)(this + 0x68) = param_2;
if (param_2 == 0) {
param_2 = 0;
}
else {
memcpy(__dest,param_1,(ulong)param_2);
}
}
}
/* WARNING: Could not recover jumptable at 0x0010d582. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*(long *)this + 0xa0))(this,param_2);
return;
}
| |
39,468 | glfwPlatformIconifyWindow | untodesu[P]riteg/build_O3/_deps/glfw-src/src/x11_window.c | void _glfwPlatformIconifyWindow(_GLFWwindow* window)
{
if (window->x11.overrideRedirect)
{
// Override-redirect windows cannot be iconified or restored, as those
// tasks are performed by the window manager
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
return;
}
XIconifyWindow(_glfw.x11.display, window->x11.handle, _glfw.x11.screen);
XFlush(_glfw.x11.display);
} | O3 | c | glfwPlatformIconifyWindow:
cmpl $0x0, 0x358(%rdi)
je 0x23289
leaq 0x6295c(%rip), %rsi # 0x85bd9
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
jmp 0x18e91
pushq %rbx
leaq 0x853a7(%rip), %rbx # 0xa8638
movq 0x1fec0(%rbx), %rax
movq 0x348(%rdi), %rsi
movl 0x1fec8(%rbx), %edx
movq %rax, %rdi
callq 0xc430
movq 0x1fec0(%rbx), %rdi
popq %rbx
jmp 0xcce0
| _glfwPlatformIconifyWindow:
cmp dword ptr [rdi+358h], 0
jz short loc_23289
lea rsi, aX11Iconificati; "X11: Iconification of full screen windo"...
mov edi, 10008h
xor eax, eax
jmp _glfwInputError
loc_23289:
push rbx
lea rbx, _glfw
mov rax, [rbx+1FEC0h]
mov rsi, [rdi+348h]
mov edx, [rbx+1FEC8h]
mov rdi, rax
call _XIconifyWindow
mov rdi, [rbx+1FEC0h]
pop rbx
jmp _XFlush
| long long ( * glfwPlatformIconifyWindow(long long a1))(_QWORD, _QWORD)
{
if ( *(_DWORD *)(a1 + 856) )
return glfwInputError(
0x10008u,
(long long)"X11: Iconification of full screen windows requires a WM that supports EWMH full screen");
XIconifyWindow(*(_QWORD *)&glfw[32688], *(_QWORD *)(a1 + 840), (unsigned int)glfw[32690]);
return (long long ( *)(_QWORD, _QWORD))XFlush(*(_QWORD *)&glfw[32688]);
}
| _glfwPlatformIconifyWindow:
CMP dword ptr [RDI + 0x358],0x0
JZ 0x00123289
LEA RSI,[0x185bd9]
MOV EDI,0x10008
XOR EAX,EAX
JMP 0x00118e91
LAB_00123289:
PUSH RBX
LEA RBX,[0x1a8638]
MOV RAX,qword ptr [RBX + 0x1fec0]
MOV RSI,qword ptr [RDI + 0x348]
MOV EDX,dword ptr [RBX + 0x1fec8]
MOV RDI,RAX
CALL 0x0010c430
MOV RDI,qword ptr [RBX + 0x1fec0]
POP RBX
JMP 0x0010cce0
|
void _glfwPlatformIconifyWindow(long param_1)
{
if (*(int *)(param_1 + 0x358) != 0) {
_glfwInputError(0x10008,
"X11: Iconification of full screen windows requires a WM that supports EWMH full screen"
);
return;
}
XIconifyWindow(DAT_001c84f8,*(int8 *)(param_1 + 0x348),DAT_001c8500);
XFlush(DAT_001c84f8);
return;
}
| |
39,469 | httplib::detail::SocketStream::write(char const*, unsigned long) | nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h | inline ssize_t SocketStream::write(const char *ptr, size_t size) {
if (!is_writable()) { return -1; }
#if defined(_WIN32) && !defined(_WIN64)
size =
(std::min)(size, static_cast<size_t>((std::numeric_limits<int>::max)()));
#endif
return send_socket(sock_, ptr, size, CPPHTTPLIB_SEND_FLAGS);
} | O1 | c | httplib::detail::SocketStream::write(char const*, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
callq *0x18(%rax)
movq $-0x1, %r15
testb %al, %al
je 0xa7b2
movl 0x8(%r12), %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x8290
movq %rax, %r15
testq %rax, %rax
jns 0xa7b2
callq 0x8050
cmpl $0x4, (%rax)
je 0xa791
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN7httplib6detail12SocketStream5writeEPKcm:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, rdx
mov r14, rsi
mov r12, rdi
mov rax, [rdi]
call qword ptr [rax+18h]
mov r15, 0FFFFFFFFFFFFFFFFh
test al, al
jz short loc_A7B2
mov ebp, [r12+8]
loc_A791:
mov edi, ebp
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
call _send
mov r15, rax
test rax, rax
jns short loc_A7B2
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_A791
loc_A7B2:
mov rax, r15
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| write:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
MOV R15,-0x1
TEST AL,AL
JZ 0x0010a7b2
MOV EBP,dword ptr [R12 + 0x8]
LAB_0010a791:
MOV EDI,EBP
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
CALL 0x00108290
MOV R15,RAX
TEST RAX,RAX
JNS 0x0010a7b2
CALL 0x00108050
CMP dword ptr [RAX],0x4
JZ 0x0010a791
LAB_0010a7b2:
MOV RAX,R15
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* httplib::detail::SocketStream::write(char const*, unsigned long) */
ssize_t __thiscall
httplib::detail::SocketStream::write(SocketStream *this,char *param_1,ulong param_2)
{
int __fd;
char cVar1;
int *piVar2;
ssize_t sVar3;
cVar1 = (**(code **)(*(long *)this + 0x18))();
sVar3 = -1;
if (cVar1 != '\0') {
__fd = *(int *)(this + 8);
do {
sVar3 = send(__fd,param_1,param_2,0);
if (-1 < sVar3) {
return sVar3;
}
piVar2 = __errno_location();
} while (*piVar2 == 4);
}
return sVar3;
}
| ||
39,470 | ma_redo_not_needed_for_page | eloqsql/storage/maria/ma_recovery_util.c | my_bool _ma_redo_not_needed_for_page(uint16 shortid, LSN lsn,
pgcache_page_no_t page,
my_bool index)
{
if (cmp_translog_addr(lsn, checkpoint_start) < 0)
{
/*
64-bit key is formed like this:
Most significant byte: 0 if data page, 1 if index page
Next 2 bytes: table's short id
Next 5 bytes: page number
*/
char llbuf[22];
uint64 file_and_page_id=
(((uint64)((index << 16) | shortid)) << 40) | page;
struct st_dirty_page *dirty_page= (struct st_dirty_page *)
my_hash_search(&all_dirty_pages,
(uchar *)&file_and_page_id, sizeof(file_and_page_id));
DBUG_PRINT("info", ("page %lld in dirty pages list: %d",
(ulonglong) page,
dirty_page != NULL));
if ((dirty_page == NULL) ||
cmp_translog_addr(lsn, dirty_page->rec_lsn) < 0)
{
tprint(tracef, ", ignoring page %s because of dirty_pages list\n",
llstr((ulonglong) page, llbuf));
return TRUE;
}
}
return FALSE;
} | O0 | c | ma_redo_not_needed_for_page:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movw %di, %cx
movq %fs:0x28, %rdi
movq %rdi, -0x8(%rbp)
movw %cx, -0x24(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdx, -0x38(%rbp)
movb %al, -0x39(%rbp)
movq -0x30(%rbp), %rax
subq 0xc1bd24(%rip), %rax # 0xc79378
cmpq $0x0, %rax
jge 0x5d6e2
movsbl -0x39(%rbp), %eax
shll $0x10, %eax
movzwl -0x24(%rbp), %ecx
orl %ecx, %eax
cltq
shlq $0x28, %rax
orq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xc1bd08(%rip), %rdi # 0xc79388
leaq -0x48(%rbp), %rsi
movl $0x8, %edx
callq 0xdda50
movq %rax, -0x50(%rbp)
jmp 0x5d694
cmpq $0x0, -0x50(%rbp)
je 0x5d6ad
movq -0x30(%rbp), %rax
movq -0x50(%rbp), %rcx
subq 0x8(%rcx), %rax
cmpq $0x0, %rax
jge 0x5d6e0
movq 0xc1bd44(%rip), %rax # 0xc793f8
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x14a0c0
movq -0x58(%rbp), %rdi
movq %rax, %rdx
leaq 0xf3f24(%rip), %rsi # 0x1515f7
movb $0x0, %al
callq 0x5d420
movb $0x1, -0x21(%rbp)
jmp 0x5d6e6
jmp 0x5d6e2
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x59(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x5d707
movb -0x59(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
callq 0x2a270
nopl (%rax)
| _ma_redo_not_needed_for_page:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, cl
mov cx, di
mov rdi, fs:28h
mov [rbp+var_8], rdi
mov [rbp+var_24], cx
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov [rbp+var_39], al
mov rax, [rbp+var_30]
sub rax, cs:checkpoint_start
cmp rax, 0
jge loc_5D6E2
movsx eax, [rbp+var_39]
shl eax, 10h
movzx ecx, [rbp+var_24]
or eax, ecx
cdqe
shl rax, 28h
or rax, [rbp+var_38]
mov [rbp+var_48], rax
lea rdi, all_dirty_pages
lea rsi, [rbp+var_48]
mov edx, 8
call my_hash_search
mov [rbp+var_50], rax
jmp short $+2
loc_5D694:
cmp [rbp+var_50], 0
jz short loc_5D6AD
mov rax, [rbp+var_30]
mov rcx, [rbp+var_50]
sub rax, [rcx+8]
cmp rax, 0
jge short loc_5D6E0
loc_5D6AD:
mov rax, cs:tracef
mov [rbp+var_58], rax
mov rdi, [rbp+var_38]
lea rsi, [rbp+var_20]
call llstr
mov rdi, [rbp+var_58]
mov rdx, rax
lea rsi, aIgnoringPageSB; ", ignoring page %s because of dirty_pag"...
mov al, 0
call tprint
mov [rbp+var_21], 1
jmp short loc_5D6E6
loc_5D6E0:
jmp short $+2
loc_5D6E2:
mov [rbp+var_21], 0
loc_5D6E6:
mov al, [rbp+var_21]
mov [rbp+var_59], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_5D707
mov al, [rbp+var_59]
add rsp, 60h
pop rbp
retn
loc_5D707:
call ___stack_chk_fail
| char ma_redo_not_needed_for_page(
unsigned __int16 a1,
long long a2,
long long a3,
char a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v12; // rax
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
char v19; // [rsp+0h] [rbp-60h]
long long v20; // [rsp+8h] [rbp-58h]
long long v21; // [rsp+10h] [rbp-50h]
long long v22; // [rsp+18h] [rbp-48h] BYREF
char v23; // [rsp+27h] [rbp-39h]
long long v24; // [rsp+28h] [rbp-38h]
long long v25; // [rsp+30h] [rbp-30h]
unsigned __int16 v26; // [rsp+3Ch] [rbp-24h]
_BYTE v28[24]; // [rsp+40h] [rbp-20h] BYREF
unsigned long long v29; // [rsp+58h] [rbp-8h]
v29 = __readfsqword(0x28u);
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
if ( a2 - checkpoint_start >= 0 )
return 0;
v22 = v24 | ((long long)(v26 | (v23 << 16)) << 40);
v21 = my_hash_search(&all_dirty_pages, &v22, 8LL);
if ( v21 )
{
if ( v25 - *(_QWORD *)(v21 + 8) >= 0 )
return 0;
}
v20 = tracef;
v12 = llstr(v24, v28);
tprint(
v20,
(long long)", ignoring page %s because of dirty_pages list\n",
v12,
v13,
v14,
v15,
a5,
a6,
a7,
a8,
v16,
v17,
a11,
a12,
v19);
return 1;
}
| _ma_redo_not_needed_for_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,CL
MOV CX,DI
MOV RDI,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RDI
MOV word ptr [RBP + -0x24],CX
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RBP + -0x39],AL
MOV RAX,qword ptr [RBP + -0x30]
SUB RAX,qword ptr [0x00d79378]
CMP RAX,0x0
JGE 0x0015d6e2
MOVSX EAX,byte ptr [RBP + -0x39]
SHL EAX,0x10
MOVZX ECX,word ptr [RBP + -0x24]
OR EAX,ECX
CDQE
SHL RAX,0x28
OR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[0xd79388]
LEA RSI,[RBP + -0x48]
MOV EDX,0x8
CALL 0x001dda50
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0015d694
LAB_0015d694:
CMP qword ptr [RBP + -0x50],0x0
JZ 0x0015d6ad
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,qword ptr [RCX + 0x8]
CMP RAX,0x0
JGE 0x0015d6e0
LAB_0015d6ad:
MOV RAX,qword ptr [0x00d793f8]
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x38]
LEA RSI,[RBP + -0x20]
CALL 0x0024a0c0
MOV RDI,qword ptr [RBP + -0x58]
MOV RDX,RAX
LEA RSI,[0x2515f7]
MOV AL,0x0
CALL 0x0015d420
MOV byte ptr [RBP + -0x21],0x1
JMP 0x0015d6e6
LAB_0015d6e0:
JMP 0x0015d6e2
LAB_0015d6e2:
MOV byte ptr [RBP + -0x21],0x0
LAB_0015d6e6:
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0x59],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0015d707
MOV AL,byte ptr [RBP + -0x59]
ADD RSP,0x60
POP RBP
RET
LAB_0015d707:
CALL 0x0012a270
|
int8
_ma_redo_not_needed_for_page(int2 param_1,long param_2,ulong param_3,int1 param_4)
{
int8 uVar1;
long lVar2;
int8 uVar3;
long in_FS_OFFSET;
ulong local_50;
int1 local_41;
ulong local_40;
long local_38;
int2 local_2c;
int1 local_29;
int1 local_28 [24];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_41 = param_4;
local_40 = param_3;
local_38 = param_2;
local_2c = param_1;
if (param_2 - checkpoint_start < 0) {
local_50 = (long)(int)CONCAT12(param_4,param_1) << 0x28 | param_3;
lVar2 = my_hash_search(all_dirty_pages,&local_50,8);
uVar1 = tracef;
if ((lVar2 == 0) || (local_38 - *(long *)(lVar2 + 8) < 0)) {
uVar3 = llstr(local_40,local_28);
tprint(uVar1,", ignoring page %s because of dirty_pages list\n",uVar3);
local_29 = 1;
goto LAB_0015d6e6;
}
}
local_29 = 0;
LAB_0015d6e6:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_29);
}
| |
39,471 | trnman_recreate_trn_from_recovery | eloqsql/storage/maria/trnman.c | TRN *trnman_recreate_trn_from_recovery(uint16 shortid, TrID longid)
{
TrID old_trid_generator= global_trid_generator;
TRN *trn;
DBUG_ASSERT(maria_in_recovery && !maria_multi_threaded);
global_trid_generator= longid-1; /* force a correct trid in the new trn */
if (unlikely((trn= trnman_new_trn(NULL)) == NULL))
return NULL;
/* deallocate excessive allocations of trnman_new_trn() */
global_trid_generator= old_trid_generator;
set_if_bigger(global_trid_generator, longid);
short_trid_to_active_trn[trn->short_id]= 0;
DBUG_ASSERT(short_trid_to_active_trn[shortid] == NULL);
short_trid_to_active_trn[shortid]= trn;
trn->short_id= shortid;
return trn;
} | O3 | c | trnman_recreate_trn_from_recovery:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
movq 0xbd4331(%rip), %r15 # 0xc01240
leaq -0x1(%rsi), %rax
movq %rax, 0xbd4326(%rip) # 0xc01240
xorl %edi, %edi
callq 0x619bc
testq %rax, %rax
je 0x2cf55
cmpq %r14, %r15
cmovaq %r15, %r14
movq %r14, 0xbd430c(%rip) # 0xc01240
movq 0xbd4025(%rip), %rcx # 0xc00f60
movzwl 0xac(%rax), %edx
andq $0x0, (%rcx,%rdx,8)
movzwl %bx, %edx
movq %rax, (%rcx,%rdx,8)
movw %dx, 0xac(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| trnman_recreate_trn_from_recovery:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov ebx, edi
mov r15, cs:global_trid_generator
lea rax, [rsi-1]
mov cs:global_trid_generator, rax
xor edi, edi
call trnman_new_trn
test rax, rax
jz short loc_2CF55
cmp r15, r14
cmova r14, r15
mov cs:global_trid_generator, r14
mov rcx, cs:short_trid_to_active_trn
movzx edx, word ptr [rax+0ACh]
and qword ptr [rcx+rdx*8], 0
movzx edx, bx
mov [rcx+rdx*8], rax
mov [rax+0ACh], dx
loc_2CF55:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long trnman_recreate_trn_from_recovery(unsigned __int16 a1, unsigned long long a2)
{
long long v2; // r14
unsigned long long v3; // r15
long long result; // rax
long long v5; // rcx
v2 = a2;
v3 = global_trid_generator;
global_trid_generator = a2 - 1;
result = trnman_new_trn(0LL);
if ( result )
{
if ( v3 > a2 )
v2 = v3;
global_trid_generator = v2;
v5 = short_trid_to_active_trn;
*(_QWORD *)(short_trid_to_active_trn + 8LL * *(unsigned __int16 *)(result + 172)) = 0LL;
*(_QWORD *)(v5 + 8LL * a1) = result;
*(_WORD *)(result + 172) = a1;
}
return result;
}
| trnman_recreate_trn_from_recovery:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV EBX,EDI
MOV R15,qword ptr [0x00d01240]
LEA RAX,[RSI + -0x1]
MOV qword ptr [0x00d01240],RAX
XOR EDI,EDI
CALL 0x001619bc
TEST RAX,RAX
JZ 0x0012cf55
CMP R15,R14
CMOVA R14,R15
MOV qword ptr [0x00d01240],R14
MOV RCX,qword ptr [0x00d00f60]
MOVZX EDX,word ptr [RAX + 0xac]
AND qword ptr [RCX + RDX*0x8],0x0
MOVZX EDX,BX
MOV qword ptr [RCX + RDX*0x8],RAX
MOV word ptr [RAX + 0xac],DX
LAB_0012cf55:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void trnman_recreate_trn_from_recovery(ushort param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
long lVar3;
uVar2 = global_trid_generator;
global_trid_generator = param_2 - 1;
lVar3 = trnman_new_trn(0);
lVar1 = short_trid_to_active_trn;
if (lVar3 != 0) {
global_trid_generator = param_2;
if (param_2 < uVar2) {
global_trid_generator = uVar2;
}
*(int8 *)(short_trid_to_active_trn + (ulong)*(ushort *)(lVar3 + 0xac) * 8) = 0;
*(long *)(lVar1 + (ulong)param_1 * 8) = lVar3;
*(ushort *)(lVar3 + 0xac) = param_1;
}
return;
}
| |
39,472 | 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::__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>>>>>::scan_comment() | llama.cpp/common/json.hpp | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
case '\r':
case char_traits<char_type>::eof():
case '\0':
return true;
default:
break;
}
}
}
// multi-line comments skip input until */ is read
case '*':
{
while (true)
{
switch (get())
{
case char_traits<char_type>::eof():
case '\0':
{
error_message = "invalid comment; missing closing '*/'";
return false;
}
case '*':
{
switch (get())
{
case '/':
return true;
default:
{
unget();
continue;
}
}
}
default:
continue;
}
}
}
// unexpected character after reading '/'
default:
{
error_message = "invalid comment; expecting '/' or '*' after '/'";
return false;
}
}
} | O3 | cpp | 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::__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>>>>>::scan_comment():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21688
cmpl $0x2f, %eax
je 0x857ed
cmpl $0x2a, %eax
jne 0x8580a
movq %rbx, %rdi
callq 0x21688
leal 0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x85813
cmpl $0x2a, %eax
jne 0x857c1
movq %rbx, %rdi
callq 0x21688
cmpl $0x2f, %eax
je 0x85806
movq %rbx, %rdi
callq 0x8607c
jmp 0x857c1
movl $0x4803, %ebp # imm = 0x4803
movq %rbx, %rdi
callq 0x21688
incl %eax
cmpl $0xf, %eax
jae 0x857f2
btl %eax, %ebp
jae 0x857f2
movb $0x1, %al
jmp 0x85820
leaq 0x93fc4(%rip), %rax # 0x1197d5
jmp 0x8581a
leaq 0x93f95(%rip), %rax # 0x1197af
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_commentEv:
push rbp
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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(void)
cmp eax, 2Fh ; '/'
jz short loc_857ED
cmp eax, 2Ah ; '*'
jnz short loc_8580A
loc_857C1:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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(void)
lea ecx, [rax+1]
cmp ecx, 2
jb short loc_85813
cmp eax, 2Ah ; '*'
jnz short loc_857C1
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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(void)
cmp eax, 2Fh ; '/'
jz short loc_85806
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; 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>>>::unget(void)
jmp short loc_857C1
loc_857ED:
mov ebp, 4803h
loc_857F2:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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(void)
inc eax
cmp eax, 0Fh
jnb short loc_857F2
bt ebp, eax
jnb short loc_857F2
loc_85806:
mov al, 1
jmp short loc_85820
loc_8580A:
lea rax, aInvalidComment; "invalid comment; expecting '/' or '*' a"...
jmp short loc_8581A
loc_85813:
lea rax, aInvalidComment_0; "invalid comment; missing closing '*/'"
loc_8581A:
mov [rbx+70h], rax
xor eax, eax
loc_85820:
add rsp, 8
pop rbx
pop rbp
retn
| char 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>>>::scan_comment(
__m128i *a1)
{
int v1; // eax
int v2; // eax
int v3; // ebp
unsigned int v4; // eax
const char *v6; // rax
v1 = 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(a1);
if ( v1 == 47 )
{
v3 = 18435;
do
{
do
v4 = 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(a1)
+ 1;
while ( v4 >= 0xF );
}
while ( !_bittest(&v3, v4) );
return 1;
}
else
{
if ( v1 == 42 )
{
while ( 1 )
{
v2 = 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(a1);
if ( (unsigned int)(v2 + 1) < 2 )
break;
if ( v2 == 42 )
{
if ( (unsigned int)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(a1) == 47 )
return 1;
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>>>::unget(a1);
}
}
v6 = "invalid comment; missing closing '*/'";
}
else
{
v6 = "invalid comment; expecting '/' or '*' after '/'";
}
a1[7].m128i_i64[0] = (long long)v6;
return 0;
}
}
| scan_comment:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00121688
CMP EAX,0x2f
JZ 0x001857ed
CMP EAX,0x2a
JNZ 0x0018580a
LAB_001857c1:
MOV RDI,RBX
CALL 0x00121688
LEA ECX,[RAX + 0x1]
CMP ECX,0x2
JC 0x00185813
CMP EAX,0x2a
JNZ 0x001857c1
MOV RDI,RBX
CALL 0x00121688
CMP EAX,0x2f
JZ 0x00185806
MOV RDI,RBX
CALL 0x0018607c
JMP 0x001857c1
LAB_001857ed:
MOV EBP,0x4803
LAB_001857f2:
MOV RDI,RBX
CALL 0x00121688
INC EAX
CMP EAX,0xf
JNC 0x001857f2
BT EBP,EAX
JNC 0x001857f2
LAB_00185806:
MOV AL,0x1
JMP 0x00185820
LAB_0018580a:
LEA RAX,[0x2197d5]
JMP 0x0018581a
LAB_00185813:
LEA RAX,[0x2197af]
LAB_0018581a:
MOV qword ptr [RBX + 0x70],RAX
XOR EAX,EAX
LAB_00185820:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* 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::__cxx11::string, 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 > > >::scan_comment() */
int8 __thiscall
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::__cxx11::string,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>>>
::scan_comment(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>>>
*this)
{
int iVar1;
int8 uVar2;
char *pcVar3;
iVar1 = get(this);
if (iVar1 == 0x2f) {
do {
do {
iVar1 = get(this);
} while (0xe < iVar1 + 1U);
} while ((0x4803U >> (iVar1 + 1U & 0x1f) & 1) == 0);
LAB_00185806:
uVar2 = 1;
}
else {
if (iVar1 == 0x2a) {
while (iVar1 = get(this), 1 < iVar1 + 1U) {
if (iVar1 == 0x2a) {
iVar1 = get(this);
if (iVar1 == 0x2f) goto LAB_00185806;
unget(this);
}
}
pcVar3 = "invalid comment; missing closing \'*/\'";
}
else {
pcVar3 = "invalid comment; expecting \'/\' or \'*\' after \'/\'";
}
*(char **)(this + 0x70) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
| |
39,473 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool):
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x18(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
andb $0x1, %cl
movb %cl, 0x13f(%rsp)
andb $0x1, %al
movb %al, 0x13e(%rsp)
movb $0x0, 0x13d(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0xd9dd0
movq 0x148(%rsp), %rdi
callq 0xd9ef0
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0x12e691
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x68(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xd9f20
jmp 0x12e6b6
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movzbl 0x13e(%rsp), %r9d
movzbl 0x13f(%rsp), %r8d
andl $0x1, %r8d
andl $0x1, %r9d
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rcx
callq 0xd9e10
jmp 0x12e6eb
movq 0x10(%rsp), %rdx
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
callq 0xd9fd0
jmp 0x12e701
leaq 0x70(%rsp), %rdi
callq 0xda6b0
leaq 0x30(%rsp), %rdi
callq 0xd9dc0
movb $0x1, 0x13d(%rsp)
testb $0x1, 0x13d(%rsp)
jne 0x12e777
jmp 0x12e76d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x12e784
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x12e761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xda6b0
leaq 0x30(%rsp), %rdi
callq 0xd9dc0
jmp 0x12e784
movq 0x10(%rsp), %rdi
callq 0xd9d90
movq 0x18(%rsp), %rax
addq $0x158, %rsp # imm = 0x158
retq
movq 0x10(%rsp), %rdi
callq 0xd9d90
movq 0x58(%rsp), %rdi
callq 0x5ebf0
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
sub rsp, 158h
mov [rsp+158h+var_150], rdx
mov [rsp+158h+var_148], rdi
mov al, r8b
mov r8, rdi
mov [rsp+158h+var_140], r8
mov [rsp+158h+var_8], rdi
mov [rsp+158h+var_10], rsi
mov [rsp+158h+var_18], rdx
and cl, 1
mov [rsp+158h+var_19], cl
and al, 1
mov [rsp+158h+var_1A], al
mov [rsp+158h+var_1B], 0
xor eax, eax
mov esi, eax
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))
mov rdi, [rsp+158h+var_10]
call _ZN8nlohmann16json_abi_v3_11_36detail13input_adapterINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS1_36container_input_adapter_factory_impl31container_input_adapter_factoryIT_vE12adapter_typeERKSB_; nlohmann::json_abi_v3_11_3::detail::input_adapter<std::string>(std::string const&)
mov [rsp+158h+var_138], rdx
mov [rsp+158h+var_130], rax
jmp short $+2
loc_12E691:
mov rsi, [rsp+158h+var_150]
mov rax, [rsp+158h+var_138]
mov rcx, [rsp+158h+var_130]
mov [rsp+158h+var_F8], rcx
mov [rsp+158h+var_F0], rax
lea rdi, [rsp+158h+var_128]
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&)
jmp short $+2
loc_12E6B6:
mov rsi, [rsp+158h+var_F8]
mov rdx, [rsp+158h+var_F0]
movzx r9d, [rsp+158h+var_1A]
movzx r8d, [rsp+158h+var_19]
and r8d, 1
and r9d, 1
lea rdi, [rsp+158h+var_E8]
lea rcx, [rsp+158h+var_128]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS9_EEEEEENSF_6parserISD_T_EESO_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,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,bool)
jmp short $+2
loc_12E6EB:
mov rdx, [rsp+158h+var_148]
lea rdi, [rsp+158h+var_E8]
mov esi, 1
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_; 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>>>::parse(bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
jmp short $+2
loc_12E701:
lea rdi, [rsp+158h+var_E8]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~parser()
lea rdi, [rsp+158h+var_128]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; 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()
mov [rsp+158h+var_1B], 1
test [rsp+158h+var_1B], 1
jnz short loc_12E777
jmp short loc_12E76D
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
jmp short loc_12E784
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
jmp short loc_12E761
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
lea rdi, [rsp+arg_68]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~parser()
loc_12E761:
lea rdi, [rsp+arg_28]
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEED2Ev; 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()
jmp short loc_12E784
loc_12E76D:
mov rdi, [rsp+158h+var_148]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_12E777:
mov rax, [rsp+158h+var_140]
add rsp, 158h
retn
loc_12E784:
mov rdi, [rsp+arg_8]
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, [rsp+arg_50]
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
long long a1,
long long a2,
long long a3,
char a4,
char a5)
{
long long v5; // rdx
_BYTE v8[48]; // [rsp+30h] [rbp-128h] BYREF
long long v9; // [rsp+60h] [rbp-F8h]
long long v10; // [rsp+68h] [rbp-F0h]
_BYTE v11[206]; // [rsp+70h] [rbp-E8h] BYREF
char v12; // [rsp+13Eh] [rbp-1Ah]
char v13; // [rsp+13Fh] [rbp-19h]
long long v14; // [rsp+140h] [rbp-18h]
long long v15; // [rsp+148h] [rbp-10h]
long long v16; // [rsp+150h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4 & 1;
v12 = a5 & 1;
v11[205] = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(a1);
v9 = nlohmann::json_abi_v3_11_3::detail::input_adapter<std::string>(a2);
v10 = v5;
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(
(std::_Function_base *)v8,
a3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(
(long long)v11,
v9,
v10,
(long long)v8,
v13 & 1,
v12 & 1);
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)v11,
1,
a1);
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>>>::~parser((std::_Function_base *)v11);
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((std::_Function_base *)v8);
return a1;
}
| |||
39,474 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x6adae
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6adae
movq (%r12), %r15
movq 0x8(%r12), %r12
movq %rsp, %rdi
movq %r13, %rsi
callq 0x6a784
addq %r15, %r12
movzbl %r14b, %r8d
movzbl %bpl, %r9d
leaq 0x20(%rsp), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x6a6d8
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x6a7e2
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x6b2e0
movq -0x18(%r14), %rax
testq %rax, %rax
je 0x6a657
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x6a66e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a6b2
jmp 0x6a6b2
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6ad80
jmp 0x6a699
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x6a6bd
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x6a6bd
movq %rax, %rdi
callq 0x25a95
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6adae
movq %rbx, %rdi
callq 0x70460
movq %r14, %rdi
callq 0x1bff0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRKS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov ebp, r8d
mov r14d, ecx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov byte ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r15, [r12]
mov r12, [r12+8]
mov rdi, rsp
mov rsi, r13
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&)
add r12, r15
movzx r8d, r14b
movzx r9d, bpl
lea rdi, [rsp+118h+var_F8]
mov rcx, rsp
mov rsi, r15
mov rdx, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS9_EEEEEENSF_6parserISD_T_EESO_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,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,bool)
lea rdi, [rsp+118h+var_F8]; int
mov esi, 1
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_; 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>>>::parse(bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
lea r14, [rsp+118h+var_D0]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~lexer()
mov rax, [r14-18h]
test rax, rax
jz short loc_6A657
lea rdi, [rsp+118h+var_F8]
mov rsi, rdi
mov edx, 3
call rax
loc_6A657:
mov rax, [rsp+118h+var_108]
test rax, rax
jz short loc_6A66E
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_6A66E:
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_6A6B2
jmp short loc_6A6B2
mov r14, rax
lea rdi, [rsp+118h+var_F8]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~parser()
jmp short loc_6A699
mov r14, rax
loc_6A699:
mov rax, [rsp+118h+var_108]
test rax, rax
jz short loc_6A6BD
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_6A6BD
loc_6A6B2:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
loc_6A6BD:
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string const&>(
long long a1,
long long *a2,
long long a3,
unsigned __int8 a4,
unsigned __int8 a5)
{
long long v8; // r15
long long v9; // r12
_BYTE v11[16]; // [rsp+0h] [rbp-118h] BYREF
void ( *v12)(_BYTE *, _BYTE *, long long); // [rsp+10h] [rbp-108h]
int v13[4]; // [rsp+20h] [rbp-F8h] BYREF
void ( *v14)(int *, int *, long long); // [rsp+30h] [rbp-E8h]
_BYTE v15[208]; // [rsp+48h] [rbp-D0h] BYREF
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1,
1LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1,
1LL);
v8 = *a2;
v9 = a2[1];
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(
v11,
a3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(
v13,
v8,
v8 + v9,
v11,
a4,
a5);
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((int)v13);
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>>>::~lexer(
v15,
1LL);
if ( v14 )
v14(v13, v13, 3LL);
if ( v12 )
v12(v11, v11, 3LL);
return a1;
}
| parse<std::__cxx11::string_const&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV EBP,R8D
MOV R14D,ECX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV byte ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV ESI,0x1
CALL 0x0016adae
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0016adae
MOV R15,qword ptr [R12]
MOV R12,qword ptr [R12 + 0x8]
LAB_0016a5f7:
MOV RDI,RSP
MOV RSI,R13
CALL 0x0016a784
ADD R12,R15
LAB_0016a605:
MOVZX R8D,R14B
MOVZX R9D,BPL
LEA RDI,[RSP + 0x20]
MOV RCX,RSP
MOV RSI,R15
MOV RDX,R12
CALL 0x0016a6d8
LAB_0016a620:
LEA RDI,[RSP + 0x20]
MOV ESI,0x1
MOV RDX,RBX
CALL 0x0016a7e2
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x0016b2e0
MOV RAX,qword ptr [R14 + -0x18]
TEST RAX,RAX
JZ 0x0016a657
LAB_0016a648:
LEA RDI,[RSP + 0x20]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0016a657:
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x0016a66e
LAB_0016a661:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0016a66e:
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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<std::__cxx11::string const&>(std::__cxx11::string const&,
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>&)>, bool, bool) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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<std::__cxx11::string_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>
*this,long *param_1,function *param_3,int1 param_4,int1 param_5)
{
long lVar1;
long lVar2;
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>&)>
afStack_118 [16];
code *local_108;
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_f8 [16];
code *local_e8;
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>>>
local_d0 [160];
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
*(int8 *)(this + 8) = 0;
assert_invariant(SUB81(this,0));
assert_invariant(SUB81(this,0));
lVar1 = *param_1;
lVar2 = param_1[1];
/* try { // try from 0016a5f7 to 0016a601 has its CatchHandler @ 0016a6ba */
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(afStack_118,param_3);
/* try { // try from 0016a605 to 0016a61f has its CatchHandler @ 0016a696 */
parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
(local_f8,lVar1,lVar2 + lVar1,afStack_118,param_4,param_5);
/* try { // try from 0016a620 to 0016a631 has its CatchHandler @ 0016a687 */
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(local_f8,true,(basic_json *)this);
detail::
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>>>
::~lexer(local_d0);
if (local_e8 != (code *)0x0) {
/* try { // try from 0016a648 to 0016a656 has its CatchHandler @ 0016a685 */
(*local_e8)(local_f8,local_f8,3);
}
if (local_108 != (code *)0x0) {
/* try { // try from 0016a661 to 0016a66d has its CatchHandler @ 0016a683 */
(*local_108)(afStack_118,afStack_118,3);
}
return this;
}
| |
39,475 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
xorl %esi, %esi
callq 0x4d9e0
movq (%r12), %r15
movq 0x8(%r12), %r12
movq %rsp, %rdi
movq %r13, %rsi
callq 0x4da80
addq %r15, %r12
movzbl %r14b, %r8d
movzbl %bpl, %r9d
leaq 0x20(%rsp), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x4da00
leaq 0x20(%rsp), %rdi
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x4dac6
leaq 0x20(%rsp), %rdi
callq 0x4de90
movq %rsp, %rdi
callq 0x2f504
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x4de90
jmp 0x6c0ee
movq %rax, %r14
movq %rsp, %rdi
callq 0x2f504
jmp 0x6c0fb
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d9cc
movq %r14, %rdi
callq 0x24fe0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov ebp, r8d
mov r14d, ecx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
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))
mov r15, [r12]
mov r12, [r12+8]
mov rdi, rsp
mov rsi, r13
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&)
add r12, r15
movzx r8d, r14b
movzx r9d, bpl
lea rdi, [rsp+118h+var_F8]
mov rcx, rsp
mov rsi, r15
mov rdx, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS9_EEEEEENSF_6parserISD_T_EESO_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,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,bool)
lea rdi, [rsp+118h+var_F8]
push 1
pop rsi
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_; 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>>>::parse(bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
lea rdi, [rsp+118h+var_F8]; this
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~parser()
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rdi, [rsp+arg_18]; this
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~parser()
jmp short loc_6C0EE
mov r14, rax
loc_6C0EE:
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_6C0FB
mov r14, rax
loc_6C0FB:
mov rdi, rbx
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 __Unwind_Resume
| _BYTE * nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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<std::string&>(
_BYTE *a1,
long long *a2,
long long a3,
unsigned __int8 a4,
unsigned __int8 a5)
{
long long v8; // r15
long long v9; // r12
int v10; // ecx
int v11; // r8d
int v12; // r9d
__int128 v14[2]; // [rsp+0h] [rbp-118h] BYREF
_BYTE v15[248]; // [rsp+20h] [rbp-F8h] BYREF
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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);
v8 = *a2;
v9 = a2[1];
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(
v14,
a3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(
(long long)v15,
v8,
v8 + v9,
v14,
a4,
a5);
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)v15,
1,
a1,
v10,
v11,
v12);
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>>>::~parser((std::_Function_base *)v15);
std::_Function_base::~_Function_base((std::_Function_base *)v14);
return a1;
}
| parse<std::__cxx11::string&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV EBP,R8D
MOV R14D,ECX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
XOR ESI,ESI
CALL 0x0014d9e0
MOV R15,qword ptr [R12]
MOV R12,qword ptr [R12 + 0x8]
LAB_0016c07c:
MOV RDI,RSP
MOV RSI,R13
CALL 0x0014da80
ADD R12,R15
LAB_0016c08a:
MOVZX R8D,R14B
MOVZX R9D,BPL
LEA RDI,[RSP + 0x20]
MOV RCX,RSP
MOV RSI,R15
MOV RDX,R12
CALL 0x0014da00
LAB_0016c0a5:
LEA RDI,[RSP + 0x20]
PUSH 0x1
POP RSI
MOV RDX,RBX
CALL 0x0014dac6
LAB_0016c0b5:
LEA RDI,[RSP + 0x20]
CALL 0x0014de90
MOV RDI,RSP
CALL 0x0012f504
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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<std::__cxx11::string&>(std::__cxx11::string&, 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>&)>, bool, bool) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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<std::__cxx11::string&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,long *param_1,function *param_3,int1 param_4,int1 param_5)
{
long lVar1;
long lVar2;
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>&)>
afStack_118 [32];
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_f8 [200];
basic_json((_func_decltype_nullptr *)this);
lVar1 = *param_1;
lVar2 = param_1[1];
/* try { // try from 0016c07c to 0016c086 has its CatchHandler @ 0016c0f8 */
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(afStack_118,param_3);
/* try { // try from 0016c08a to 0016c0a4 has its CatchHandler @ 0016c0eb */
parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
(local_f8,lVar1,lVar2 + lVar1,afStack_118,param_4,param_5);
/* try { // try from 0016c0a5 to 0016c0b4 has its CatchHandler @ 0016c0dc */
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(local_f8,true,this);
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>>>
::~parser(local_f8);
std::_Function_base::~_Function_base((_Function_base *)afStack_118);
return this;
}
| |
39,476 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_WARN_UNUSED_RESULT
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false)
{
basic_json result;
parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::parse<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::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::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, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movb $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x1, %esi
callq 0x6b800
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6b800
movq (%r12), %r15
movq 0x8(%r12), %r12
movq %rsp, %rdi
movq %r13, %rsi
callq 0x6b1a2
addq %r15, %r12
movzbl %r14b, %r8d
movzbl %bpl, %r9d
leaq 0x20(%rsp), %rdi
movq %rsp, %rcx
movq %r15, %rsi
movq %r12, %rdx
callq 0x6b0f6
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x6b200
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x6bd32
movq -0x18(%r14), %rax
testq %rax, %rax
je 0x91d4f
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x91d66
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x91daa
jmp 0x91daa
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x6b7d2
jmp 0x91d91
movq %rax, %r14
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x91db5
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x91db5
movq %rax, %rdi
callq 0x259fd
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6b800
movq %rbx, %rdi
callq 0x70bac
movq %r14, %rdi
callq 0x1bff0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5parseIRS9_EESD_OT_St8functionIFbiNS0_6detail13parse_event_tERSD_EEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov ebp, r8d
mov r14d, ecx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov byte ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r15, [r12]
mov r12, [r12+8]
mov rdi, rsp
mov rsi, r13
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&)
add r12, r15
movzx r8d, r14b
movzx r9d, bpl
lea rdi, [rsp+118h+var_F8]
mov rcx, rsp
mov rsi, r15
mov rdx, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6parserINS0_6detail22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcS9_EEEEEENSF_6parserISD_T_EESO_St8functionIFbiNSF_13parse_event_tERSD_EEbb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>,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,bool)
lea rdi, [rsp+118h+var_F8]; int
mov esi, 1
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_; 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>>>::parse(bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
lea r14, [rsp+118h+var_D0]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~lexer()
mov rax, [r14-18h]
test rax, rax
jz short loc_91D4F
lea rdi, [rsp+118h+var_F8]
mov rsi, rdi
mov edx, 3
call rax
loc_91D4F:
mov rax, [rsp+118h+var_108]
test rax, rax
jz short loc_91D66
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_91D66:
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_91DAA
jmp short loc_91DAA
mov r14, rax
lea rdi, [rsp+118h+var_F8]
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; 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>>>::~parser()
jmp short loc_91D91
mov r14, rax
loc_91D91:
mov rax, [rsp+118h+var_108]
test rax, rax
jz short loc_91DB5
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_91DB5
loc_91DAA:
mov rdi, rax
call __clang_call_terminate
mov r14, rax
loc_91DB5:
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parse<std::string&>(
long long a1,
long long *a2,
long long a3,
unsigned __int8 a4,
unsigned __int8 a5)
{
long long v8; // r15
long long v9; // r12
__int128 v11; // [rsp+0h] [rbp-118h] BYREF
void ( *v12)(__int128 *, __int128 *, long long); // [rsp+10h] [rbp-108h]
int v13[4]; // [rsp+20h] [rbp-F8h] BYREF
void ( *v14)(int *, int *, long long); // [rsp+30h] [rbp-E8h]
_QWORD v15[26]; // [rsp+48h] [rbp-D0h] BYREF
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
v8 = *a2;
v9 = a2[1];
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(
&v11,
a3);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>(
(long long)v13,
v8,
v8 + v9,
&v11,
a4,
a5);
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)v13,
1,
(_BYTE *)a1);
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>>>::~lexer(v15);
if ( v14 )
v14(v13, v13, 3LL);
if ( v12 )
v12(&v11, &v11, 3LL);
return a1;
}
| parse<std::__cxx11::string&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV EBP,R8D
MOV R14D,ECX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV byte ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV ESI,0x1
CALL 0x0016b800
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0016b800
MOV R15,qword ptr [R12]
MOV R12,qword ptr [R12 + 0x8]
LAB_00191cef:
MOV RDI,RSP
MOV RSI,R13
CALL 0x0016b1a2
ADD R12,R15
LAB_00191cfd:
MOVZX R8D,R14B
MOVZX R9D,BPL
LEA RDI,[RSP + 0x20]
MOV RCX,RSP
MOV RSI,R15
MOV RDX,R12
CALL 0x0016b0f6
LAB_00191d18:
LEA RDI,[RSP + 0x20]
MOV ESI,0x1
MOV RDX,RBX
CALL 0x0016b200
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x0016bd32
MOV RAX,qword ptr [R14 + -0x18]
TEST RAX,RAX
JZ 0x00191d4f
LAB_00191d40:
LEA RDI,[RSP + 0x20]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00191d4f:
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x00191d66
LAB_00191d59:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_00191d66:
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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<std::__cxx11::string&>(std::__cxx11::string&, 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>&)>, bool, bool) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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<std::__cxx11::string&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,long *param_1,function *param_3,int1 param_4,int1 param_5)
{
long lVar1;
long lVar2;
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>&)>
afStack_118 [16];
code *local_108;
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_f8 [16];
code *local_e8;
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>>>
local_d0 [160];
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
*(int8 *)(this + 8) = 0;
assert_invariant(SUB81(this,0));
assert_invariant(SUB81(this,0));
lVar1 = *param_1;
lVar2 = param_1[1];
/* try { // try from 00191cef to 00191cf9 has its CatchHandler @ 00191db2 */
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(afStack_118,param_3);
/* try { // try from 00191cfd to 00191d17 has its CatchHandler @ 00191d8e */
parser<nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
(local_f8,lVar1,lVar2 + lVar1,afStack_118,param_4,param_5);
/* try { // try from 00191d18 to 00191d29 has its CatchHandler @ 00191d7f */
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(local_f8,true,(basic_json *)this);
detail::
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>>>
::~lexer(local_d0);
if (local_e8 != (code *)0x0) {
/* try { // try from 00191d40 to 00191d4e has its CatchHandler @ 00191d7d */
(*local_e8)(local_f8,local_f8,3);
}
if (local_108 != (code *)0x0) {
/* try { // try from 00191d59 to 00191d65 has its CatchHandler @ 00191d7b */
(*local_108)(afStack_118,afStack_118,3);
}
return this;
}
| |
39,477 | testing::internal::UnitTestImpl::ConfigureXmlOutput() | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format == "json") {
listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format != "") {
GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
<< output_format << "\" ignored.";
}
} | O1 | cpp | testing::internal::UnitTestImpl::ConfigureXmlOutput():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x1ecc0
leaq 0xf2f7(%rip), %rsi # 0x4110c
movq %r14, %rdi
callq 0x9160
testl %eax, %eax
je 0x31ebf
leaq 0x11d01(%rip), %rsi # 0x43b2d
leaq 0x20(%rsp), %rdi
callq 0x9160
testl %eax, %eax
je 0x31ef9
leaq 0x117ab(%rip), %rsi # 0x435f0
leaq 0x20(%rsp), %rdi
callq 0x9160
testl %eax, %eax
je 0x31f4c
leaq 0x10b9d(%rip), %rdx # 0x429fb
movq %rsp, %rdi
movl $0x1, %esi
movl $0x15db, %ecx # imm = 0x15DB
callq 0x1b13e
movq 0x28171(%rip), %rdi # 0x59fe8
leaq 0x11cb4(%rip), %rsi # 0x43b32
movl $0x25, %edx
callq 0x95a0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x2814f(%rip), %rdi # 0x59fe8
callq 0x95a0
leaq 0x11cb3(%rip), %rsi # 0x43b58
movl $0xa, %edx
movq %rax, %rdi
callq 0x95a0
movq %rsp, %rdi
callq 0x1b280
jmp 0x31f4c
movl $0x28, %edi
callq 0x9490
movq %rax, %r14
movq %rsp, %rdi
callq 0x1ed86
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x28192
addq $0x1f8, %rbx # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30d28
jmp 0x31f31
movl $0x28, %edi
callq 0x9490
movq %rax, %r14
movq %rsp, %rdi
callq 0x1ed86
movb $0x1, %bpl
movq (%rsp), %rsi
movq %r14, %rdi
callq 0x2c678
addq $0x1f8, %rbx # imm = 0x1F8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x30d28
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31f4c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31f67
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x94c0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x31f74
jmp 0x31f7e
movq %rax, %rbx
movb $0x1, %bpl
jmp 0x31fae
jmp 0x31f90
movq %rax, %rbx
jmp 0x31fc0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b280
jmp 0x31fc0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31fae
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x94c0
testb %bpl, %bpl
je 0x31fc0
movl $0x28, %esi
movq %r14, %rdi
callq 0x94c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x31fdb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rdi
callq 0x99a0
nop
| _ZN7testing8internal12UnitTestImpl18ConfigureXmlOutputEv:
push rbp; __int64
push r14; int
push rbx; void *
sub rsp, 40h
mov rbx, rdi
lea r14, [rsp+58h+var_38]
mov rdi, r14; int
call _ZN7testing8internal15UnitTestOptions15GetOutputFormatB5cxx11Ev; testing::internal::UnitTestOptions::GetOutputFormat(void)
lea rsi, aXml_0; "xml"
mov rdi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_31EBF
lea rsi, aJson; "json"
lea rdi, [rsp+58h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_31EF9
lea rsi, aSFromSSMsTotal+1Ah; ""
lea rdi, [rsp+58h+var_38]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz loc_31F4C
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov rdi, rsp
mov esi, 1
mov ecx, 15DBh
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aWarningUnrecog; "WARNING: unrecognized output format \""
mov edx, 25h ; '%'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, qword ptr [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aIgnored; "\" ignored."
mov edx, 0Ah
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, rsp; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp loc_31F4C
loc_31EBF:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rsp; int
call _ZN7testing8internal15UnitTestOptions27GetAbsolutePathToOutputFileB5cxx11Ev; testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(void)
mov bpl, 1
mov rsi, [rsp+58h+var_58]; char *
mov rdi, r14; this
call _ZN7testing8internal24XmlUnitTestResultPrinterC2EPKc; testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*)
add rbx, 1F8h
xor ebp, ebp
mov rdi, rbx; this
mov rsi, r14; testing::TestEventListener *
call _ZN7testing18TestEventListeners22SetDefaultXmlGeneratorEPNS_17TestEventListenerE; testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener *)
jmp short loc_31F31
loc_31EF9:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rsp; int
call _ZN7testing8internal15UnitTestOptions27GetAbsolutePathToOutputFileB5cxx11Ev; testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile(void)
mov bpl, 1
mov rsi, [rsp+58h+var_58]; char *
mov rdi, r14; this
call _ZN7testing8internal25JsonUnitTestResultPrinterC2EPKc; testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(char const*)
add rbx, 1F8h
xor ebp, ebp
mov rdi, rbx; this
mov rsi, r14; testing::TestEventListener *
call _ZN7testing18TestEventListeners22SetDefaultXmlGeneratorEPNS_17TestEventListenerE; testing::TestEventListeners::SetDefaultXmlGenerator(testing::TestEventListener *)
loc_31F31:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_31F4C
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_31F4C:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_31F67
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_31F67:
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
jmp short loc_31F74
jmp short loc_31F7E
loc_31F74:
mov rbx, rax
mov bpl, 1
jmp short loc_31FAE
jmp short loc_31F90
loc_31F7E:
mov rbx, rax
jmp short loc_31FC0
mov rbx, rax
mov rdi, rsp; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_31FC0
loc_31F90:
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_31FAE
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_31FAE:
test bpl, bpl
jz short loc_31FC0
mov esi, 28h ; '('; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_31FC0:
lea rax, [rsp+arg_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_31FDB
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_31FDB:
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::UnitTestImpl::ConfigureXmlOutput(testing::internal::UnitTestImpl *this)
{
long long v1; // rax
testing::internal::XmlUnitTestResultPrinter *v2; // r14
testing::internal::JsonUnitTestResultPrinter *v3; // r14
char *v4[2]; // [rsp+0h] [rbp-58h] BYREF
long long v5; // [rsp+10h] [rbp-48h] BYREF
int v6[2]; // [rsp+20h] [rbp-38h] BYREF
long long v7; // [rsp+28h] [rbp-30h]
long long v8; // [rsp+30h] [rbp-28h] BYREF
testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11](v6);
if ( !(unsigned int)std::string::compare(v6, "xml") )
{
v2 = (testing::internal::XmlUnitTestResultPrinter *)operator new(0x28uLL);
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11](v4);
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(v2, v4[0]);
testing::TestEventListeners::SetDefaultXmlGenerator((testing::internal::UnitTestImpl *)((char *)this + 504), v2);
}
else
{
if ( (unsigned int)std::string::compare(v6, "json") )
{
if ( (unsigned int)std::string::compare(v6, "") )
{
testing::internal::GTestLog::GTestLog(
v4,
1,
"/workspace/llm4binary/github/2025_star3/seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc",
5595);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "WARNING: unrecognized output format \"", 37LL);
v1 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *(_QWORD *)v6, v7);
std::__ostream_insert<char,std::char_traits<char>>(v1, "\" ignored.", 10LL);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)v4);
}
goto LABEL_9;
}
v3 = (testing::internal::JsonUnitTestResultPrinter *)operator new(0x28uLL);
testing::internal::UnitTestOptions::GetAbsolutePathToOutputFile[abi:cxx11](v4);
testing::internal::JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(v3, v4[0]);
testing::TestEventListeners::SetDefaultXmlGenerator((testing::internal::UnitTestImpl *)((char *)this + 504), v3);
}
if ( (long long *)v4[0] != &v5 )
operator delete(v4[0], v5 + 1);
LABEL_9:
if ( *(long long **)v6 != &v8 )
operator delete(*(void **)v6, v8 + 1);
}
| ConfigureXmlOutput:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x0011ecc0
LEA RSI,[0x14110c]
MOV RDI,R14
CALL 0x00109160
TEST EAX,EAX
JZ 0x00131ebf
LEA RSI,[0x143b2d]
LEA RDI,[RSP + 0x20]
CALL 0x00109160
TEST EAX,EAX
JZ 0x00131ef9
LEA RSI,[0x1435f0]
LEA RDI,[RSP + 0x20]
CALL 0x00109160
TEST EAX,EAX
JZ 0x00131f4c
LAB_00131e57:
LEA RDX,[0x1429fb]
MOV RDI,RSP
MOV ESI,0x1
MOV ECX,0x15db
CALL 0x0011b13e
LAB_00131e70:
MOV RDI,qword ptr [0x00159fe8]
LEA RSI,[0x143b32]
MOV EDX,0x25
CALL 0x001095a0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [0x00159fe8]
CALL 0x001095a0
LEA RSI,[0x143b58]
MOV EDX,0xa
MOV RDI,RAX
CALL 0x001095a0
MOV RDI,RSP
CALL 0x0011b280
JMP 0x00131f4c
LAB_00131ebf:
MOV EDI,0x28
CALL 0x00109490
LAB_00131ec9:
MOV R14,RAX
MOV RDI,RSP
CALL 0x0011ed86
MOV BPL,0x1
MOV RSI,qword ptr [RSP]
LAB_00131edb:
MOV RDI,R14
CALL 0x00128192
ADD RBX,0x1f8
XOR EBP,EBP
MOV RDI,RBX
MOV RSI,R14
CALL 0x00130d28
JMP 0x00131f31
LAB_00131ef9:
MOV EDI,0x28
CALL 0x00109490
LAB_00131f03:
MOV R14,RAX
MOV RDI,RSP
CALL 0x0011ed86
MOV BPL,0x1
MOV RSI,qword ptr [RSP]
LAB_00131f15:
MOV RDI,R14
CALL 0x0012c678
ADD RBX,0x1f8
XOR EBP,EBP
MOV RDI,RBX
MOV RSI,R14
CALL 0x00130d28
LAB_00131f31:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00131f4c
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001094c0
LAB_00131f4c:
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00131f67
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001094c0
LAB_00131f67:
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* testing::internal::UnitTestImpl::ConfigureXmlOutput() */
void __thiscall testing::internal::UnitTestImpl::ConfigureXmlOutput(UnitTestImpl *this)
{
int iVar1;
ostream *poVar2;
XmlUnitTestResultPrinter *this_00;
JsonUnitTestResultPrinter *this_01;
long *local_58 [2];
long local_48 [2];
long *local_38;
long local_30;
long local_28 [2];
UnitTestOptions::GetOutputFormat_abi_cxx11_((UnitTestOptions *)&local_38);
iVar1 = std::__cxx11::string::compare((char *)&local_38);
if (iVar1 == 0) {
/* try { // try from 00131ebf to 00131ec8 has its CatchHandler @ 00131f7e */
this_00 = (XmlUnitTestResultPrinter *)operator_new(0x28);
/* try { // try from 00131ec9 to 00131ed3 has its CatchHandler @ 00131f74 */
UnitTestOptions::GetAbsolutePathToOutputFile_abi_cxx11_((UnitTestOptions *)local_58);
/* try { // try from 00131edb to 00131ef6 has its CatchHandler @ 00131f90 */
XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(this_00,(char *)local_58[0]);
TestEventListeners::SetDefaultXmlGenerator
((TestEventListeners *)(this + 0x1f8),(TestEventListener *)this_00);
}
else {
iVar1 = std::__cxx11::string::compare((char *)&local_38);
if (iVar1 != 0) {
iVar1 = std::__cxx11::string::compare((char *)&local_38);
if (iVar1 != 0) {
/* try { // try from 00131e57 to 00131e6f has its CatchHandler @ 00131f72 */
GTestLog::GTestLog((GTestLog *)local_58,1,
"/workspace/llm4binary/github/2025_star3/seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc"
,0x15db);
/* try { // try from 00131e70 to 00131eb1 has its CatchHandler @ 00131f83 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00159fe8,"WARNING: unrecognized output format \"",0x25);
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00159fe8,(char *)local_38,local_30);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"\" ignored.",10);
GTestLog::~GTestLog((GTestLog *)local_58);
}
goto LAB_00131f4c;
}
/* try { // try from 00131ef9 to 00131f02 has its CatchHandler @ 00131f7e */
this_01 = (JsonUnitTestResultPrinter *)operator_new(0x28);
/* try { // try from 00131f03 to 00131f0d has its CatchHandler @ 00131f70 */
UnitTestOptions::GetAbsolutePathToOutputFile_abi_cxx11_((UnitTestOptions *)local_58);
/* try { // try from 00131f15 to 00131f30 has its CatchHandler @ 00131f7c */
JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(this_01,(char *)local_58[0]);
TestEventListeners::SetDefaultXmlGenerator
((TestEventListeners *)(this + 0x1f8),(TestEventListener *)this_01);
}
if (local_58[0] != local_48) {
operator_delete(local_58[0],local_48[0] + 1);
}
LAB_00131f4c:
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return;
}
| |
39,478 | ftxui::Screen::ToString[abi:cxx11]() const | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/screen/screen.cpp | std::string Screen::ToString() const {
std::stringstream ss;
const Pixel default_pixel;
const Pixel* previous_pixel_ref = &default_pixel;
for (int y = 0; y < dimy_; ++y) {
// New line in between two lines.
if (y != 0) {
UpdatePixelStyle(this, ss, *previous_pixel_ref, default_pixel);
previous_pixel_ref = &default_pixel;
ss << "\r\n";
}
// After printing a fullwith character, we need to skip the next cell.
bool previous_fullwidth = false;
for (const auto& pixel : pixels_[y]) {
if (!previous_fullwidth) {
UpdatePixelStyle(this, ss, *previous_pixel_ref, pixel);
previous_pixel_ref = &pixel;
ss << pixel.character;
}
previous_fullwidth = (string_width(pixel.character) == 2);
}
}
// Reset the style to default:
UpdatePixelStyle(this, ss, *previous_pixel_ref, default_pixel);
return ss.str();
} | O1 | cpp | ftxui::Screen::ToString[abi:cxx11]() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xb2a0
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x32be6
cmpl $0x0, 0x14(%r14)
jle 0x39f6a
leaq 0x10(%rsp), %rdx
xorl %r12d, %r12d
leaq 0x40(%rsp), %r13
testq %r12, %r12
je 0x39ee8
movq %r14, %rdi
movq %r13, %rsi
leaq 0x10(%rsp), %rcx
callq 0x3a02c
movl $0x2, %edx
leaq 0x50(%rsp), %rdi
leaq 0x3d01(%rip), %rsi # 0x3dbdf
callq 0xb490
leaq 0x10(%rsp), %rdx
movq 0x18(%r14), %rax
leaq (%r12,%r12,2), %rcx
movq (%rax,%rcx,8), %rbp
movq 0x8(%rax,%rcx,8), %r15
cmpq %r15, %rbp
je 0x39f54
addq $0x8, %rbp
xorl %eax, %eax
testb $0x1, %al
je 0x39f0d
movq %rdx, %rbx
jmp 0x39f31
leaq -0x8(%rbp), %rbx
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rcx
callq 0x3a02c
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
leaq 0x50(%rsp), %rdi
callq 0xb490
movq %rbp, %rdi
callq 0x3b662
cmpl $0x2, %eax
sete %al
leaq 0x30(%rbp), %rcx
addq $0x28, %rbp
movq %rbx, %rdx
cmpq %r15, %rbp
movq %rcx, %rbp
jne 0x39f04
jmp 0x39f57
movq %rdx, %rbx
incq %r12
movslq 0x14(%r14), %rax
movq %rbx, %rdx
cmpq %rax, %r12
jl 0x39eb8
leaq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3a02c
movq 0x8(%rsp), %rbx
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0xb6b0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x39fac
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x1ffbd(%rip), %rsi # 0x59f70
leaq 0x40(%rsp), %rdi
callq 0xb2e0
leaq 0xc0(%rsp), %rdi
callq 0xb120
movq %rbx, %rax
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3a006
jmp 0x39fe8
jmp 0x39fe8
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a006
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb400
movq 0x1ff63(%rip), %rsi # 0x59f70
leaq 0x40(%rsp), %rdi
callq 0xb2e0
leaq 0xc0(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xb780
| _ZNK5ftxui6Screen8ToStringB5cxx11Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1C8h
mov r14, rsi
mov [rsp+1F8h+var_1F0], rdi
lea rdi, [rsp+1F8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rbx, [rsp+1F8h+var_1E8]
mov rdi, rbx; this
call _ZN5ftxui5PixelC2Ev; ftxui::Pixel::Pixel(void)
cmp dword ptr [r14+14h], 0
jle loc_39F6A
lea rdx, [rsp+1F8h+var_1E8]
xor r12d, r12d
lea r13, [rsp+1F8h+var_1B8]
loc_39EB8:
test r12, r12
jz short loc_39EE8
mov rdi, r14
mov rsi, r13
lea rcx, [rsp+1F8h+var_1E8]
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD_; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&)
mov edx, 2
lea rdi, [rsp+1F8h+var_1A8]
lea rsi, asc_3DBDF; "\r\n"
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdx, [rsp+1F8h+var_1E8]
loc_39EE8:
mov rax, [r14+18h]
lea rcx, [r12+r12*2]
mov rbp, [rax+rcx*8]
mov r15, [rax+rcx*8+8]
cmp rbp, r15
jz short loc_39F54
add rbp, 8
xor eax, eax
loc_39F04:
test al, 1
jz short loc_39F0D
mov rbx, rdx
jmp short loc_39F31
loc_39F0D:
lea rbx, [rbp-8]
mov rdi, r14
mov rsi, r13
mov rcx, rbx
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD_; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&)
mov rsi, [rbp+0]
mov rdx, [rbp+8]
lea rdi, [rsp+1F8h+var_1A8]
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_39F31:
mov rdi, rbp
call _ZN5ftxui12string_widthERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; ftxui::string_width(std::string const&)
cmp eax, 2
setz al
lea rcx, [rbp+30h]
add rbp, 28h ; '('
mov rdx, rbx
cmp rbp, r15
mov rbp, rcx
jnz short loc_39F04
jmp short loc_39F57
loc_39F54:
mov rbx, rdx
loc_39F57:
inc r12
movsxd rax, dword ptr [r14+14h]
mov rdx, rbx
cmp r12, rax
jl loc_39EB8
loc_39F6A:
lea rsi, [rsp+1F8h+var_1B8]
lea rcx, [rsp+1F8h+var_1E8]
mov rdi, r14
mov rdx, rbx
call _ZN5ftxui12_GLOBAL__N_116UpdatePixelStyleEPKNS_6ScreenERNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEERKNS_5PixelESD_; ftxui::`anonymous namespace'::UpdatePixelStyle(ftxui::Screen const*,std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> &,ftxui::Pixel const&,ftxui::Pixel const&)
mov rbx, [rsp+1F8h+var_1F0]
lea rsi, [rsp+1F8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rax, [rsp+1F8h+var_1D0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_39FAC
mov rsi, [rsp+1F8h+var_1D0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_39FAC:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1F8h+var_1B8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1F8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 1C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_3A006
jmp short loc_39FE8
jmp short $+2
loc_39FE8:
mov rbx, rax
lea rax, [rsp+arg_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3A006
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3A006:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_38]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_B8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long ftxui::Screen::ToString[abi:cxx11](long long a1, long long a2)
{
char *v2; // rbx
char *v3; // rdx
long long v4; // r12
long long v5; // rax
_QWORD *v6; // rbp
_QWORD *v7; // r15
_QWORD *v8; // rbp
bool v9; // al
bool v10; // zf
char v12[8]; // [rsp+10h] [rbp-1E8h] BYREF
long long *v13; // [rsp+18h] [rbp-1E0h]
long long v14; // [rsp+28h] [rbp-1D0h] BYREF
_BYTE v15[16]; // [rsp+40h] [rbp-1B8h] BYREF
char v16[8]; // [rsp+50h] [rbp-1A8h] BYREF
char v17[104]; // [rsp+58h] [rbp-1A0h] BYREF
char v18[312]; // [rsp+C0h] [rbp-138h] BYREF
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v15);
v2 = v12;
ftxui::Pixel::Pixel((ftxui::Pixel *)v12);
if ( *(int *)(a2 + 20) > 0 )
{
v3 = v12;
v4 = 0LL;
do
{
if ( v4 )
{
ftxui::`anonymous namespace'::UpdatePixelStyle(a2, v15, v3, v12);
std::__ostream_insert<char,std::char_traits<char>>(v16, "\r\n", 2LL);
v3 = v12;
}
v5 = *(_QWORD *)(a2 + 24);
v6 = *(_QWORD **)(v5 + 24 * v4);
v7 = *(_QWORD **)(v5 + 24 * v4 + 8);
if ( v6 == v7 )
{
v2 = v3;
}
else
{
v8 = v6 + 1;
v9 = 0;
do
{
if ( v9 )
{
v2 = v3;
}
else
{
v2 = (char *)(v8 - 1);
ftxui::`anonymous namespace'::UpdatePixelStyle(a2, v15, v3, v8 - 1);
std::__ostream_insert<char,std::char_traits<char>>(v16, *v8, v8[1]);
}
v9 = (unsigned int)ftxui::string_width(v8) == 2;
v3 = v2;
v10 = v8 + 5 == v7;
v8 += 6;
}
while ( !v10 );
}
++v4;
v3 = v2;
}
while ( v4 < *(int *)(a2 + 20) );
}
ftxui::`anonymous namespace'::UpdatePixelStyle(a2, v15, v2, v12);
std::stringbuf::str(a1, v17);
if ( v13 != &v14 )
operator delete(v13, v14 + 1);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v15,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v18);
return a1;
}
| ToString[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1c8
MOV R14,RSI
MOV qword ptr [RSP + 0x8],RDI
LEA RDI,[RSP + 0x40]
CALL 0x0010b2a0
LAB_00139e93:
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00132be6
CMP dword ptr [R14 + 0x14],0x0
JLE 0x00139f6a
LEA RDX,[RSP + 0x10]
XOR R12D,R12D
LEA R13,[RSP + 0x40]
LAB_00139eb8:
TEST R12,R12
JZ 0x00139ee8
LAB_00139ebd:
MOV RDI,R14
MOV RSI,R13
LEA RCX,[RSP + 0x10]
CALL 0x0013a02c
MOV EDX,0x2
LEA RDI,[RSP + 0x50]
LEA RSI,[0x13dbdf]
CALL 0x0010b490
LEA RDX,[RSP + 0x10]
LAB_00139ee8:
MOV RAX,qword ptr [R14 + 0x18]
LEA RCX,[R12 + R12*0x2]
MOV RBP,qword ptr [RAX + RCX*0x8]
MOV R15,qword ptr [RAX + RCX*0x8 + 0x8]
CMP RBP,R15
JZ 0x00139f54
ADD RBP,0x8
XOR EAX,EAX
LAB_00139f04:
TEST AL,0x1
JZ 0x00139f0d
MOV RBX,RDX
JMP 0x00139f31
LAB_00139f0d:
LEA RBX,[RBP + -0x8]
MOV RDI,R14
MOV RSI,R13
MOV RCX,RBX
CALL 0x0013a02c
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RBP + 0x8]
LEA RDI,[RSP + 0x50]
CALL 0x0010b490
LAB_00139f31:
MOV RDI,RBP
CALL 0x0013b662
CMP EAX,0x2
SETZ AL
LEA RCX,[RBP + 0x30]
ADD RBP,0x28
MOV RDX,RBX
CMP RBP,R15
MOV RBP,RCX
JNZ 0x00139f04
JMP 0x00139f57
LAB_00139f54:
MOV RBX,RDX
LAB_00139f57:
INC R12
MOVSXD RAX,dword ptr [R14 + 0x14]
MOV RDX,RBX
CMP R12,RAX
JL 0x00139eb8
LAB_00139f6a:
LEA RSI,[RSP + 0x40]
LEA RCX,[RSP + 0x10]
MOV RDI,R14
MOV RDX,RBX
CALL 0x0013a02c
MOV RBX,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x58]
MOV RDI,RBX
CALL 0x0010b6b0
LAB_00139f91:
LEA RAX,[RSP + 0x28]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00139fac
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0010b400
LAB_00139fac:
MOV RSI,qword ptr [0x00159f70]
LEA RDI,[RSP + 0x40]
CALL 0x0010b2e0
LEA RDI,[RSP + 0xc0]
CALL 0x0010b120
MOV RAX,RBX
ADD RSP,0x1c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Screen::ToString[abi:cxx11]() const */
int8 ftxui::Screen::ToString_abi_cxx11_(void)
{
string *psVar1;
int iVar2;
Pixel *this;
string *psVar3;
string *psVar4;
Screen *in_RSI;
int8 in_RDI;
long lVar5;
bool bVar6;
Pixel local_1e8 [8];
long *local_1e0;
long local_1d0 [3];
stringstream local_1b8 [16];
ostream local_1a8 [112];
ios_base local_138 [264];
std::__cxx11::stringstream::stringstream(local_1b8);
/* try { // try from 00139e93 to 00139e9f has its CatchHandler @ 00139fdf */
this = local_1e8;
Pixel::Pixel(this);
if (0 < *(int *)(in_RSI + 0x14)) {
this = local_1e8;
lVar5 = 0;
do {
if (lVar5 != 0) {
/* try { // try from 00139ebd to 00139ee2 has its CatchHandler @ 00139fe6 */
(anonymous_namespace)::UpdatePixelStyle(in_RSI,local_1b8,this,local_1e8);
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\r\n",2);
this = local_1e8;
}
psVar3 = *(string **)(*(long *)(in_RSI + 0x18) + lVar5 * 0x18);
psVar1 = *(string **)(*(long *)(in_RSI + 0x18) + 8 + lVar5 * 0x18);
if (psVar3 != psVar1) {
bVar6 = false;
psVar3 = psVar3 + 8;
do {
if (!bVar6) {
/* try { // try from 00139f0d to 00139f38 has its CatchHandler @ 00139fe8 */
(anonymous_namespace)::UpdatePixelStyle(in_RSI,local_1b8,this,(Pixel *)(psVar3 + -8));
std::__ostream_insert<char,std::char_traits<char>>
(local_1a8,*(char **)psVar3,*(long *)(psVar3 + 8));
this = (Pixel *)(psVar3 + -8);
}
iVar2 = string_width(psVar3);
bVar6 = iVar2 == 2;
psVar4 = psVar3 + 0x28;
psVar3 = psVar3 + 0x30;
} while (psVar4 != psVar1);
}
lVar5 = lVar5 + 1;
} while (lVar5 < *(int *)(in_RSI + 0x14));
}
/* try { // try from 00139f6a to 00139f90 has its CatchHandler @ 00139fe4 */
(anonymous_namespace)::UpdatePixelStyle(in_RSI,local_1b8,this,local_1e8);
std::__cxx11::stringbuf::str();
if (local_1e0 != local_1d0) {
operator_delete(local_1e0,local_1d0[0] + 1);
}
std::__cxx11::stringstream::~stringstream(local_1b8);
std::ios_base::~ios_base(local_138);
return in_RDI;
}
| |
39,479 | my_charset_get_by_name | eloqsql/mysys/charset.c | CHARSET_INFO *
my_charset_get_by_name(MY_CHARSET_LOADER *loader,
const char *cs_name, uint cs_flags, myf flags)
{
uint cs_number;
CHARSET_INFO *cs;
DBUG_ENTER("get_charset_by_csname");
DBUG_PRINT("enter",("name: '%s'", cs_name));
my_pthread_once(&charsets_initialized, init_available_charsets);
cs_number= get_charset_number(cs_name, cs_flags, flags);
cs= cs_number ? get_internal_charset(loader, cs_number, flags) : NULL;
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_name, index_file);
}
DBUG_RETURN(cs);
} | O0 | c | my_charset_get_by_name:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x228(%rbp)
movq %rsi, -0x230(%rbp)
movl %edx, -0x234(%rbp)
movq %rcx, -0x240(%rbp)
jmp 0x815e5
leaq 0x3bfff8(%rip), %rdi # 0x4415e4
leaq -0xae3(%rip), %rsi # 0x80b10
callq 0x2a360
movq -0x230(%rbp), %rdi
movl -0x234(%rbp), %esi
movq -0x240(%rbp), %rdx
callq 0x80dd0
movl %eax, -0x244(%rbp)
cmpl $0x0, -0x244(%rbp)
je 0x81642
movq -0x228(%rbp), %rdi
movl -0x244(%rbp), %esi
movq -0x240(%rbp), %rdx
callq 0x81160
movq %rax, -0x258(%rbp)
jmp 0x8164d
xorl %eax, %eax
movq %rax, -0x258(%rbp)
jmp 0x8164d
movq -0x258(%rbp), %rax
movq %rax, -0x250(%rbp)
cmpq $0x0, -0x250(%rbp)
jne 0x816b0
movq -0x240(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x816b0
leaq -0x220(%rbp), %rdi
callq 0x807d0
movq %rax, %rdi
leaq 0x7cbc6(%rip), %rsi # 0xfe252
callq 0x2a3c0
movq -0x230(%rbp), %rdx
leaq -0x220(%rbp), %rcx
movl $0x16, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x98310
jmp 0x816b2
movq -0x250(%rbp), %rax
movq %rax, -0x260(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x816e2
movq -0x260(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x2a420
nopw (%rax,%rax)
| my_charset_get_by_name:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_228], rdi
mov [rbp+var_230], rsi
mov [rbp+var_234], edx
mov [rbp+var_240], rcx
jmp short $+2
loc_815E5:
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, [rbp+var_230]
mov esi, [rbp+var_234]
mov rdx, [rbp+var_240]
call get_charset_number
mov [rbp+var_244], eax
cmp [rbp+var_244], 0
jz short loc_81642
mov rdi, [rbp+var_228]
mov esi, [rbp+var_244]
mov rdx, [rbp+var_240]
call get_internal_charset
mov [rbp+var_258], rax
jmp short loc_8164D
loc_81642:
xor eax, eax
mov [rbp+var_258], rax
jmp short $+2
loc_8164D:
mov rax, [rbp+var_258]
mov [rbp+var_250], rax
cmp [rbp+var_250], 0
jnz short loc_816B0
mov rax, [rbp+var_240]
and rax, 10h
cmp rax, 0
jz short loc_816B0
lea rdi, [rbp+var_220]
call get_charsets_dir
mov rdi, rax
lea rsi, aIndexXml; "Index.xml"
call _stpcpy
mov rdx, [rbp+var_230]
lea rcx, [rbp+var_220]
mov edi, 16h
mov esi, 4
mov al, 0
call my_error
loc_816B0:
jmp short $+2
loc_816B2:
mov rax, [rbp+var_250]
mov [rbp+var_260], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_816E2
mov rax, [rbp+var_260]
add rsp, 260h
pop rbp
retn
loc_816E2:
call ___stack_chk_fail
| long long my_charset_get_by_name(long long a1, long long a2, unsigned int a3, long long a4)
{
long long charsets_dir; // rax
int v5; // r8d
int v6; // r9d
long long internal_charset; // [rsp+8h] [rbp-258h]
unsigned int charset_number; // [rsp+1Ch] [rbp-244h]
_BYTE v12[536]; // [rsp+40h] [rbp-220h] BYREF
unsigned long long v13; // [rsp+258h] [rbp-8h]
v13 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
charset_number = get_charset_number(a2, a3, a4);
if ( charset_number )
internal_charset = get_internal_charset(a1, charset_number, a4);
else
internal_charset = 0LL;
if ( !internal_charset && (a4 & 0x10) != 0 )
{
charsets_dir = get_charsets_dir((long long)v12);
stpcpy(charsets_dir, "Index.xml");
my_error(22, 4, a2, (unsigned int)v12, v5, v6);
}
return internal_charset;
}
| my_charset_get_by_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x228],RDI
MOV qword ptr [RBP + -0x230],RSI
MOV dword ptr [RBP + -0x234],EDX
MOV qword ptr [RBP + -0x240],RCX
JMP 0x001815e5
LAB_001815e5:
LEA RDI,[0x5415e4]
LEA RSI,[0x180b10]
CALL 0x0012a360
MOV RDI,qword ptr [RBP + -0x230]
MOV ESI,dword ptr [RBP + -0x234]
MOV RDX,qword ptr [RBP + -0x240]
CALL 0x00180dd0
MOV dword ptr [RBP + -0x244],EAX
CMP dword ptr [RBP + -0x244],0x0
JZ 0x00181642
MOV RDI,qword ptr [RBP + -0x228]
MOV ESI,dword ptr [RBP + -0x244]
MOV RDX,qword ptr [RBP + -0x240]
CALL 0x00181160
MOV qword ptr [RBP + -0x258],RAX
JMP 0x0018164d
LAB_00181642:
XOR EAX,EAX
MOV qword ptr [RBP + -0x258],RAX
JMP 0x0018164d
LAB_0018164d:
MOV RAX,qword ptr [RBP + -0x258]
MOV qword ptr [RBP + -0x250],RAX
CMP qword ptr [RBP + -0x250],0x0
JNZ 0x001816b0
MOV RAX,qword ptr [RBP + -0x240]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001816b0
LEA RDI,[RBP + -0x220]
CALL 0x001807d0
MOV RDI,RAX
LEA RSI,[0x1fe252]
CALL 0x0012a3c0
MOV RDX,qword ptr [RBP + -0x230]
LEA RCX,[RBP + -0x220]
MOV EDI,0x16
MOV ESI,0x4
MOV AL,0x0
CALL 0x00198310
LAB_001816b0:
JMP 0x001816b2
LAB_001816b2:
MOV RAX,qword ptr [RBP + -0x250]
MOV qword ptr [RBP + -0x260],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001816e2
MOV RAX,qword ptr [RBP + -0x260]
ADD RSP,0x260
POP RBP
RET
LAB_001816e2:
CALL 0x0012a420
|
long my_charset_get_by_name(int8 param_1,int8 param_2,int4 param_3,ulong param_4)
{
int iVar1;
char *__dest;
long in_FS_OFFSET;
long local_260;
int1 local_228 [536];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
iVar1 = get_charset_number(param_2,param_3,param_4);
if (iVar1 == 0) {
local_260 = 0;
}
else {
local_260 = get_internal_charset(param_1,iVar1,param_4);
}
if ((local_260 == 0) && ((param_4 & 0x10) != 0)) {
__dest = (char *)get_charsets_dir(local_228);
stpcpy(__dest,"Index.xml");
my_error(0x16,4,param_2,local_228);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_260;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,480 | list_walk | eloqsql/mysys/list.c | int list_walk(LIST *list, list_walk_action action, uchar* argument)
{
int error=0;
while (list)
{
if ((error = (*action)(list->data,argument)))
return error;
list=list_rest(list);
}
return 0;
} | O3 | c | list_walk:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x94754
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
jne 0x94752
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x94737
jmp 0x94754
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| list_walk:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
xor ebx, ebx
test rdi, rdi
jz short loc_94754
mov r14, rdx
mov r15, rsi
mov r12, rdi
loc_94737:
mov rdi, [r12+10h]
mov rsi, r14
call r15
test eax, eax
jnz short loc_94752
mov r12, [r12+8]
test r12, r12
jnz short loc_94737
jmp short loc_94754
loc_94752:
mov ebx, eax
loc_94754:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long list_walk(long long a1, long long ( *a2)(_QWORD, long long), long long a3)
{
unsigned int v3; // ebx
long long v5; // r12
unsigned int v6; // eax
v3 = 0;
if ( a1 )
{
v5 = a1;
while ( 1 )
{
v6 = a2(*(_QWORD *)(v5 + 16), a3);
if ( v6 )
break;
v5 = *(_QWORD *)(v5 + 8);
if ( !v5 )
return v3;
}
return v6;
}
return v3;
}
| list_walk:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
XOR EBX,EBX
TEST RDI,RDI
JZ 0x00194754
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LAB_00194737:
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,R14
CALL R15
TEST EAX,EAX
JNZ 0x00194752
MOV R12,qword ptr [R12 + 0x8]
TEST R12,R12
JNZ 0x00194737
JMP 0x00194754
LAB_00194752:
MOV EBX,EAX
LAB_00194754:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int list_walk(long param_1,code *param_2,int8 param_3)
{
int iVar1;
if (param_1 != 0) {
do {
iVar1 = (*param_2)(*(int8 *)(param_1 + 0x10),param_3);
if (iVar1 != 0) {
return iVar1;
}
param_1 = *(long *)(param_1 + 8);
} while (param_1 != 0);
}
return 0;
}
| |
39,481 | mi_log | eloqsql/storage/myisam/mi_log.c | int mi_log(int activate_log)
{
int error=0;
char buff[FN_REFLEN];
DBUG_ENTER("mi_log");
log_type=activate_log;
if (activate_log)
{
if (!myisam_pid)
myisam_pid=(ulong) getpid();
if (myisam_log_file < 0)
{
if ((myisam_log_file= mysql_file_create(mi_key_file_log,
fn_format(buff,
myisam_log_filename,
"", ".log", 4),
0,
(O_RDWR | O_BINARY | O_APPEND),
MYF(0))) < 0)
DBUG_RETURN(my_errno);
}
}
else if (myisam_log_file >= 0)
{
error= mysql_file_close(myisam_log_file, MYF(0)) ? my_errno : 0 ;
myisam_log_file= -1;
}
DBUG_RETURN(error);
} | O3 | c | mi_log:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x270, %rsp # imm = 0x270
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movl %edi, 0xb82df7(%rip) # 0xbffa08
testl %edi, %edi
je 0x7ccd1
cmpq $0x0, 0xb82ddf(%rip) # 0xbffa00
jne 0x7cc31
callq 0x29910
cltq
movq %rax, 0xb82dcf(%rip) # 0xbffa00
leaq 0x3086f8(%rip), %r12 # 0x385330
cmpl $0x0, (%r12)
jns 0x7cd18
leaq 0xb82d96(%rip), %rax # 0xbff9e0
movl (%rax), %r14d
leaq 0x3086d4(%rip), %rax # 0x385328
movq (%rax), %rsi
leaq 0x631bb(%rip), %rdx # 0xdfe19
leaq 0x5ec89(%rip), %rcx # 0xdb8ee
leaq -0x230(%rbp), %rdi
movl $0x4, %r8d
callq 0x949d4
movq %rax, %rbx
leaq 0x30938f(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x288(%rbp), %rdi
leaq -0x238(%rbp), %r15
movl %r14d, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %r15, %r8
callq *0x148(%rax)
movq %rax, (%r15)
testq %rax, %rax
jne 0x7cd44
movq %rbx, %rdi
xorl %esi, %esi
movl $0x402, %edx # imm = 0x402
xorl %ecx, %ecx
callq 0x9ded8
movl %eax, (%r12)
testl %eax, %eax
jns 0x7cd18
callq 0xa1b22
movl (%rax), %eax
jmp 0x7cd25
leaq 0x308658(%rip), %r15 # 0x385330
movl (%r15), %ebx
testl %ebx, %ebx
js 0x7cd18
leaq 0x30932a(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x230(%rbp), %rdi
movl %ebx, %esi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7cd68
movl %ebx, %edi
xorl %esi, %esi
callq 0xa0585
testl %eax, %eax
je 0x7cd1c
callq 0xa1b22
movl (%rax), %eax
jmp 0x7cd1e
xorl %eax, %eax
jmp 0x7cd25
xorl %eax, %eax
movl $0xffffffff, (%r15) # imm = 0xFFFFFFFF
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x7cd81
addq $0x270, %rsp # imm = 0x270
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x238(%rbp), %rdx
leaq -0x23c(%rbp), %r14
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x2db5e
movl (%r14), %eax
jmp 0x7ccc0
leaq -0x288(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2dbb9
movl (%r14), %eax
jmp 0x7cd0b
callq 0x29270
| mi_log:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 270h
mov rax, fs:28h
mov [rbp+var_28], rax
mov cs:log_type, edi
test edi, edi
jz loc_7CCD1
cmp cs:myisam_pid, 0
jnz short loc_7CC31
call _getpid
cdqe
mov cs:myisam_pid, rax
loc_7CC31:
lea r12, myisam_log_file
cmp dword ptr [r12], 0
jns loc_7CD18
lea rax, mi_key_file_log
mov r14d, [rax]
lea rax, myisam_log_filename
mov rsi, [rax]
lea rdx, asc_DFE15+4; ""
lea rcx, aMyisamLog+6; ".log"
lea rdi, [rbp+var_230]
mov r8d, 4
call fn_format
mov rbx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_288]
lea r15, [rbp+var_238]
mov esi, r14d
xor edx, edx
mov rcx, rbx
mov r8, r15
call qword ptr [rax+148h]
mov [r15], rax
test rax, rax
jnz loc_7CD44
mov rdi, rbx
xor esi, esi
mov edx, 402h
xor ecx, ecx
call my_create
loc_7CCC0:
mov [r12], eax
test eax, eax
jns short loc_7CD18
call _my_thread_var
mov eax, [rax]
jmp short loc_7CD25
loc_7CCD1:
lea r15, myisam_log_file
mov ebx, [r15]
test ebx, ebx
js short loc_7CD18
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_230]
mov esi, ebx
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz short loc_7CD68
mov edi, ebx
xor esi, esi
call my_close
loc_7CD0B:
test eax, eax
jz short loc_7CD1C
call _my_thread_var
mov eax, [rax]
jmp short loc_7CD1E
loc_7CD18:
xor eax, eax
jmp short loc_7CD25
loc_7CD1C:
xor eax, eax
loc_7CD1E:
mov dword ptr [r15], 0FFFFFFFFh
loc_7CD25:
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_7CD81
add rsp, 270h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7CD44:
lea rdx, [rbp+var_238]
lea r14, [rbp+var_23C]
mov rdi, rax
mov rsi, rbx
mov rcx, r14
call mi_log_cold_1
mov eax, [r14]
jmp loc_7CCC0
loc_7CD68:
lea r14, [rbp+var_288]
mov rdi, rax
mov esi, ebx
mov rdx, r14
call mi_log_cold_2
mov eax, [r14]
jmp short loc_7CD0B
loc_7CD81:
call ___stack_chk_fail
| long long mi_log(int a1)
{
unsigned int v1; // r14d
long long v2; // rbx
long long v3; // rax
long long v4; // rdi
const char *v5; // rsi
int v6; // eax
long long result; // rax
unsigned int v8; // ebx
long long v9; // rax
long long v10; // rdi
const char *v11; // rsi
unsigned int v12; // eax
unsigned int v13[19]; // [rsp+8h] [rbp-288h] BYREF
int v14; // [rsp+54h] [rbp-23Ch] BYREF
long long v15; // [rsp+58h] [rbp-238h] BYREF
_BYTE v16[520]; // [rsp+60h] [rbp-230h] BYREF
unsigned long long v17; // [rsp+268h] [rbp-28h]
v17 = __readfsqword(0x28u);
log_type = a1;
if ( a1 )
{
if ( !myisam_pid )
myisam_pid = (int)getpid();
if ( (myisam_log_file & 0x80000000) != 0 )
{
v1 = mi_key_file_log;
v2 = fn_format(v16, myisam_log_filename, "", ".log", 4LL);
v3 = ((long long ( *)(unsigned int *, _QWORD, _QWORD, long long, long long *))PSI_server[41])(
v13,
v1,
0LL,
v2,
&v15);
v15 = v3;
if ( v3 )
{
v4 = v3;
v5 = (const char *)v2;
mi_log_cold_1(v3, v2, &v15, (unsigned int *)&v14);
v6 = v14;
}
else
{
v4 = v2;
v5 = 0LL;
v6 = my_create(v2, 0LL, 1026LL, 0LL);
}
myisam_log_file = v6;
if ( v6 < 0 )
return *(unsigned int *)my_thread_var(v4, v5);
}
return 0LL;
}
v8 = myisam_log_file;
if ( (myisam_log_file & 0x80000000) != 0 )
return 0LL;
v9 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v16, myisam_log_file, 4LL);
if ( v9 )
{
v10 = v9;
v11 = (const char *)v8;
mi_log_cold_2(v9, v8, v13);
v12 = v13[0];
}
else
{
v10 = v8;
v11 = 0LL;
v12 = my_close(v8, 0LL);
}
if ( v12 )
result = *(unsigned int *)my_thread_var(v10, v11);
else
result = 0LL;
myisam_log_file = -1;
return result;
}
| mi_log:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x270
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV dword ptr [0x00cffa08],EDI
TEST EDI,EDI
JZ 0x0017ccd1
CMP qword ptr [0x00cffa00],0x0
JNZ 0x0017cc31
CALL 0x00129910
CDQE
MOV qword ptr [0x00cffa00],RAX
LAB_0017cc31:
LEA R12,[0x485330]
CMP dword ptr [R12],0x0
JNS 0x0017cd18
LEA RAX,[0xcff9e0]
MOV R14D,dword ptr [RAX]
LEA RAX,[0x485328]
MOV RSI,qword ptr [RAX]
LEA RDX,[0x1dfe19]
LEA RCX,[0x1db8ee]
LEA RDI,[RBP + -0x230]
MOV R8D,0x4
CALL 0x001949d4
MOV RBX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x288]
LEA R15,[RBP + -0x238]
MOV ESI,R14D
XOR EDX,EDX
MOV RCX,RBX
MOV R8,R15
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R15],RAX
TEST RAX,RAX
JNZ 0x0017cd44
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x402
XOR ECX,ECX
CALL 0x0019ded8
LAB_0017ccc0:
MOV dword ptr [R12],EAX
TEST EAX,EAX
JNS 0x0017cd18
CALL 0x001a1b22
MOV EAX,dword ptr [RAX]
JMP 0x0017cd25
LAB_0017ccd1:
LEA R15,[0x485330]
MOV EBX,dword ptr [R15]
TEST EBX,EBX
JS 0x0017cd18
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x230]
MOV ESI,EBX
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017cd68
MOV EDI,EBX
XOR ESI,ESI
CALL 0x001a0585
LAB_0017cd0b:
TEST EAX,EAX
JZ 0x0017cd1c
CALL 0x001a1b22
MOV EAX,dword ptr [RAX]
JMP 0x0017cd1e
LAB_0017cd18:
XOR EAX,EAX
JMP 0x0017cd25
LAB_0017cd1c:
XOR EAX,EAX
LAB_0017cd1e:
MOV dword ptr [R15],0xffffffff
LAB_0017cd25:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x0017cd81
ADD RSP,0x270
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017cd44:
LEA RDX,[RBP + -0x238]
LEA R14,[RBP + -0x23c]
MOV RDI,RAX
MOV RSI,RBX
MOV RCX,R14
CALL 0x0012db5e
MOV EAX,dword ptr [R14]
JMP 0x0017ccc0
LAB_0017cd68:
LEA R14,[RBP + -0x288]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012dbb9
MOV EAX,dword ptr [R14]
JMP 0x0017cd0b
LAB_0017cd81:
CALL 0x00129270
|
int4 mi_log(int param_1)
{
int iVar1;
__pid_t _Var2;
int4 uVar3;
int8 uVar4;
int4 *puVar5;
long lVar6;
long in_FS_OFFSET;
int local_290 [19];
int local_244;
long local_240;
int1 local_238 [520];
long local_30;
iVar1 = myisam_log_file;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
log_type = param_1;
if (param_1 == 0) {
if (-1 < myisam_log_file) {
lVar6 = (**(code **)(PSI_server + 0x158))(local_238,myisam_log_file,4);
if (lVar6 == 0) {
local_290[0] = my_close(iVar1,0);
}
else {
mi_log_cold_2(lVar6,iVar1,local_290);
}
if (local_290[0] == 0) {
uVar3 = 0;
}
else {
puVar5 = (int4 *)_my_thread_var();
uVar3 = *puVar5;
}
myisam_log_file = -1;
goto LAB_0017cd25;
}
}
else {
if (myisam_pid == 0) {
_Var2 = getpid();
myisam_pid = (long)_Var2;
}
uVar3 = mi_key_file_log;
if (myisam_log_file < 0) {
uVar4 = fn_format(local_238,myisam_log_filename,&DAT_001dfe19,".log",4);
local_240 = (**(code **)(PSI_server + 0x148))(local_290,uVar3,0,uVar4,&local_240);
if (local_240 == 0) {
local_244 = my_create(uVar4,0,0x402,0);
}
else {
mi_log_cold_1(local_240,uVar4,&local_240,&local_244);
}
myisam_log_file = local_244;
if (local_244 < 0) {
puVar5 = (int4 *)_my_thread_var();
uVar3 = *puVar5;
goto LAB_0017cd25;
}
}
}
uVar3 = 0;
LAB_0017cd25:
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return uVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
39,482 | StartTree::Matrix<float>::assign(StartTree::Matrix<float> const&) | iqtree3/utils/bionj2.cpp | void assign(const Matrix& rhs) {
if (this==&rhs) {
return;
}
setSize(rhs.n);
#pragma omp parallel for
for (size_t r=0; r<n; ++r) {
T * destRow = rows[r];
T const * sourceRow = rhs.rows[r];
T const * const endSourceRow = sourceRow + n;
for (; sourceRow<endSourceRow; ++destRow, ++sourceRow) {
*destRow = *sourceRow;
}
rowTotals[r] = rhs.rowTotals[r];
}
} | O3 | cpp | StartTree::Matrix<float>::assign(StartTree::Matrix<float> const&):
cmpq %rsi, %rdi
je 0x21561
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2155a
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdi
xorl %r8d, %r8d
testq %rax, %rax
jle 0x21546
movq (%rsi,%r8,8), %r9
leaq (%r9,%rax,4), %r10
movq (%rcx,%r8,8), %r11
movss (%r9), %xmm0
movss %xmm0, (%r11)
addq $0x4, %r11
addq $0x4, %r9
cmpq %r10, %r9
jb 0x2152f
movss (%rdi,%r8,4), %xmm0
movss %xmm0, (%rdx,%r8,4)
incq %r8
cmpq %rax, %r8
jne 0x2151e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN9StartTree6MatrixIfE6assignERKS1_:
cmp rdi, rsi
jz short locret_21561
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rsi, [rsi+8]
mov rax, [rdi]
call qword ptr [rax]
mov rax, [r14+8]
test rax, rax
jz short loc_2155A
mov rcx, [r14+20h]
mov rdx, [r14+28h]
mov rsi, [rbx+20h]
mov rdi, [rbx+28h]
xor r8d, r8d
loc_2151E:
test rax, rax
jle short loc_21546
mov r9, [rsi+r8*8]
lea r10, [r9+rax*4]
mov r11, [rcx+r8*8]
loc_2152F:
movss xmm0, dword ptr [r9]
movss dword ptr [r11], xmm0
add r11, 4
add r9, 4
cmp r9, r10
jb short loc_2152F
loc_21546:
movss xmm0, dword ptr [rdi+r8*4]
movss dword ptr [rdx+r8*4], xmm0
inc r8
cmp r8, rax
jnz short loc_2151E
loc_2155A:
add rsp, 8
pop rbx
pop r14
locret_21561:
retn
| long long StartTree::Matrix<float>::assign(_QWORD *a1, _QWORD *a2)
{
long long result; // rax
long long v4; // rcx
long long v5; // rdx
long long v6; // rsi
long long v7; // rdi
long long i; // r8
_DWORD *v9; // r9
_DWORD *v10; // r10
_DWORD *v11; // r11
if ( a1 != a2 )
{
(*(void ( **)(_QWORD *, _QWORD))*a1)(a1, a2[1]);
result = a1[1];
if ( result )
{
v4 = a1[4];
v5 = a1[5];
v6 = a2[4];
v7 = a2[5];
for ( i = 0LL; i != result; ++i )
{
if ( result > 0 )
{
v9 = *(_DWORD **)(v6 + 8 * i);
v10 = &v9[result];
v11 = *(_DWORD **)(v4 + 8 * i);
do
*v11++ = *v9++;
while ( v9 < v10 );
}
*(_DWORD *)(v5 + 4 * i) = *(_DWORD *)(v7 + 4 * i);
}
}
}
return result;
}
| assign:
CMP RDI,RSI
JZ 0x00121561
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX]
MOV RAX,qword ptr [R14 + 0x8]
TEST RAX,RAX
JZ 0x0012155a
MOV RCX,qword ptr [R14 + 0x20]
MOV RDX,qword ptr [R14 + 0x28]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RBX + 0x28]
XOR R8D,R8D
LAB_0012151e:
TEST RAX,RAX
JLE 0x00121546
MOV R9,qword ptr [RSI + R8*0x8]
LEA R10,[R9 + RAX*0x4]
MOV R11,qword ptr [RCX + R8*0x8]
LAB_0012152f:
MOVSS XMM0,dword ptr [R9]
MOVSS dword ptr [R11],XMM0
ADD R11,0x4
ADD R9,0x4
CMP R9,R10
JC 0x0012152f
LAB_00121546:
MOVSS XMM0,dword ptr [RDI + R8*0x4]
MOVSS dword ptr [RDX + R8*0x4],XMM0
INC R8
CMP R8,RAX
JNZ 0x0012151e
LAB_0012155a:
ADD RSP,0x8
POP RBX
POP R14
LAB_00121561:
RET
|
/* StartTree::Matrix<float>::assign(StartTree::Matrix<float> const&) */
void __thiscall StartTree::Matrix<float>::assign(Matrix<float> *this,Matrix *param_1)
{
int4 *puVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
long lVar7;
int4 *puVar8;
int4 *puVar9;
if (this != (Matrix<float> *)param_1) {
(*(code *)**(int8 **)this)(this,*(int8 *)(param_1 + 8));
lVar2 = *(long *)(this + 8);
if (lVar2 != 0) {
lVar3 = *(long *)(this + 0x20);
lVar4 = *(long *)(this + 0x28);
lVar5 = *(long *)(param_1 + 0x20);
lVar6 = *(long *)(param_1 + 0x28);
lVar7 = 0;
do {
if (0 < lVar2) {
puVar8 = *(int4 **)(lVar5 + lVar7 * 8);
puVar1 = puVar8 + lVar2;
puVar9 = *(int4 **)(lVar3 + lVar7 * 8);
do {
*puVar9 = *puVar8;
puVar9 = puVar9 + 1;
puVar8 = puVar8 + 1;
} while (puVar8 < puVar1);
}
*(int4 *)(lVar4 + lVar7 * 4) = *(int4 *)(lVar6 + lVar7 * 4);
lVar7 = lVar7 + 1;
} while (lVar7 != lVar2);
}
}
return;
}
| |
39,483 | ma_block_start_trans | eloqsql/storage/maria/ma_state.c | my_bool _ma_block_start_trans(void* param)
{
MARIA_HA *info=(MARIA_HA*) param;
DBUG_ENTER("_ma_block_start_trans");
if (info->s->lock_key_trees)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
TODO: Fix this by having one extra state pre-allocated
*/
DBUG_RETURN(_ma_setup_live_state(info));
}
else
{
/*
We come here in the following cases:
- The table is a temporary table
- It's a table which is crash safe but not yet versioned, for
example a table with fulltext or rtree keys
Set the current state to point to save_state so that the
block_format code don't count the same record twice.
Copy also the current state. This may have been wrong if the
same file was used several times in the last statement
*/
info->state= info->state_start;
*info->state= info->s->state.state;
}
/*
Info->trn is set if this table is already handled and we are
called from maria_versioning()
*/
if (info->s->base.born_transactional && !info->trn)
{
/*
Assume for now that this doesn't fail (It can only fail in
out of memory conditions)
*/
DBUG_RETURN(maria_create_trn_hook(info) != 0);
}
DBUG_RETURN(0);
} | O0 | c | ma_block_start_trans:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x7e3(%rax)
je 0x4a104
jmp 0x4a0f6
movq -0x18(%rbp), %rdi
callq 0x492e0
movb %al, -0x1(%rbp)
jmp 0x4a177
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
addq $0x18, %rsi
movl $0x38, %edx
callq 0x2a090
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl 0x44c(%rax), %eax
cmpl $0x0, %eax
je 0x4a171
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4a171
jmp 0x4a151
leaq 0x42d720(%rip), %rax # 0x477878
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
jmp 0x4a177
jmp 0x4a173
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| _ma_block_start_trans:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rax, [rax]
cmp byte ptr [rax+7E3h], 0
jz short loc_4A104
jmp short $+2
loc_4A0F6:
mov rdi, [rbp+var_18]
call _ma_setup_live_state
mov [rbp+var_1], al
jmp short loc_4A177
loc_4A104:
mov rax, [rbp+var_18]
mov rcx, [rax+60h]
mov rax, [rbp+var_18]
mov [rax+20h], rcx
mov rax, [rbp+var_18]
mov rdi, [rax+20h]
mov rax, [rbp+var_18]
mov rsi, [rax]
add rsi, 18h
mov edx, 38h ; '8'
call _memcpy
mov rax, [rbp+var_18]
mov rax, [rax]
movsx eax, byte ptr [rax+44Ch]
cmp eax, 0
jz short loc_4A171
mov rax, [rbp+var_18]
cmp qword ptr [rax+8], 0
jnz short loc_4A171
jmp short $+2
loc_4A151:
lea rax, maria_create_trn_hook
mov rax, [rax]
mov rdi, [rbp+var_18]
call rax
cmp eax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_1], al
jmp short loc_4A177
loc_4A171:
jmp short $+2
loc_4A173:
mov [rbp+var_1], 0
loc_4A177:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char ma_block_start_trans(long long *a1)
{
if ( *(_BYTE *)(*a1 + 2019) )
return ma_setup_live_state(a1);
a1[4] = a1[12];
memcpy(a1[4], *a1 + 24, 56LL);
return *(_BYTE *)(*a1 + 1100) && !a1[1] && (unsigned int)maria_create_trn_hook(a1) != 0;
}
| _ma_block_start_trans:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x7e3],0x0
JZ 0x0014a104
JMP 0x0014a0f6
LAB_0014a0f6:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001492e0
MOV byte ptr [RBP + -0x1],AL
JMP 0x0014a177
LAB_0014a104:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
ADD RSI,0x18
MOV EDX,0x38
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOVSX EAX,byte ptr [RAX + 0x44c]
CMP EAX,0x0
JZ 0x0014a171
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x8],0x0
JNZ 0x0014a171
JMP 0x0014a151
LAB_0014a151:
LEA RAX,[0x577878]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x1],AL
JMP 0x0014a177
LAB_0014a171:
JMP 0x0014a173
LAB_0014a173:
MOV byte ptr [RBP + -0x1],0x0
LAB_0014a177:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 _ma_block_start_trans(long *param_1)
{
int iVar1;
int1 local_9;
if (*(char *)(*param_1 + 0x7e3) == '\0') {
param_1[4] = param_1[0xc];
memcpy((void *)param_1[4],(void *)(*param_1 + 0x18),0x38);
if ((*(char *)(*param_1 + 0x44c) == '\0') || (param_1[1] != 0)) {
local_9 = 0;
}
else {
iVar1 = (*maria_create_trn_hook)(param_1);
local_9 = iVar1 != 0;
}
}
else {
local_9 = _ma_setup_live_state(param_1);
}
return local_9;
}
| |
39,484 | func_uni_ksc5601_onechar | eloqsql/strings/ctype-euc_kr.c | static int func_uni_ksc5601_onechar(int code){
if ((code>=0x00A1)&&(code<=0x0167))
return(tab_uni_ksc56010[code-0x00A1]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_ksc56011[code-0x02C7]);
if ((code>=0x2015)&&(code<=0x2312))
return(tab_uni_ksc56012[code-0x2015]);
if ((code>=0x2460)&&(code<=0x266D))
return(tab_uni_ksc56013[code-0x2460]);
if ((code>=0x3000)&&(code<=0x327F))
return(tab_uni_ksc56014[code-0x3000]);
if ((code>=0x3380)&&(code<=0x33DD))
return(tab_uni_ksc56015[code-0x3380]);
if ((code>=0x4E00)&&(code<=0x947F))
return(tab_uni_ksc56016[code-0x4E00]);
if ((code>=0x9577)&&(code<=0x9F9C))
return(tab_uni_ksc56017[code-0x9577]);
if ((code>=0xAC00)&&(code<=0xD7A3))
return(tab_uni_ksc56018[code-0xAC00]);
if ((code>=0xF900)&&(code<=0xFA0B))
return(tab_uni_ksc56019[code-0xF900]);
if ((code>=0xFF01)&&(code<=0xFFE6))
return(tab_uni_ksc560110[code-0xFF01]);
return(0);
} | O0 | c | func_uni_ksc5601_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa1, -0x8(%rbp)
jl 0x48c47
cmpl $0x167, -0x8(%rbp) # imm = 0x167
jg 0x48c47
movl -0x8(%rbp), %eax
subl $0xa1, %eax
movslq %eax, %rcx
leaq 0x111db5(%rip), %rax # 0x15a9f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x48c77
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x48c77
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0x111f15(%rip), %rax # 0x15ab80
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x2015, -0x8(%rbp) # imm = 0x2015
jl 0x48ca7
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x48ca7
movl -0x8(%rbp), %eax
subl $0x2015, %eax # imm = 0x2015
movslq %eax, %rcx
leaq 0x112205(%rip), %rax # 0x15aea0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x48cd7
cmpl $0x266d, -0x8(%rbp) # imm = 0x266D
jg 0x48cd7
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0x1127d5(%rip), %rax # 0x15b4a0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x48d07
cmpl $0x327f, -0x8(%rbp) # imm = 0x327F
jg 0x48d07
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0x112bc5(%rip), %rax # 0x15b8c0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x3380, -0x8(%rbp) # imm = 0x3380
jl 0x48d37
cmpl $0x33dd, -0x8(%rbp) # imm = 0x33DD
jg 0x48d37
movl -0x8(%rbp), %eax
subl $0x3380, %eax # imm = 0x3380
movslq %eax, %rcx
leaq 0x113095(%rip), %rax # 0x15bdc0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x48d67
cmpl $0x947f, -0x8(%rbp) # imm = 0x947F
jg 0x48d67
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0x113125(%rip), %rax # 0x15be80
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0x9577, -0x8(%rbp) # imm = 0x9577
jl 0x48d97
cmpl $0x9f9c, -0x8(%rbp) # imm = 0x9F9C
jg 0x48d97
movl -0x8(%rbp), %eax
subl $0x9577, %eax # imm = 0x9577
movslq %eax, %rcx
leaq 0x11bdf5(%rip), %rax # 0x164b80
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0xac00, -0x8(%rbp) # imm = 0xAC00
jl 0x48dc4
cmpl $0xd7a3, -0x8(%rbp) # imm = 0xD7A3
jg 0x48dc4
movl -0x8(%rbp), %eax
subl $0xac00, %eax # imm = 0xAC00
movslq %eax, %rcx
leaq 0x11d215(%rip), %rax # 0x165fd0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0xf900, -0x8(%rbp) # imm = 0xF900
jl 0x48df1
cmpl $0xfa0b, -0x8(%rbp) # imm = 0xFA0B
jg 0x48df1
movl -0x8(%rbp), %eax
subl $0xf900, %eax # imm = 0xF900
movslq %eax, %rcx
leaq 0x122938(%rip), %rax # 0x16b720
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
cmpl $0xff01, -0x8(%rbp) # imm = 0xFF01
jl 0x48e1e
cmpl $0xffe6, -0x8(%rbp) # imm = 0xFFE6
jg 0x48e1e
movl -0x8(%rbp), %eax
subl $0xff01, %eax # imm = 0xFF01
movslq %eax, %rcx
leaq 0x122b2b(%rip), %rax # 0x16b940
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x48e25
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_ksc5601_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A1h
jl short loc_48C47
cmp [rbp+var_8], 167h
jg short loc_48C47
mov eax, [rbp+var_8]
sub eax, 0A1h
movsxd rcx, eax
lea rax, tab_uni_ksc56010
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48C47:
cmp [rbp+var_8], 2C7h
jl short loc_48C77
cmp [rbp+var_8], 451h
jg short loc_48C77
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_ksc56011
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48C77:
cmp [rbp+var_8], 2015h
jl short loc_48CA7
cmp [rbp+var_8], 2312h
jg short loc_48CA7
mov eax, [rbp+var_8]
sub eax, 2015h
movsxd rcx, eax
lea rax, tab_uni_ksc56012
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48CA7:
cmp [rbp+var_8], 2460h
jl short loc_48CD7
cmp [rbp+var_8], 266Dh
jg short loc_48CD7
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_ksc56013
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48CD7:
cmp [rbp+var_8], 3000h
jl short loc_48D07
cmp [rbp+var_8], 327Fh
jg short loc_48D07
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_ksc56014
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48D07:
cmp [rbp+var_8], 3380h
jl short loc_48D37
cmp [rbp+var_8], 33DDh
jg short loc_48D37
mov eax, [rbp+var_8]
sub eax, 3380h
movsxd rcx, eax
lea rax, tab_uni_ksc56015
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48D37:
cmp [rbp+var_8], 4E00h
jl short loc_48D67
cmp [rbp+var_8], 947Fh
jg short loc_48D67
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_ksc56016
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48D67:
cmp [rbp+var_8], 9577h
jl short loc_48D97
cmp [rbp+var_8], 9F9Ch
jg short loc_48D97
mov eax, [rbp+var_8]
sub eax, 9577h
movsxd rcx, eax
lea rax, tab_uni_ksc56017
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_48E25
loc_48D97:
cmp [rbp+var_8], 0AC00h
jl short loc_48DC4
cmp [rbp+var_8], 0D7A3h
jg short loc_48DC4
mov eax, [rbp+var_8]
sub eax, 0AC00h
movsxd rcx, eax
lea rax, tab_uni_ksc56018
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_48E25
loc_48DC4:
cmp [rbp+var_8], 0F900h
jl short loc_48DF1
cmp [rbp+var_8], 0FA0Bh
jg short loc_48DF1
mov eax, [rbp+var_8]
sub eax, 0F900h
movsxd rcx, eax
lea rax, tab_uni_ksc56019
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_48E25
loc_48DF1:
cmp [rbp+var_8], 0FF01h
jl short loc_48E1E
cmp [rbp+var_8], 0FFE6h
jg short loc_48E1E
mov eax, [rbp+var_8]
sub eax, 0FF01h
movsxd rcx, eax
lea rax, tab_uni_ksc560110
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_48E25
loc_48E1E:
mov [rbp+var_4], 0
loc_48E25:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_ksc5601_onechar(int a1)
{
if ( a1 < 161 || a1 > 359 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8213 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9837 )
{
if ( a1 < 12288 || a1 > 12927 )
{
if ( a1 < 13184 || a1 > 13277 )
{
if ( a1 < 19968 || a1 > 38015 )
{
if ( a1 < 38263 || a1 > 40860 )
{
if ( a1 < 44032 || a1 > 55203 )
{
if ( a1 < 63744 || a1 > 64011 )
{
if ( a1 < 65281 || a1 > 65510 )
return 0;
else
return tab_uni_ksc560110[a1 - 65281];
}
else
{
return tab_uni_ksc56019[a1 - 63744];
}
}
else
{
return tab_uni_ksc56018[a1 - 44032];
}
}
else
{
return tab_uni_ksc56017[a1 - 38263];
}
}
else
{
return tab_uni_ksc56016[a1 - 19968];
}
}
else
{
return tab_uni_ksc56015[a1 - 13184];
}
}
else
{
return tab_uni_ksc56014[a1 - 12288];
}
}
else
{
return tab_uni_ksc56013[a1 - 9312];
}
}
else
{
return tab_uni_ksc56012[a1 - 8213];
}
}
else
{
return tab_uni_ksc56011[a1 - 711];
}
}
else
{
return tab_uni_ksc56010[a1 - 161];
}
}
| func_uni_ksc5601_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa1
JL 0x00148c47
CMP dword ptr [RBP + -0x8],0x167
JG 0x00148c47
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa1
MOVSXD RCX,EAX
LEA RAX,[0x25a9f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148c47:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x00148c77
CMP dword ptr [RBP + -0x8],0x451
JG 0x00148c77
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x25ab80]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148c77:
CMP dword ptr [RBP + -0x8],0x2015
JL 0x00148ca7
CMP dword ptr [RBP + -0x8],0x2312
JG 0x00148ca7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2015
MOVSXD RCX,EAX
LEA RAX,[0x25aea0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148ca7:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x00148cd7
CMP dword ptr [RBP + -0x8],0x266d
JG 0x00148cd7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x25b4a0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148cd7:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x00148d07
CMP dword ptr [RBP + -0x8],0x327f
JG 0x00148d07
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x25b8c0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148d07:
CMP dword ptr [RBP + -0x8],0x3380
JL 0x00148d37
CMP dword ptr [RBP + -0x8],0x33dd
JG 0x00148d37
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3380
MOVSXD RCX,EAX
LEA RAX,[0x25bdc0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148d37:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x00148d67
CMP dword ptr [RBP + -0x8],0x947f
JG 0x00148d67
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x25be80]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148d67:
CMP dword ptr [RBP + -0x8],0x9577
JL 0x00148d97
CMP dword ptr [RBP + -0x8],0x9f9c
JG 0x00148d97
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9577
MOVSXD RCX,EAX
LEA RAX,[0x264b80]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148d97:
CMP dword ptr [RBP + -0x8],0xac00
JL 0x00148dc4
CMP dword ptr [RBP + -0x8],0xd7a3
JG 0x00148dc4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xac00
MOVSXD RCX,EAX
LEA RAX,[0x265fd0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148dc4:
CMP dword ptr [RBP + -0x8],0xf900
JL 0x00148df1
CMP dword ptr [RBP + -0x8],0xfa0b
JG 0x00148df1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xf900
MOVSXD RCX,EAX
LEA RAX,[0x26b720]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148df1:
CMP dword ptr [RBP + -0x8],0xff01
JL 0x00148e1e
CMP dword ptr [RBP + -0x8],0xffe6
JG 0x00148e1e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xff01
MOVSXD RCX,EAX
LEA RAX,[0x26b940]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00148e25
LAB_00148e1e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00148e25:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_ksc5601_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa1) || (0x167 < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2015) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x266d < param_1)) {
if ((param_1 < 0x3000) || (0x327f < param_1)) {
if ((param_1 < 0x3380) || (0x33dd < param_1)) {
if ((param_1 < 0x4e00) || (0x947f < param_1)) {
if ((param_1 < 0x9577) || (0x9f9c < param_1)) {
if ((param_1 < 0xac00) || (0xd7a3 < param_1)) {
if ((param_1 < 0xf900) || (0xfa0b < param_1)) {
if ((param_1 < 0xff01) || (0xffe6 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_ksc560110 + (long)(param_1 + -0xff01) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56019 + (long)(param_1 + -0xf900) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56018 + (long)(param_1 + -0xac00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56017 + (long)(param_1 + -0x9577) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56016 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56015 + (long)(param_1 + -0x3380) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56014 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56013 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56012 + (long)(param_1 + -0x2015) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56011 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_ksc56010 + (long)(param_1 + -0xa1) * 2);
}
return uVar1;
}
| |
39,485 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> minja::Value::get<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 | monkey531[P]llama/common/./minja.hpp | inline json Value::get<json>() const {
if (is_primitive()) return primitive_;
if (is_null()) return json();
if (array_) {
std::vector<json> res;
for (const auto& item : *array_) {
res.push_back(item.get<json>());
}
return res;
}
if (object_) {
json res = json::object();
for (const auto& [key, value] : *object_) {
if (key.is_string()) {
res[key.get<std::string>()] = value.get<json>();
} else if (key.is_primitive()) {
res[key.dump()] = value.get<json>();
} else {
throw std::runtime_error("Invalid key type for conversion to JSON: " + key.dump());
}
}
if (is_callable()) {
res["__callable__"] = true;
}
return res;
}
throw std::runtime_error("get<json> not defined for this value type: " + dump());
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> minja::Value::get<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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
movq 0x20(%rsi), %rcx
movq %rax, %rsi
orq %rcx, %rsi
movq 0x30(%r14), %rdx
orq %rdx, %rsi
jne 0x75c18
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b1f8
jmp 0x75e6e
testq %rdx, %rdx
sete %dl
movq %rax, %rsi
orq %rcx, %rsi
sete %sil
cmpb $0x0, 0x40(%r14)
sete %dil
andb %sil, %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x75c67
movb $0x0, (%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3d970
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3d970
jmp 0x75e6e
testq %rax, %rax
je 0x75cd9
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rax), %r14
movq 0x8(%rax), %r13
cmpq %r13, %r14
je 0x75cc1
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x75bd6
movq %r12, %rdi
movq %r15, %rsi
callq 0x3f08e
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r15, %rdi
callq 0x4a5c0
addq $0x50, %r14
cmpq %r13, %r14
jne 0x75c90
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x76830
movq %rsp, %rdi
callq 0x3efba
jmp 0x75e6e
testq %rcx, %rcx
je 0x75ee9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2afce
movq 0x20(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
cmpq %r13, %r15
je 0x75e10
leaq 0xa8(%rsp), %rbp
leaq 0x50(%rsp), %r12
leaq 0x10(%r15), %rsi
movzbl (%r15), %eax
testl %eax, %eax
je 0x75d8e
cmpl $0x4, %eax
je 0x75d8e
cmpl $0x3, %eax
jne 0x75d84
leaq 0x40(%rsp), %rdi
callq 0x75bd6
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3f9aa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6fb22
movq %rax, %rdi
leaq 0x40(%rsp), %r12
movq %r12, %rsi
callq 0x46ee0
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rcx
movq %rcx, %rax
cmpq %rcx, %rdi
jne 0x75ddc
leaq 0x40(%rsp), %r12
jmp 0x75dec
addb $-0x5, %al
cmpb $0x3, %al
ja 0x75e83
movq %rbp, %rdi
callq 0x75bd6
movq %r12, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2bc5e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6fb22
movq %rax, %rdi
movq %rbp, %rsi
callq 0x46ee0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rcx
movq %rcx, %rax
movq %rbp, %r12
cmpq %rcx, %rdi
je 0x75de9
movq (%rax), %rsi
incq %rsi
callq 0x186a0
jmp 0x75dec
movq %rbp, %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r12, %rdi
callq 0x4a5c0
addq $0x60, %r15
cmpq %r13, %r15
leaq 0x50(%rsp), %r12
jne 0x75d17
cmpq $0x0, 0x30(%r14)
je 0x75e6e
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %r14
movaps %xmm0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3fab4
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
leaq 0x472bf(%rip), %rsi # 0xbd103
movq %rbx, %rdi
callq 0x69088
leaq 0x70(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x46ee0
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r14, %rdi
callq 0x4a5c0
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %r12
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl $0x20, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2bc5e
leaq 0x47225(%rip), %rsi # 0xbd0d9
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x30c3b
movb $0x1, %bpl
movq %rsp, %rsi
movq %r12, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x7a118(%rip), %rsi # 0xefff0
movq 0x7a0a1(%rip), %rdx # 0xeff80
movq %r12, %rdi
callq 0x18b30
jmp 0x75f44
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x471ff(%rip), %rsi # 0xbd110
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x30c3b
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x7a0bb(%rip), %rsi # 0xefff0
movq 0x7a044(%rip), %rdx # 0xeff80
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75f62
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75f7d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x75faa
jmp 0x760eb
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75faa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x75faa
movq %rax, %r14
movq %rbx, %rdi
callq 0x18500
jmp 0x760eb
movq %rax, %r14
leaq 0x70(%rsp), %r15
jmp 0x76099
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75fe2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x75ffd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x7602f
jmp 0x760b0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7602f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x7602f
jmp 0x760c4
movq %rax, %r14
movq %r12, %rdi
callq 0x18500
jmp 0x760b0
movq %rax, %r14
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x76066
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x76066
movq %rax, %r14
leaq 0x40(%rsp), %r15
jmp 0x76099
movq %rax, %r14
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x76091
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x76091
movq %rax, %r14
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r15, %rdi
callq 0x4a5c0
jmp 0x760b0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3d970
movq %rbx, %rdi
callq 0x4a5c0
jmp 0x760eb
movq %rax, %r14
jmp 0x760e3
movq %rax, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3d970
movq %rbx, %rdi
callq 0x4a5c0
movq %rsp, %rdi
callq 0x3efba
movq %r14, %rdi
callq 0x18b90
| _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+10h]
mov rcx, [rsi+20h]
mov rsi, rax
or rsi, rcx
mov rdx, [r14+30h]
or rsi, rdx
jnz short loc_75C18
add r14, 40h ; '@'
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp loc_75E6E
loc_75C18:
test rdx, rdx
setz dl
mov rsi, rax
or rsi, rcx
setz sil
cmp byte ptr [r14+40h], 0
setz dil
and dil, sil
and dil, dl
cmp dil, 1
jnz short loc_75C67
mov byte ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
jmp loc_75E6E
loc_75C67:
test rax, rax
jz short loc_75CD9
xorps xmm0, xmm0
movaps [rsp+0E8h+var_E8], xmm0
mov [rsp+0E8h+var_D8], 0
mov r14, [rax]
mov r13, [rax+8]
cmp r14, r13
jz short loc_75CC1
lea r15, [rsp+0E8h+var_C8]
mov r12, rsp
loc_75C90:
mov rdi, r15
mov rsi, r14
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r14, 50h ; 'P'
cmp r14, r13
jnz short loc_75C90
loc_75CC1:
mov rsi, rsp
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS3_ISD_SaISD_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
jmp loc_75E6E
loc_75CD9:
test rcx, rcx
jz loc_75EE9
mov rdi, rbx
xor esi, esi
xor edx, edx
xor ecx, ecx
mov r8d, 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
mov rax, [r14+20h]
mov r15, [rax]
mov r13, [rax+8]
cmp r15, r13
jz loc_75E10
lea rbp, [rsp+0E8h+var_40]
lea r12, [rsp+0E8h+var_98]
loc_75D17:
lea rsi, [r15+10h]
movzx eax, byte ptr [r15]
test eax, eax
jz short loc_75D8E
cmp eax, 4
jz short loc_75D8E
cmp eax, 3
jnz short loc_75D84
lea rdi, [rsp+0E8h+var_A8]
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
lea r12, [rsp+0E8h+var_60]
mov rdi, r12
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rdi, rbx
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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[](std::string)
mov rdi, rax
lea r12, [rsp+0E8h+var_A8]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+0E8h+var_60]
lea rcx, [rsp+0E8h+var_50]
mov rax, rcx
cmp rdi, rcx
jnz short loc_75DDC
lea r12, [rsp+0E8h+var_A8]
jmp short loc_75DEC
loc_75D84:
add al, 0FBh
cmp al, 3
ja loc_75E83
loc_75D8E:
mov rdi, rbp
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
mov rdi, r12
mov rsi, r15
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_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>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
mov rdi, rbx
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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[](std::string)
mov rdi, rax
mov rsi, rbp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+0E8h+var_98]; void *
lea rcx, [rsp+0E8h+var_88]
mov rax, rcx
mov r12, rbp
cmp rdi, rcx
jz short loc_75DE9
loc_75DDC:
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_75DEC
loc_75DE9:
mov r12, rbp
loc_75DEC:
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r15, 60h ; '`'
cmp r15, r13
lea r12, [rsp+0E8h+var_98]
jnz loc_75D17
loc_75E10:
cmp qword ptr [r14+30h], 0
jz short loc_75E6E
xorps xmm0, xmm0
lea r14, [rsp+0E8h+var_78]
movaps xmmword ptr [r14], xmm0
mov rdi, r14
mov esi, 1
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE4EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_9boolean_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::boolean_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
lea rsi, aCallable; "__callable__"
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_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 r14, [rsp+0E8h+var_78]
mov rdi, rax
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
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_75E6E:
mov rax, rbx
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75E83:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r12, rax
lea rdi, [rsp+0E8h+var_C8]
mov rsi, r15
mov edx, 0FFFFFFFFh
mov ecx, 20h ; ' '
xor r8d, r8d
xor r9d, r9d
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dumpEicbNS0_6detail15error_handler_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>::dump(int,char,bool,nlohmann::json_abi_v3_11_3::detail::error_handler_t)
lea rsi, aInvalidKeyType; "Invalid key type for conversion to JSON"...
mov rdi, rsp
lea rdx, [rsp+0E8h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, r12
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, r12; void *
call ___cxa_throw
jmp short loc_75F44
loc_75EE9:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0E8h+var_C8]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetJsonNotDefi; "get<json> not defined for this value ty"...
mov rdi, rsp
lea rdx, [rsp+0E8h+var_C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_75F44:
mov r14, rax
lea rax, [rsp+0E8h+var_D8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_75F62
mov rsi, [rsp+0E8h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_75F62:
lea rax, [rsp+0E8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_75F7D
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_75F7D:
test bpl, bpl
jnz short loc_75FAA
jmp loc_760EB
mov r14, rax
lea rax, [rsp+0E8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_75FAA
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_75FAA
mov r14, rax
loc_75FAA:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp loc_760EB
mov r14, rax
lea r15, [rsp+0E8h+var_78]
jmp loc_76099
mov r14, rax
lea rax, [rsp+0E8h+var_D8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_75FE2
mov rsi, [rsp+0E8h+var_D8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_75FE2:
lea rax, [rsp+0E8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_75FFD
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_75FFD:
test bpl, bpl
jnz short loc_7602F
jmp loc_760B0
mov r14, rax
lea rax, [rsp+0E8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7602F
mov rsi, [rsp+0E8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7602F
jmp loc_760C4
mov r14, rax
loc_7602F:
mov rdi, r12; void *
call ___cxa_free_exception
jmp short loc_760B0
mov r14, rax
mov rdi, [rsp+0E8h+var_60]; void *
lea rax, [rsp+0E8h+var_50]
cmp rdi, rax
jz short loc_76066
mov rsi, [rsp+0E8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_76066
mov r14, rax
loc_76066:
lea r15, [rsp+0E8h+var_A8]
jmp short loc_76099
mov r14, rax
mov rdi, [rsp+0E8h+var_98]; void *
lea rax, [rsp+0E8h+var_88]
cmp rdi, rax
jz short loc_76091
mov rsi, [rsp+0E8h+var_88]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_76091
mov r14, rax
loc_76091:
lea r15, [rsp+0E8h+var_40]
loc_76099:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_760B0
mov r14, rax
loc_760B0:
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_760EB
loc_760C4:
mov r14, rax
jmp short loc_760E3
mov r14, rax
lea rbx, [rsp+0E8h+var_C8]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_760E3:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_760EB:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1,
long long a2)
{
unsigned long long v4; // rax
long long v5; // rcx
long long v6; // rdx
long long v7; // r14
long long v8; // r13
long long v9; // rax
_BYTE *v10; // r15
_BYTE *v11; // r13
_BYTE *v12; // rsi
int v13; // eax
long long v14; // rax
char *v15; // r12
void *v16; // rdi
_QWORD *v17; // rax
long long v18; // rax
long long v19; // rax
void *v21; // r12
void *exception; // rbx
__int128 v23; // [rsp+0h] [rbp-E8h] BYREF
long long v24; // [rsp+10h] [rbp-D8h]
void **v25[2]; // [rsp+20h] [rbp-C8h] BYREF
_BYTE v26[16]; // [rsp+40h] [rbp-A8h] BYREF
void *v27[2]; // [rsp+50h] [rbp-98h] BYREF
_QWORD v28[2]; // [rsp+60h] [rbp-88h] BYREF
__int128 v29; // [rsp+70h] [rbp-78h] BYREF
void *v30[2]; // [rsp+88h] [rbp-60h] BYREF
_QWORD v31[2]; // [rsp+98h] [rbp-50h] BYREF
_BYTE v32[64]; // [rsp+A8h] [rbp-40h] BYREF
v4 = *(_QWORD *)(a2 + 16);
v5 = *(_QWORD *)(a2 + 32);
v6 = *(_QWORD *)(a2 + 48);
if ( !(v6 | v5 | 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>::basic_json(
a1,
a2 + 64);
return a1;
}
if ( v6 == 0 && (v5 | v4) == 0 && *(_BYTE *)(a2 + 64) == 0 )
{
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return a1;
}
if ( v4 )
{
v23 = 0LL;
v24 = 0LL;
v7 = *(_QWORD *)v4;
v8 = *(_QWORD *)(v4 + 8);
if ( *(_QWORD *)v4 != v8 )
{
do
{
minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
v25,
v7);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(long long)&v23,
(long long)v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v25);
v7 += 80LL;
}
while ( v7 != v8 );
}
((void ( *)(long long, __int128 *))ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS3_ISD_SaISD_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_)(
a1,
&v23);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector((long long)&v23);
return a1;
}
if ( !v5 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v25, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)&v23, (long long)"get<json> not defined for this value type: ", (long long)v25);
std::runtime_error::runtime_error(exception, &v23);
__cxa_throw(
exception,
(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>::basic_json(
a1,
0LL,
0LL,
0LL,
1LL);
v9 = *(_QWORD *)(a2 + 32);
v10 = *(_BYTE **)v9;
v11 = *(_BYTE **)(v9 + 8);
if ( *(_BYTE **)v9 != v11 )
{
while ( 1 )
{
v12 = v10 + 16;
v13 = (unsigned __int8)*v10;
if ( !*v10 || v13 == 4 )
goto LABEL_17;
if ( v13 != 3 )
break;
minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
v26,
v12);
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
(long long)v30,
(long long)v10);
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>::operator[](
a1,
(long long *)v30);
v15 = v26;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v14,
(long long)v26);
v16 = v30[0];
v17 = v31;
if ( v30[0] != v31 )
goto LABEL_18;
v15 = v26;
LABEL_20:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(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>::data::~data((void ***)v15);
v10 += 96;
if ( v10 == v11 )
goto LABEL_21;
}
if ( (unsigned __int8)(v13 - 5) > 3u )
{
v21 = __cxa_allocate_exception(0x10uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)v25,
(long long)v10,
-1,
32,
0,
0);
std::operator+<char>((long long)&v23, (long long)"Invalid key type for conversion to JSON: ", (long long)v25);
std::runtime_error::runtime_error(v21, &v23);
__cxa_throw(
v21,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
LABEL_17:
minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
v32,
v12);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)v27,
(long long)v10,
-1,
32,
0,
0);
v18 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
a1,
(long long *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v18,
(long long)v32);
v16 = v27[0];
v17 = v28;
v15 = v32;
if ( v27[0] == v28 )
{
v15 = v32;
goto LABEL_20;
}
LABEL_18:
operator delete(v16, *v17 + 1LL);
goto LABEL_20;
}
LABEL_21:
if ( *(_QWORD *)(a2 + 48) )
{
v29 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
(unsigned __int8 *)&v29,
1u);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v29);
v19 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
a1,
(long long)"__callable__");
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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=(
v19,
(long long)&v29);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v29);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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 ***)&v29);
}
return a1;
}
| get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x10]
MOV RCX,qword ptr [RSI + 0x20]
MOV RSI,RAX
OR RSI,RCX
MOV RDX,qword ptr [R14 + 0x30]
OR RSI,RDX
JNZ 0x00175c18
ADD R14,0x40
MOV RDI,RBX
MOV RSI,R14
CALL 0x0012b1f8
JMP 0x00175e6e
LAB_00175c18:
TEST RDX,RDX
SETZ DL
MOV RSI,RAX
OR RSI,RCX
SETZ SIL
CMP byte ptr [R14 + 0x40],0x0
SETZ DIL
AND DIL,SIL
AND DIL,DL
CMP DIL,0x1
JNZ 0x00175c67
MOV byte ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0013d970
MOV RDI,RBX
MOV ESI,0x1
CALL 0x0013d970
JMP 0x00175e6e
LAB_00175c67:
TEST RAX,RAX
JZ 0x00175cd9
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV R14,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R14,R13
JZ 0x00175cc1
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_00175c90:
MOV RDI,R15
MOV RSI,R14
CALL 0x00175bd6
LAB_00175c9b:
MOV RDI,R12
MOV RSI,R15
CALL 0x0013f08e
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R15
CALL 0x0014a5c0
ADD R14,0x50
CMP R14,R13
JNZ 0x00175c90
LAB_00175cc1:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00176830
LAB_00175ccc:
MOV RDI,RSP
CALL 0x0013efba
JMP 0x00175e6e
LAB_00175cd9:
TEST RCX,RCX
JZ 0x00175ee9
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,0x1
CALL 0x0012afce
MOV RAX,qword ptr [R14 + 0x20]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R15,R13
JZ 0x00175e10
LEA RBP,[RSP + 0xa8]
LEA R12,[RSP + 0x50]
LAB_00175d17:
LEA RSI,[R15 + 0x10]
MOVZX EAX,byte ptr [R15]
TEST EAX,EAX
JZ 0x00175d8e
CMP EAX,0x4
JZ 0x00175d8e
CMP EAX,0x3
JNZ 0x00175d84
LAB_00175d2d:
LEA RDI,[RSP + 0x40]
CALL 0x00175bd6
LAB_00175d37:
LEA R12,[RSP + 0x88]
MOV RDI,R12
MOV RSI,R15
CALL 0x0013f9aa
LAB_00175d4a:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0016fb22
MOV RDI,RAX
LEA R12,[RSP + 0x40]
MOV RSI,R12
CALL 0x00146ee0
MOV RDI,qword ptr [RSP + 0x88]
LEA RCX,[RSP + 0x98]
MOV RAX,RCX
CMP RDI,RCX
JNZ 0x00175ddc
LEA R12,[RSP + 0x40]
JMP 0x00175dec
LAB_00175d84:
ADD AL,0xfb
CMP AL,0x3
JA 0x00175e83
LAB_00175d8e:
MOV RDI,RBP
CALL 0x00175bd6
LAB_00175d96:
MOV RDI,R12
MOV RSI,R15
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0012bc5e
LAB_00175db1:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0016fb22
MOV RDI,RAX
MOV RSI,RBP
CALL 0x00146ee0
MOV RDI,qword ptr [RSP + 0x50]
LEA RCX,[RSP + 0x60]
MOV RAX,RCX
MOV R12,RBP
CMP RDI,RCX
JZ 0x00175de9
LAB_00175ddc:
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001186a0
JMP 0x00175dec
LAB_00175de9:
MOV R12,RBP
LAB_00175dec:
MOV RDI,R12
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R12
CALL 0x0014a5c0
ADD R15,0x60
CMP R15,R13
LEA R12,[RSP + 0x50]
JNZ 0x00175d17
LAB_00175e10:
CMP qword ptr [R14 + 0x30],0x0
JZ 0x00175e6e
XORPS XMM0,XMM0
LEA R14,[RSP + 0x70]
MOVAPS xmmword ptr [R14],XMM0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013fab4
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
LAB_00175e3d:
LEA RSI,[0x1bd103]
MOV RDI,RBX
CALL 0x00169088
LAB_00175e4c:
LEA R14,[RSP + 0x70]
MOV RDI,RAX
MOV RSI,R14
CALL 0x00146ee0
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R14
CALL 0x0014a5c0
LAB_00175e6e:
MOV RAX,RBX
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175e83:
MOV EDI,0x10
CALL 0x00118360
MOV R12,RAX
LAB_00175e90:
LEA RDI,[RSP + 0x20]
MOV RSI,R15
MOV EDX,0xffffffff
MOV ECX,0x20
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0012bc5e
LAB_00175ead:
LEA RSI,[0x1bd0d9]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00130c3b
MOV BPL,0x1
LAB_00175ec4:
MOV RSI,RSP
MOV RDI,R12
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R12
CALL 0x00118b30
LAB_00175ee9:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_00175ef6:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_00175f0a:
LEA RSI,[0x1bd110]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00130c3b
MOV BPL,0x1
LAB_00175f21:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,RBX
CALL 0x00118b30
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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 */
void minja::Value::
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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)
{
char cVar1;
long lVar2;
char *pcVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar4;
long *plVar5;
basic_json *pbVar6;
runtime_error *prVar7;
long in_RSI;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*in_RDI;
long *plVar8;
data *this;
long lVar9;
char *pcVar10;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
data local_c8 [32];
data local_a8 [16];
long *local_98 [2];
long local_88 [2];
int8 local_78;
int8 uStack_70;
long *local_60 [2];
long local_50 [2];
data local_40 [16];
plVar5 = *(long **)(in_RSI + 0x10);
lVar9 = *(long *)(in_RSI + 0x20);
if ((plVar5 == (long *)0x0 && lVar9 == 0) && *(long *)(in_RSI + 0x30) == 0) {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(in_RDI,(basic_json *)(in_RSI + 0x40));
}
else if ((*(char *)(in_RSI + 0x40) == '\0' && (plVar5 == (long *)0x0 && lVar9 == 0)) &&
*(long *)(in_RSI + 0x30) == 0) {
*in_RDI = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
*(int8 *)(in_RDI + 8) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(in_RDI,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(in_RDI,0));
}
else if (plVar5 == (long *)0x0) {
if (lVar9 == 0) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00175ef6 to 00175f09 has its CatchHandler @ 00175fa7 */
dump_abi_cxx11_((int)local_c8,SUB81(in_RSI,0));
/* try { // try from 00175f0a to 00175f1d has its CatchHandler @ 00175f87 */
std::operator+((char *)&local_e8,(string *)"get<json> not defined for this value type: ");
/* try { // try from 00175f21 to 00175f43 has its CatchHandler @ 00175f44 */
std::runtime_error::runtime_error(prVar7,(string *)&local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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();
pcVar10 = (char *)**(int8 **)(in_RSI + 0x20);
pcVar3 = (char *)(*(int8 **)(in_RSI + 0x20))[1];
if (pcVar10 != pcVar3) {
do {
cVar1 = *pcVar10;
if ((cVar1 == '\0') || (cVar1 == '\x04')) {
LAB_00175d8e:
/* try { // try from 00175d8e to 00175d95 has its CatchHandler @ 001760ad */
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
();
/* try { // try from 00175d96 to 00175db0 has its CatchHandler @ 0017608e */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_98,pcVar10,0xffffffff,0x20,0,0);
/* try { // try from 00175db1 to 00175dbb has its CatchHandler @ 0017606d */
pbVar4 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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[]();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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=(pbVar4,local_40);
plVar5 = local_88;
plVar8 = local_98[0];
this = local_40;
if (local_98[0] != plVar5) {
LAB_00175ddc:
operator_delete(plVar8,*plVar5 + 1);
}
}
else {
if (cVar1 != '\x03') {
if (3 < (byte)(cVar1 - 5U)) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10,pcVar10 + 0x10);
/* try { // try from 00175e90 to 00175eac has its CatchHandler @ 0017602c */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::dump(local_c8,pcVar10,0xffffffff,0x20,0,0);
/* try { // try from 00175ead to 00175ec0 has its CatchHandler @ 00176007 */
std::operator+((char *)&local_e8,(string *)"Invalid key type for conversion to JSON: "
);
/* try { // try from 00175ec4 to 00175ee6 has its CatchHandler @ 00175fc4 */
std::runtime_error::runtime_error(prVar7,(string *)&local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
goto LAB_00175d8e;
}
/* try { // try from 00175d2d to 00175d36 has its CatchHandler @ 001760ad */
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
();
/* try { // try from 00175d37 to 00175d49 has its CatchHandler @ 00176063 */
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(local_60,pcVar10);
/* try { // try from 00175d4a to 00175d54 has its CatchHandler @ 00176039 */
pbVar4 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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[]();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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=(pbVar4,local_a8);
plVar5 = local_50;
plVar8 = local_60[0];
this = local_a8;
if (local_60[0] != plVar5) goto LAB_00175ddc;
this = local_a8;
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(this,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(this);
pcVar10 = pcVar10 + 0x60;
} while (pcVar10 != pcVar3);
}
if (*(long *)(in_RSI + 0x30) != 0) {
local_78 = 0;
uStack_70 = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_78,1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_78,0));
/* try { // try from 00175e3d to 00175e4b has its CatchHandler @ 00175fb7 */
pbVar6 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>(in_RDI,"__callable__");
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)pbVar6,(data *)&local_78);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_78,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_78);
}
}
else {
local_e8 = 0;
uStack_e0 = 0;
local_d8 = 0;
lVar9 = *plVar5;
lVar2 = plVar5[1];
if (lVar9 != lVar2) {
do {
/* try { // try from 00175c90 to 00175c9a has its CatchHandler @ 001760c4 */
get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
();
/* try { // try from 00175c9b to 00175ca5 has its CatchHandler @ 001760c9 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_e8,(basic_json *)local_c8);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_c8,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_c8);
lVar9 = lVar9 + 0x50;
} while (lVar9 != lVar2);
}
/* try { // try from 00175cc1 to 00175ccb has its CatchHandler @ 00176027 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS3_ISD_SaISD_EESG_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
();
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_e8);
}
return;
}
| |
39,486 | ftxui::separatorCharacter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/separator.cpp | Element separatorCharacter(std::string value) {
return std::make_shared<Separator>(std::move(value));
} | O2 | cpp | ftxui::separatorCharacter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl $0x90, %edi
callq 0xc450
movq %rax, %r14
leaq 0x7(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x311ab(%rip), %rax # 0x50608
movq %rax, (%r14)
leaq 0x10(%r14), %r15
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xc5a0
movq %r15, %rdi
callq 0x1ef28
leaq 0x311d8(%rip), %rax # 0x50658
movq %rax, 0x10(%r14)
movq %r14, %rcx
subq $-0x80, %rcx
movq %rcx, 0x70(%r14)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x1f4af
movq %rdx, 0x70(%r14)
movq 0x28(%rsp), %rcx
movq %rcx, 0x80(%r14)
jmp 0x1f4b5
movups (%rax), %xmm0
movups %xmm0, (%rcx)
leaq 0x40(%rsp), %r12
leaq 0x18(%rsp), %rdi
movq 0x8(%rdi), %rcx
movq %rcx, 0x78(%r14)
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0xc8c8
leaq 0x8(%rsp), %rdi
andq $0x0, 0x8(%rdi)
callq 0x1f95a
movq %r15, (%rbx)
andq $0x0, (%r12)
movq %r14, 0x8(%rbx)
andq $0x0, -0x8(%r12)
movq %r12, %rdi
callq 0x13452
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xc8c8
leaq 0x8(%rsp), %rdi
callq 0x1f95a
movq %rbx, %rdi
callq 0xc7f0
| _ZN5ftxui18separatorCharacterENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov r12, rsi
mov rbx, rdi
mov edi, 90h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea rax, [rsp+68h+var_61]
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_58], r14
mov rax, 100000001h
mov [r14+8], rax
lea rax, off_50608
mov [r14], rax
lea r15, [r14+10h]
lea rdi, [rsp+68h+var_50]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
mov rdi, r15; this
call _ZN5ftxui4NodeC2Ev; ftxui::Node::Node(void)
lea rax, off_50658
mov [r14+10h], rax
mov rcx, r14
sub rcx, 0FFFFFFFFFFFFFF80h
mov [r14+70h], rcx
lea rax, [rsp+68h+var_40]
mov rdx, [rax-10h]
cmp rdx, rax
jz short loc_1F4AF
mov [r14+70h], rdx
mov rcx, [rsp+68h+var_40]
mov [r14+80h], rcx
jmp short loc_1F4B5
loc_1F4AF:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rcx], xmm0
loc_1F4B5:
lea r12, [rsp+68h+var_28]
lea rdi, [rsp+68h+var_50]; void *
mov rcx, [rdi+8]
mov [r14+78h], rcx
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+68h+var_60]
and qword ptr [rdi+8], 0
call _ZNSt15__allocated_ptrISaISt23_Sp_counted_ptr_inplaceIN5ftxui12_GLOBAL__N_19SeparatorESaIS3_ELN9__gnu_cxx12_Lock_policyE2EEEED2Ev; std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::`anonymous namespace'::Separator,std::allocator<ftxui::`anonymous namespace'::Separator>,(__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr()
mov [rbx], r15
and qword ptr [r12], 0
mov [rbx+8], r14
and qword ptr [r12-8], 0
mov rdi, r12
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_0]
call _ZNSt15__allocated_ptrISaISt23_Sp_counted_ptr_inplaceIN5ftxui12_GLOBAL__N_19SeparatorESaIS3_ELN9__gnu_cxx12_Lock_policyE2EEEED2Ev; std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::`anonymous namespace'::Separator,std::allocator<ftxui::`anonymous namespace'::Separator>,(__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr()
mov rdi, rbx
call __Unwind_Resume
| _QWORD * ftxui::separatorCharacter(_QWORD *a1, long long a2)
{
long long v2; // r14
char v4; // [rsp+7h] [rbp-61h] BYREF
char *v5; // [rsp+8h] [rbp-60h]
long long v6; // [rsp+10h] [rbp-58h]
__int128 *v7; // [rsp+18h] [rbp-50h] BYREF
long long v8; // [rsp+20h] [rbp-48h]
__int128 v9; // [rsp+28h] [rbp-40h] BYREF
long long v10; // [rsp+38h] [rbp-30h]
_QWORD v11[5]; // [rsp+40h] [rbp-28h] BYREF
v2 = operator new(0x90uLL);
v5 = &v4;
v6 = v2;
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = off_50608;
std::string::basic_string(&v7, a2);
ftxui::Node::Node((ftxui::Node *)(v2 + 16));
*(_QWORD *)(v2 + 16) = off_50658;
*(_QWORD *)(v2 + 112) = v2 + 128;
if ( v7 == &v9 )
{
*(_OWORD *)(v2 + 128) = v9;
}
else
{
*(_QWORD *)(v2 + 112) = v7;
*(_QWORD *)(v2 + 128) = v9;
}
*(_QWORD *)(v2 + 120) = v8;
v7 = &v9;
v8 = 0LL;
LOBYTE(v9) = 0;
std::string::~string(&v7);
v6 = 0LL;
std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::`anonymous namespace'::Separator,std::allocator<ftxui::`anonymous namespace'::Separator>,(__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr();
*a1 = v2 + 16;
v11[0] = 0LL;
a1[1] = v2;
v10 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v11);
return a1;
}
| separatorCharacter:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R12,RSI
MOV RBX,RDI
MOV EDI,0x90
CALL 0x0010c450
MOV R14,RAX
LEA RAX,[RSP + 0x7]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],R14
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x150608]
MOV qword ptr [R14],RAX
LEA R15,[R14 + 0x10]
LEA RDI,[RSP + 0x18]
MOV RSI,R12
CALL 0x0010c5a0
LAB_0011f471:
MOV RDI,R15
CALL 0x0011ef28
LAB_0011f479:
LEA RAX,[0x150658]
MOV qword ptr [R14 + 0x10],RAX
MOV RCX,R14
SUB RCX,-0x80
MOV qword ptr [R14 + 0x70],RCX
LEA RAX,[RSP + 0x28]
MOV RDX,qword ptr [RAX + -0x10]
CMP RDX,RAX
JZ 0x0011f4af
MOV qword ptr [R14 + 0x70],RDX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [R14 + 0x80],RCX
JMP 0x0011f4b5
LAB_0011f4af:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RCX],XMM0
LAB_0011f4b5:
LEA R12,[RSP + 0x40]
LEA RDI,[RSP + 0x18]
MOV RCX,qword ptr [RDI + 0x8]
MOV qword ptr [R14 + 0x78],RCX
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
CALL 0x0010c8c8
LEA RDI,[RSP + 0x8]
AND qword ptr [RDI + 0x8],0x0
CALL 0x0011f95a
MOV qword ptr [RBX],R15
AND qword ptr [R12],0x0
MOV qword ptr [RBX + 0x8],R14
AND qword ptr [R12 + -0x8],0x0
MOV RDI,R12
CALL 0x00113452
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::separatorCharacter(std::__cxx11::string) */
ftxui * __thiscall ftxui::separatorCharacter(ftxui *this,string *param_2)
{
int8 *puVar1;
int1 local_61;
int1 *local_60;
int8 *local_58;
int1 *local_50;
int8 local_48;
int1 local_40;
int7 uStack_3f;
int8 uStack_38;
int8 local_30;
int8 local_28;
puVar1 = (int8 *)operator_new(0x90);
local_60 = &local_61;
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_00150608;
local_58 = puVar1;
std::__cxx11::string::string((string *)&local_50,param_2);
/* try { // try from 0011f471 to 0011f478 has its CatchHandler @ 0011f510 */
Node::Node((Node *)(puVar1 + 2));
puVar1[2] = &PTR__Separator_00150658;
puVar1[0xe] = puVar1 + 0x10;
if (local_50 == &local_40) {
puVar1[0x10] = CONCAT71(uStack_3f,local_40);
puVar1[0x11] = uStack_38;
}
else {
puVar1[0xe] = local_50;
puVar1[0x10] = CONCAT71(uStack_3f,local_40);
}
puVar1[0xf] = local_48;
local_48 = 0;
local_40 = 0;
local_50 = &local_40;
std::__cxx11::string::~string((string *)&local_50);
local_58 = (int8 *)0x0;
std::
__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::(anonymous_namespace)::Separator,std::allocator<ftxui::(anonymous_namespace)::Separator>,(__gnu_cxx::_Lock_policy)2>>>
::~__allocated_ptr((__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::(anonymous_namespace)::Separator,std::allocator<ftxui::(anonymous_namespace)::Separator>,(__gnu_cxx::_Lock_policy)2>>>
*)&local_60);
*(Node **)this = (Node *)(puVar1 + 2);
local_28 = 0;
*(int8 **)(this + 8) = puVar1;
local_30 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_28);
return this;
}
| |
39,487 | ftxui::Screen::ResetPosition[abi:cxx11](bool) const | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/screen/screen.cpp | std::string Screen::ResetPosition(bool clear) const {
std::stringstream ss;
if (clear) {
ss << "\r"; // MOVE_LEFT;
ss << "\x1b[2K"; // CLEAR_SCREEN;
for (int y = 1; y < dimy_; ++y) {
ss << "\x1B[1A"; // MOVE_UP;
ss << "\x1B[2K"; // CLEAR_LINE;
}
} else {
ss << "\r"; // MOVE_LEFT;
for (int y = 1; y < dimy_; ++y) {
ss << "\x1B[1A"; // MOVE_UP;
}
}
return ss.str();
} | O1 | cpp | ftxui::Screen::ResetPosition[abi:cxx11](bool) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0xb2a0
leaq 0x10(%rsp), %r15
testl %ebp, %ebp
je 0x3a6ae
leaq 0x5987(%rip), %rsi # 0x3ffd0
movl $0x1, %edx
movq %r15, %rdi
callq 0xb490
leaq 0x63fc(%rip), %rsi # 0x40a59
movl $0x4, %edx
movq %r15, %rdi
callq 0xb490
cmpl $0x2, 0x14(%r14)
jl 0x3a6ed
movl $0x1, %ebp
leaq 0x63e1(%rip), %r12 # 0x40a5e
leaq 0x63d5(%rip), %r13 # 0x40a59
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0xb490
movl $0x4, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0xb490
incl %ebp
cmpl 0x14(%r14), %ebp
jl 0x3a684
jmp 0x3a6ed
leaq 0x591b(%rip), %rsi # 0x3ffd0
movl $0x1, %edx
movq %r15, %rdi
callq 0xb490
cmpl $0x2, 0x14(%r14)
jl 0x3a6ed
movl $0x1, %ebp
leaq 0x6389(%rip), %r12 # 0x40a5e
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0xb490
incl %ebp
cmpl 0x14(%r14), %ebp
jl 0x3a6d5
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0xb6b0
movq 0x1f86f(%rip), %rsi # 0x59f70
movq %rsp, %rdi
callq 0xb2e0
leaq 0x80(%rsp), %rdi
callq 0xb120
movq %rbx, %rax
addq $0x188, %rsp # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a72f
jmp 0x3a72f
movq %rax, %rbx
movq 0x1f837(%rip), %rsi # 0x59f70
movq %rsp, %rdi
callq 0xb2e0
leaq 0x80(%rsp), %rdi
callq 0xb120
movq %rbx, %rdi
callq 0xb780
| _ZNK5ftxui6Screen13ResetPositionB5cxx11Eb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 188h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rdi, rsp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea r15, [rsp+1B8h+var_1A8]
test ebp, ebp
jz short loc_3A6AE
lea rsi, unk_3FFD0
mov edx, 1
mov rdi, 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 rsi, a2k; "\x1B[2K"
mov edx, 4
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cmp dword ptr [r14+14h], 2
jl short loc_3A6ED
mov ebp, 1
lea r12, a1a; "\x1B[1A"
lea r13, a2k; "\x1B[2K"
loc_3A684:
mov edx, 4
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov edx, 4
mov rdi, r15
mov rsi, r13
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
inc ebp
cmp ebp, [r14+14h]
jl short loc_3A684
jmp short loc_3A6ED
loc_3A6AE:
lea rsi, unk_3FFD0
mov edx, 1
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cmp dword ptr [r14+14h], 2
jl short loc_3A6ED
mov ebp, 1
lea r12, a1a; "\x1B[1A"
loc_3A6D5:
mov edx, 4
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
inc ebp
cmp ebp, [r14+14h]
jl short loc_3A6D5
loc_3A6ED:
lea rsi, [rsp+1B8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov rdi, rsp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1B8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 188h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_3A72F
jmp short $+2
loc_3A72F:
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
mov rdi, rsp
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_78]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long ftxui::Screen::ResetPosition[abi:cxx11](long long a1, long long a2, int a3)
{
int v4; // ebp
int v5; // ebp
_BYTE v7[16]; // [rsp+0h] [rbp-1B8h] BYREF
_BYTE v8[8]; // [rsp+10h] [rbp-1A8h] BYREF
_BYTE v9[104]; // [rsp+18h] [rbp-1A0h] BYREF
_BYTE v10[312]; // [rsp+80h] [rbp-138h] BYREF
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v7);
if ( a3 )
{
std::__ostream_insert<char,std::char_traits<char>>(v8, &unk_3FFD0, 1LL);
std::__ostream_insert<char,std::char_traits<char>>(v8, "\x1B[2K", 4LL);
if ( *(int *)(a2 + 20) >= 2 )
{
v4 = 1;
do
{
std::__ostream_insert<char,std::char_traits<char>>(v8, "\x1B[1A", 4LL);
std::__ostream_insert<char,std::char_traits<char>>(v8, "\x1B[2K", 4LL);
++v4;
}
while ( v4 < *(_DWORD *)(a2 + 20) );
}
}
else
{
std::__ostream_insert<char,std::char_traits<char>>(v8, &unk_3FFD0, 1LL);
if ( *(int *)(a2 + 20) >= 2 )
{
v5 = 1;
do
{
std::__ostream_insert<char,std::char_traits<char>>(v8, "\x1B[1A", 4LL);
++v5;
}
while ( v5 < *(_DWORD *)(a2 + 20) );
}
}
std::stringbuf::str(a1, v9);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v7,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v10);
return a1;
}
| ResetPosition[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x188
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSP
CALL 0x0010b2a0
LEA R15,[RSP + 0x10]
TEST EBP,EBP
JZ 0x0013a6ae
LAB_0013a642:
LEA RSI,[0x13ffd0]
MOV EDX,0x1
MOV RDI,R15
CALL 0x0010b490
LEA RSI,[0x140a59]
MOV EDX,0x4
MOV RDI,R15
CALL 0x0010b490
CMP dword ptr [R14 + 0x14],0x2
JL 0x0013a6ed
MOV EBP,0x1
LEA R12,[0x140a5e]
LEA R13,[0x140a59]
LAB_0013a684:
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R12
CALL 0x0010b490
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R13
CALL 0x0010b490
INC EBP
CMP EBP,dword ptr [R14 + 0x14]
JL 0x0013a684
JMP 0x0013a6ed
LAB_0013a6ae:
LEA RSI,[0x13ffd0]
MOV EDX,0x1
MOV RDI,R15
CALL 0x0010b490
CMP dword ptr [R14 + 0x14],0x2
JL 0x0013a6ed
MOV EBP,0x1
LEA R12,[0x140a5e]
LAB_0013a6d5:
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R12
CALL 0x0010b490
INC EBP
CMP EBP,dword ptr [R14 + 0x14]
JL 0x0013a6d5
LAB_0013a6ed:
LEA RSI,[RSP + 0x18]
LAB_0013a6f2:
MOV RDI,RBX
CALL 0x0010b6b0
LAB_0013a6fa:
MOV RSI,qword ptr [0x00159f70]
MOV RDI,RSP
CALL 0x0010b2e0
LEA RDI,[RSP + 0x80]
CALL 0x0010b120
MOV RAX,RBX
ADD RSP,0x188
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::Screen::ResetPosition[abi:cxx11](bool) const */
int8 ftxui::Screen::ResetPosition_abi_cxx11_(bool param_1)
{
int in_EDX;
int iVar1;
long in_RSI;
int7 in_register_00000039;
stringstream asStack_1b8 [16];
ostream local_1a8 [112];
ios_base local_138 [264];
std::__cxx11::stringstream::stringstream(asStack_1b8);
if (in_EDX == 0) {
/* try { // try from 0013a6ae to 0013a6c1 has its CatchHandler @ 0013a72b */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\r",1);
if (1 < *(int *)(in_RSI + 0x14)) {
iVar1 = 1;
do {
/* try { // try from 0013a6d5 to 0013a6e4 has its CatchHandler @ 0013a72d */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\x1b[1A",4);
iVar1 = iVar1 + 1;
} while (iVar1 < *(int *)(in_RSI + 0x14));
}
}
else {
/* try { // try from 0013a642 to 0013a669 has its CatchHandler @ 0013a72b */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\r",1);
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\x1b[2K",4);
if (1 < *(int *)(in_RSI + 0x14)) {
iVar1 = 1;
do {
/* try { // try from 0013a684 to 0013a6a3 has its CatchHandler @ 0013a72f */
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\x1b[1A",4);
std::__ostream_insert<char,std::char_traits<char>>(local_1a8,"\x1b[2K",4);
iVar1 = iVar1 + 1;
} while (iVar1 < *(int *)(in_RSI + 0x14));
}
}
/* try { // try from 0013a6f2 to 0013a6f9 has its CatchHandler @ 0013a72b */
std::__cxx11::stringbuf::str();
std::__cxx11::stringstream::~stringstream(asStack_1b8);
std::ios_base::~ios_base(local_138);
return CONCAT71(in_register_00000039,param_1);
}
| |
39,488 | dequantize_row_q8_0 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_q8_0(const block_q8_0 * restrict x, float * restrict y, int64_t k) {
static const int qk = QK8_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int j = 0; j < qk; ++j) {
y[i*qk + j] = x[i].qs[j]*d;
}
}
} | O0 | c | dequantize_row_q8_0:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x6ec0a
jmp 0x6ec29
leaq 0x5213f(%rip), %rdi # 0xc0d50
leaq 0x52144(%rip), %rsi # 0xc0d5c
movl $0x160, %edx # imm = 0x160
leaq 0x524d1(%rip), %rcx # 0xc10f5
callq 0x44810
movq -0x18(%rbp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6ecc0
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x22, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %edi
callq 0x6e6e0
movss %xmm0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x20, -0x28(%rbp)
jge 0x6ecb3
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x22, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movsbl 0x2(%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
mulss -0x24(%rbp), %xmm0
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x5, %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6ec6c
jmp 0x6ecb5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6ec41
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| dequantize_row_q8_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov ecx, 20h ; ' '
cqo
idiv rcx
cmp rdx, 0
jnz short loc_6EC0A
jmp short loc_6EC29
loc_6EC0A:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov edx, 160h
lea rcx, aVoidDequantize_3; "void dequantize_row_q8_0(const block_q8"...
call ___assert_fail
loc_6EC29:
mov rax, [rbp+var_18]
mov ecx, 20h ; ' '
cqo
idiv rcx
mov [rbp+var_1C], eax
mov [rbp+var_20], 0
loc_6EC41:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jge short loc_6ECC0
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
imul rcx, 22h ; '"'
add rax, rcx
movzx edi, word ptr [rax]
call ggml_lookup_fp16_to_fp32_0
movss [rbp+var_24], xmm0
mov [rbp+var_28], 0
loc_6EC6C:
cmp [rbp+var_28], 20h ; ' '
jge short loc_6ECB3
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
imul rcx, 22h ; '"'
add rax, rcx
movsxd rcx, [rbp+var_28]
movsx eax, byte ptr [rax+rcx+2]
cvtsi2ss xmm0, eax
mulss xmm0, [rbp+var_24]
mov rax, [rbp+var_10]
mov ecx, [rbp+var_20]
shl ecx, 5
add ecx, [rbp+var_28]
movsxd rcx, ecx
movss dword ptr [rax+rcx*4], xmm0
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp short loc_6EC6C
loc_6ECB3:
jmp short $+2
loc_6ECB5:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_6EC41
loc_6ECC0:
add rsp, 30h
pop rbp
retn
| long long dequantize_row_q8_0(long long a1, long long a2, long long a3)
{
long long result; // rax
int j; // [rsp+8h] [rbp-28h]
float v5; // [rsp+Ch] [rbp-24h]
int i; // [rsp+10h] [rbp-20h]
if ( a3 % 32 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
352LL,
"void dequantize_row_q8_0(const block_q8_0 *restrict, float *restrict, int64_t)");
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= (int)(a3 / 32) )
break;
v5 = ggml_lookup_fp16_to_fp32_0(*(_WORD *)(34LL * i + a1));
for ( j = 0; j < 32; ++j )
*(float *)(a2 + 4LL * (j + 32 * i)) = (float)*(char *)(34LL * i + a1 + j + 2) * v5;
}
return result;
}
| dequantize_row_q8_0:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x20
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x0016ec0a
JMP 0x0016ec29
LAB_0016ec0a:
LEA RDI,[0x1c0d50]
LEA RSI,[0x1c0d5c]
MOV EDX,0x160
LEA RCX,[0x1c10f5]
CALL 0x00144810
LAB_0016ec29:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x20
CQO
IDIV RCX
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x20],0x0
LAB_0016ec41:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x0016ecc0
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
IMUL RCX,RCX,0x22
ADD RAX,RCX
MOVZX EDI,word ptr [RAX]
CALL 0x0016e6e0
MOVSS dword ptr [RBP + -0x24],XMM0
MOV dword ptr [RBP + -0x28],0x0
LAB_0016ec6c:
CMP dword ptr [RBP + -0x28],0x20
JGE 0x0016ecb3
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
IMUL RCX,RCX,0x22
ADD RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x28]
MOVSX EAX,byte ptr [RAX + RCX*0x1 + 0x2]
CVTSI2SS XMM0,EAX
MULSS XMM0,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x20]
SHL ECX,0x5
ADD ECX,dword ptr [RBP + -0x28]
MOVSXD RCX,ECX
MOVSS dword ptr [RAX + RCX*0x4],XMM0
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0016ec6c
LAB_0016ecb3:
JMP 0x0016ecb5
LAB_0016ecb5:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0016ec41
LAB_0016ecc0:
ADD RSP,0x30
POP RBP
RET
|
void dequantize_row_q8_0(long param_1,long param_2,long param_3)
{
float fVar1;
int local_30;
int local_28;
if (param_3 % 0x20 == 0) {
for (local_28 = 0; local_28 < (int)(param_3 / 0x20); local_28 = local_28 + 1) {
fVar1 = (float)ggml_lookup_fp16_to_fp32(*(int2 *)(param_1 + (long)local_28 * 0x22));
for (local_30 = 0; local_30 < 0x20; local_30 = local_30 + 1) {
*(float *)(param_2 + (long)(local_28 * 0x20 + local_30) * 4) =
(float)(int)*(char *)(param_1 + (long)local_28 * 0x22 + 2 + (long)local_30) * fVar1;
}
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x160,
"void dequantize_row_q8_0(const block_q8_0 *restrict, float *restrict, int64_t)");
}
| |
39,489 | dequantize_row_q8_0 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_q8_0(const block_q8_0 * restrict x, float * restrict y, int64_t k) {
static const int qk = QK8_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int j = 0; j < qk; ++j) {
y[i*qk + j] = x[i].qs[j]*d;
}
}
} | O2 | c | dequantize_row_q8_0:
pushq %rax
testb $0x1f, %dl
jne 0x329d1
shrq $0x5, %rdx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
leaq 0x2(%rdi), %rcx
movq 0x40629(%rip), %r8 # 0x72fa8
cmpq %rdx, %rax
je 0x329cf
movl %eax, %r9d
andl $0x7ffffff, %r9d # imm = 0x7FFFFFF
shlq $0x7, %r9
addq %rsi, %r9
imulq $0x22, %rax, %r10
movzwl (%rdi,%r10), %r10d
movss (%r8,%r10,4), %xmm0
xorl %r10d, %r10d
cmpq $0x20, %r10
je 0x329c6
movsbl (%rcx,%r10), %r11d
cvtsi2ss %r11d, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%r9,%r10,4)
incq %r10
jmp 0x329a7
incq %rax
addq $0x22, %rcx
jmp 0x3297f
popq %rax
retq
leaq 0x2b080(%rip), %rdi # 0x5da58
leaq 0x2b085(%rip), %rsi # 0x5da64
leaq 0x2b417(%rip), %rcx # 0x5ddfd
movl $0x160, %edx # imm = 0x160
callq 0x1dfb0
| dequantize_row_q8_0:
push rax
test dl, 1Fh
jnz short loc_329D1
shr rdx, 5
xor eax, eax
test edx, edx
cmovle edx, eax
lea rcx, [rdi+2]
mov r8, cs:ggml_table_f32_f16_ptr
loc_3297F:
cmp rax, rdx
jz short loc_329CF
mov r9d, eax
and r9d, 7FFFFFFh
shl r9, 7
add r9, rsi
imul r10, rax, 22h ; '"'
movzx r10d, word ptr [rdi+r10]
movss xmm0, dword ptr [r8+r10*4]
xor r10d, r10d
loc_329A7:
cmp r10, 20h ; ' '
jz short loc_329C6
movsx r11d, byte ptr [rcx+r10]
cvtsi2ss xmm1, r11d
mulss xmm1, xmm0
movss dword ptr [r9+r10*4], xmm1
inc r10
jmp short loc_329A7
loc_329C6:
inc rax
add rcx, 22h ; '"'
jmp short loc_3297F
loc_329CF:
pop rax
retn
loc_329D1:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_3; "void dequantize_row_q8_0(const block_q8"...
mov edx, 160h
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> dequantize_row_q8_0(
long long a1,
long long a2,
unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
long long v5; // rcx
float v6; // xmm0_4
long long i; // r10
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
352LL,
"void dequantize_row_q8_0(const block_q8_0 *restrict, float *restrict, int64_t)");
v3 = a3 >> 5;
v4 = 0LL;
if ( (int)v3 <= 0 )
v3 = 0LL;
v5 = a1 + 2;
while ( v4 != v3 )
{
v6 = ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 34 * v4)];
for ( i = 0LL; i != 32; ++i )
*(float *)(a2 + ((unsigned long long)(v4 & 0x7FFFFFF) << 7) + 4 * i) = (float)*(char *)(v5 + i) * v6;
++v4;
v5 += 34LL;
}
}
| dequantize_row_q8_0:
PUSH RAX
TEST DL,0x1f
JNZ 0x001329d1
SHR RDX,0x5
XOR EAX,EAX
TEST EDX,EDX
CMOVLE EDX,EAX
LEA RCX,[RDI + 0x2]
MOV R8,qword ptr [0x00172fa8]
LAB_0013297f:
CMP RAX,RDX
JZ 0x001329cf
MOV R9D,EAX
AND R9D,0x7ffffff
SHL R9,0x7
ADD R9,RSI
IMUL R10,RAX,0x22
MOVZX R10D,word ptr [RDI + R10*0x1]
MOVSS XMM0,dword ptr [R8 + R10*0x4]
XOR R10D,R10D
LAB_001329a7:
CMP R10,0x20
JZ 0x001329c6
MOVSX R11D,byte ptr [RCX + R10*0x1]
CVTSI2SS XMM1,R11D
MULSS XMM1,XMM0
MOVSS dword ptr [R9 + R10*0x4],XMM1
INC R10
JMP 0x001329a7
LAB_001329c6:
INC RAX
ADD RCX,0x22
JMP 0x0013297f
LAB_001329cf:
POP RAX
RET
LAB_001329d1:
LEA RDI,[0x15da58]
LEA RSI,[0x15da64]
LEA RCX,[0x15ddfd]
MOV EDX,0x160
CALL 0x0011dfb0
|
int8 dequantize_row_q8_0(long param_1,long param_2,ulong param_3)
{
float fVar1;
int *puVar2;
int8 in_RAX;
ulong uVar3;
long lVar4;
ulong uVar5;
long lVar6;
puVar2 = PTR_ggml_table_f32_f16_00172fa8;
if ((param_3 & 0x1f) == 0) {
uVar3 = 0;
uVar5 = param_3 >> 5 & 0xffffffff;
if ((int)(param_3 >> 5) < 1) {
uVar5 = uVar3;
}
lVar4 = param_1 + 2;
for (; uVar3 != uVar5; uVar3 = uVar3 + 1) {
fVar1 = *(float *)(puVar2 + (ulong)*(ushort *)(param_1 + uVar3 * 0x22) * 4);
for (lVar6 = 0; lVar6 != 0x20; lVar6 = lVar6 + 1) {
*(float *)((ulong)((uint)uVar3 & 0x7ffffff) * 0x80 + param_2 + lVar6 * 4) =
(float)(int)*(char *)(lVar4 + lVar6) * fVar1;
}
lVar4 = lVar4 + 0x22;
}
return in_RAX;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x160,
"void dequantize_row_q8_0(const block_q8_0 *restrict, float *restrict, int64_t)");
}
| |
39,490 | dequantize_row_q8_0 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void dequantize_row_q8_0(const block_q8_0 * restrict x, float * restrict y, int64_t k) {
static const int qk = QK8_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (int j = 0; j < qk; ++j) {
y[i*qk + j] = x[i].qs[j]*d;
}
}
} | O3 | c | dequantize_row_q8_0:
pushq %rax
testb $0x1f, %dl
jne 0x2d76c
shrq $0x5, %rdx
testl %edx, %edx
jle 0x2d76a
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x2(%rdi), %rax
xorl %ecx, %ecx
movq 0x40893(%rip), %r8 # 0x6dfa8
movq %rcx, %r9
shlq $0x5, %r9
leaq (%r9,%rcx,2), %r9
movzwl (%rdi,%r9), %r9d
movss (%r8,%r9,4), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
xorl %r9d, %r9d
movd (%rax,%r9), %xmm1
punpcklbw %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
punpcklwd %xmm1, %xmm1 # xmm1 = xmm1[0,0,1,1,2,2,3,3]
psrad $0x18, %xmm1
cvtdq2ps %xmm1, %xmm1
mulps %xmm0, %xmm1
movups %xmm1, (%rsi,%r9,4)
addq $0x4, %r9
cmpq $0x20, %r9
jne 0x2d732
incq %rcx
addq $0x22, %rax
subq $-0x80, %rsi
cmpq %rdx, %rcx
jne 0x2d715
popq %rax
retq
leaq 0x2e575(%rip), %rdi # 0x5bce8
leaq 0x2e57a(%rip), %rsi # 0x5bcf4
leaq 0x2e90c(%rip), %rcx # 0x5c08d
movl $0x160, %edx # imm = 0x160
callq 0x16b00
| dequantize_row_q8_0:
push rax
test dl, 1Fh
jnz short loc_2D76C
shr rdx, 5
test edx, edx
jle short loc_2D76A
and edx, 7FFFFFFFh
lea rax, [rdi+2]
xor ecx, ecx
mov r8, cs:ggml_table_f32_f16_ptr
loc_2D715:
mov r9, rcx
shl r9, 5
lea r9, [r9+rcx*2]
movzx r9d, word ptr [rdi+r9]
movss xmm0, dword ptr [r8+r9*4]
shufps xmm0, xmm0, 0
xor r9d, r9d
loc_2D732:
movd xmm1, dword ptr [rax+r9]
punpcklbw xmm1, xmm1
punpcklwd xmm1, xmm1
psrad xmm1, 18h
cvtdq2ps xmm1, xmm1
mulps xmm1, xmm0
movups xmmword ptr [rsi+r9*4], xmm1
add r9, 4
cmp r9, 20h ; ' '
jnz short loc_2D732
inc rcx
add rax, 22h ; '"'
sub rsi, 0FFFFFFFFFFFFFF80h
cmp rcx, rdx
jnz short loc_2D715
loc_2D76A:
pop rax
retn
loc_2D76C:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidDequantize_3; "void dequantize_row_q8_0(const block_q8"...
mov edx, 160h
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> dequantize_row_q8_0(
long long a1,
long long a2,
unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rdx
long long v5; // rax
long long v6; // rcx
__m128 v7; // xmm0
__m128 v8; // xmm0
long long i; // r9
__m128i v10; // xmm1
__m128i v11; // xmm1
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
352LL,
"void dequantize_row_q8_0(const block_q8_0 *restrict, float *restrict, int64_t)");
v3 = a3 >> 5;
if ( (int)v3 > 0 )
{
v4 = v3 & 0x7FFFFFFF;
v5 = a1 + 2;
v6 = 0LL;
do
{
v7 = (__m128)LODWORD(ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 34 * v6)]);
v8 = _mm_shuffle_ps(v7, v7, 0);
for ( i = 0LL; i != 32; i += 4LL )
{
v10 = _mm_cvtsi32_si128(*(_DWORD *)(v5 + i));
v11 = _mm_unpacklo_epi8(v10, v10);
*(__m128 *)(a2 + 4 * i) = _mm_mul_ps(_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(v11, v11), 0x18u)), v8);
}
++v6;
v5 += 34LL;
a2 += 128LL;
}
while ( v6 != v4 );
}
}
| dequantize_row_q8_0:
PUSH RAX
TEST DL,0x1f
JNZ 0x0012d76c
SHR RDX,0x5
TEST EDX,EDX
JLE 0x0012d76a
AND EDX,0x7fffffff
LEA RAX,[RDI + 0x2]
XOR ECX,ECX
MOV R8,qword ptr [0x0016dfa8]
LAB_0012d715:
MOV R9,RCX
SHL R9,0x5
LEA R9,[R9 + RCX*0x2]
MOVZX R9D,word ptr [RDI + R9*0x1]
MOVSS XMM0,dword ptr [R8 + R9*0x4]
SHUFPS XMM0,XMM0,0x0
XOR R9D,R9D
LAB_0012d732:
MOVD XMM1,dword ptr [RAX + R9*0x1]
PUNPCKLBW XMM1,XMM1
PUNPCKLWD XMM1,XMM1
PSRAD XMM1,0x18
CVTDQ2PS XMM1,XMM1
MULPS XMM1,XMM0
MOVUPS xmmword ptr [RSI + R9*0x4],XMM1
ADD R9,0x4
CMP R9,0x20
JNZ 0x0012d732
INC RCX
ADD RAX,0x22
SUB RSI,-0x80
CMP RCX,RDX
JNZ 0x0012d715
LAB_0012d76a:
POP RAX
RET
LAB_0012d76c:
LEA RDI,[0x15bce8]
LEA RSI,[0x15bcf4]
LEA RCX,[0x15c08d]
MOV EDX,0x160
CALL 0x00116b00
|
int8 dequantize_row_q8_0(long param_1,long param_2,ulong param_3)
{
float *pfVar1;
float fVar2;
int4 uVar3;
int8 uVar4;
ulong uVar5;
int6 uVar6;
int1 auVar7 [12];
int *puVar8;
int8 in_RAX;
long lVar9;
ulong uVar10;
uint uVar11;
long lVar12;
short sVar13;
int1 auVar14 [16];
int1 auVar15 [16];
int1 auVar16 [16];
int1 uVar17;
int2 uVar18;
puVar8 = PTR_ggml_table_f32_f16_0016dfa8;
if ((param_3 & 0x1f) == 0) {
uVar11 = (uint)(param_3 >> 5);
if (0 < (int)uVar11) {
lVar9 = param_1 + 2;
uVar10 = 0;
do {
fVar2 = *(float *)(puVar8 + (ulong)*(ushort *)(param_1 + uVar10 * 0x22) * 4);
lVar12 = 0;
do {
uVar3 = *(int4 *)(lVar9 + lVar12);
uVar17 = (int1)((uint)uVar3 >> 0x18);
uVar18 = CONCAT11(uVar17,uVar17);
uVar17 = (int1)((uint)uVar3 >> 0x10);
uVar4 = CONCAT35(CONCAT21(uVar18,uVar17),CONCAT14(uVar17,uVar3));
uVar17 = (int1)((uint)uVar3 >> 8);
uVar6 = CONCAT51(CONCAT41((int)((ulong)uVar4 >> 0x20),uVar17),uVar17);
sVar13 = CONCAT11((char)uVar3,(char)uVar3);
uVar5 = CONCAT62(uVar6,sVar13);
auVar16._8_4_ = 0;
auVar16._0_8_ = uVar5;
auVar16._12_2_ = uVar18;
auVar16._14_2_ = uVar18;
uVar18 = (int2)((ulong)uVar4 >> 0x20);
auVar15._12_4_ = auVar16._12_4_;
auVar15._8_2_ = 0;
auVar15._0_8_ = uVar5;
auVar15._10_2_ = uVar18;
auVar14._10_6_ = auVar15._10_6_;
auVar14._8_2_ = uVar18;
auVar14._0_8_ = uVar5;
uVar18 = (int2)uVar6;
auVar7._4_8_ = auVar14._8_8_;
auVar7._2_2_ = uVar18;
auVar7._0_2_ = uVar18;
pfVar1 = (float *)(param_2 + lVar12 * 4);
*pfVar1 = (float)((int)sVar13 >> 8) * fVar2;
pfVar1[1] = (float)(auVar7._0_4_ >> 0x18) * fVar2;
pfVar1[2] = (float)(auVar14._8_4_ >> 0x18) * fVar2;
pfVar1[3] = (float)(auVar15._12_4_ >> 0x18) * fVar2;
lVar12 = lVar12 + 4;
} while (lVar12 != 0x20);
uVar10 = uVar10 + 1;
lVar9 = lVar9 + 0x22;
param_2 = param_2 + 0x80;
} while (uVar10 != (uVar11 & 0x7fffffff));
}
return in_RAX;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x160,
"void dequantize_row_q8_0(const block_q8_0 *restrict, float *restrict, int64_t)");
}
| |
39,491 | mbedtls_md5_starts_ret | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/md5.c | int mbedtls_md5_starts_ret(mbedtls_md5_context *ctx)
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
return 0;
} | O3 | c | mbedtls_md5_starts_ret:
movaps 0x257ca(%rip), %xmm0 # 0xb03e0
movups %xmm0, (%rdi)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%rdi)
xorl %eax, %eax
retq
| mbedtls_md5_starts_ret:
movaps xmm0, cs:xmmword_B03E0
movups xmmword ptr [rdi], xmm0
mov rax, 1032547698BADCFEh
mov [rdi+10h], rax
xor eax, eax
retn
| long long mbedtls_md5_starts_ret(long long a1)
{
*(_OWORD *)a1 = xmmword_B03E0;
*(_QWORD *)(a1 + 16) = 0x1032547698BADCFELL;
return 0LL;
}
| mbedtls_md5_starts_ret:
MOVAPS XMM0,xmmword ptr [0x001b03e0]
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,0x1032547698badcfe
MOV qword ptr [RDI + 0x10],RAX
XOR EAX,EAX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 mbedtls_md5_starts_ret(int8 *param_1)
{
int8 uVar1;
uVar1 = _UNK_001b03e8;
*param_1 = _DAT_001b03e0;
param_1[1] = uVar1;
param_1[2] = 0x1032547698badcfe;
return 0;
}
| |
39,492 | update_output_type | eloqsql/plugin/server_audit/server_audit.c | static void update_output_type(MYSQL_THD thd,
struct st_mysql_sys_var *var __attribute__((unused)),
void *var_ptr __attribute__((unused)), const void *save)
{
ulong new_output_type= *((ulong *) save);
if (output_type == new_output_type)
return;
ADD_ATOMIC(internal_stop_logging, 1);
mysql_prlock_wrlock(&lock_operations);
if (logging)
{
log_current_query(thd);
stop_logging();
}
output_type= new_output_type;
error_header();
fprintf(stderr, "Output was redirected to '%s'\n",
output_type_names[output_type]);
if (logging)
start_logging();
mysql_prlock_unlock(&lock_operations);
ADD_ATOMIC(internal_stop_logging, -1);
} | O3 | c | update_output_type:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rcx), %r15
cmpq %r15, 0x7a57(%rip) # 0xed08
jne 0x72be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x7a88(%rip), %r14 # 0xed50
movq %r14, %rdi
callq 0x3340
incl 0x5e76(%rip) # 0xd14c
movq %r14, %rdi
callq 0x31f0
cmpq $0x0, 0x78e2(%rip) # 0xebc8
jne 0x7396
leaq 0x786d(%rip), %rdi # 0xeb60
callq 0x30c0
cmpb $0x0, 0x66f1(%rip) # 0xd9f0
je 0x730e
movq %rbx, %rdi
callq 0x73b2
callq 0x7456
movq %r15, 0x79f3(%rip) # 0xed08
callq 0x6aaf
movq 0x4cd7(%rip), %rax # 0xbff8
movq (%rax), %rdi
movq 0x79dd(%rip), %rax # 0xed08
leaq 0x5b6e(%rip), %rcx # 0xcea0
movq (%rcx,%rax,8), %rcx
leaq 0x2352(%rip), %rdx # 0x968f
movl $0x1, %esi
xorl %eax, %eax
callq 0x3300
cmpb $0x0, 0x66a0(%rip) # 0xd9f0
je 0x7357
callq 0x74cd
movq 0x786a(%rip), %rdi # 0xebc8
testq %rdi, %rdi
jne 0x73a0
leaq 0x77f6(%rip), %rdi # 0xeb60
callq 0x3110
leaq 0x79da(%rip), %rbx # 0xed50
movq %rbx, %rdi
callq 0x3340
decl 0x5dc8(%rip) # 0xd14c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x31f0
callq 0x341c
jmp 0x72f8
movq 0x4c09(%rip), %rax # 0xbfb0
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x7363
| update_output_type:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r15, [rcx]
cmp cs:output_type, r15
jnz short loc_72BE
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_72BE:
mov rbx, rdi
lea r14, lock_atomic
mov rdi, r14
call _pthread_mutex_lock
inc cs:internal_stop_logging
mov rdi, r14
call _pthread_mutex_unlock
cmp cs:qword_EBC8, 0
jnz loc_7396
lea rdi, lock_operations
call _rw_pr_wrlock
loc_72F8:
cmp cs:logging, 0
jz short loc_730E
mov rdi, rbx
call log_current_query
call stop_logging
loc_730E:
mov cs:output_type, r15
call error_header
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rax, cs:output_type
lea rcx, output_type_names
mov rcx, [rcx+rax*8]
lea rdx, aOutputWasRedir; "Output was redirected to '%s'\n"
mov esi, 1
xor eax, eax
call ___fprintf_chk
cmp cs:logging, 0
jz short loc_7357
call start_logging
loc_7357:
mov rdi, cs:qword_EBC8
test rdi, rdi
jnz short loc_73A0
loc_7363:
lea rdi, lock_operations
call _rw_pr_unlock
lea rbx, lock_atomic
mov rdi, rbx
call _pthread_mutex_lock
dec cs:internal_stop_logging
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_7396:
call update_output_type_cold_1
jmp loc_72F8
loc_73A0:
mov rax, cs:PSI_server_ptr
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_7363
| long long update_output_type(long long a1, long long a2, long long a3, long long *a4)
{
long long v4; // r15
long long v5; // rdi
long long result; // rax
v4 = *a4;
if ( output_type != *a4 )
{
pthread_mutex_lock(&lock_atomic);
++internal_stop_logging;
pthread_mutex_unlock(&lock_atomic);
if ( qword_EBC8 )
update_output_type_cold_1(&lock_atomic);
else
rw_pr_wrlock(&lock_operations);
if ( logging )
{
log_current_query(a1);
stop_logging(a1);
}
output_type = v4;
error_header();
v5 = stderr;
__fprintf_chk(stderr, 1LL, "Output was redirected to '%s'\n", output_type_names[output_type]);
if ( logging )
start_logging(v5);
if ( qword_EBC8 )
((void ( *)(long long))PSI_server[45])(qword_EBC8);
rw_pr_unlock(&lock_operations);
pthread_mutex_lock(&lock_atomic);
--internal_stop_logging;
return pthread_mutex_unlock(&lock_atomic);
}
return result;
}
| update_output_type:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R15,qword ptr [RCX]
CMP qword ptr [0x0010ed08],R15
JNZ 0x001072be
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001072be:
MOV RBX,RDI
LEA R14,[0x10ed50]
MOV RDI,R14
CALL 0x00103340
INC dword ptr [0x0010d14c]
MOV RDI,R14
CALL 0x001031f0
CMP qword ptr [0x0010ebc8],0x0
JNZ 0x00107396
LEA RDI,[0x10eb60]
CALL 0x001030c0
LAB_001072f8:
CMP byte ptr [0x0010d9f0],0x0
JZ 0x0010730e
MOV RDI,RBX
CALL 0x001073b2
CALL 0x00107456
LAB_0010730e:
MOV qword ptr [0x0010ed08],R15
CALL 0x00106aaf
MOV RAX,qword ptr [0x0010bff8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [0x0010ed08]
LEA RCX,[0x10cea0]
MOV RCX,qword ptr [RCX + RAX*0x8]
LEA RDX,[0x10968f]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00103300
CMP byte ptr [0x0010d9f0],0x0
JZ 0x00107357
CALL 0x001074cd
LAB_00107357:
MOV RDI,qword ptr [0x0010ebc8]
TEST RDI,RDI
JNZ 0x001073a0
LAB_00107363:
LEA RDI,[0x10eb60]
CALL 0x00103110
LEA RBX,[0x10ed50]
MOV RDI,RBX
CALL 0x00103340
DEC dword ptr [0x0010d14c]
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001031f0
LAB_00107396:
CALL 0x0010341c
JMP 0x001072f8
LAB_001073a0:
MOV RAX,qword ptr [0x0010bfb0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00107363
|
void update_output_type(int8 param_1,int8 param_2,int8 param_3,long *param_4)
{
long lVar1;
lVar1 = *param_4;
if (output_type == lVar1) {
return;
}
pthread_mutex_lock((pthread_mutex_t *)lock_atomic);
internal_stop_logging = internal_stop_logging + 1;
pthread_mutex_unlock((pthread_mutex_t *)lock_atomic);
if (lock_operations._104_8_ == 0) {
rw_pr_wrlock(lock_operations);
}
else {
update_output_type_cold_1();
}
if (logging != '\0') {
log_current_query(param_1);
stop_logging();
}
output_type = lVar1;
error_header();
__fprintf_chk(*(int8 *)PTR_stderr_0010bff8,1,"Output was redirected to \'%s\'\n",
*(int8 *)(output_type_names + output_type * 8));
if (logging != '\0') {
start_logging();
}
if (lock_operations._104_8_ != 0) {
(**(code **)(*(long *)PTR_PSI_server_0010bfb0 + 0x168))();
}
rw_pr_unlock(lock_operations);
pthread_mutex_lock((pthread_mutex_t *)lock_atomic);
internal_stop_logging = internal_stop_logging + -1;
pthread_mutex_unlock((pthread_mutex_t *)lock_atomic);
return;
}
| |
39,493 | emit_class_init_start | bluesky950520[P]quickjs/quickjs.c | static __exception int emit_class_init_start(JSParseState *s,
ClassFieldsDef *cf)
{
int label_add_brand;
cf->fields_init_fd = js_parse_function_class_fields_init(s);
if (!cf->fields_init_fd)
return -1;
s->cur_func = cf->fields_init_fd;
if (!cf->is_static) {
/* add the brand to the newly created instance */
/* XXX: would be better to add the code only if needed, maybe in a
later pass */
emit_op(s, OP_push_false); /* will be patched later */
cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
label_add_brand = emit_goto(s, OP_if_false, -1);
emit_op(s, OP_scope_get_var);
emit_atom(s, JS_ATOM_this);
emit_u16(s, 0);
emit_op(s, OP_scope_get_var);
emit_atom(s, JS_ATOM_home_object);
emit_u16(s, 0);
emit_op(s, OP_add_brand);
emit_label(s, label_add_brand);
}
s->cur_func = s->cur_func->parent;
return 0;
} | O1 | c | emit_class_init_start:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
movq (%rdi), %rdi
movq 0x18(%rbx), %r8
andl $0x0, (%rsp)
xorl %r12d, %r12d
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x1194f
testq %rax, %rax
je 0x11cc8
andl $0x0, 0x88(%rax)
pushq $0x1
popq %rcx
movq %rcx, 0x48(%rax)
andl $0x0, 0x78(%rax)
movaps 0x8cb6b(%rip), %xmm0 # 0x9e810
movups %xmm0, 0x60(%rax)
movq %rcx, 0x70(%rax)
movl $0xffff8000, %ecx # imm = 0xFFFF8000
andl 0x84(%rax), %ecx
orl $0x600, %ecx # imm = 0x600
movw %cx, 0x84(%rax)
movq %rax, %r12
movq %r12, (%r15)
testq %r12, %r12
je 0x11e20
movq %r12, 0x90(%rbx)
cmpl $0x0, 0x14(%r15)
jne 0x11e0a
movl $0x138, %r14d # imm = 0x138
leaq (%r12,%r14), %rdi
movl 0x140(%r12), %eax
movl %eax, 0x168(%r12)
pushq $0x9
popq %rsi
callq 0x1b4d0
movq (%r15), %rax
movl 0x168(%rax), %eax
movl %eax, 0x10(%r15)
pushq $0x69
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x64d83
movl %eax, %ebp
movq 0x90(%rbx), %rax
leaq (%rax,%r14), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0xb7, %esi
callq 0x1b4d0
movq 0x90(%rbx), %rdi
addq %r14, %rdi
leaq 0x18(%rsp), %rsi
movl $0x8, (%rsi)
pushq $0x4
popq %r15
movq %r15, %rdx
callq 0x1b422
movq 0x90(%rbx), %rdi
addq %r14, %rdi
leaq 0x14(%rsp), %rsi
andw $0x0, (%rsi)
pushq $0x2
popq %r12
movq %r12, %rdx
callq 0x1b422
movq 0x90(%rbx), %rax
leaq (%rax,%r14), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0xb7, %esi
callq 0x1b4d0
movq 0x90(%rbx), %rdi
addq %r14, %rdi
leaq 0x1c(%rsp), %rsi
movl $0x74, (%rsi)
movq %r15, %rdx
callq 0x1b422
movq 0x90(%rbx), %rdi
addq %r14, %rdi
leaq 0x16(%rsp), %rsi
andw $0x0, (%rsi)
movq %r12, %rdx
callq 0x1b422
movq 0x90(%rbx), %rax
addq %rax, %r14
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
pushq $0x2d
popq %rsi
movq %r14, %rdi
callq 0x1b4d0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x64ef1
movq 0x90(%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x90(%rbx)
xorl %eax, %eax
jmp 0x11e23
pushq $-0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| emit_class_init_start:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov r15, rsi
mov rbx, rdi
mov rsi, [rdi+90h]
mov rdi, [rdi]
mov r8, [rbx+18h]
and [rsp+48h+var_48], 0
xor r12d, r12d
xor edx, edx
xor ecx, ecx
xor r9d, r9d
call js_new_function_def
test rax, rax
jz short loc_11CC8
and dword ptr [rax+88h], 0
push 1
pop rcx
mov [rax+48h], rcx
and dword ptr [rax+78h], 0
movaps xmm0, cs:xmmword_9E810
movups xmmword ptr [rax+60h], xmm0
mov [rax+70h], rcx
mov ecx, 0FFFF8000h
and ecx, [rax+84h]
or ecx, 600h
mov [rax+84h], cx
mov r12, rax
loc_11CC8:
mov [r15], r12
test r12, r12
jz loc_11E20
mov [rbx+90h], r12
cmp dword ptr [r15+14h], 0
jnz loc_11E0A
mov r14d, 138h
lea rdi, [r12+r14]
mov eax, [r12+140h]
mov [r12+168h], eax
push 9
pop rsi
call dbuf_putc
mov rax, [r15]
mov eax, [rax+168h]
mov [r15+10h], eax
push 69h ; 'i'
pop rsi
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
call emit_goto
mov ebp, eax
mov rax, [rbx+90h]
lea rdi, [rax+r14]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 0B7h
call dbuf_putc
mov rdi, [rbx+90h]
add rdi, r14
lea rsi, [rsp+48h+var_30]
mov dword ptr [rsi], 8
push 4
pop r15
mov rdx, r15
call dbuf_put
mov rdi, [rbx+90h]
add rdi, r14
lea rsi, [rsp+48h+var_34]
and word ptr [rsi], 0
push 2
pop r12
mov rdx, r12
call dbuf_put
mov rax, [rbx+90h]
lea rdi, [rax+r14]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 0B7h
call dbuf_putc
mov rdi, [rbx+90h]
add rdi, r14
lea rsi, [rsp+48h+var_2C]
mov dword ptr [rsi], 74h ; 't'
mov rdx, r15
call dbuf_put
mov rdi, [rbx+90h]
add rdi, r14
lea rsi, [rsp+48h+var_32]
and word ptr [rsi], 0
mov rdx, r12
call dbuf_put
mov rax, [rbx+90h]
add r14, rax
mov ecx, [rax+140h]
mov [rax+168h], ecx
push 2Dh ; '-'
pop rsi
mov rdi, r14
call dbuf_putc
mov rdi, rbx
mov esi, ebp
call emit_label
loc_11E0A:
mov rax, [rbx+90h]
mov rax, [rax+8]
mov [rbx+90h], rax
xor eax, eax
jmp short loc_11E23
loc_11E20:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_11E23:
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long emit_class_init_start(long long *a1, _DWORD *a2)
{
_QWORD *v3; // r12
_QWORD *v4; // rax
unsigned int v5; // ebp
long long v6; // rax
long long v7; // rdi
long long v8; // rdi
long long v9; // rax
long long v10; // rdi
long long v11; // rdi
long long v12; // rax
__int16 v14; // [rsp+14h] [rbp-34h] BYREF
__int16 v15; // [rsp+16h] [rbp-32h] BYREF
int v16; // [rsp+18h] [rbp-30h] BYREF
int v17[11]; // [rsp+1Ch] [rbp-2Ch] BYREF
v3 = 0LL;
v4 = js_new_function_def(*a1, a1[18], 0, 0, a1[3], 0, 0);
if ( v4 )
{
*((_DWORD *)v4 + 34) = 0;
v4[9] = 1LL;
*((_DWORD *)v4 + 30) = 0;
*((_OWORD *)v4 + 6) = xmmword_9E810;
v4[14] = 1LL;
*((_WORD *)v4 + 66) = *((_WORD *)v4 + 66) & 0x8000 | 0x600;
v3 = v4;
}
*(_QWORD *)a2 = v3;
if ( !v3 )
return -1LL;
a1[18] = (long long)v3;
if ( !a2[5] )
{
*((_DWORD *)v3 + 90) = *((_DWORD *)v3 + 80);
dbuf_putc(v3 + 39, 9LL);
a2[4] = *(_DWORD *)(*(_QWORD *)a2 + 360LL);
v5 = emit_goto(a1, 105LL, -1LL);
v6 = a1[18];
*(_DWORD *)(v6 + 360) = *(_DWORD *)(v6 + 320);
dbuf_putc(v6 + 312, 183LL);
v7 = a1[18] + 312;
v16 = 8;
dbuf_put(v7, &v16, 4LL);
v8 = a1[18] + 312;
v14 = 0;
dbuf_put(v8, &v14, 2LL);
v9 = a1[18];
*(_DWORD *)(v9 + 360) = *(_DWORD *)(v9 + 320);
dbuf_putc(v9 + 312, 183LL);
v10 = a1[18] + 312;
v17[0] = 116;
dbuf_put(v10, v17, 4LL);
v11 = a1[18] + 312;
v15 = 0;
dbuf_put(v11, &v15, 2LL);
v12 = a1[18];
*(_DWORD *)(v12 + 360) = *(_DWORD *)(v12 + 320);
dbuf_putc(v12 + 312, 45LL);
emit_label(a1, v5);
}
a1[18] = *(_QWORD *)(a1[18] + 8);
return 0LL;
}
| emit_class_init_start:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV R15,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x90]
MOV RDI,qword ptr [RDI]
MOV R8,qword ptr [RBX + 0x18]
AND dword ptr [RSP],0x0
XOR R12D,R12D
XOR EDX,EDX
XOR ECX,ECX
XOR R9D,R9D
CALL 0x0011194f
TEST RAX,RAX
JZ 0x00111cc8
AND dword ptr [RAX + 0x88],0x0
PUSH 0x1
POP RCX
MOV qword ptr [RAX + 0x48],RCX
AND dword ptr [RAX + 0x78],0x0
MOVAPS XMM0,xmmword ptr [0x0019e810]
MOVUPS xmmword ptr [RAX + 0x60],XMM0
MOV qword ptr [RAX + 0x70],RCX
MOV ECX,0xffff8000
AND ECX,dword ptr [RAX + 0x84]
OR ECX,0x600
MOV word ptr [RAX + 0x84],CX
MOV R12,RAX
LAB_00111cc8:
MOV qword ptr [R15],R12
TEST R12,R12
JZ 0x00111e20
MOV qword ptr [RBX + 0x90],R12
CMP dword ptr [R15 + 0x14],0x0
JNZ 0x00111e0a
MOV R14D,0x138
LEA RDI,[R12 + R14*0x1]
MOV EAX,dword ptr [R12 + 0x140]
MOV dword ptr [R12 + 0x168],EAX
PUSH 0x9
POP RSI
CALL 0x0011b4d0
MOV RAX,qword ptr [R15]
MOV EAX,dword ptr [RAX + 0x168]
MOV dword ptr [R15 + 0x10],EAX
PUSH 0x69
POP RSI
PUSH -0x1
POP RDX
MOV RDI,RBX
CALL 0x00164d83
MOV EBP,EAX
MOV RAX,qword ptr [RBX + 0x90]
LEA RDI,[RAX + R14*0x1]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0xb7
CALL 0x0011b4d0
MOV RDI,qword ptr [RBX + 0x90]
ADD RDI,R14
LEA RSI,[RSP + 0x18]
MOV dword ptr [RSI],0x8
PUSH 0x4
POP R15
MOV RDX,R15
CALL 0x0011b422
MOV RDI,qword ptr [RBX + 0x90]
ADD RDI,R14
LEA RSI,[RSP + 0x14]
AND word ptr [RSI],0x0
PUSH 0x2
POP R12
MOV RDX,R12
CALL 0x0011b422
MOV RAX,qword ptr [RBX + 0x90]
LEA RDI,[RAX + R14*0x1]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0xb7
CALL 0x0011b4d0
MOV RDI,qword ptr [RBX + 0x90]
ADD RDI,R14
LEA RSI,[RSP + 0x1c]
MOV dword ptr [RSI],0x74
MOV RDX,R15
CALL 0x0011b422
MOV RDI,qword ptr [RBX + 0x90]
ADD RDI,R14
LEA RSI,[RSP + 0x16]
AND word ptr [RSI],0x0
MOV RDX,R12
CALL 0x0011b422
MOV RAX,qword ptr [RBX + 0x90]
ADD R14,RAX
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
PUSH 0x2d
POP RSI
MOV RDI,R14
CALL 0x0011b4d0
MOV RDI,RBX
MOV ESI,EBP
CALL 0x00164ef1
LAB_00111e0a:
MOV RAX,qword ptr [RBX + 0x90]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x90],RAX
XOR EAX,EAX
JMP 0x00111e23
LAB_00111e20:
PUSH -0x1
POP RAX
LAB_00111e23:
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 emit_class_init_start(int8 *param_1,long *param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
long lVar4;
int8 uVar5;
long lVar6;
int2 local_34;
int2 local_32;
int4 local_30;
int4 local_2c;
lVar4 = js_new_function_def(*param_1,param_1[0x12],0,0,param_1[3],0,0);
lVar6 = 0;
if (lVar4 != 0) {
*(int4 *)(lVar4 + 0x88) = 0;
*(int8 *)(lVar4 + 0x48) = 1;
*(int4 *)(lVar4 + 0x78) = 0;
uVar2 = _UNK_0019e81c;
uVar1 = _UNK_0019e818;
uVar3 = _UNK_0019e814;
*(int4 *)(lVar4 + 0x60) = _DAT_0019e810;
*(int4 *)(lVar4 + 100) = uVar3;
*(int4 *)(lVar4 + 0x68) = uVar1;
*(int4 *)(lVar4 + 0x6c) = uVar2;
*(int8 *)(lVar4 + 0x70) = 1;
*(ushort *)(lVar4 + 0x84) = (ushort)*(int4 *)(lVar4 + 0x84) & 0x8000 | 0x600;
lVar6 = lVar4;
}
*param_2 = lVar6;
if (lVar6 == 0) {
uVar5 = 0xffffffffffffffff;
}
else {
param_1[0x12] = lVar6;
if (*(int *)((long)param_2 + 0x14) == 0) {
*(int4 *)(lVar6 + 0x168) = *(int4 *)(lVar6 + 0x140);
dbuf_putc(lVar6 + 0x138,9);
*(int4 *)(param_2 + 2) = *(int4 *)(*param_2 + 0x168);
uVar3 = emit_goto(param_1,0x69,0xffffffffffffffff);
lVar6 = param_1[0x12];
*(int4 *)(lVar6 + 0x168) = *(int4 *)(lVar6 + 0x140);
dbuf_putc(lVar6 + 0x138,0xb7);
local_30 = 8;
dbuf_put(param_1[0x12] + 0x138,&local_30,4);
local_34 = 0;
dbuf_put(param_1[0x12] + 0x138,&local_34,2);
lVar6 = param_1[0x12];
*(int4 *)(lVar6 + 0x168) = *(int4 *)(lVar6 + 0x140);
dbuf_putc(lVar6 + 0x138,0xb7);
local_2c = 0x74;
dbuf_put(param_1[0x12] + 0x138,&local_2c,4);
local_32 = 0;
dbuf_put(param_1[0x12] + 0x138,&local_32,2);
lVar6 = param_1[0x12];
*(int4 *)(lVar6 + 0x168) = *(int4 *)(lVar6 + 0x140);
dbuf_putc(lVar6 + 0x138,0x2d);
emit_label(param_1,uVar3);
}
param_1[0x12] = *(int8 *)(param_1[0x12] + 8);
uVar5 = 0;
}
return uVar5;
}
| |
39,494 | emit_class_init_start | bluesky950520[P]quickjs/quickjs.c | static __exception int emit_class_init_start(JSParseState *s,
ClassFieldsDef *cf)
{
int label_add_brand;
cf->fields_init_fd = js_parse_function_class_fields_init(s);
if (!cf->fields_init_fd)
return -1;
s->cur_func = cf->fields_init_fd;
if (!cf->is_static) {
/* add the brand to the newly created instance */
/* XXX: would be better to add the code only if needed, maybe in a
later pass */
emit_op(s, OP_push_false); /* will be patched later */
cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
label_add_brand = emit_goto(s, OP_if_false, -1);
emit_op(s, OP_scope_get_var);
emit_atom(s, JS_ATOM_this);
emit_u16(s, 0);
emit_op(s, OP_scope_get_var);
emit_atom(s, JS_ATOM_home_object);
emit_u16(s, 0);
emit_op(s, OP_add_brand);
emit_label(s, label_add_brand);
}
s->cur_func = s->cur_func->parent;
return 0;
} | O2 | c | emit_class_init_start:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
movq (%rdi), %rdi
movq 0x18(%rbx), %r8
andl $0x0, (%rsp)
xorl %ebp, %ebp
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x4b7d3
testq %rax, %rax
je 0x5a0f3
andl $0x0, 0x88(%rax)
pushq $0x1
popq %rcx
movq %rcx, 0x48(%rax)
andl $0x0, 0x78(%rax)
movaps 0x2b748(%rip), %xmm0 # 0x85770
movups %xmm0, 0x60(%rax)
movq %rcx, 0x70(%rax)
movl $0xffff8000, %ecx # imm = 0xFFFF8000
andl 0x84(%rax), %ecx
orl $0x600, %ecx # imm = 0x600
movw %cx, 0x84(%rax)
movq %rax, (%r14)
movq %rax, 0x90(%rbx)
cmpl %ebp, 0x14(%r14)
jne 0x5a0e4
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x4fa1b
movq (%r14), %rax
movl 0x168(%rax), %eax
movl %eax, 0x10(%r14)
pushq $0x69
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x5605a
movl %eax, %ebp
movq %rbx, %rdi
movl $0xb7, %esi
callq 0x4fa1b
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x563de
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4fa3a
movq %rbx, %rdi
movl $0xb7, %esi
callq 0x4fa1b
pushq $0x74
popq %rsi
movq %rbx, %rdi
callq 0x563de
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4fa3a
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x4fa1b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5617c
movq 0x90(%rbx), %rax
movq 0x8(%rax), %rax
movq %rax, 0x90(%rbx)
xorl %eax, %eax
jmp 0x5a0fa
andq $0x0, (%r14)
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| emit_class_init_start:
push rbp
push r14
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov rsi, [rdi+90h]
mov rdi, [rdi]
mov r8, [rbx+18h]
and [rsp+28h+var_28], 0
xor ebp, ebp
xor edx, edx
xor ecx, ecx
xor r9d, r9d
call js_new_function_def
test rax, rax
jz loc_5A0F3
and dword ptr [rax+88h], 0
push 1
pop rcx
mov [rax+48h], rcx
and dword ptr [rax+78h], 0
movaps xmm0, cs:xmmword_85770
movups xmmword ptr [rax+60h], xmm0
mov [rax+70h], rcx
mov ecx, 0FFFF8000h
and ecx, [rax+84h]
or ecx, 600h
mov [rax+84h], cx
mov [r14], rax
mov [rbx+90h], rax
cmp [r14+14h], ebp
jnz loc_5A0E4
push 9
pop rsi
mov rdi, rbx
call emit_op
mov rax, [r14]
mov eax, [rax+168h]
mov [r14+10h], eax
push 69h ; 'i'
pop rsi
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rdi, rbx
call emit_goto
mov ebp, eax
mov rdi, rbx
mov esi, 0B7h
call emit_op
push 8
pop rsi
mov rdi, rbx
call emit_u32
mov rdi, rbx
xor esi, esi
call emit_u16
mov rdi, rbx
mov esi, 0B7h
call emit_op
push 74h ; 't'
pop rsi
mov rdi, rbx
call emit_u32
mov rdi, rbx
xor esi, esi
call emit_u16
push 2Dh ; '-'
pop rsi
mov rdi, rbx
call emit_op
mov rdi, rbx
mov esi, ebp
call emit_label
mov rax, [rbx+90h]
loc_5A0E4:
mov rax, [rax+8]
mov [rbx+90h], rax
xor eax, eax
jmp short loc_5A0FA
loc_5A0F3:
and qword ptr [r14], 0
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_5A0FA:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long emit_class_init_start(long long a1, _DWORD *a2)
{
long long v2; // rax
int v3; // ebp
v2 = js_new_function_def(*(_QWORD *)a1, *(_QWORD *)(a1 + 144), 0, 0, *(unsigned __int8 **)(a1 + 24), 0, 0);
if ( v2 )
{
*(_DWORD *)(v2 + 136) = 0;
*(_QWORD *)(v2 + 72) = 1LL;
*(_DWORD *)(v2 + 120) = 0;
*(_OWORD *)(v2 + 96) = xmmword_85770;
*(_QWORD *)(v2 + 112) = 1LL;
*(_WORD *)(v2 + 132) = *(_WORD *)(v2 + 132) & 0x8000 | 0x600;
*(_QWORD *)a2 = v2;
*(_QWORD *)(a1 + 144) = v2;
if ( !a2[5] )
{
emit_op(a1, 9);
a2[4] = *(_DWORD *)(*(_QWORD *)a2 + 360LL);
v3 = emit_goto(a1, 105, -1);
emit_op(a1, 183);
emit_u32(a1, 8u);
emit_u16(a1, 0);
emit_op(a1, 183);
emit_u32(a1, 0x74u);
emit_u16(a1, 0);
emit_op(a1, 45);
emit_label(a1, v3);
v2 = *(_QWORD *)(a1 + 144);
}
*(_QWORD *)(a1 + 144) = *(_QWORD *)(v2 + 8);
return 0LL;
}
else
{
*(_QWORD *)a2 = 0LL;
return -1LL;
}
}
| emit_class_init_start:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x90]
MOV RDI,qword ptr [RDI]
MOV R8,qword ptr [RBX + 0x18]
AND dword ptr [RSP],0x0
XOR EBP,EBP
XOR EDX,EDX
XOR ECX,ECX
XOR R9D,R9D
CALL 0x0014b7d3
TEST RAX,RAX
JZ 0x0015a0f3
AND dword ptr [RAX + 0x88],0x0
PUSH 0x1
POP RCX
MOV qword ptr [RAX + 0x48],RCX
AND dword ptr [RAX + 0x78],0x0
MOVAPS XMM0,xmmword ptr [0x00185770]
MOVUPS xmmword ptr [RAX + 0x60],XMM0
MOV qword ptr [RAX + 0x70],RCX
MOV ECX,0xffff8000
AND ECX,dword ptr [RAX + 0x84]
OR ECX,0x600
MOV word ptr [RAX + 0x84],CX
MOV qword ptr [R14],RAX
MOV qword ptr [RBX + 0x90],RAX
CMP dword ptr [R14 + 0x14],EBP
JNZ 0x0015a0e4
PUSH 0x9
POP RSI
MOV RDI,RBX
CALL 0x0014fa1b
MOV RAX,qword ptr [R14]
MOV EAX,dword ptr [RAX + 0x168]
MOV dword ptr [R14 + 0x10],EAX
PUSH 0x69
POP RSI
PUSH -0x1
POP RDX
MOV RDI,RBX
CALL 0x0015605a
MOV EBP,EAX
MOV RDI,RBX
MOV ESI,0xb7
CALL 0x0014fa1b
PUSH 0x8
POP RSI
MOV RDI,RBX
CALL 0x001563de
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0014fa3a
MOV RDI,RBX
MOV ESI,0xb7
CALL 0x0014fa1b
PUSH 0x74
POP RSI
MOV RDI,RBX
CALL 0x001563de
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0014fa3a
PUSH 0x2d
POP RSI
MOV RDI,RBX
CALL 0x0014fa1b
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0015617c
MOV RAX,qword ptr [RBX + 0x90]
LAB_0015a0e4:
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x90],RAX
XOR EAX,EAX
JMP 0x0015a0fa
LAB_0015a0f3:
AND qword ptr [R14],0x0
PUSH -0x1
POP RAX
LAB_0015a0fa:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 emit_class_init_start(int8 *param_1,long *param_2)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
long lVar4;
int8 uVar5;
lVar4 = js_new_function_def(*param_1,param_1[0x12],0,0,param_1[3],0,0);
if (lVar4 == 0) {
*param_2 = 0;
uVar5 = 0xffffffffffffffff;
}
else {
*(int4 *)(lVar4 + 0x88) = 0;
*(int8 *)(lVar4 + 0x48) = 1;
*(int4 *)(lVar4 + 0x78) = 0;
uVar2 = _UNK_0018577c;
uVar1 = _UNK_00185778;
uVar3 = _UNK_00185774;
*(int4 *)(lVar4 + 0x60) = _DAT_00185770;
*(int4 *)(lVar4 + 100) = uVar3;
*(int4 *)(lVar4 + 0x68) = uVar1;
*(int4 *)(lVar4 + 0x6c) = uVar2;
*(int8 *)(lVar4 + 0x70) = 1;
*(ushort *)(lVar4 + 0x84) = (ushort)*(int4 *)(lVar4 + 0x84) & 0x8000 | 0x600;
*param_2 = lVar4;
param_1[0x12] = lVar4;
if (*(int *)((long)param_2 + 0x14) == 0) {
emit_op(param_1,9);
*(int4 *)(param_2 + 2) = *(int4 *)(*param_2 + 0x168);
uVar3 = emit_goto(param_1,0x69,0xffffffffffffffff);
emit_op(param_1,0xb7);
emit_u32(param_1,8);
emit_u16(param_1,0);
emit_op(param_1,0xb7);
emit_u32(param_1,0x74);
emit_u16(param_1,0);
emit_op(param_1,0x2d);
emit_label(param_1,uVar3);
lVar4 = param_1[0x12];
}
param_1[0x12] = *(int8 *)(lVar4 + 8);
uVar5 = 0;
}
return uVar5;
}
| |
39,495 | resolve_scope_private_field1 | bluesky950520[P]quickjs/quickjs.c | static int resolve_scope_private_field1(JSContext *ctx,
BOOL *pis_ref, int *pvar_kind,
JSFunctionDef *s,
JSAtom var_name, int scope_level)
{
int idx, var_kind;
JSFunctionDef *fd;
BOOL is_ref;
fd = s;
is_ref = FALSE;
for(;;) {
idx = find_private_class_field_all(ctx, fd, var_name, scope_level);
if (idx >= 0) {
var_kind = fd->vars[idx].var_kind;
if (is_ref) {
idx = get_closure_var(ctx, s, fd, FALSE, idx, var_name,
TRUE, TRUE, JS_VAR_NORMAL);
if (idx < 0)
return -1;
}
break;
}
scope_level = fd->parent_scope_level;
if (!fd->parent) {
if (fd->is_eval) {
/* closure of the eval function (top level) */
for (idx = 0; idx < fd->closure_var_count; idx++) {
JSClosureVar *cv = &fd->closure_var[idx];
if (cv->var_name == var_name) {
var_kind = cv->var_kind;
is_ref = TRUE;
if (fd != s) {
idx = get_closure_var2(ctx, s, fd,
FALSE,
cv->is_arg, idx,
cv->var_name, cv->is_const,
cv->is_lexical,
cv->var_kind);
if (idx < 0)
return -1;
}
goto done;
}
}
}
/* XXX: no line number info */
// XXX: resolve_scope_private_field1() should take JSParseState *s and use js_parse_error_atom
JS_ThrowSyntaxErrorAtom(ctx, "undefined private field '%s'",
var_name);
return -1;
} else {
fd = fd->parent;
}
is_ref = TRUE;
}
done:
*pis_ref = is_ref;
*pvar_kind = var_kind;
return idx;
} | O3 | c | resolve_scope_private_field1:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %eax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb $0x1, %sil
movq %rcx, %rdx
movq 0xf8(%rdx), %rdi
movslq %r9d, %r8
movl 0x4(%rdi,%r8,8), %r9d
testl %r9d, %r9d
js 0x70a34
movq 0x90(%rdx), %rdi
movl %r9d, %r8d
shlq $0x4, %r8
cmpl %eax, (%rdi,%r8)
je 0x70a48
addq %rdi, %r8
movl 0x8(%r8), %r9d
testl %r9d, %r9d
jns 0x70a1b
movq 0x8(%rdx), %rdi
testq %rdi, %rdi
je 0x70a91
movl 0x14(%rdx), %r9d
xorl %esi, %esi
movq %rdi, %rdx
jmp 0x70a00
movl 0xc(%rdi,%r8), %r12d
shrl $0x4, %r12d
andl $0xf, %r12d
xorl %r13d, %r13d
testb $0x1, %sil
jne 0x70a89
movl $0x1, %r13d
movq %r15, %rdi
movq %rcx, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
pushq $0x0
pushq %r13
pushq %r13
pushq %rax
callq 0x6f2f3
addq $0x20, %rsp
movl %eax, %r9d
testl %eax, %eax
js 0x70ade
movl %r13d, (%r14)
movl %r12d, (%rbx)
jmp 0x70ae4
cmpl $0x0, 0x38(%rdx)
je 0x70abc
movslq 0x198(%rdx), %rsi
testq %rsi, %rsi
jle 0x70abc
movq 0x1a0(%rdx), %rdi
xorl %r9d, %r9d
cmpl %eax, 0x4(%rdi,%r9,8)
je 0x70af5
incq %r9
cmpq %r9, %rsi
jne 0x70aad
movq 0x18(%r15), %rdi
movq %rsp, %rsi
movl %eax, %edx
callq 0x21e0b
leaq 0x324d8(%rip), %rsi # 0xa2fa9
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x220b9
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
movl %r9d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movzbl (%rdi,%r9,8), %esi
movl %esi, %r12d
shrl $0x4, %r12d
cmpq %rcx, %rdx
je 0x70b46
movl %esi, %r8d
shrl %r8d
andl $0x1, %r8d
movl %esi, %r10d
shrl $0x2, %r10d
andl $0x1, %r10d
shrb $0x3, %sil
andb $0x1, %sil
movzbl %sil, %r11d
movq %r15, %rdi
movq %rcx, %rsi
xorl %ecx, %ecx
pushq %r12
pushq %r11
pushq %r10
pushq %rax
callq 0x6f2f3
addq $0x20, %rsp
testl %eax, %eax
js 0x70ade
movl %eax, %r9d
movl $0x1, %r13d
jmp 0x70a89
| resolve_scope_private_field1:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 40h
mov eax, r8d
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov sil, 1
mov rdx, rcx
loc_70A00:
mov rdi, [rdx+0F8h]
movsxd r8, r9d
mov r9d, [rdi+r8*8+4]
test r9d, r9d
js short loc_70A34
mov rdi, [rdx+90h]
loc_70A1B:
mov r8d, r9d
shl r8, 4
cmp [rdi+r8], eax
jz short loc_70A48
add r8, rdi
mov r9d, [r8+8]
test r9d, r9d
jns short loc_70A1B
loc_70A34:
mov rdi, [rdx+8]
test rdi, rdi
jz short loc_70A91
mov r9d, [rdx+14h]
xor esi, esi
mov rdx, rdi
jmp short loc_70A00
loc_70A48:
mov r12d, [rdi+r8+0Ch]
shr r12d, 4
and r12d, 0Fh
xor r13d, r13d
test sil, 1
jnz short loc_70A89
mov r13d, 1
mov rdi, r15
mov rsi, rcx
mov ecx, 1
xor r8d, r8d
push 0
push r13
push r13
push rax
call get_closure_var2
add rsp, 20h
mov r9d, eax
test eax, eax
js short loc_70ADE
loc_70A89:
mov [r14], r13d
mov [rbx], r12d
jmp short loc_70AE4
loc_70A91:
cmp dword ptr [rdx+38h], 0
jz short loc_70ABC
movsxd rsi, dword ptr [rdx+198h]
test rsi, rsi
jle short loc_70ABC
mov rdi, [rdx+1A0h]
xor r9d, r9d
loc_70AAD:
cmp [rdi+r9*8+4], eax
jz short loc_70AF5
inc r9
cmp rsi, r9
jnz short loc_70AAD
loc_70ABC:
mov rdi, [r15+18h]
mov rsi, rsp
mov edx, eax
call JS_AtomGetStrRT
lea rsi, aUndefinedPriva; "undefined private field '%s'"
mov rdi, r15
mov rdx, rax
xor eax, eax
call JS_ThrowSyntaxError
loc_70ADE:
mov r9d, 0FFFFFFFFh
loc_70AE4:
mov eax, r9d
add rsp, 40h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_70AF5:
movzx esi, byte ptr [rdi+r9*8]
mov r12d, esi
shr r12d, 4
cmp rdx, rcx
jz short loc_70B46
mov r8d, esi
shr r8d, 1
and r8d, 1
mov r10d, esi
shr r10d, 2
and r10d, 1
shr sil, 3
and sil, 1
movzx r11d, sil
mov rdi, r15
mov rsi, rcx
xor ecx, ecx
push r12
push r11
push r10
push rax
call get_closure_var2
add rsp, 20h
test eax, eax
js short loc_70ADE
mov r9d, eax
loc_70B46:
mov r13d, 1
jmp loc_70A89
| long long resolve_scope_private_field1(
long long a1,
int *a2,
int *a3,
long long a4,
unsigned int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v18; // si
long long i; // rdx
long long v20; // r9
long long v21; // rdi
long long v22; // r8
int v23; // r12d
int v24; // r13d
long long v25; // rsi
long long v26; // rdi
long long StrRT; // rax
long long v28; // rcx
long long v29; // r8
long long v30; // r9
__m128 v31; // xmm4
__m128 v32; // xmm5
int closure_var2; // eax
char v35[104]; // [rsp+0h] [rbp-68h] BYREF
v18 = 1;
for ( i = a4; ; i = *(_QWORD *)(i + 8) )
{
LODWORD(v20) = *(_DWORD *)(*(_QWORD *)(i + 248) + 8LL * a6 + 4);
if ( (int)v20 >= 0 )
{
v21 = *(_QWORD *)(i + 144);
while ( 1 )
{
v22 = 16LL * (unsigned int)v20;
if ( *(_DWORD *)(v21 + v22) == a5 )
break;
LODWORD(v20) = *(_DWORD *)(v21 + v22 + 8);
if ( (int)v20 < 0 )
goto LABEL_6;
}
v23 = (*(_DWORD *)(v21 + v22 + 12) >> 4) & 0xF;
v24 = 0;
if ( (v18 & 1) == 0 )
{
v24 = 1;
LODWORD(v20) = get_closure_var2(a1, a4, i, 1, 0, v20, a7, a8, a9, a10, a11, a12, a13, a14, a5, 1, 1, 0);
if ( (int)v20 < 0 )
goto LABEL_17;
}
LABEL_10:
*a2 = v24;
*a3 = v23;
return (unsigned int)v20;
}
LABEL_6:
if ( !*(_QWORD *)(i + 8) )
break;
a6 = *(_DWORD *)(i + 20);
v18 = 0;
}
if ( !*(_DWORD *)(i + 56) || (v25 = *(int *)(i + 408), v25 <= 0) )
{
LABEL_16:
StrRT = JS_AtomGetStrRT(*(_QWORD *)(a1 + 24), v35, a5);
JS_ThrowSyntaxError(
a1,
(long long)"undefined private field '%s'",
StrRT,
v28,
v29,
v30,
a7,
a8,
a9,
a10,
v31,
v32,
a13,
a14,
v35[0]);
goto LABEL_17;
}
v26 = *(_QWORD *)(i + 416);
v20 = 0LL;
while ( *(_DWORD *)(v26 + 8 * v20 + 4) != a5 )
{
if ( v25 == ++v20 )
goto LABEL_16;
}
v23 = *(unsigned __int8 *)(v26 + 8 * v20) >> 4;
if ( i == a4 )
{
LABEL_22:
v24 = 1;
goto LABEL_10;
}
closure_var2 = get_closure_var2(
a1,
a4,
i,
0,
(*(unsigned __int8 *)(v26 + 8 * v20) >> 1) & 1,
v20,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
a5,
(*(unsigned __int8 *)(v26 + 8 * v20) >> 2) & 1,
(*(_BYTE *)(v26 + 8 * v20) & 8) != 0,
v23);
if ( closure_var2 >= 0 )
{
LODWORD(v20) = closure_var2;
goto LABEL_22;
}
LABEL_17:
LODWORD(v20) = -1;
return (unsigned int)v20;
}
| resolve_scope_private_field1:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV EAX,R8D
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV SIL,0x1
MOV RDX,RCX
LAB_00170a00:
MOV RDI,qword ptr [RDX + 0xf8]
MOVSXD R8,R9D
MOV R9D,dword ptr [RDI + R8*0x8 + 0x4]
TEST R9D,R9D
JS 0x00170a34
MOV RDI,qword ptr [RDX + 0x90]
LAB_00170a1b:
MOV R8D,R9D
SHL R8,0x4
CMP dword ptr [RDI + R8*0x1],EAX
JZ 0x00170a48
ADD R8,RDI
MOV R9D,dword ptr [R8 + 0x8]
TEST R9D,R9D
JNS 0x00170a1b
LAB_00170a34:
MOV RDI,qword ptr [RDX + 0x8]
TEST RDI,RDI
JZ 0x00170a91
MOV R9D,dword ptr [RDX + 0x14]
XOR ESI,ESI
MOV RDX,RDI
JMP 0x00170a00
LAB_00170a48:
MOV R12D,dword ptr [RDI + R8*0x1 + 0xc]
SHR R12D,0x4
AND R12D,0xf
XOR R13D,R13D
TEST SIL,0x1
JNZ 0x00170a89
MOV R13D,0x1
MOV RDI,R15
MOV RSI,RCX
MOV ECX,0x1
XOR R8D,R8D
PUSH 0x0
PUSH R13
PUSH R13
PUSH RAX
CALL 0x0016f2f3
ADD RSP,0x20
MOV R9D,EAX
TEST EAX,EAX
JS 0x00170ade
LAB_00170a89:
MOV dword ptr [R14],R13D
MOV dword ptr [RBX],R12D
JMP 0x00170ae4
LAB_00170a91:
CMP dword ptr [RDX + 0x38],0x0
JZ 0x00170abc
MOVSXD RSI,dword ptr [RDX + 0x198]
TEST RSI,RSI
JLE 0x00170abc
MOV RDI,qword ptr [RDX + 0x1a0]
XOR R9D,R9D
LAB_00170aad:
CMP dword ptr [RDI + R9*0x8 + 0x4],EAX
JZ 0x00170af5
INC R9
CMP RSI,R9
JNZ 0x00170aad
LAB_00170abc:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RSP
MOV EDX,EAX
CALL 0x00121e0b
LEA RSI,[0x1a2fa9]
MOV RDI,R15
MOV RDX,RAX
XOR EAX,EAX
CALL 0x001220b9
LAB_00170ade:
MOV R9D,0xffffffff
LAB_00170ae4:
MOV EAX,R9D
ADD RSP,0x40
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00170af5:
MOVZX ESI,byte ptr [RDI + R9*0x8]
MOV R12D,ESI
SHR R12D,0x4
CMP RDX,RCX
JZ 0x00170b46
MOV R8D,ESI
SHR R8D,0x1
AND R8D,0x1
MOV R10D,ESI
SHR R10D,0x2
AND R10D,0x1
SHR SIL,0x3
AND SIL,0x1
MOVZX R11D,SIL
MOV RDI,R15
MOV RSI,RCX
XOR ECX,ECX
PUSH R12
PUSH R11
PUSH R10
PUSH RAX
CALL 0x0016f2f3
ADD RSP,0x20
TEST EAX,EAX
JS 0x00170ade
MOV R9D,EAX
LAB_00170b46:
MOV R13D,0x1
JMP 0x00170a89
|
ulong resolve_scope_private_field1
(long param_1,int4 *param_2,uint *param_3,long param_4,int param_5,int param_6
)
{
byte bVar1;
long lVar2;
uint uVar3;
int8 uVar4;
long lVar5;
bool bVar6;
long lVar7;
ulong uVar8;
uint uVar9;
int4 uVar10;
int1 auStack_68 [64];
bVar6 = true;
lVar5 = param_4;
while( true ) {
uVar9 = *(uint *)(*(long *)(lVar5 + 0xf8) + 4 + (long)param_6 * 8);
if (-1 < (int)uVar9) {
lVar2 = *(long *)(lVar5 + 0x90);
do {
uVar8 = (ulong)uVar9;
lVar7 = uVar8 * 0x10;
if (*(int *)(lVar2 + lVar7) == param_5) {
uVar9 = *(uint *)(lVar2 + 0xc + lVar7) >> 4 & 0xf;
uVar10 = 0;
if (bVar6) goto LAB_00170a89;
uVar10 = 1;
uVar3 = get_closure_var2(param_1,param_4,lVar5,1,0,uVar8,param_5,1,1,0);
uVar8 = (ulong)uVar3;
if (-1 < (int)uVar3) goto LAB_00170a89;
goto LAB_00170ade;
}
uVar9 = *(uint *)(lVar7 + lVar2 + 8);
} while (-1 < (int)uVar9);
}
if (*(long *)(lVar5 + 8) == 0) break;
param_6 = *(int *)(lVar5 + 0x14);
bVar6 = false;
lVar5 = *(long *)(lVar5 + 8);
}
if ((*(int *)(lVar5 + 0x38) != 0) && (0 < (long)*(int *)(lVar5 + 0x198))) {
uVar8 = 0;
do {
if (*(int *)(*(long *)(lVar5 + 0x1a0) + 4 + uVar8 * 8) == param_5) {
bVar1 = *(byte *)(*(long *)(lVar5 + 0x1a0) + uVar8 * 8);
uVar9 = (uint)(bVar1 >> 4);
if (lVar5 != param_4) {
uVar3 = get_closure_var2(param_1,param_4,lVar5,0,bVar1 >> 1 & 1,uVar8,param_5,
bVar1 >> 2 & 1,bVar1 >> 3 & 1,uVar9);
if ((int)uVar3 < 0) goto LAB_00170ade;
uVar8 = (ulong)uVar3;
}
uVar10 = 1;
LAB_00170a89:
*param_2 = uVar10;
*param_3 = uVar9;
goto LAB_00170ae4;
}
uVar8 = uVar8 + 1;
} while ((long)*(int *)(lVar5 + 0x198) != uVar8);
}
uVar4 = JS_AtomGetStrRT(*(int8 *)(param_1 + 0x18),auStack_68,param_5);
JS_ThrowSyntaxError(param_1,"int private field \'%s\'",uVar4);
LAB_00170ade:
uVar8 = 0xffffffff;
LAB_00170ae4:
return uVar8 & 0xffffffff;
}
| |
39,496 | 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::__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>>>>>::reset() | monkey531[P]llama/common/json.hpp | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | O2 | cpp | 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::__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>>>>>::reset():
pushq %rax
movq %rdi, %rax
andq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x3e788
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x3e5fe
popq %rax
retq
movq %rax, %rdi
callq 0x27215
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
and qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_3E788
mov [rax+40h], rcx
loc_3E788:
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> 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>>>::reset(
long long a1)
{
long long v2; // rdi
long long v3; // rcx
char v4; // [rsp+1h] [rbp-1h] BYREF
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v2 = a1 + 56;
v3 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v3 )
*(_QWORD *)(a1 + 64) = v3;
v4 = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v2, &v4);
}
| reset:
PUSH RAX
MOV RAX,RDI
AND qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x0013e788
MOV qword ptr [RAX + 0x40],RCX
LAB_0013e788:
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_0013e792:
CALL 0x0013e5fe
POP RAX
RET
|
/* 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::__cxx11::string, 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 > > >::reset() */
int8 __thiscall
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::__cxx11::string,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>>>
::reset(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>>>
*this)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 0013e792 to 0013e796 has its CatchHandler @ 0013e799 */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
| |
39,497 | mysql_client_plugin_deinit | eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c | void mysql_client_plugin_deinit()
{
int i;
struct st_client_plugin_int *p;
if (!initialized)
return;
for (i=0; i < MYSQL_CLIENT_MAX_PLUGINS; i++)
for (p= plugin_list[i]; p; p= p->next)
{
if (p->plugin->deinit)
p->plugin->deinit();
if (p->dlhandle)
(void)dlclose(p->dlhandle);
}
memset(&plugin_list, 0, sizeof(plugin_list));
initialized= 0;
ma_free_root(&mem_root, MYF(0));
pthread_mutex_destroy(&LOCK_load_client_plugin);
} | O3 | c | mysql_client_plugin_deinit:
cmpb $0x1, 0x248ef(%rip) # 0x4c860
jne 0x27ffc
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r14d, %r14d
leaq 0x24945(%rip), %rbx # 0x4c8d0
movq (%rbx,%r14,8), %r15
testq %r15, %r15
je 0x27fb6
movq 0x10(%r15), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0x27fa3
callq *%rax
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x27fb1
callq 0x13360
movq (%r15), %r15
jmp 0x27f8f
incq %r14
cmpq $0x3, %r14
jne 0x27f8b
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movb $0x0, 0x24888(%rip) # 0x4c860
leaq 0x248b1(%rip), %rdi # 0x4c890
xorl %esi, %esi
callq 0x1e81b
leaq 0x2487b(%rip), %rdi # 0x4c868
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13540
retq
| mysql_client_plugin_deinit:
cmp cs:initialized, 1
jnz locret_27FFC
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
xor r14d, r14d
lea rbx, plugin_list
loc_27F8B:
mov r15, [rbx+r14*8]
loc_27F8F:
test r15, r15
jz short loc_27FB6
mov rax, [r15+10h]
mov rax, [rax+48h]
test rax, rax
jz short loc_27FA3
call rax
loc_27FA3:
mov rdi, [r15+8]
test rdi, rdi
jz short loc_27FB1
call _dlclose
loc_27FB1:
mov r15, [r15]
jmp short loc_27F8F
loc_27FB6:
inc r14
cmp r14, 3
jnz short loc_27F8B
xorps xmm0, xmm0
movaps xmmword ptr [rbx+30h], xmm0
movaps xmmword ptr [rbx+20h], xmm0
movaps xmmword ptr [rbx+10h], xmm0
movaps xmmword ptr [rbx], xmm0
mov cs:initialized, 0
lea rdi, mem_root
xor esi, esi
call ma_free_root
lea rdi, LOCK_load_client_plugin
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_destroy
locret_27FFC:
retn
| long long mysql_client_plugin_deinit(long long a1)
{
long long result; // rax
long long i; // r14
_QWORD *j; // r15
void ( *v4)(long long); // rax
if ( initialized == 1 )
{
for ( i = 0LL; i != 3; ++i )
{
for ( j = (_QWORD *)*((_QWORD *)plugin_list + i); j; j = (_QWORD *)*j )
{
v4 = *(void ( **)(long long))(j[2] + 72LL);
if ( v4 )
v4(a1);
a1 = j[1];
if ( a1 )
dlclose(a1);
}
}
plugin_list[3] = 0LL;
plugin_list[2] = 0LL;
plugin_list[1] = 0LL;
plugin_list[0] = 0LL;
initialized = 0;
ma_free_root((long long)&mem_root, 0);
return pthread_mutex_destroy(&LOCK_load_client_plugin);
}
return result;
}
| mysql_client_plugin_deinit:
CMP byte ptr [0x0014c860],0x1
JNZ 0x00127ffc
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
XOR R14D,R14D
LEA RBX,[0x14c8d0]
LAB_00127f8b:
MOV R15,qword ptr [RBX + R14*0x8]
LAB_00127f8f:
TEST R15,R15
JZ 0x00127fb6
MOV RAX,qword ptr [R15 + 0x10]
MOV RAX,qword ptr [RAX + 0x48]
TEST RAX,RAX
JZ 0x00127fa3
CALL RAX
LAB_00127fa3:
MOV RDI,qword ptr [R15 + 0x8]
TEST RDI,RDI
JZ 0x00127fb1
CALL 0x00113360
LAB_00127fb1:
MOV R15,qword ptr [R15]
JMP 0x00127f8f
LAB_00127fb6:
INC R14
CMP R14,0x3
JNZ 0x00127f8b
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBX + 0x30],XMM0
MOVAPS xmmword ptr [RBX + 0x20],XMM0
MOVAPS xmmword ptr [RBX + 0x10],XMM0
MOVAPS xmmword ptr [RBX],XMM0
MOV byte ptr [0x0014c860],0x0
LEA RDI,[0x14c890]
XOR ESI,ESI
CALL 0x0011e81b
LEA RDI,[0x14c868]
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00113540
LAB_00127ffc:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void mysql_client_plugin_deinit(void)
{
long lVar1;
int8 *puVar2;
if (initialized == '\x01') {
lVar1 = 0;
do {
for (puVar2 = (int8 *)(&plugin_list)[lVar1]; puVar2 != (int8 *)0x0;
puVar2 = (int8 *)*puVar2) {
if (*(code **)(puVar2[2] + 0x48) != (code *)0x0) {
(**(code **)(puVar2[2] + 0x48))();
}
if (puVar2[1] != 0) {
dlclose();
}
}
lVar1 = lVar1 + 1;
} while (lVar1 != 3);
_DAT_0014c900 = 0;
uRam000000000014c908 = 0;
_DAT_0014c8f0 = 0;
uRam000000000014c8f8 = 0;
_DAT_0014c8e0 = 0;
uRam000000000014c8e8 = 0;
plugin_list = 0;
DAT_0014c8d8 = 0;
initialized = 0;
ma_free_root(mem_root,0);
pthread_mutex_destroy((pthread_mutex_t *)LOCK_load_client_plugin);
return;
}
return;
}
| |
39,498 | void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<long, 0>(long) | monkey531[P]llama/common/./json.hpp | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
{{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
{{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
{{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
{{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
{{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
{{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
{{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
{{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
}
};
// special case for "0"
if (x == 0)
{
o->write_character('0');
return;
}
// use a pointer to fill the buffer
auto buffer_ptr = number_buffer.begin(); // NOLINT(llvm-qualified-auto,readability-qualified-auto,cppcoreguidelines-pro-type-vararg,hicpp-vararg)
number_unsigned_t abs_value;
unsigned int n_chars{};
if (is_negative_number(x))
{
*buffer_ptr = '-';
abs_value = remove_sign(static_cast<number_integer_t>(x));
// account one more byte for the minus sign
n_chars = 1 + count_digits(abs_value);
}
else
{
abs_value = static_cast<number_unsigned_t>(x);
n_chars = count_digits(abs_value);
}
// spare 1 byte for '\0'
JSON_ASSERT(n_chars < number_buffer.size() - 1);
// jump to the end to generate the string from backward,
// so we later avoid reversing the result
buffer_ptr += n_chars;
// Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
// See: https://www.youtube.com/watch?v=o4-CwDo2zpg
while (abs_value >= 100)
{
const auto digits_index = static_cast<unsigned>((abs_value % 100));
abs_value /= 100;
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
if (abs_value >= 10)
{
const auto digits_index = static_cast<unsigned>(abs_value);
*(--buffer_ptr) = digits_to_99[digits_index][1];
*(--buffer_ptr) = digits_to_99[digits_index][0];
}
else
{
*(--buffer_ptr) = static_cast<char>('0' + abs_value);
}
o->write_characters(number_buffer.data(), n_chars);
} | O1 | cpp | void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::dump_integer<long, 0>(long):
pushq %rbx
testq %rsi, %rsi
je 0x75c62
movq %rsi, %rcx
leaq 0x10(%rdi), %rsi
testq %rcx, %rcx
js 0x75c73
movl $0x1, %r9d
cmpq $0xa, %rcx
jb 0x75ce7
movl $0x4, %r9d
movabsq $0x346dc5d63886594b, %r10 # imm = 0x346DC5D63886594B
movq %rcx, %r8
cmpq $0x63, %r8
jbe 0x75cd0
cmpq $0x3e7, %r8 # imm = 0x3E7
jbe 0x75cd6
cmpq $0x2710, %r8 # imm = 0x2710
jb 0x75ce7
movq %r8, %rax
mulq %r10
shrq $0xb, %rdx
addl $0x4, %r9d
cmpq $0x1869f, %r8 # imm = 0x1869F
movq %rdx, %r8
ja 0x75c1b
addl $-0x3, %r9d
jmp 0x75ce7
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rbx
jmpq *%rax
movb $0x2d, (%rsi)
negq %rcx
movl $0x1, %r9d
cmpq $0xa, %rcx
jb 0x75ce4
movl $0x4, %r9d
movabsq $0x346dc5d63886594b, %r10 # imm = 0x346DC5D63886594B
movq %rcx, %r8
cmpq $0x63, %r8
jbe 0x75cdb
cmpq $0x3e7, %r8 # imm = 0x3E7
jbe 0x75ce1
cmpq $0x2710, %r8 # imm = 0x2710
jb 0x75ce4
movq %r8, %rax
mulq %r10
shrq $0xb, %rdx
addl $0x4, %r9d
cmpq $0x1869f, %r8 # imm = 0x1869F
movq %rdx, %r8
ja 0x75c98
addl $-0x3, %r9d
jmp 0x75ce4
addl $-0x2, %r9d
jmp 0x75ce7
decl %r9d
jmp 0x75ce7
addl $-0x2, %r9d
jmp 0x75ce4
decl %r9d
incl %r9d
cmpl $0x3f, %r9d
jae 0x75d7f
movl %r9d, %r8d
leaq (%rsi,%r8), %r9
leaq 0xde8a8(%rip), %r10 # 0x1545a7
cmpq $0x64, %rcx
jb 0x75d40
movabsq $0x28f5c28f5c28f5c3, %r11 # imm = 0x28F5C28F5C28F5C3
movq %rcx, %rax
shrq $0x2, %rax
mulq %r11
shrq $0x2, %rdx
imull $0x64, %edx, %eax
movl %ecx, %ebx
subl %eax, %ebx
movzwl (%r10,%rbx,2), %eax
movw %ax, -0x2(%r9)
addq $-0x2, %r9
cmpq $0x270f, %rcx # imm = 0x270F
movq %rdx, %rcx
ja 0x75d0f
jmp 0x75d43
movq %rcx, %rdx
cmpq $0xa, %rdx
jb 0x75d5f
movb (%r10,%rdx,2), %al
movb 0x1(%r10,%rdx,2), %cl
movb %cl, -0x1(%r9)
movq $-0x2, %rcx
jmp 0x75d6b
orb $0x30, %dl
movq $-0x1, %rcx
movl %edx, %eax
movb %al, (%r9,%rcx)
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %r8, %rdx
popq %rbx
jmpq *%rax
leaq 0xd6008(%rip), %rdi # 0x14bd8e
leaq 0xd604d(%rip), %rdx # 0x14bdda
leaq 0xd7cc4(%rip), %rcx # 0x14da58
movl $0x4952, %esi # imm = 0x4952
xorl %eax, %eax
callq 0x20250
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
push rbx
test rsi, rsi
jz short loc_75C62
mov rcx, rsi
lea rsi, [rdi+10h]
test rcx, rcx
js short loc_75C73
mov r9d, 1
cmp rcx, 0Ah
jb loc_75CE7
mov r9d, 4
mov r10, 346DC5D63886594Bh
mov r8, rcx
loc_75C1B:
cmp r8, 63h ; 'c'
jbe loc_75CD0
cmp r8, 3E7h
jbe loc_75CD6
cmp r8, 2710h
jb loc_75CE7
mov rax, r8
mul r10
shr rdx, 0Bh
add r9d, 4
cmp r8, 1869Fh
mov r8, rdx
ja short loc_75C1B
add r9d, 0FFFFFFFDh
jmp loc_75CE7
loc_75C62:
mov rdi, [rdi]
mov rax, [rdi]
mov rax, [rax]
mov esi, 30h ; '0'
pop rbx
jmp rax
loc_75C73:
mov byte ptr [rsi], 2Dh ; '-'
neg rcx
mov r9d, 1
cmp rcx, 0Ah
jb short loc_75CE4
mov r9d, 4
mov r10, 346DC5D63886594Bh
mov r8, rcx
loc_75C98:
cmp r8, 63h ; 'c'
jbe short loc_75CDB
cmp r8, 3E7h
jbe short loc_75CE1
cmp r8, 2710h
jb short loc_75CE4
mov rax, r8
mul r10
shr rdx, 0Bh
add r9d, 4
cmp r8, 1869Fh
mov r8, rdx
ja short loc_75C98
add r9d, 0FFFFFFFDh
jmp short loc_75CE4
loc_75CD0:
add r9d, 0FFFFFFFEh
jmp short loc_75CE7
loc_75CD6:
dec r9d
jmp short loc_75CE7
loc_75CDB:
add r9d, 0FFFFFFFEh
jmp short loc_75CE4
loc_75CE1:
dec r9d
loc_75CE4:
inc r9d
loc_75CE7:
cmp r9d, 3Fh ; '?'
jnb loc_75D7F
mov r8d, r9d
lea r9, [rsi+r8]
lea r10, _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99; "000102030405060708091011121314151617181"...
cmp rcx, 64h ; 'd'
jb short loc_75D40
mov r11, 28F5C28F5C28F5C3h
loc_75D0F:
mov rax, rcx
shr rax, 2
mul r11
shr rdx, 2
imul eax, edx, 64h ; 'd'
mov ebx, ecx
sub ebx, eax
movzx eax, word ptr [r10+rbx*2]
mov [r9-2], ax
add r9, 0FFFFFFFFFFFFFFFEh
cmp rcx, 270Fh
mov rcx, rdx
ja short loc_75D0F
jmp short loc_75D43
loc_75D40:
mov rdx, rcx
loc_75D43:
cmp rdx, 0Ah
jb short loc_75D5F
mov al, [r10+rdx*2]
mov cl, [r10+rdx*2+1]
mov [r9-1], cl
mov rcx, 0FFFFFFFFFFFFFFFEh
jmp short loc_75D6B
loc_75D5F:
or dl, 30h
mov rcx, 0FFFFFFFFFFFFFFFFh
mov eax, edx
loc_75D6B:
mov [r9+rcx], al
mov rdi, [rdi]
mov rax, [rdi]
mov rax, [rax+8]
mov rdx, r8
pop rbx
jmp rax
loc_75D7F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsNumberBu; "n_chars < number_buffer.size() - 1"
mov esi, 4952h
xor eax, eax
call _ggml_abort
| long long ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_(
_QWORD *a1,
unsigned long long a2)
{
unsigned long long v2; // rcx
_BYTE *v3; // rsi
unsigned int v4; // r9d
unsigned long long v5; // r8
bool v6; // cc
int v8; // r9d
unsigned long long v9; // r8
long long v10; // r8
_BYTE *v11; // r9
unsigned long long v12; // rdx
char v13; // al
long long v14; // rcx
double v15; // xmm0_8
if ( !a2 )
return (**(long long ( ***)(_QWORD, long long))*a1)(*a1, 48LL);
v2 = a2;
v3 = a1 + 2;
if ( (v2 & 0x8000000000000000LL) != 0LL )
{
*v3 = 45;
v2 = -(long long)v2;
v8 = 1;
if ( v2 >= 0xA )
{
v8 = 4;
v9 = v2;
while ( 1 )
{
if ( v9 <= 0x63 )
{
v8 -= 2;
goto LABEL_22;
}
if ( v9 <= 0x3E7 )
break;
if ( v9 < 0x2710 )
goto LABEL_22;
v8 += 4;
v6 = v9 <= 0x1869F;
v9 /= 0x2710uLL;
if ( v6 )
{
v8 -= 3;
goto LABEL_22;
}
}
--v8;
}
LABEL_22:
v4 = v8 + 1;
}
else
{
v4 = 1;
if ( v2 >= 0xA )
{
v4 = 4;
v5 = v2;
while ( 1 )
{
if ( v5 <= 0x63 )
{
v4 -= 2;
goto LABEL_23;
}
if ( v5 <= 0x3E7 )
break;
if ( v5 < 0x2710 )
goto LABEL_23;
v4 += 4;
v6 = v5 <= 0x1869F;
v5 /= 0x2710uLL;
if ( v6 )
{
v4 -= 3;
goto LABEL_23;
}
}
--v4;
}
}
LABEL_23:
if ( v4 >= 0x3F )
{
v15 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
18770LL,
"GGML_ASSERT(%s) failed",
"n_chars < number_buffer.size() - 1");
return nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::dump_float(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
v15);
}
else
{
v10 = v4;
v11 = &v3[v4];
if ( v2 < 0x64 )
{
v12 = v2;
}
else
{
do
{
v12 = v2 / 0x64;
*((_WORD *)v11 - 1) = *(_WORD *)&ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[2 * (v2 % 0x64)];
v11 -= 2;
v6 = v2 <= 0x270F;
v2 /= 0x64uLL;
}
while ( !v6 );
}
if ( v12 < 0xA )
{
v14 = -1LL;
v13 = v12 | 0x30;
}
else
{
v13 = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[2 * v12];
*(v11 - 1) = ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99[2 * v12 + 1];
v14 = -2LL;
}
v11[v14] = v13;
return (*(long long ( **)(_QWORD, _BYTE *, long long))(*(_QWORD *)*a1 + 8LL))(*a1, v3, v10);
}
}
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_:
PUSH RBX
TEST RSI,RSI
JZ 0x00175c62
MOV RCX,RSI
LEA RSI,[RDI + 0x10]
TEST RCX,RCX
JS 0x00175c73
MOV R9D,0x1
CMP RCX,0xa
JC 0x00175ce7
MOV R9D,0x4
MOV R10,0x346dc5d63886594b
MOV R8,RCX
LAB_00175c1b:
CMP R8,0x63
JBE 0x00175cd0
CMP R8,0x3e7
JBE 0x00175cd6
CMP R8,0x2710
JC 0x00175ce7
MOV RAX,R8
MUL R10
SHR RDX,0xb
ADD R9D,0x4
CMP R8,0x1869f
MOV R8,RDX
JA 0x00175c1b
ADD R9D,-0x3
JMP 0x00175ce7
LAB_00175c62:
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV ESI,0x30
POP RBX
JMP RAX
LAB_00175c73:
MOV byte ptr [RSI],0x2d
NEG RCX
MOV R9D,0x1
CMP RCX,0xa
JC 0x00175ce4
MOV R9D,0x4
MOV R10,0x346dc5d63886594b
MOV R8,RCX
LAB_00175c98:
CMP R8,0x63
JBE 0x00175cdb
CMP R8,0x3e7
JBE 0x00175ce1
CMP R8,0x2710
JC 0x00175ce4
MOV RAX,R8
MUL R10
SHR RDX,0xb
ADD R9D,0x4
CMP R8,0x1869f
MOV R8,RDX
JA 0x00175c98
ADD R9D,-0x3
JMP 0x00175ce4
LAB_00175cd0:
ADD R9D,-0x2
JMP 0x00175ce7
LAB_00175cd6:
DEC R9D
JMP 0x00175ce7
LAB_00175cdb:
ADD R9D,-0x2
JMP 0x00175ce4
LAB_00175ce1:
DEC R9D
LAB_00175ce4:
INC R9D
LAB_00175ce7:
CMP R9D,0x3f
JNC 0x00175d7f
MOV R8D,R9D
LEA R9,[RSI + R8*0x1]
LEA R10,[0x2545a7]
CMP RCX,0x64
JC 0x00175d40
MOV R11,0x28f5c28f5c28f5c3
LAB_00175d0f:
MOV RAX,RCX
SHR RAX,0x2
MUL R11
SHR RDX,0x2
IMUL EAX,EDX,0x64
MOV EBX,ECX
SUB EBX,EAX
MOVZX EAX,word ptr [R10 + RBX*0x2]
MOV word ptr [R9 + -0x2],AX
ADD R9,-0x2
CMP RCX,0x270f
MOV RCX,RDX
JA 0x00175d0f
JMP 0x00175d43
LAB_00175d40:
MOV RDX,RCX
LAB_00175d43:
CMP RDX,0xa
JC 0x00175d5f
MOV AL,byte ptr [R10 + RDX*0x2]
MOV CL,byte ptr [R10 + RDX*0x2 + 0x1]
MOV byte ptr [R9 + -0x1],CL
MOV RCX,-0x2
JMP 0x00175d6b
LAB_00175d5f:
OR DL,0x30
MOV RCX,-0x1
MOV EAX,EDX
LAB_00175d6b:
MOV byte ptr [R9 + RCX*0x1],AL
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,R8
POP RBX
JMP RAX
LAB_00175d7f:
LEA RDI,[0x24bd8e]
LEA RDX,[0x24bdda]
LEA RCX,[0x24da58]
MOV ESI,0x4952
XOR EAX,EAX
CALL 0x00120250
|
void _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_
(int8 *param_1,ulong param_2)
{
int8 *puVar1;
bool bVar2;
int iVar3;
long lVar4;
byte bVar5;
ulong uVar6;
int iVar7;
ulong uVar8;
int1 *puVar9;
if (param_2 == 0) {
/* WARNING: Could not recover jumptable at 0x00175c71. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)**(int8 **)*param_1)((int8 *)*param_1,0x30);
return;
}
puVar1 = param_1 + 2;
if ((long)param_2 < 0) {
*(int1 *)puVar1 = 0x2d;
param_2 = -param_2;
iVar7 = 1;
if (9 < param_2) {
uVar8 = param_2;
iVar3 = 4;
do {
iVar7 = iVar3;
if (uVar8 < 100) {
iVar7 = iVar7 + -2;
goto LAB_00175ce4;
}
if (uVar8 < 1000) {
iVar7 = iVar7 + -1;
goto LAB_00175ce4;
}
if (uVar8 < 10000) goto LAB_00175ce4;
bVar2 = 99999 < uVar8;
uVar8 = uVar8 / 10000;
iVar3 = iVar7 + 4;
} while (bVar2);
iVar7 = iVar7 + 1;
}
LAB_00175ce4:
uVar8 = (ulong)(iVar7 + 1);
}
else {
uVar8 = 1;
if (9 < param_2) {
uVar8 = 4;
uVar6 = param_2;
do {
iVar7 = (int)uVar8;
if (uVar6 < 100) {
uVar8 = (ulong)(iVar7 - 2);
goto LAB_00175ce7;
}
if (uVar6 < 1000) {
uVar8 = (ulong)(iVar7 - 1);
goto LAB_00175ce7;
}
if (uVar6 < 10000) goto LAB_00175ce7;
uVar8 = (ulong)(iVar7 + 4);
bVar2 = 99999 < uVar6;
uVar6 = uVar6 / 10000;
} while (bVar2);
uVar8 = (ulong)(iVar7 + 1);
}
}
LAB_00175ce7:
if (0x3e < (uint)uVar8) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",0x4952,
"GGML_ASSERT(%s) failed","n_chars < number_buffer.size() - 1");
}
puVar9 = (int1 *)((long)puVar1 + uVar8);
uVar6 = param_2;
if (99 < param_2) {
do {
uVar6 = param_2 / 100;
*(int2 *)(puVar9 + -2) =
*(int2 *)
(
_ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
+ (ulong)(uint)((int)param_2 + (int)uVar6 * -100) * 2);
puVar9 = puVar9 + -2;
bVar2 = 9999 < param_2;
param_2 = uVar6;
} while (bVar2);
}
if (uVar6 < 10) {
bVar5 = (byte)uVar6 | 0x30;
lVar4 = -1;
}
else {
bVar5 = _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
[uVar6 * 2];
puVar9[-1] = _ZZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12dump_integerIlTnNSt9enable_ifIXoooooosr3std11is_integralIT_EE5valuesr3std7is_sameISJ_mEE5valuesr3std7is_sameISJ_lEE5valuesr3std7is_sameISJ_hEE5valueEiE4typeELi0EEEvSJ_E12digits_to_99
[uVar6 * 2 + 1];
lVar4 = -2;
}
puVar9[lVar4] = bVar5;
/* WARNING: Could not recover jumptable at 0x00175d7d. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*(long *)*param_1 + 8))((long *)*param_1,puVar1,uVar8);
return;
}
| |
39,499 | my_xml_error_pos | eloqsql/strings/xml.c | size_t my_xml_error_pos(MY_XML_PARSER *p)
{
const char *beg=p->beg;
const char *s;
for ( s=p->beg ; s<p->cur; s++)
{
if (s[0] == '\n')
beg=s;
}
return (size_t) (p->cur-beg);
} | O3 | c | my_xml_error_pos:
movq 0x128(%rdi), %rcx
movq 0x130(%rdi), %rax
cmpq %rax, %rcx
jae 0x5b352
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rdx
cmpb $0xa, (%rcx)
cmoveq %rcx, %rdx
incq %rcx
cmpq %rax, %rcx
jne 0x5b340
popq %rbp
jmp 0x5b355
movq %rcx, %rdx
subq %rdx, %rax
retq
| my_xml_error_pos:
mov rcx, [rdi+128h]
mov rax, [rdi+130h]
cmp rcx, rax
jnb short loc_5B352
push rbp
mov rbp, rsp
mov rdx, rcx
loc_5B340:
cmp byte ptr [rcx], 0Ah
cmovz rdx, rcx
inc rcx
cmp rcx, rax
jnz short loc_5B340
pop rbp
jmp short loc_5B355
loc_5B352:
mov rdx, rcx
loc_5B355:
sub rax, rdx
retn
| long long my_xml_error_pos(long long a1)
{
_BYTE *v1; // rcx
_BYTE *v2; // rax
_BYTE *v3; // rdx
v1 = *(_BYTE **)(a1 + 296);
v2 = *(_BYTE **)(a1 + 304);
if ( v1 >= v2 )
{
v3 = *(_BYTE **)(a1 + 296);
}
else
{
v3 = *(_BYTE **)(a1 + 296);
do
{
if ( *v1 == 10 )
v3 = v1;
++v1;
}
while ( v1 != v2 );
}
return v2 - v3;
}
| my_xml_error_pos:
MOV RCX,qword ptr [RDI + 0x128]
MOV RAX,qword ptr [RDI + 0x130]
CMP RCX,RAX
JNC 0x0015b352
PUSH RBP
MOV RBP,RSP
MOV RDX,RCX
LAB_0015b340:
CMP byte ptr [RCX],0xa
CMOVZ RDX,RCX
INC RCX
CMP RCX,RAX
JNZ 0x0015b340
POP RBP
JMP 0x0015b355
LAB_0015b352:
MOV RDX,RCX
LAB_0015b355:
SUB RAX,RDX
RET
|
long my_xml_error_pos(long param_1)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
pcVar2 = *(char **)(param_1 + 0x128);
pcVar1 = *(char **)(param_1 + 0x130);
pcVar3 = pcVar2;
if (pcVar2 < pcVar1) {
do {
if (*pcVar2 == '\n') {
pcVar3 = pcVar2;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar1);
}
return (long)pcVar1 - (long)pcVar3;
}
|
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.