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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
52,300 | ggml_are_same_shape | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return
(t0->ne[0] == t1->ne[0] ) &&
(t0->ne[1] == t1->ne[1] ) &&
(t0->ne[2] == t1->ne[2] ) &&
(t0->ne[3] == t1->ne[3] );
} | O1 | c | ggml_are_same_shape:
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x8e3ce
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x8e3ce
movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x8e3ce
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
| ggml_are_same_shape:
mov rax, [rdi+10h]
cmp rax, [rsi+10h]
jnz short loc_8E3CE
mov rax, [rdi+18h]
cmp rax, [rsi+18h]
jnz short loc_8E3CE
mov rax, [rdi+20h]
cmp rax, [rsi+20h]
jnz short loc_8E3CE
mov rax, [rdi+28h]
cmp rax, [rsi+28h]
setz al
retn
loc_8E3CE:
xor eax, eax
retn
| bool ggml_are_same_shape(_QWORD *a1, _QWORD *a2)
{
return a1[2] == a2[2] && a1[3] == a2[3] && a1[4] == a2[4] && a1[5] == a2[5];
}
| |||
52,301 | ggml_are_same_shape | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return
(t0->ne[0] == t1->ne[0] ) &&
(t0->ne[1] == t1->ne[1] ) &&
(t0->ne[2] == t1->ne[2] ) &&
(t0->ne[3] == t1->ne[3] );
} | O2 | c | ggml_are_same_shape:
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x67e53
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x67e53
movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x67e53
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
| ggml_are_same_shape:
mov rax, [rdi+10h]
cmp rax, [rsi+10h]
jnz short loc_67E53
mov rax, [rdi+18h]
cmp rax, [rsi+18h]
jnz short loc_67E53
mov rax, [rdi+20h]
cmp rax, [rsi+20h]
jnz short loc_67E53
mov rax, [rdi+28h]
cmp rax, [rsi+28h]
setz al
retn
loc_67E53:
xor eax, eax
retn
| bool ggml_are_same_shape(_QWORD *a1, _QWORD *a2)
{
return a1[2] == a2[2] && a1[3] == a2[3] && a1[4] == a2[4] && a1[5] == a2[5];
}
| ggml_are_same_shape:
MOV RAX,qword ptr [RDI + 0x10]
CMP RAX,qword ptr [RSI + 0x10]
JNZ 0x00167e53
MOV RAX,qword ptr [RDI + 0x18]
CMP RAX,qword ptr [RSI + 0x18]
JNZ 0x00167e53
MOV RAX,qword ptr [RDI + 0x20]
CMP RAX,qword ptr [RSI + 0x20]
JNZ 0x00167e53
MOV RAX,qword ptr [RDI + 0x28]
CMP RAX,qword ptr [RSI + 0x28]
SETZ AL
RET
LAB_00167e53:
XOR EAX,EAX
RET
|
int8 ggml_are_same_shape(long param_1,long param_2)
{
if (((*(long *)(param_1 + 0x10) == *(long *)(param_2 + 0x10)) &&
(*(long *)(param_1 + 0x18) == *(long *)(param_2 + 0x18))) &&
(*(long *)(param_1 + 0x20) == *(long *)(param_2 + 0x20))) {
return CONCAT71((int7)((ulong)*(long *)(param_1 + 0x28) >> 8),
*(long *)(param_1 + 0x28) == *(long *)(param_2 + 0x28));
}
return 0;
}
| |
52,302 | ggml_are_same_shape | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | bool ggml_are_same_shape(const struct ggml_tensor * t0, const struct ggml_tensor * t1) {
static_assert(GGML_MAX_DIMS == 4, "GGML_MAX_DIMS is not 4 - update this function");
return
(t0->ne[0] == t1->ne[0] ) &&
(t0->ne[1] == t1->ne[1] ) &&
(t0->ne[2] == t1->ne[2] ) &&
(t0->ne[3] == t1->ne[3] );
} | O3 | c | ggml_are_same_shape:
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x8d13d
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
jne 0x8d13d
movq 0x20(%rdi), %rax
cmpq 0x20(%rsi), %rax
jne 0x8d13d
movq 0x28(%rdi), %rax
cmpq 0x28(%rsi), %rax
sete %al
retq
xorl %eax, %eax
retq
| ggml_are_same_shape:
mov rax, [rdi+10h]
cmp rax, [rsi+10h]
jnz short loc_8D13D
mov rax, [rdi+18h]
cmp rax, [rsi+18h]
jnz short loc_8D13D
mov rax, [rdi+20h]
cmp rax, [rsi+20h]
jnz short loc_8D13D
mov rax, [rdi+28h]
cmp rax, [rsi+28h]
setz al
retn
loc_8D13D:
xor eax, eax
retn
| bool ggml_are_same_shape(_QWORD *a1, _QWORD *a2)
{
return a1[2] == a2[2] && a1[3] == a2[3] && a1[4] == a2[4] && a1[5] == a2[5];
}
| |||
52,303 | ftxui::separator() | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/separator.cpp | Element separator() {
return std::make_shared<SeparatorAuto>(LIGHT);
} | O3 | cpp | ftxui::separator():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x70, %edi
callq 0xb3e0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x3357a(%rip), %rax # 0x575f8
movq %rax, (%rbx)
movq %rbx, %r15
addq $0x10, %r15
movq %r15, %rdi
callq 0x23de0
leaq 0x335b1(%rip), %rax # 0x57648
movq %rax, 0x10(%rbx)
movl $0x0, 0x6c(%rbx)
movq %r15, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x70, %esi
movq %rbx, %rdi
callq 0xb400
movq %r14, %rdi
callq 0xb780
| _ZN5ftxui9separatorEv:
push r15
push r14
push rbx
mov r14, rdi
mov edi, 70h ; 'p'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rax, 100000001h
mov [rbx+8], rax
lea rax, off_575F8
mov [rbx], rax
mov r15, rbx
add r15, 10h
mov rdi, r15; this
call _ZN5ftxui4NodeC2Ev; ftxui::Node::Node(void)
lea rax, off_57648
mov [rbx+10h], rax
mov dword ptr [rbx+6Ch], 0
mov [r14], r15
mov [r14+8], rbx
mov rax, r14
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov esi, 70h ; 'p'; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
| ftxui * ftxui::separator(ftxui *this)
{
long long v1; // rbx
v1 = operator new(0x70uLL);
*(_QWORD *)(v1 + 8) = 0x100000001LL;
*(_QWORD *)v1 = off_575F8;
ftxui::Node::Node((ftxui::Node *)(v1 + 16));
*(_QWORD *)(v1 + 16) = off_57648;
*(_DWORD *)(v1 + 108) = 0;
*(_QWORD *)this = v1 + 16;
*((_QWORD *)this + 1) = v1;
return this;
}
| separator:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDI
MOV EDI,0x70
CALL 0x0010b3e0
MOV RBX,RAX
MOV RAX,0x100000001
MOV qword ptr [RBX + 0x8],RAX
LEA RAX,[0x1575f8]
MOV qword ptr [RBX],RAX
MOV R15,RBX
ADD R15,0x10
LAB_00124088:
MOV RDI,R15
CALL 0x00123de0
LAB_00124090:
LEA RAX,[0x157648]
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x6c],0x0
MOV qword ptr [R14],R15
MOV qword ptr [R14 + 0x8],RBX
MOV RAX,R14
POP RBX
POP R14
POP R15
RET
|
/* ftxui::separator() */
ftxui * __thiscall ftxui::separator(ftxui *this)
{
int8 *puVar1;
puVar1 = (int8 *)operator_new(0x70);
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_001575f8;
/* try { // try from 00124088 to 0012408f has its CatchHandler @ 001240b2 */
Node::Node((Node *)(puVar1 + 2));
puVar1[2] = &PTR__Node_00157648;
*(int4 *)((long)puVar1 + 0x6c) = 0;
*(Node **)this = (Node *)(puVar1 + 2);
*(int8 **)(this + 8) = puVar1;
return this;
}
| |
52,304 | common_params_get_system_info[abi:cxx11](common_params const&) | monkey531[P]llama/common/common.cpp | std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
DWORD logicalProcessorCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
os << " / " << logicalProcessorCount << " | " << llama_print_system_info();
#else
os << " / " << std::thread::hardware_concurrency() << " | " << llama_print_system_info();
#endif
return os.str();
} | O2 | cpp | common_params_get_system_info[abi:cxx11](common_params const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x23bd0
leaq 0x5fa2c(%rip), %rsi # 0xb335e
movq %r15, %rdi
callq 0x238d0
movl 0x274(%r14), %esi
movq %rax, %rdi
callq 0x23f40
cmpl $-0x1, 0x488(%r14)
je 0x53982
leaq 0x5fa1e(%rip), %rsi # 0xb3378
leaq 0x8(%rsp), %rdi
callq 0x238d0
movl 0x488(%r14), %esi
movq %rax, %rdi
callq 0x23f40
leaq 0x654e9(%rip), %rsi # 0xb8e63
movq %rax, %rdi
callq 0x238d0
leaq 0x5fa04(%rip), %rsi # 0xb338d
leaq 0x8(%rsp), %rdi
callq 0x238d0
movq %rax, %r14
callq 0x23c10
movl %eax, %esi
movq %r14, %rdi
callq 0x23640
leaq 0x658fe(%rip), %rsi # 0xb92aa
movq %rax, %rdi
callq 0x238d0
movq %rax, %r14
callq 0x23540
movq %r14, %rdi
movq %rax, %rsi
callq 0x238d0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x23de0
leaq 0x8(%rsp), %rdi
callq 0x231e0
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x231e0
movq %rbx, %rdi
callq 0x23fb0
| _Z29common_params_get_system_infoB5cxx11RK13common_params:
push r15
push r14
push rbx
sub rsp, 180h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+198h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aSystemInfoNThr; "system_info: n_threads = "
mov rdi, r15
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [r14+274h]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
cmp dword ptr [r14+488h], 0FFFFFFFFh
jz short loc_53982
lea rsi, aNThreadsBatch; " (n_threads_batch = "
lea rdi, [rsp+198h+var_190]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [r14+488h]
mov rdi, rax
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, a09401910201912+51h; ")"
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_53982:
lea rsi, asc_B338D; " / "
lea rdi, [rsp+198h+var_190]; this
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov r14, rax
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov esi, eax
mov rdi, r14
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
lea rsi, asc_B92A9+1; " | "
mov rdi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov r14, rax
call _llama_print_system_info
mov rdi, r14
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, [rsp+198h+var_188]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rdi, [rsp+198h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, rbx
add rsp, 180h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, rbx
call __Unwind_Resume
| long long common_params_get_system_info[abi:cxx11](long long a1, long long a2)
{
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // r14
unsigned int v7; // eax
long long v8; // rdi
long long v9; // r14
long long v10; // rax
_BYTE v12[8]; // [rsp+8h] [rbp-190h] BYREF
_BYTE v13[392]; // [rsp+10h] [rbp-188h] BYREF
std::ostringstream::basic_ostringstream(v12);
v3 = std::operator<<<std::char_traits<char>>(v12, "system_info: n_threads = ");
std::ostream::operator<<(v3, *(unsigned int *)(a2 + 628));
if ( *(_DWORD *)(a2 + 1160) != -1 )
{
v4 = std::operator<<<std::char_traits<char>>(v12, " (n_threads_batch = ");
v5 = std::ostream::operator<<(v4, *(unsigned int *)(a2 + 1160));
std::operator<<<std::char_traits<char>>(v5, ")");
}
v6 = std::operator<<<std::char_traits<char>>(v12, " / ");
v7 = std::thread::hardware_concurrency((std::thread *)v12);
v8 = std::ostream::_M_insert<unsigned long>(v6, v7);
v9 = std::operator<<<std::char_traits<char>>(v8, " | ");
v10 = llama_print_system_info();
std::operator<<<std::char_traits<char>>(v9, v10);
std::stringbuf::str(a1, v13);
std::ostringstream::~ostringstream(v12);
return a1;
}
| common_params_get_system_info[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x180
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00123bd0
LAB_0015392b:
LEA RSI,[0x1b335e]
MOV RDI,R15
CALL 0x001238d0
MOV ESI,dword ptr [R14 + 0x274]
MOV RDI,RAX
CALL 0x00123f40
CMP dword ptr [R14 + 0x488],-0x1
JZ 0x00153982
LEA RSI,[0x1b3378]
LEA RDI,[RSP + 0x8]
CALL 0x001238d0
MOV ESI,dword ptr [R14 + 0x488]
MOV RDI,RAX
CALL 0x00123f40
LEA RSI,[0x1b8e63]
MOV RDI,RAX
CALL 0x001238d0
LAB_00153982:
LEA RSI,[0x1b338d]
LEA RDI,[RSP + 0x8]
CALL 0x001238d0
MOV R14,RAX
CALL 0x00123c10
MOV ESI,EAX
MOV RDI,R14
CALL 0x00123640
LEA RSI,[0x1b92aa]
MOV RDI,RAX
CALL 0x001238d0
MOV R14,RAX
CALL 0x00123540
MOV RDI,R14
MOV RSI,RAX
CALL 0x001238d0
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00123de0
LAB_001539d4:
LEA RDI,[RSP + 0x8]
CALL 0x001231e0
MOV RAX,RBX
ADD RSP,0x180
POP RBX
POP R14
POP R15
RET
|
/* common_params_get_system_info[abi:cxx11](common_params const&) */
common_params * common_params_get_system_info_abi_cxx11_(common_params *param_1)
{
ostream *poVar1;
char *pcVar2;
long in_RSI;
ostringstream local_190 [376];
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 0015392b to 001539d3 has its CatchHandler @ 001539ee */
poVar1 = std::operator<<((ostream *)local_190,"system_info: n_threads = ");
std::ostream::operator<<(poVar1,*(int *)(in_RSI + 0x274));
if (*(int *)(in_RSI + 0x488) != -1) {
poVar1 = std::operator<<((ostream *)local_190," (n_threads_batch = ");
poVar1 = (ostream *)std::ostream::operator<<(poVar1,*(int *)(in_RSI + 0x488));
std::operator<<(poVar1,")");
}
poVar1 = std::operator<<((ostream *)local_190," / ");
std::thread::hardware_concurrency();
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)poVar1);
poVar1 = std::operator<<(poVar1," | ");
pcVar2 = (char *)llama_print_system_info();
std::operator<<(poVar1,pcVar2);
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
return param_1;
}
| |
52,305 | mysql_commit_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_commit_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_commit,
(parms->mysql),
parms->mysql,
my_bool,
r_my_bool)
} | O0 | c | mysql_commit_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x53740
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_commit_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_commit
mov [rbp+var_11], al
mov cl, [rbp+var_11]
mov rax, [rbp+var_20]
mov [rax+8], cl
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| long long mysql_commit_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*a1 + 1152) + 40LL);
*(_BYTE *)(v2 + 8) = mysql_commit(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_commit_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00153740
MOV byte ptr [RBP + -0x11],AL
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x8],CL
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_commit_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_commit(*param_1);
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
52,306 | my_block_write | eloqsql/mysys/mf_iocache.c | int my_block_write(IO_CACHE *info, const uchar *Buffer, size_t Count,
my_off_t pos)
{
size_t length;
int error=0;
/*
Assert that we cannot come here with a shared cache. If we do one
day, we might need to add a call to copy_to_read_buffer().
*/
DBUG_ASSERT(!info->share);
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
if (pos < info->pos_in_file)
{
/* Of no overlap, write everything without buffering */
if (pos + Count <= info->pos_in_file)
return (int)mysql_file_pwrite(info->file, Buffer, Count, pos,
info->myflags | MY_NABP);
/* Write the part of the block that is before buffer */
length= (uint) (info->pos_in_file - pos);
if (mysql_file_pwrite(info->file, Buffer, length, pos, info->myflags | MY_NABP))
info->error= error= -1;
Buffer+=length;
pos+= length;
Count-= length;
}
/* Check if we want to write inside the used part of the buffer.*/
length= (size_t) (info->write_end - info->buffer);
if (pos < info->pos_in_file + length)
{
size_t offset= (size_t) (pos - info->pos_in_file);
length-=offset;
if (length > Count)
length=Count;
memcpy(info->buffer+offset, Buffer, length);
Buffer+=length;
Count-= length;
/* Fix length of buffer if the new data was larger */
if (info->buffer+length > info->write_pos)
info->write_pos=info->buffer+length;
if (!Count)
return (error);
}
/* Write at the end of the current buffer; This is the normal case */
if (_my_b_write(info, Buffer, Count))
error= -1;
return error;
} | O0 | c | my_block_write:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
jmp 0xe1e81
jmp 0xe1e83
jmp 0xe1e85
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xe1f76
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
ja 0xe1ee9
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
orq $0x4, %rax
leaq 0x722db(%rip), %rdi # 0x1541ae
movl $0x673, %esi # imm = 0x673
movq %rax, (%rsp)
callq 0xe2070
movl %eax, -0x4(%rbp)
jmp 0xe2067
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq -0x28(%rbp), %rax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
orq $0x4, %rax
leaq 0x72288(%rip), %rdi # 0x1541ae
movl $0x676, %esi # imm = 0x676
movq %rax, (%rsp)
callq 0xe2070
cmpq $0x0, %rax
je 0xe1f4f
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jae 0xe2044
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xe1fd5
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
addq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x2a090
movq -0x30(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0xe2033
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0xe2042
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2067
jmp 0xe2044
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe0f00
cmpl $0x0, %eax
je 0xe2061
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
| my_block_write:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_34], 0
jmp short $+2
loc_E1E81:
jmp short $+2
loc_E1E83:
jmp short $+2
loc_E1E85:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jnb loc_E1F76
mov rax, [rbp+var_28]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
ja short loc_E1EE9
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
mov r9, [rbp+var_28]
mov rax, [rbp+var_10]
mov rax, [rax+0F8h]
or rax, 4
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 673h
mov [rsp+50h+var_50], rax
call inline_mysql_file_pwrite_3
mov [rbp+var_4], eax
jmp loc_E2067
loc_E1EE9:
mov rax, [rbp+var_10]
mov rax, [rax]
sub rax, [rbp+var_28]
mov eax, eax
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_30]
mov r9, [rbp+var_28]
mov rax, [rbp+var_10]
mov rax, [rax+0F8h]
or rax, 4
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 676h
mov [rsp+50h+var_50], rax
call inline_mysql_file_pwrite_3
cmp rax, 0
jz short loc_E1F4F
mov [rbp+var_34], 0FFFFFFFFh
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
loc_E1F4F:
mov rax, [rbp+var_30]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_30]
add rax, [rbp+var_28]
mov [rbp+var_28], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
loc_E1F76:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
add rcx, [rbp+var_30]
cmp rax, rcx
jnb loc_E2044
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
sub rax, [rcx]
mov [rbp+var_40], rax
mov rcx, [rbp+var_40]
mov rax, [rbp+var_30]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
jbe short loc_E1FD5
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
loc_E1FD5:
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
add rdi, [rbp+var_40]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
call _memcpy
mov rax, [rbp+var_30]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rcx, [rbp+var_30]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
add rax, [rbp+var_30]
mov rcx, [rbp+var_10]
cmp rax, [rcx+40h]
jbe short loc_E2033
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
loc_E2033:
cmp [rbp+var_20], 0
jnz short loc_E2042
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_E2067
loc_E2042:
jmp short $+2
loc_E2044:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _my_b_write
cmp eax, 0
jz short loc_E2061
mov [rbp+var_34], 0FFFFFFFFh
loc_E2061:
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
loc_E2067:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_block_write(long long a1, const char *a2, unsigned long long a3, unsigned long long a4)
{
unsigned long long v5; // [rsp+10h] [rbp-40h]
unsigned int v6; // [rsp+1Ch] [rbp-34h]
long long v7; // [rsp+20h] [rbp-30h]
long long v8; // [rsp+20h] [rbp-30h]
unsigned long long v9; // [rsp+20h] [rbp-30h]
unsigned long long v10; // [rsp+28h] [rbp-28h]
unsigned long long v11; // [rsp+30h] [rbp-20h]
const char *v12; // [rsp+38h] [rbp-18h]
v12 = a2;
v11 = a3;
v10 = a4;
v6 = 0;
if ( a4 < *(_QWORD *)a1 )
{
if ( a3 + a4 <= *(_QWORD *)a1 )
return (unsigned int)inline_mysql_file_pwrite_3(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1651,
*(_DWORD *)(a1 + 212),
(_DWORD)a2,
a3,
a4,
*(_QWORD *)(a1 + 248) | 4LL);
v7 = (unsigned int)*(_QWORD *)a1 - (unsigned int)a4;
if ( inline_mysql_file_pwrite_3(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1654,
*(_DWORD *)(a1 + 212),
(_DWORD)a2,
(unsigned int)*(_QWORD *)a1 - (unsigned int)a4,
a4,
*(_QWORD *)(a1 + 248) | 4LL) )
{
v6 = -1;
*(_DWORD *)(a1 + 228) = -1;
}
v12 = &a2[v7];
v10 += v7;
v11 -= v7;
}
v8 = *(_QWORD *)(a1 + 72) - *(_QWORD *)(a1 + 32);
if ( v10 >= v8 + *(_QWORD *)a1 )
goto LABEL_20;
v5 = v10 - *(_QWORD *)a1;
v9 = v8 - v5;
if ( v9 > v11 )
v9 = v11;
memcpy(v5 + *(_QWORD *)(a1 + 32), v12, v9);
v12 += v9;
v11 -= v9;
if ( v9 + *(_QWORD *)(a1 + 32) > *(_QWORD *)(a1 + 64) )
*(_QWORD *)(a1 + 64) = v9 + *(_QWORD *)(a1 + 32);
if ( v11 )
{
LABEL_20:
if ( (unsigned int)my_b_write(a1, v12, v11) )
return (unsigned int)-1;
return v6;
}
else
{
return v6;
}
}
| my_block_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 dword ptr [RBP + -0x34],0x0
JMP 0x001e1e81
LAB_001e1e81:
JMP 0x001e1e83
LAB_001e1e83:
JMP 0x001e1e85
LAB_001e1e85:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JNC 0x001e1f76
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JA 0x001e1ee9
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf8]
OR RAX,0x4
LEA RDI,[0x2541ae]
MOV ESI,0x673
MOV qword ptr [RSP],RAX
CALL 0x001e2070
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2067
LAB_001e1ee9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RBP + -0x28]
MOV EAX,EAX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf8]
OR RAX,0x4
LEA RDI,[0x2541ae]
MOV ESI,0x676
MOV qword ptr [RSP],RAX
CALL 0x001e2070
CMP RAX,0x0
JZ 0x001e1f4f
MOV dword ptr [RBP + -0x34],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
LAB_001e1f4f:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001e1f76:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
ADD RCX,qword ptr [RBP + -0x30]
CMP RAX,RCX
JNC 0x001e2044
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RCX]
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001e1fd5
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
LAB_001e1fd5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x20]
ADD RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0012a090
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
ADD RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x40]
JBE 0x001e2033
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
LAB_001e2033:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001e2042
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e2067
LAB_001e2042:
JMP 0x001e2044
LAB_001e2044:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001e0f00
CMP EAX,0x0
JZ 0x001e2061
MOV dword ptr [RBP + -0x34],0xffffffff
LAB_001e2061:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
LAB_001e2067:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4 my_block_write(ulong *param_1,void *param_2,ulong param_3,ulong param_4)
{
int4 uVar1;
int iVar2;
long lVar3;
int4 local_3c;
size_t local_38;
ulong local_30;
ulong local_28;
void *local_20;
local_3c = 0;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
if (param_4 < *param_1) {
if (param_4 + param_3 <= *param_1) {
uVar1 = inline_mysql_file_pwrite
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x673,
*(int4 *)((long)param_1 + 0xd4),param_2,param_3,param_4,
param_1[0x1f] | 4);
return uVar1;
}
local_28 = (ulong)(uint)((int)*param_1 - (int)param_4);
lVar3 = inline_mysql_file_pwrite
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x676,
*(int4 *)((long)param_1 + 0xd4),param_2,local_28,param_4,
param_1[0x1f] | 4);
if (lVar3 != 0) {
local_3c = 0xffffffff;
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
}
local_20 = (void *)(local_28 + (long)param_2);
local_30 = local_28 + param_4;
local_28 = param_3 - local_28;
}
if (local_30 < *param_1 + (param_1[9] - param_1[4])) {
local_38 = (param_1[9] - param_1[4]) - (local_30 - *param_1);
if (local_28 < local_38) {
local_38 = local_28;
}
memcpy((void *)(param_1[4] + (local_30 - *param_1)),local_20,local_38);
local_20 = (void *)(local_38 + (long)local_20);
local_28 = local_28 - local_38;
if (param_1[8] < param_1[4] + local_38) {
param_1[8] = param_1[4] + local_38;
}
if (local_28 == 0) {
return local_3c;
}
}
iVar2 = _my_b_write(param_1,local_20,local_28);
if (iVar2 != 0) {
local_3c = 0xffffffff;
}
return local_3c;
}
| |
52,307 | my_coll_lexem_print_error | eloqsql/strings/ctype-uca.c | static void my_coll_lexem_print_error(MY_COLL_LEXEM *lexem,
char *errstr, size_t errsize,
const char *txt)
{
char tail[30];
size_t len= lexem->end - lexem->prev;
strmake (tail, lexem->prev, (size_t) MY_MIN(len, sizeof(tail)-1));
errstr[errsize-1]= '\0';
my_snprintf(errstr, errsize - 1,
"%s at '%s'", txt[0] ? txt : "Syntax error", tail);
} | O0 | c | my_coll_lexem_print_error:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x1d, -0x58(%rbp)
jae 0xb8b54
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0xb8b5f
movl $0x1d, %eax
movq %rax, -0x70(%rbp)
jmp 0xb8b5f
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rdx
callq 0xe1440
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xb8bad
movq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0xb8bbd
leaq 0x2ff17(%rip), %rax # 0xe8acb
movq %rax, -0x88(%rbp)
jmp 0xb8bbd
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rcx
leaq 0x2feed(%rip), %rdx # 0xe8ac0
xorl %eax, %eax
leaq -0x30(%rbp), %r8
callq 0xe08b0
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb8bf9
addq $0x90, %rsp
popq %rbp
retq
callq 0x29420
nop
| my_coll_lexem_print_error:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov [rbp+var_50], rcx
mov rax, [rbp+var_38]
mov rax, [rax+10h]
mov rcx, [rbp+var_38]
mov rcx, [rcx+18h]
sub rax, rcx
mov [rbp+var_58], rax
lea rax, [rbp+var_30]
mov [rbp+var_68], rax
mov rax, [rbp+var_38]
mov rax, [rax+18h]
mov [rbp+var_60], rax
cmp [rbp+var_58], 1Dh
jnb short loc_B8B54
mov rax, [rbp+var_58]
mov [rbp+var_70], rax
jmp short loc_B8B5F
loc_B8B54:
mov eax, 1Dh
mov [rbp+var_70], rax
jmp short $+2
loc_B8B5F:
mov rsi, [rbp+var_60]
mov rdi, [rbp+var_68]
mov rdx, [rbp+var_70]
call strmake
mov rax, [rbp+var_40]
mov rcx, [rbp+var_48]
sub rcx, 1
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov rax, [rbp+var_48]
sub rax, 1
mov [rbp+var_78], rax
mov rax, [rbp+var_50]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_B8BAD
mov rax, [rbp+var_50]
mov [rbp+var_88], rax
jmp short loc_B8BBD
loc_B8BAD:
lea rax, aSyntaxError; "Syntax error"
mov [rbp+var_88], rax
jmp short $+2
loc_B8BBD:
mov rsi, [rbp+var_78]
mov rdi, [rbp+var_80]
mov rcx, [rbp+var_88]
lea rdx, aSAtS; "%s at '%s'"
xor eax, eax
lea r8, [rbp+var_30]
call my_snprintf
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B8BF9
add rsp, 90h
pop rbp
retn
loc_B8BF9:
call ___stack_chk_fail
| unsigned long long my_coll_lexem_print_error(long long a1, long long a2, long long a3, _BYTE *a4)
{
int v4; // r9d
int v6; // [rsp+18h] [rbp-78h]
long long v7; // [rsp+30h] [rbp-60h]
unsigned long long v8; // [rsp+38h] [rbp-58h]
_BYTE v11[40]; // [rsp+60h] [rbp-30h] BYREF
unsigned long long v12; // [rsp+88h] [rbp-8h]
v12 = __readfsqword(0x28u);
v8 = *(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 24);
v7 = *(_QWORD *)(a1 + 24);
if ( v8 >= 0x1D )
strmake(v11, v7, 29LL);
else
strmake(v11, v7, v8);
*(_BYTE *)(a2 + a3 - 1) = 0;
v6 = a3 - 1;
if ( *a4 )
my_snprintf(a2, v6, (unsigned int)"%s at '%s'", (_DWORD)a4, (unsigned int)v11, v4);
else
my_snprintf(a2, v6, (unsigned int)"%s at '%s'", (unsigned int)"Syntax error", (unsigned int)v11, v4);
return __readfsqword(0x28u);
}
| my_coll_lexem_print_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RCX + 0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x60],RAX
CMP qword ptr [RBP + -0x58],0x1d
JNC 0x001b8b54
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001b8b5f
LAB_001b8b54:
MOV EAX,0x1d
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001b8b5f
LAB_001b8b5f:
MOV RSI,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RBP + -0x68]
MOV RDX,qword ptr [RBP + -0x70]
CALL 0x001e1440
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x48]
SUB RCX,0x1
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x48]
SUB RAX,0x1
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001b8bad
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x001b8bbd
LAB_001b8bad:
LEA RAX,[0x1e8acb]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x001b8bbd
LAB_001b8bbd:
MOV RSI,qword ptr [RBP + -0x78]
MOV RDI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
LEA RDX,[0x1e8ac0]
XOR EAX,EAX
LEA R8,[RBP + -0x30]
CALL 0x001e08b0
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b8bf9
ADD RSP,0x90
POP RBP
RET
LAB_001b8bf9:
CALL 0x00129420
|
void my_coll_lexem_print_error(long param_1,long param_2,long param_3,char *param_4)
{
long in_FS_OFFSET;
char *local_90;
ulong local_78;
int1 local_38 [40];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_78 = *(long *)(param_1 + 0x10) - *(long *)(param_1 + 0x18);
if (0x1c < local_78) {
local_78 = 0x1d;
}
strmake(local_38,*(int8 *)(param_1 + 0x18),local_78);
*(int1 *)(param_2 + param_3 + -1) = 0;
local_90 = param_4;
if (*param_4 == '\0') {
local_90 = "Syntax error";
}
my_snprintf(param_2,param_3 + -1,"%s at \'%s\'",local_90,local_38);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
| |
52,308 | minja::Value::operator-(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | Value operator-(const Value& rhs) const {
if (is_number_integer() && rhs.is_number_integer())
return get<int64_t>() - rhs.get<int64_t>();
else
return get<double>() - rhs.get<double>();
} | O2 | cpp | minja::Value::operator-(minja::Value const&) const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x75186
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x1, %al
ja 0x75186
movq %rsi, %rdi
callq 0x67a0a
movq %rax, %r15
movq %r14, %rdi
callq 0x67a0a
subq %rax, %r15
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x67ac0
jmp 0x751b5
movq %rsi, %rdi
callq 0x67ade
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x67ade
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
leaq 0x8(%rsp), %rsi
movsd %xmm1, (%rsi)
movq %rbx, %rdi
callq 0x67b94
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZNK5minja5ValuemiERKS0_:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdx
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
cmp al, 1
ja short loc_75186
mov al, [r14+40h]
add al, 0FBh
cmp al, 1
ja short loc_75186
mov rdi, rsi
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
mov r15, rax
mov rdi, r14
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
sub r15, rax
lea rsi, [rsp+28h+var_20]; __int64 *
mov [rsi], r15
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKl; minja::Value::Value(long const&)
jmp short loc_751B5
loc_75186:
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd [rsp+28h+var_28], xmm0
mov rdi, r14
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
movsd xmm1, [rsp+28h+var_28]
subsd xmm1, xmm0
lea rsi, [rsp+28h+var_20]; double *
movsd qword ptr [rsi], xmm1
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKd; minja::Value::Value(double const&)
loc_751B5:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| minja::Value * minja::Value::operator-(minja::Value *this, minja::Value *a2, minja::Value *a3, double a4)
{
long long v5; // r15
long long v7[4]; // [rsp+8h] [rbp-20h] BYREF
if ( (unsigned __int8)(*((_BYTE *)a2 + 64) - 5) > 1u || (unsigned __int8)(*((_BYTE *)a3 + 64) - 5) > 1u )
{
minja::Value::get<double>(a2);
minja::Value::get<double>(a3);
*(double *)v7 = a4 - a4;
minja::Value::Value(this, (const double *)v7);
}
else
{
v5 = minja::Value::get<long>(a2);
v7[0] = v5 - minja::Value::get<long>(a3);
minja::Value::Value(this, v7);
}
return this;
}
| operator-:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x00175186
MOV AL,byte ptr [R14 + 0x40]
ADD AL,0xfb
CMP AL,0x1
JA 0x00175186
MOV RDI,RSI
CALL 0x00167a0a
MOV R15,RAX
MOV RDI,R14
CALL 0x00167a0a
SUB R15,RAX
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],R15
MOV RDI,RBX
CALL 0x00167ac0
JMP 0x001751b5
LAB_00175186:
MOV RDI,RSI
CALL 0x00167ade
MOVSD qword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x00167ade
MOVSD XMM1,qword ptr [RSP]
SUBSD XMM1,XMM0
LEA RSI,[RSP + 0x8]
MOVSD qword ptr [RSI],XMM1
MOV RDI,RBX
CALL 0x00167b94
LAB_001751b5:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
Value * __thiscall minja::Value::operator-(Value *this,Value *param_1)
{
long lVar1;
long lVar2;
Value *in_RDX;
double dVar3;
double local_20;
if (((byte)((char)param_1[0x40] - 5U) < 2) && ((byte)((char)in_RDX[0x40] - 5U) < 2)) {
lVar1 = get<long>(param_1);
lVar2 = get<long>(in_RDX);
local_20 = (double)(lVar1 - lVar2);
Value(this,(long *)&local_20);
}
else {
dVar3 = get<double>(param_1);
local_20 = get<double>(in_RDX);
local_20 = dVar3 - local_20;
Value(this,&local_20);
}
return this;
}
| |
52,309 | minja::ElifTemplateToken::~ElifTemplateToken() | monkey531[P]llama/common/minja.hpp | ElifTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::Elif, location, pre, post), condition(std::move(c)) {} | O3 | cpp | minja::ElifTemplateToken::~ElifTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x93ecd(%rip), %rax # 0x139b68
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0xa5cb0
callq 0x7b578
leaq 0x93631(%rip), %rax # 0x1392e8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa5ccd
popq %rbx
jmp 0x7b578
popq %rbx
retq
nop
| _ZN5minja17ElifTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja17ElifTemplateTokenE; `vtable for'minja::ElifTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_A5CB0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A5CB0:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_A5CCD
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_A5CCD:
pop rbx
retn
| void minja::ElifTemplateToken::~ElifTemplateToken(minja::ElifTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ElifTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~ElifTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x239b68]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x001a5cb0
CALL 0x0017b578
LAB_001a5cb0:
LEA RAX,[0x2392e8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x001a5ccd
POP RBX
JMP 0x0017b578
LAB_001a5ccd:
POP RBX
RET
|
/* minja::ElifTemplateToken::~ElifTemplateToken() */
void __thiscall minja::ElifTemplateToken::~ElifTemplateToken(ElifTemplateToken *this)
{
*(int ***)this = &PTR__ElifTemplateToken_00239b78;
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_002392f8;
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;
}
| |
52,310 | my_hash_sort_simple_nopad | eloqsql/strings/ctype-simple.c | void my_hash_sort_simple_nopad(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for (; key < (uchar*) end ; key++)
{
MY_HASH_ADD(m1, m2, (uint) sort_order[(uint) *key]);
}
*nr1= m1;
*nr2= m2;
} | O0 | c | my_hash_sort_simple_nopad:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x41c74
jmp 0x41c22
movq -0x40(%rbp), %rax
andq $0x3f, %rax
addq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x40(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x48(%rbp)
jmp 0x41c66
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x41c16
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| my_hash_sort_simple_nopad:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax+58h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_48], rax
loc_41C16:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_41C74
jmp short $+2
loc_41C22:
mov rax, [rbp+var_40]
and rax, 3Fh
add rax, [rbp+var_48]
mov rcx, [rbp+var_30]
mov rdx, [rbp+var_10]
movzx edx, byte ptr [rdx]
mov edx, edx
movzx ecx, byte ptr [rcx+rdx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_40]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rax, [rbp+var_48]
add rax, 3
mov [rbp+var_48], rax
jmp short $+2
loc_41C66:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_41C16
loc_41C74:
mov rcx, [rbp+var_40]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
| _QWORD * my_hash_sort_simple_nopad(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-48h]
long long v7; // [rsp+8h] [rbp-40h]
unsigned __int8 *v8; // [rsp+38h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v8) * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
| my_hash_sort_simple_nopad:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_00141c16:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x00141c74
JMP 0x00141c22
LAB_00141c22:
MOV RAX,qword ptr [RBP + -0x40]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x10]
MOVZX EDX,byte ptr [RDX]
MOV EDX,EDX
MOVZX ECX,byte ptr [RCX + RDX*0x1]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x40]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x3
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00141c66
LAB_00141c66:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00141c16
LAB_00141c74:
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_simple_nopad(long param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_50;
ulong local_48;
byte *local_18;
local_48 = *param_4;
local_50 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_48 = ((local_48 & 0x3f) + local_50) *
(ulong)*(byte *)(*(long *)(param_1 + 0x58) + (ulong)*local_18) + local_48 * 0x100 ^
local_48;
local_50 = local_50 + 3;
}
*param_4 = local_48;
*param_5 = local_50;
return;
}
| |
52,311 | SchemaConverter::_not_strings(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | llama.cpp/common/json-schema-to-grammar.cpp | std::string _not_strings(const std::vector<std::string> & strings) {
struct TrieNode {
std::map<char, TrieNode> children;
bool is_end_of_string;
TrieNode() : is_end_of_string(false) {}
void insert(const std::string & string) {
auto node = this;
for (char c : string) {
node = &node->children[c];
}
node->is_end_of_string = true;
}
};
TrieNode trie;
for (const auto & s : strings) {
trie.insert(s);
}
std::string char_rule = _add_primitive("char", PRIMITIVE_RULES.at("char"));
std::ostringstream out;
out << "[\"] ( ";
std::function<void(const TrieNode &)> visit = [&](const TrieNode & node) {
std::ostringstream rejects;
auto first = true;
for (const auto & kv : node.children) {
rejects << kv.first;
if (first) {
first = false;
} else {
out << " | ";
}
out << "[" << kv.first << "]";
if (!kv.second.children.empty()) {
out << " (";
visit(kv.second);
out << ")";
} else if (kv.second.is_end_of_string) {
out << " " << char_rule << "+";
}
}
if (!node.children.empty()) {
if (!first) {
out << " | ";
}
out << "[^\"" << rejects.str() << "] " << char_rule << "*";
}
};
visit(trie);
out << " )";
if (!trie.is_end_of_string) {
out << "?";
}
out << " [\"] space";
return out.str();
} | O3 | cpp | SchemaConverter::_not_strings(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq (%rdx), %r14
movq 0x8(%rdx), %r13
cmpq %r13, %r14
je 0x4ae65
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4b760
addq $0x20, %r14
cmpq %r13, %r14
jne 0x4ae51
leaq 0x90(%rsp), %r13
movq %r13, -0x10(%r13)
movl $0x72616863, %eax # imm = 0x72616863
movl %eax, (%r13)
movl $0x4, %ecx
movq %rcx, -0x8(%r13)
xorl %edx, %edx
movb %dl, 0x4(%r13)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movl %eax, (%rbp)
movq %rcx, -0x8(%rbp)
movb %dl, 0x4(%rbp)
leaq 0x2dc45(%rip), %rdi # 0x78ae8
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x4f526
testq %rax, %rax
je 0x4b053
addq $0x28, %rax
leaq 0x28(%rsp), %r15
leaq 0x80(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rcx
callq 0x47dd2
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4aeef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17100
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x4af0c
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x17100
leaq 0x80(%rsp), %rdi
callq 0x17a50
leaq 0x15eda(%rip), %rsi # 0x60dfa
leaq 0x80(%rsp), %r12
movl $0x6, %edx
movq %r12, %rdi
callq 0x17a80
movq $0x0, 0x10(%rsp)
movl $0x18, %edi
callq 0x17140
movq %r12, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x8(%rsp)
leaq 0xaed(%rip), %rcx # 0x4ba4c
movq %rcx, 0x20(%rsp)
leaq 0xae9(%rip), %rcx # 0x4ba54
movq %rcx, 0x18(%rsp)
leaq 0x48(%rsp), %rsi
movq %rax, %rdi
callq 0x4ba7c
leaq 0x15326(%rip), %rsi # 0x602aa
leaq 0x80(%rsp), %rdi
movl $0x2, %edx
callq 0x17a80
cmpb $0x0, 0x78(%rsp)
jne 0x4afb6
leaq 0x12616(%rip), %rsi # 0x5d5ba
leaq 0x80(%rsp), %rdi
movl $0x1, %edx
callq 0x17a80
leaq 0x15e44(%rip), %rsi # 0x60e01
leaq 0x80(%rsp), %rdi
movl $0xa, %edx
callq 0x17a80
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x17410
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4aff8
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x2cf79(%rip), %rsi # 0x77f78
leaq 0x80(%rsp), %rdi
callq 0x17810
leaq 0xf0(%rsp), %rdi
callq 0x177f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b034
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17100
leaq 0x48(%rsp), %rdi
callq 0x4bdbc
movq %rbx, %rax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15ce3(%rip), %rdi # 0x60d3d
callq 0x176e0
jmp 0x4b0fb
jmp 0x4b066
movq %rax, %rbx
jmp 0x4b0bd
movq %rax, %rbx
jmp 0x4b0de
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4b08a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x17100
movq 0x80(%rsp), %rdi
cmpq %r13, %rdi
je 0x4b106
movq 0x90(%rsp), %rsi
jmp 0x4b0f1
movq %rax, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4b0bd
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x2ceb4(%rip), %rsi # 0x77f78
leaq 0x80(%rsp), %rdi
callq 0x17810
leaq 0xf0(%rsp), %rdi
callq 0x177f0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4b106
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x17100
jmp 0x4b106
movq %rax, %rdi
callq 0x25387
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4bdbc
movq %rbx, %rdi
callq 0x17710
| _ZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1F8h
mov r12, rsi
mov rbx, rdi
lea rax, [rsp+228h+var_1D8]
mov dword ptr [rax], 0
xor ecx, ecx
mov [rax+8], rcx
mov [rax+10h], rax
mov [rax+18h], rax
mov [rax+20h], rcx
mov byte ptr [rax+28h], 0
mov r14, [rdx]
mov r13, [rdx+8]
cmp r14, r13
jz short loc_4AE65
lea r15, [rsp+228h+var_1E0]
loc_4AE51:
mov rdi, r15
mov rsi, r14
call _ZZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEEN8TrieNode6insertERKS6_; SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode::insert(std::string const&)
add r14, 20h ; ' '
cmp r14, r13
jnz short loc_4AE51
loc_4AE65:
lea r13, [rsp+228h+var_198]
mov [r13-10h], r13
mov eax, 72616863h
mov [r13+0], eax
mov ecx, 4
mov [r13-8], rcx
xor edx, edx
mov [r13+4], dl
lea rbp, [rsp+228h+var_210]
mov [rbp-10h], rbp
mov [rbp+0], eax
mov [rbp-8], rcx
mov [rbp+4], dl
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
lea r14, [rsp+228h+var_220]
mov rsi, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_11BuiltinRuleESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
test rax, rax
jz loc_4B053
add rax, 28h ; '('
lea r15, [rsp+228h+var_200]
lea rdx, [rsp+228h+var_1A8]; int
mov rdi, r15; int
mov rsi, r12; int
mov rcx, rax; int
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
mov rdi, [rsp+228h+var_220]; void *
cmp rdi, rbp
jz short loc_4AEEF
mov rsi, [rsp+228h+var_210]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4AEEF:
mov rdi, [rsp+228h+var_1A8]; void *
cmp rdi, r13
jz short loc_4AF0C
mov rsi, [rsp+228h+var_198]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4AF0C:
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, asc_60DFA; "[\"] ( "
lea r12, [rsp+228h+var_1A8]
mov edx, 6
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov [rsp+228h+var_218], 0
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
mov [rax+8], r14
mov [rax+10h], r15
mov [rsp+228h+var_220], rax
lea rcx, _ZNSt17_Function_handlerIFvRKZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEE8TrieNodeEZNS0_12_not_stringsESB_EUlSE_E_E9_M_invokeERKSt9_Any_dataSE_; std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_invoke(std::_Any_data const&,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)
mov [rsp+228h+var_208], rcx
lea rcx, _ZNSt17_Function_handlerIFvRKZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEE8TrieNodeEZNS0_12_not_stringsESB_EUlSE_E_E10_M_managerERSt9_Any_dataRKSI_St18_Manager_operation; std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+228h+var_210], rcx
lea rsi, [rsp+228h+var_1E0]
mov rdi, rax
call _ZZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEENKUlRKZNS_12_not_stringsESA_E8TrieNodeE_clESD_; SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}::operator()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)
lea rsi, a09401910201912+50h; " )"
lea rdi, [rsp+228h+var_1A8]
mov edx, 2
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
cmp [rsp+228h+var_1B0], 0
jnz short loc_4AFB6
lea rsi, aRootA_0+0Ch; "?"
lea rdi, [rsp+228h+var_1A8]
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_4AFB6:
lea rsi, aSpace_6; " [\"] space"
lea rdi, [rsp+228h+var_1A8]
mov edx, 0Ah
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, [rsp+228h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rax, [rsp+228h+var_210]
test rax, rax
jz short loc_4AFF8
lea rdi, [rsp+228h+var_220]
mov rsi, rdi
mov edx, 3
call rax
loc_4AFF8:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+228h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
lea rax, [rsp+228h+var_1F0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4B034
mov rsi, [rsp+228h+var_1F0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4B034:
lea rdi, [rsp+228h+var_1E0]
call _ZNSt8_Rb_treeIcSt4pairIKcZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS9_EEE8TrieNodeESt10_Select1stISF_ESt4lessIcESaISF_EED2Ev; std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree()
mov rax, rbx
add rsp, 1F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4B053:
lea rdi, aUnorderedMapAt; "unordered_map::at"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
jmp loc_4B0FB
jmp short $+2
loc_4B066:
mov rbx, rax
jmp short loc_4B0BD
mov rbx, rax
jmp short loc_4B0DE
mov rbx, rax
mov rdi, [rsp+228h+var_220]; void *
cmp rdi, rbp
jz short loc_4B08A
mov rsi, [rsp+228h+var_210]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4B08A:
mov rdi, [rsp+228h+var_1A8]
cmp rdi, r13
jz short loc_4B106
mov rsi, [rsp+228h+var_198]
jmp short loc_4B0F1
mov rbx, rax
mov rax, [rsp+228h+var_210]
test rax, rax
jz short loc_4B0BD
lea rdi, [rsp+228h+var_220]
mov rsi, rdi
mov edx, 3
call rax
loc_4B0BD:
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+228h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+228h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_4B0DE:
lea rax, [rsp+228h+var_1F0]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4B106
mov rsi, [rsp+228h+var_1F0]
loc_4B0F1:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_4B106
loc_4B0FB:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_4B106:
lea rdi, [rsp+228h+var_1E0]
call _ZNSt8_Rb_treeIcSt4pairIKcZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS9_EEE8TrieNodeESt10_Select1stISF_ESt4lessIcESaISF_EED2Ev; std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| long long SchemaConverter::_not_strings(long long a1, long long a2, long long *a3)
{
long long v3; // r14
long long v4; // r13
long long v5; // rax
void ***v6; // rax
void *v8; // [rsp+8h] [rbp-220h] BYREF
long long v9; // [rsp+10h] [rbp-218h]
_QWORD v10[2]; // [rsp+18h] [rbp-210h] BYREF
int v11[4]; // [rsp+28h] [rbp-200h] BYREF
long long v12; // [rsp+38h] [rbp-1F0h] BYREF
_BYTE v13[8]; // [rsp+48h] [rbp-1E0h] BYREF
int v14; // [rsp+50h] [rbp-1D8h] BYREF
long long v15; // [rsp+58h] [rbp-1D0h]
int *v16; // [rsp+60h] [rbp-1C8h]
int *v17; // [rsp+68h] [rbp-1C0h]
long long v18; // [rsp+70h] [rbp-1B8h]
char v19; // [rsp+78h] [rbp-1B0h]
void *v20; // [rsp+80h] [rbp-1A8h] BYREF
long long v21; // [rsp+88h] [rbp-1A0h] BYREF
char v22[96]; // [rsp+90h] [rbp-198h] BYREF
_BYTE v23[312]; // [rsp+F0h] [rbp-138h] BYREF
v14 = 0;
v15 = 0LL;
v16 = &v14;
v17 = &v14;
v18 = 0LL;
v19 = 0;
v3 = *a3;
v4 = a3[1];
if ( *a3 != v4 )
{
do
{
SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode::insert(v13, v3);
v3 += 32LL;
}
while ( v3 != v4 );
}
v20 = v22;
strcpy(v22, "char");
v21 = 4LL;
v8 = v10;
strcpy((char *)v10, "char");
v9 = 4LL;
v5 = std::_Hashtable<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
PRIMITIVE_RULES[abi:cxx11],
&v8);
if ( !v5 )
std::__throw_out_of_range("unordered_map::at");
SchemaConverter::_add_primitive((void **)v11, a2, &v20, (_QWORD *)(v5 + 40));
if ( v8 != v10 )
operator delete(v8, v10[0] + 1LL);
if ( v20 != v22 )
operator delete(v20, *(_QWORD *)v22 + 1LL);
std::ostringstream::basic_ostringstream(&v20);
std::__ostream_insert<char,std::char_traits<char>>(&v20, "[\"] ( ", 6LL);
v9 = 0LL;
v6 = (void ***)operator new(0x18uLL);
*v6 = &v20;
v6[1] = &v8;
v6[2] = (void **)v11;
v8 = v6;
v10[1] = std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_invoke;
v10[0] = std::_Function_handler<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&),SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}>::_M_manager;
SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1}::operator()(
v6,
v13);
std::__ostream_insert<char,std::char_traits<char>>(&v20, " )", 2LL);
if ( !v19 )
std::__ostream_insert<char,std::char_traits<char>>(&v20, "?", 1LL);
std::__ostream_insert<char,std::char_traits<char>>(&v20, " [\"] space", 10LL);
std::stringbuf::str(a1, &v21);
if ( v10[0] )
((void ( *)(void **, void **, long long))v10[0])(&v8, &v8, 3LL);
std::ostringstream::~ostringstream(&v20, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v23);
if ( *(long long **)v11 != &v12 )
operator delete(*(void **)v11, v12 + 1);
std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree(v13);
return a1;
}
| _not_strings:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f8
MOV R12,RSI
MOV RBX,RDI
LEA RAX,[RSP + 0x50]
MOV dword ptr [RAX],0x0
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
MOV qword ptr [RAX + 0x20],RCX
MOV byte ptr [RAX + 0x28],0x0
MOV R14,qword ptr [RDX]
MOV R13,qword ptr [RDX + 0x8]
CMP R14,R13
JZ 0x0014ae65
LEA R15,[RSP + 0x48]
LAB_0014ae51:
MOV RDI,R15
MOV RSI,R14
CALL 0x0014b760
ADD R14,0x20
CMP R14,R13
JNZ 0x0014ae51
LAB_0014ae65:
LEA R13,[RSP + 0x90]
MOV qword ptr [R13 + -0x10],R13
MOV EAX,0x72616863
MOV dword ptr [R13],EAX
MOV ECX,0x4
MOV qword ptr [R13 + -0x8],RCX
XOR EDX,EDX
MOV byte ptr [R13 + 0x4],DL
LEA RBP,[RSP + 0x18]
MOV qword ptr [RBP + -0x10],RBP
MOV dword ptr [RBP],EAX
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RBP + 0x4],DL
LAB_0014ae9c:
LEA RDI,[0x178ae8]
LEA R14,[RSP + 0x8]
MOV RSI,R14
CALL 0x0014f526
TEST RAX,RAX
JZ 0x0014b053
ADD RAX,0x28
LEA R15,[RSP + 0x28]
LEA RDX,[RSP + 0x80]
MOV RDI,R15
MOV RSI,R12
MOV RCX,RAX
CALL 0x00147dd2
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,RBP
JZ 0x0014aeef
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00117100
LAB_0014aeef:
MOV RDI,qword ptr [RSP + 0x80]
CMP RDI,R13
JZ 0x0014af0c
MOV RSI,qword ptr [RSP + 0x90]
INC RSI
CALL 0x00117100
LAB_0014af0c:
LEA RDI,[RSP + 0x80]
CALL 0x00117a50
LAB_0014af19:
LEA RSI,[0x160dfa]
LEA R12,[RSP + 0x80]
MOV EDX,0x6
MOV RDI,R12
CALL 0x00117a80
MOV qword ptr [RSP + 0x10],0x0
LAB_0014af3e:
MOV EDI,0x18
CALL 0x00117140
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],R14
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RSP + 0x8],RAX
LEA RCX,[0x14ba4c]
MOV qword ptr [RSP + 0x20],RCX
LEA RCX,[0x14ba54]
MOV qword ptr [RSP + 0x18],RCX
LAB_0014af70:
LEA RSI,[RSP + 0x48]
MOV RDI,RAX
CALL 0x0014ba7c
LEA RSI,[0x1602aa]
LEA RDI,[RSP + 0x80]
MOV EDX,0x2
CALL 0x00117a80
CMP byte ptr [RSP + 0x78],0x0
JNZ 0x0014afb6
LEA RSI,[0x15d5ba]
LEA RDI,[RSP + 0x80]
MOV EDX,0x1
CALL 0x00117a80
LAB_0014afb6:
LEA RSI,[0x160e01]
LEA RDI,[RSP + 0x80]
MOV EDX,0xa
CALL 0x00117a80
LEA RSI,[RSP + 0x88]
MOV RDI,RBX
CALL 0x00117410
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x0014aff8
LAB_0014afe9:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0014aff8:
MOV RSI,qword ptr [0x00177f78]
LEA RDI,[RSP + 0x80]
CALL 0x00117810
LEA RDI,[RSP + 0xf0]
CALL 0x001177f0
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0014b034
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00117100
LAB_0014b034:
LEA RDI,[RSP + 0x48]
CALL 0x0014bdbc
MOV RAX,RBX
ADD RSP,0x1f8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014b053:
LEA RDI,[0x160d3d]
CALL 0x001176e0
LAB_0014b05f:
JMP 0x0014b0fb
LAB_0014b0fb:
MOV RDI,RAX
CALL 0x00125387
|
/* SchemaConverter::_not_strings(std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&) */
vector * SchemaConverter::_not_strings(vector *param_1)
{
long lVar1;
int8 uVar2;
long *in_RDX;
BuiltinRule *in_RSI;
long lVar3;
_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*local_220;
int8 local_218;
code *local_210;
code *local_208;
long *local_200 [2];
long local_1f0 [2];
TrieNode local_1e0 [8];
int4 local_1d8 [2];
int8 local_1d0;
int4 *local_1c8;
int4 *local_1c0;
int8 local_1b8;
char local_1b0;
int4 *local_1a8;
int8 local_1a0;
int4 local_198;
uint uStack_194;
ios_base local_138 [264];
local_1c8 = local_1d8;
local_1d8[0] = 0;
local_1d0 = 0;
local_1b8 = 0;
local_1b0 = '\0';
lVar3 = *in_RDX;
lVar1 = in_RDX[1];
local_1c0 = local_1c8;
if (lVar3 != lVar1) {
do {
/* try { // try from 0014ae51 to 0014ae5b has its CatchHandler @ 0014b103 */
_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::
TrieNode::insert(std::__cxx11::string_const__(local_1e0,lVar3);
lVar3 = lVar3 + 0x20;
} while (lVar3 != lVar1);
}
local_198 = 0x72616863;
local_1a0 = 4;
uStack_194 = uStack_194 & 0xffffff00;
local_218 = 4;
local_210 = (code *)CONCAT35(local_210._5_3_,0x72616863);
/* try { // try from 0014ae9c to 0014aed7 has its CatchHandler @ 0014b070 */
local_220 = (_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*)&local_210;
local_1a8 = &local_198;
lVar3 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)PRIMITIVE_RULES_abi_cxx11_,(string *)&local_220);
if (lVar3 != 0) {
_add_primitive((string *)local_200,in_RSI);
if (local_220 !=
(_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*)&local_210) {
operator_delete(local_220,(ulong)(local_210 + 1));
}
if (local_1a8 != &local_198) {
operator_delete(local_1a8,CONCAT44(uStack_194,local_198) + 1);
}
/* try { // try from 0014af0c to 0014af18 has its CatchHandler @ 0014b06b */
std::__cxx11::ostringstream::ostringstream((ostringstream *)&local_1a8);
/* try { // try from 0014af19 to 0014af34 has its CatchHandler @ 0014b066 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8,"[\"] ( ",6);
local_218 = 0;
/* try { // try from 0014af3e to 0014af47 has its CatchHandler @ 0014b064 */
local_220 = (_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const____TrieNode_const___1_
*)operator_new(0x18);
*(ostream **)local_220 = (ostream *)&local_1a8;
*(string **)(local_220 + 8) = (string *)&local_220;
*(string **)(local_220 + 0x10) = (string *)local_200;
local_208 = std::
_Function_handler<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&),SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)#1}>
::_M_invoke;
local_210 = std::
_Function_handler<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&),SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)#1}>
::_M_manager;
/* try { // try from 0014af70 to 0014afde has its CatchHandler @ 0014b0a1 */
_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::
{lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)#1}
::operator()(local_220,local_1e0);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8," )",2);
if (local_1b0 == '\0') {
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8,"?",1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)&local_1a8," [\"] space",10);
std::__cxx11::stringbuf::str();
if (local_210 != (code *)0x0) {
/* try { // try from 0014afe9 to 0014aff7 has its CatchHandler @ 0014b05f */
(*local_210)(&local_220,&local_220,3);
}
std::__cxx11::ostringstream::~ostringstream((ostringstream *)&local_1a8);
std::ios_base::~ios_base(local_138);
if (local_200[0] != local_1f0) {
operator_delete(local_200[0],local_1f0[0] + 1);
}
std::
_Rb_tree<char,std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>,std::_Select1st<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>>
::~_Rb_tree((_Rb_tree<char,std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>,std::_Select1st<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>>
*)local_1e0);
return param_1;
}
/* try { // try from 0014b053 to 0014b05e has its CatchHandler @ 0014b070 */
uVar2 = std::__throw_out_of_range("unordered_map::at");
/* catch(type#1 @ 00000000) { ... } // from try @ 0014afe9 with catch @ 0014b05f
*/
/* catch(type#1 @ 00000000) { ... } // from try @ 0014b0ae with catch @ 0014b0fb
*/
/* WARNING: Subroutine does not return */
__clang_call_terminate(uVar2);
}
| |
52,312 | LEX::stmt_grant_sp(THD*, Grant_privilege*, Lex_grant_object_name const&, Sp_handler const&, privilege_t) | eloqsql/sql/sql_lex.cc | bool LEX::stmt_grant_sp(THD *thd,
Grant_privilege *grant,
const Lex_grant_object_name &ident,
const Sp_handler &sph,
privilege_t grant_option)
{
sql_command= SQLCOM_GRANT;
return
grant->set_object_name(thd, ident, current_select, grant_option) ||
add_grant_command(thd, grant->columns()) ||
!(m_sql_cmd= new (thd->mem_root) Sql_cmd_grant_sp(sql_command,
*grant, sph));
} | O0 | cpp | LEX::stmt_grant_sp(THD*, Grant_privilege*, Lex_grant_object_name const&, Sp_handler const&, privilege_t):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %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 -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x22, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq 0xd28(%rax), %rcx
movq -0x30(%rbp), %r8
callq 0xa909d0
movb %al, %cl
movb $0x0, -0x41(%rbp)
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x55(%rbp)
jne 0x8ddc37
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8e3c20
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
callq 0x8d6fc0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x55(%rbp)
jne 0x8ddc37
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0x80(%rbp)
movl $0x58, %edi
callq 0x7dbfd0
movq %rax, %rcx
movq %rcx, -0x78(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0x8ddc1c
movq -0x78(%rbp), %rdi
movq -0x60(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rdi, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movb $0x1, -0x41(%rbp)
movl 0x8(%rax), %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x8e3c30
jmp 0x8ddc12
movq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x8ddc1c
movq -0x60(%rbp), %rcx
movq -0x70(%rbp), %rax
movq %rax, 0x17d8(%rcx)
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x8ddc59
jmp 0x8ddc66
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7dc010
jmp 0x8ddc68
movq -0x50(%rbp), %rdi
callq 0x7589b0
nopw %cs:(%rax,%rax)
| _ZN3LEX13stmt_grant_spEP3THDP15Grant_privilegeRK21Lex_grant_object_nameRK10Sp_handler11privilege_t:
push rbp
mov rbp, rsp
sub rsp, 80h
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_8]
mov [rbp+var_60], rax
mov dword ptr [rax+8], 22h ; '"'
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_20]
mov rcx, [rax+0D28h]
mov r8, [rbp+var_30]
call _ZN15Grant_privilege15set_object_nameEP3THDRK17Grant_object_nameP13st_select_lex11privilege_t; Grant_privilege::set_object_name(THD *,Grant_object_name const&,st_select_lex *,privilege_t)
mov cl, al
mov [rbp+var_41], 0
mov al, 1
test cl, 1
mov [rbp+var_55], al
jnz loc_8DDC37
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov rdi, [rbp+var_18]; this
call _ZNK15Grant_privilege7columnsEv; Grant_privilege::columns(void)
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_68]
mov rdx, rax
call _ZN3LEX17add_grant_commandEP3THDRK4ListI10LEX_COLUMNE; LEX::add_grant_command(THD *,List<LEX_COLUMN> const&)
mov cl, al
mov al, 1
test cl, 1
mov [rbp+var_55], al
jnz short loc_8DDC37
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
mov [rbp+var_80], rsi
mov edi, 58h ; 'X'
call _ZN9Sql_allocnwEmP11st_mem_root; Sql_alloc::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_78], rcx
xor eax, eax
cmp rcx, 0
mov [rbp+var_70], rax
jz short loc_8DDC1C
mov rdi, [rbp+var_78]
mov rax, [rbp+var_60]
mov rcx, [rbp+var_80]
mov [rbp+var_38], rdi
mov [rbp+var_40], rcx
mov [rbp+var_41], 1
mov esi, [rax+8]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_28]
call _ZN16Sql_cmd_grant_spC2E16enum_sql_commandRK15Grant_privilegeRK10Sp_handler; Sql_cmd_grant_sp::Sql_cmd_grant_sp(enum_sql_command,Grant_privilege const&,Sp_handler const&)
jmp short $+2
loc_8DDC12:
mov rax, [rbp+var_78]
mov [rbp+var_70], rax
jmp short $+2
loc_8DDC1C:
mov rcx, [rbp+var_60]
mov rax, [rbp+var_70]
mov [rcx+17D8h], rax
cmp rax, 0
setnz al
xor al, 0FFh
mov [rbp+var_55], al
loc_8DDC37:
mov al, [rbp+var_55]
and al, 1
add rsp, 80h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
test [rbp+var_41], 1
jnz short loc_8DDC59
jmp short loc_8DDC66
loc_8DDC59:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_40]
call _ZN9Sql_allocdlEPvP11st_mem_root; Sql_alloc::operator delete(void *,st_mem_root *)
loc_8DDC66:
jmp short $+2
loc_8DDC68:
mov rdi, [rbp+var_50]
call __Unwind_Resume
| char LEX::stmt_grant_sp(long long a1, long long *a2, Grant_privilege *a3, long long a4, long long a5, long long a6)
{
long long v6; // rax
long long v8; // [rsp+8h] [rbp-78h]
long long v9; // [rsp+10h] [rbp-70h]
char v10; // [rsp+2Bh] [rbp-55h]
*(_DWORD *)(a1 + 8) = 34;
v10 = 1;
if ( (Grant_privilege::set_object_name(a3, a2, a4, *(_QWORD *)(a1 + 3368), a6) & 1) == 0 )
{
v6 = Grant_privilege::columns(a3);
v10 = 1;
if ( (LEX::add_grant_command(a1, (THD *)a2, v6) & 1) == 0 )
{
v8 = Sql_alloc::operator new(88LL, a2[5]);
v9 = 0LL;
if ( v8 )
{
Sql_cmd_grant_sp::Sql_cmd_grant_sp(v8, *(unsigned int *)(a1 + 8), a3, a5);
v9 = v8;
}
*(_QWORD *)(a1 + 6104) = v9;
v10 = ~(v9 != 0);
}
}
return v10 & 1;
}
| destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x20
CALL 0x008d7120
ADD RSP,0x10
POP RBP
RET
|
/* THD_list::destroy() */
void __thiscall THD_list::destroy(THD_list *this)
{
inline_mysql_rwlock_destroy((st_mysql_rwlock *)(this + 0x20));
return;
}
| |
52,313 | LEX::stmt_grant_sp(THD*, Grant_privilege*, Lex_grant_object_name const&, Sp_handler const&, privilege_t) | eloqsql/sql/sql_lex.cc | bool LEX::stmt_grant_sp(THD *thd,
Grant_privilege *grant,
const Lex_grant_object_name &ident,
const Sp_handler &sph,
privilege_t grant_option)
{
sql_command= SQLCOM_GRANT;
return
grant->set_object_name(thd, ident, current_select, grant_option) ||
add_grant_command(thd, grant->columns()) ||
!(m_sql_cmd= new (thd->mem_root) Sql_cmd_grant_sp(sql_command,
*grant, sph));
} | O3 | cpp | LEX::stmt_grant_sp(THD*, Grant_privilege*, Lex_grant_object_name const&, Sp_handler const&, privilege_t):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movl $0x22, 0x8(%rdi)
movq 0xd28(%rdi), %rax
movq %rdx, %rdi
movq %rcx, %rdx
movq %rax, %rcx
movq %r9, %r8
callq 0x84515a
movb $0x1, %r12b
testb %al, %al
jne 0x751f89
cmpl $0x0, 0x10(%r15)
je 0x751f0c
movq 0xb90(%r13), %rax
movq (%rax), %rax
movq 0x4a8(%rax), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x752f50
jmp 0x751f89
movq 0x28(%r13), %rdi
movl $0x58, %esi
callq 0xcbdbb3
testq %rax, %rax
sete %r12b
je 0x751f82
movl 0x8(%r14), %ecx
leaq 0xc0a63a(%rip), %rdx # 0x135c568
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movl 0x10(%r15), %ecx
movl %ecx, 0x20(%rax)
movq (%r15), %rdx
movq %rdx, 0x10(%rax)
testl %ecx, %ecx
je 0x751f4c
movq 0x8(%r15), %rcx
jmp 0x751f53
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x18(%rax)
movups 0x18(%r15), %xmm0
movups 0x28(%r15), %xmm1
movups %xmm0, 0x28(%rax)
movups %xmm1, 0x38(%rax)
movb 0x38(%r15), %cl
movb %cl, 0x48(%rax)
leaq 0xc041f1(%rip), %rcx # 0x1356168
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x50(%rax)
movq %rax, 0x17d8(%r14)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x6c7e0c
nop
| _ZN3LEX13stmt_grant_spEP3THDP15Grant_privilegeRK21Lex_grant_object_nameRK10Sp_handler11privilege_t:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov r15, rdx
mov r13, rsi
mov r14, rdi
mov dword ptr [rdi+8], 22h ; '"'
mov rax, [rdi+0D28h]
mov rdi, rdx
mov rdx, rcx
mov rcx, rax
mov r8, r9
call _ZN15Grant_privilege15set_object_nameEP3THDRK17Grant_object_nameP13st_select_lex11privilege_t; Grant_privilege::set_object_name(THD *,Grant_object_name const&,st_select_lex *,privilege_t)
mov r12b, 1
test al, al
jnz loc_751F89
cmp dword ptr [r15+10h], 0
jz short loc_751F0C
mov rax, [r13+0B90h]
mov rax, [rax]
mov rsi, [rax+4A8h]; char *
mov rdi, r13; this
xor edx, edx; char *
call _ZN3THD11parse_errorEPKcS1_; THD::parse_error(char const*,char const*)
jmp short loc_751F89
loc_751F0C:
mov rdi, [r13+28h]
mov esi, 58h ; 'X'
call alloc_root
test rax, rax
setz r12b
jz short loc_751F82
mov ecx, [r14+8]
lea rdx, off_135C568
mov [rax], rdx
mov [rax+8], ecx
mov ecx, [r15+10h]
mov [rax+20h], ecx
mov rdx, [r15]
mov [rax+10h], rdx
test ecx, ecx
jz short loc_751F4C
mov rcx, [r15+8]
jmp short loc_751F53
loc_751F4C:
mov rcx, rax
add rcx, 10h
loc_751F53:
mov [rax+18h], rcx
movups xmm0, xmmword ptr [r15+18h]
movups xmm1, xmmword ptr [r15+28h]
movups xmmword ptr [rax+28h], xmm0
movups xmmword ptr [rax+38h], xmm1
mov cl, [r15+38h]
mov [rax+48h], cl
lea rcx, _ZTV16Sql_cmd_grant_sp; `vtable for'Sql_cmd_grant_sp
add rcx, 10h
mov [rax], rcx
mov [rax+50h], rbx
loc_751F82:
mov [r14+17D8h], rax
loc_751F89:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rdi, rax
call __clang_call_terminate
| long long LEX::stmt_grant_sp(long long a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v5; // r12d
long long v8; // rax
int v9; // ecx
int v10; // ecx
long long v11; // rcx
__int128 v12; // xmm1
*(_DWORD *)(a1 + 8) = 34;
LOBYTE(v5) = 1;
if ( !(unsigned __int8)Grant_privilege::set_object_name(a3, a2, a4, *(_QWORD *)(a1 + 3368)) )
{
if ( *(_DWORD *)(a3 + 16) )
{
THD::parse_error((THD *)a2, *(const char **)(**(_QWORD **)(a2 + 2960) + 1192LL), 0LL);
}
else
{
v8 = alloc_root(*(_QWORD *)(a2 + 40), 88LL);
LOBYTE(v5) = v8 == 0;
if ( v8 )
{
v9 = *(_DWORD *)(a1 + 8);
*(_QWORD *)v8 = &off_135C568;
*(_DWORD *)(v8 + 8) = v9;
v10 = *(_DWORD *)(a3 + 16);
*(_DWORD *)(v8 + 32) = v10;
*(_QWORD *)(v8 + 16) = *(_QWORD *)a3;
if ( v10 )
v11 = *(_QWORD *)(a3 + 8);
else
v11 = v8 + 16;
*(_QWORD *)(v8 + 24) = v11;
v12 = *(_OWORD *)(a3 + 40);
*(_OWORD *)(v8 + 40) = *(_OWORD *)(a3 + 24);
*(_OWORD *)(v8 + 56) = v12;
*(_BYTE *)(v8 + 72) = *(_BYTE *)(a3 + 56);
*(_QWORD *)v8 = &`vtable for'Sql_cmd_grant_sp + 2;
*(_QWORD *)(v8 + 80) = a5;
}
*(_QWORD *)(a1 + 6104) = v8;
}
}
return v5;
}
| |||
52,314 | js_object_getOwnPropertyDescriptors | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_getOwnPropertyDescriptors(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
//getOwnPropertyDescriptors(obj)
JSValue obj, r;
JSObject *p;
JSPropertyEnum *props;
uint32_t len, i;
r = JS_UNDEFINED;
obj = JS_ToObject(ctx, argv[0]);
if (JS_IsException(obj))
return JS_EXCEPTION;
p = JS_VALUE_GET_OBJ(obj);
if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p,
JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK))
goto exception;
r = JS_NewObject(ctx);
if (JS_IsException(r))
goto exception;
for(i = 0; i < len; i++) {
JSValue atomValue, desc;
JSValue args[2];
atomValue = JS_AtomToValue(ctx, props[i].atom);
if (JS_IsException(atomValue))
goto exception;
args[0] = obj;
args[1] = atomValue;
desc = js_object_getOwnPropertyDescriptor(ctx, JS_UNDEFINED, 2, args, 0);
JS_FreeValue(ctx, atomValue);
if (JS_IsException(desc))
goto exception;
if (!JS_IsUndefined(desc)) {
if (JS_DefinePropertyValue(ctx, r, props[i].atom, desc,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
}
js_free_prop_enum(ctx, props, len);
JS_FreeValue(ctx, obj);
return r;
exception:
js_free_prop_enum(ctx, props, len);
JS_FreeValue(ctx, obj);
JS_FreeValue(ctx, r);
return JS_EXCEPTION;
} | O1 | c | js_object_getOwnPropertyDescriptors:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x26ddd
movq %rdx, %r15
movq %rax, 0x18(%rsp)
movl $0x6, %ebx
cmpl $0x6, %r15d
je 0x70ab7
movq 0x18(%rsp), %rcx
leaq 0x38(%rsp), %rsi
leaq 0x14(%rsp), %rdx
movq %r14, %rdi
movl $0x3, %r8d
callq 0x235bd
testl %eax, %eax
je 0x70905
movl $0x3, %r12d
xorl %r13d, %r13d
xorl %ebp, %ebp
jmp 0x70a7f
movq 0x40(%r14), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
movq %r14, %rdi
movl $0x1, %ecx
callq 0x20f05
movq %rax, %r13
movq %rdx, %r12
movq %rax, %rbp
shrq $0x20, %rbp
cmpl $0x6, %r12d
je 0x70a7f
movq %rbp, 0x50(%rsp)
movq %r13, 0x20(%rsp)
movq %r12, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movl 0x14(%rsp), %eax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x70a23
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
xorl %r15d, %r15d
movq 0x48(%rsp), %rax
movl 0x4(%rax,%r15,8), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2075a
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x70a66
movq %rax, %r13
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %r13, 0x70(%rsp)
movq %rbx, 0x78(%rsp)
movq %r14, %rdi
leaq 0x60(%rsp), %r8
xorl %r9d, %r9d
callq 0x705ba
movq %rax, %rbp
movq %rdx, %r12
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1d8c6
cmpl $0x3, %r12d
je 0x70a15
cmpl $0x6, %r12d
je 0x70a66
movq 0x48(%rsp), %rax
movl 0x4(%rax,%r15,8), %ecx
movl $0x4007, (%rsp) # imm = 0x4007
movq %r14, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbp, %r8
movq %r12, %r9
callq 0x26abb
testl %eax, %eax
js 0x70a66
incq %r15
cmpq %r15, 0x40(%rsp)
jne 0x70974
movq 0x38(%rsp), %rsi
movq %r14, %rdi
movq 0x40(%rsp), %rdx
callq 0x23e79
movq 0x18(%rsp), %rsi
movq 0x18(%r14), %rdi
movq 0x30(%rsp), %rdx
callq 0x1d8c6
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq 0x20(%rsp), %rdx
movq %rdx, %rcx
andq %rax, %rcx
movl %edx, %eax
movq 0x28(%rsp), %rbx
jmp 0x70abb
movl $0x6, %ebx
movq 0x30(%rsp), %r15
movq 0x28(%rsp), %r12
movq 0x20(%rsp), %r13
movq 0x50(%rsp), %rbp
movq 0x38(%rsp), %rsi
movl 0x14(%rsp), %edx
movq %r14, %rdi
callq 0x23e79
movq 0x18(%rsp), %rsi
movq 0x18(%r14), %rdi
movq %r15, %rdx
callq 0x1d8c6
shlq $0x20, %rbp
movl %r13d, %esi
orq %rbp, %rsi
movq 0x18(%r14), %rdi
movq %r12, %rdx
callq 0x1d8c6
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %rbx, %rdx
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_object_getOwnPropertyDescriptors:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r14, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToObject
mov r15, rdx
mov [rsp+0B8h+var_A0], rax
mov ebx, 6
cmp r15d, 6
jz loc_70AB7
mov rcx, [rsp+0B8h+var_A0]
lea rsi, [rsp+0B8h+var_80]
lea rdx, [rsp+0B8h+var_A4]
mov rdi, r14
mov r8d, 3
call JS_GetOwnPropertyNamesInternal
test eax, eax
jz short loc_70905
mov r12d, 3
xor r13d, r13d
xor ebp, ebp
jmp loc_70A7F
loc_70905:
mov rax, [r14+40h]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
mov rdi, r14
mov ecx, 1
call JS_NewObjectProtoClass
mov r13, rax
mov r12, rdx
mov rbp, rax
shr rbp, 20h
cmp r12d, 6
jz loc_70A7F
mov [rsp+0B8h+var_68], rbp
mov [rsp+0B8h+var_98], r13
mov [rsp+0B8h+var_90], r12
mov [rsp+0B8h+var_88], r15
mov eax, [rsp+0B8h+var_A4]
mov [rsp+0B8h+var_78], rax
test rax, rax
jz loc_70A23
mov rax, [rsp+0B8h+var_80]
mov [rsp+0B8h+var_70], rax
movsd xmm0, [rsp+0B8h+var_A0]
movsd [rsp+0B8h+var_60], xmm0
xor r15d, r15d
loc_70974:
mov rax, [rsp+0B8h+var_70]
mov esi, [rax+r15*8+4]
mov rdi, r14
xor edx, edx
call __JS_AtomToValue
mov rbx, rdx
cmp ebx, 6
jz loc_70A66
mov r13, rax
movsd xmm0, [rsp+0B8h+var_60]
movsd [rsp+0B8h+var_58], xmm0
mov rax, [rsp+0B8h+var_88]
mov [rsp+0B8h+var_50], rax
mov [rsp+0B8h+var_48], r13
mov [rsp+0B8h+var_40], rbx
mov rdi, r14
lea r8, [rsp+0B8h+var_58]
xor r9d, r9d
call js_object_getOwnPropertyDescriptor
mov rbp, rax
mov r12, rdx
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbx
call JS_FreeValueRT
cmp r12d, 3
jz short loc_70A15
cmp r12d, 6
jz short loc_70A66
mov rax, [rsp+0B8h+var_70]
mov ecx, [rax+r15*8+4]
mov [rsp+0B8h+var_B8], 4007h
mov rdi, r14
mov rsi, [rsp+0B8h+var_98]
mov rdx, [rsp+0B8h+var_90]
mov r8, rbp
mov r9, r12
call JS_DefinePropertyValue
test eax, eax
js short loc_70A66
loc_70A15:
inc r15
cmp [rsp+0B8h+var_78], r15
jnz loc_70974
loc_70A23:
mov rsi, [rsp+0B8h+var_80]
mov rdi, r14
mov rdx, [rsp+0B8h+var_78]
call js_free_prop_enum
mov rsi, [rsp+0B8h+var_A0]
mov rdi, [r14+18h]
mov rdx, [rsp+0B8h+var_88]
call JS_FreeValueRT
mov rax, 0FFFFFFFF00000000h
mov rdx, [rsp+0B8h+var_98]
mov rcx, rdx
and rcx, rax
mov eax, edx
mov rbx, [rsp+0B8h+var_90]
jmp short loc_70ABB
loc_70A66:
mov ebx, 6
mov r15, [rsp+0B8h+var_88]
mov r12, [rsp+0B8h+var_90]
mov r13, [rsp+0B8h+var_98]
mov rbp, [rsp+0B8h+var_68]
loc_70A7F:
mov rsi, [rsp+0B8h+var_80]
mov edx, [rsp+0B8h+var_A4]
mov rdi, r14
call js_free_prop_enum
mov rsi, [rsp+0B8h+var_A0]
mov rdi, [r14+18h]
mov rdx, r15
call JS_FreeValueRT
shl rbp, 20h
mov esi, r13d
or rsi, rbp
mov rdi, [r14+18h]
mov rdx, r12
call JS_FreeValueRT
loc_70AB7:
xor eax, eax
xor ecx, ecx
loc_70ABB:
or rax, rcx
mov rdx, rbx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long js_object_getOwnPropertyDescriptors(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
_DWORD *v14; // rax
long long v15; // rdx
long long v16; // r15
long long v17; // r12
unsigned int v18; // r13d
unsigned long long v19; // rbp
unsigned long long v20; // rax
long long v21; // rdx
long long v22; // r15
long long v23; // rsi
long long v24; // rax
long long v25; // rdx
long long v26; // rcx
__m128 v27; // xmm4
__m128 v28; // xmm5
long long v29; // rbx
_DWORD *v30; // r13
double v31; // xmm0_8
_DWORD *OwnPropertyDescriptor; // rbp
long long v33; // rdx
long long v34; // r12
__m128 v35; // xmm4
__m128 v36; // xmm5
unsigned long long v37; // rcx
long long v38; // rax
unsigned int v40; // [rsp+14h] [rbp-A4h] BYREF
_DWORD *v41; // [rsp+18h] [rbp-A0h]
unsigned long long v42; // [rsp+20h] [rbp-98h]
long long v43; // [rsp+28h] [rbp-90h]
long long v44; // [rsp+30h] [rbp-88h]
long long v45; // [rsp+38h] [rbp-80h] BYREF
long long v46; // [rsp+40h] [rbp-78h]
long long v47; // [rsp+48h] [rbp-70h]
unsigned long long v48; // [rsp+50h] [rbp-68h]
_DWORD *v49; // [rsp+58h] [rbp-60h]
long long v50[11]; // [rsp+60h] [rbp-58h] BYREF
v14 = JS_ToObject(a1, *a13, a13[1], a12, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
v16 = v15;
v41 = v14;
if ( (_DWORD)v15 == 6 )
goto LABEL_15;
if ( (unsigned int)JS_GetOwnPropertyNamesInternal(a1, &v45, &v40, (long long)v41, 3) )
{
v17 = 3LL;
v18 = 0;
v19 = 0LL;
LABEL_14:
js_free_prop_enum(a1, v45, v40);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v41, v16);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)((v19 << 32) | v18), v17);
LABEL_15:
v38 = 0LL;
v37 = 0LL;
return v37 | v38;
}
v20 = JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 16LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 24LL),
1u);
v18 = v20;
v17 = v21;
v19 = HIDWORD(v20);
if ( (_DWORD)v21 == 6 )
goto LABEL_14;
v48 = HIDWORD(v20);
v42 = v20;
v43 = v21;
v44 = v16;
v46 = v40;
if ( v40 )
{
v47 = v45;
v49 = v41;
v22 = 0LL;
while ( 1 )
{
v23 = *(unsigned int *)(v47 + 8 * v22 + 4);
v24 = _JS_AtomToValue(a1, v23, 0);
v29 = v25;
if ( (_DWORD)v25 == 6 )
break;
v30 = (_DWORD *)v24;
v31 = *(double *)&v49;
v50[0] = (long long)v49;
v50[1] = v44;
v50[2] = v24;
v50[3] = v25;
OwnPropertyDescriptor = js_object_getOwnPropertyDescriptor(
a1,
(__m128)(unsigned long long)v49,
a3,
a4,
a5,
v27,
v28,
a8,
a9,
v23,
v25,
v26,
v50,
0LL);
v34 = v33;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v30, v29);
if ( (_DWORD)v34 != 3
&& ((_DWORD)v34 == 6
|| (int)JS_DefinePropertyValue(
a1,
v42,
v43,
*(unsigned int *)(v47 + 8 * v22 + 4),
OwnPropertyDescriptor,
v34,
v31,
a3,
a4,
a5,
v35,
v36,
a8,
a9,
16391) < 0) )
{
break;
}
if ( v46 == ++v22 )
goto LABEL_12;
}
v16 = v44;
v17 = v43;
v18 = v42;
v19 = v48;
goto LABEL_14;
}
LABEL_12:
js_free_prop_enum(a1, v45, v46);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v41, v44);
v37 = v42 & 0xFFFFFFFF00000000LL;
v38 = (unsigned int)v42;
return v37 | v38;
}
| js_object_getOwnPropertyDescriptors:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00126ddd
MOV R15,RDX
MOV qword ptr [RSP + 0x18],RAX
MOV EBX,0x6
CMP R15D,0x6
JZ 0x00170ab7
MOV RCX,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x38]
LEA RDX,[RSP + 0x14]
MOV RDI,R14
MOV R8D,0x3
CALL 0x001235bd
TEST EAX,EAX
JZ 0x00170905
MOV R12D,0x3
XOR R13D,R13D
XOR EBP,EBP
JMP 0x00170a7f
LAB_00170905:
MOV RAX,qword ptr [R14 + 0x40]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV RDI,R14
MOV ECX,0x1
CALL 0x00120f05
MOV R13,RAX
MOV R12,RDX
MOV RBP,RAX
SHR RBP,0x20
CMP R12D,0x6
JZ 0x00170a7f
MOV qword ptr [RSP + 0x50],RBP
MOV qword ptr [RSP + 0x20],R13
MOV qword ptr [RSP + 0x28],R12
MOV qword ptr [RSP + 0x30],R15
MOV EAX,dword ptr [RSP + 0x14]
MOV qword ptr [RSP + 0x40],RAX
TEST RAX,RAX
JZ 0x00170a23
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x48],RAX
MOVSD XMM0,qword ptr [RSP + 0x18]
MOVSD qword ptr [RSP + 0x58],XMM0
XOR R15D,R15D
LAB_00170974:
MOV RAX,qword ptr [RSP + 0x48]
MOV ESI,dword ptr [RAX + R15*0x8 + 0x4]
MOV RDI,R14
XOR EDX,EDX
CALL 0x0012075a
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00170a66
MOV R13,RAX
MOVSD XMM0,qword ptr [RSP + 0x58]
MOVSD qword ptr [RSP + 0x60],XMM0
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],R13
MOV qword ptr [RSP + 0x78],RBX
MOV RDI,R14
LEA R8,[RSP + 0x60]
XOR R9D,R9D
CALL 0x001705ba
MOV RBP,RAX
MOV R12,RDX
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R13
MOV RDX,RBX
CALL 0x0011d8c6
CMP R12D,0x3
JZ 0x00170a15
CMP R12D,0x6
JZ 0x00170a66
MOV RAX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RAX + R15*0x8 + 0x4]
MOV dword ptr [RSP],0x4007
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV R8,RBP
MOV R9,R12
CALL 0x00126abb
TEST EAX,EAX
JS 0x00170a66
LAB_00170a15:
INC R15
CMP qword ptr [RSP + 0x40],R15
JNZ 0x00170974
LAB_00170a23:
MOV RSI,qword ptr [RSP + 0x38]
MOV RDI,R14
MOV RDX,qword ptr [RSP + 0x40]
CALL 0x00123e79
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0011d8c6
MOV RAX,-0x100000000
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,RDX
AND RCX,RAX
MOV EAX,EDX
MOV RBX,qword ptr [RSP + 0x28]
JMP 0x00170abb
LAB_00170a66:
MOV EBX,0x6
MOV R15,qword ptr [RSP + 0x30]
MOV R12,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RSP + 0x20]
MOV RBP,qword ptr [RSP + 0x50]
LAB_00170a7f:
MOV RSI,qword ptr [RSP + 0x38]
MOV EDX,dword ptr [RSP + 0x14]
MOV RDI,R14
CALL 0x00123e79
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,R15
CALL 0x0011d8c6
SHL RBP,0x20
MOV ESI,R13D
OR RSI,RBP
MOV RDI,qword ptr [R14 + 0x18]
MOV RDX,R12
CALL 0x0011d8c6
LAB_00170ab7:
XOR EAX,EAX
XOR ECX,ECX
LAB_00170abb:
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_object_getOwnPropertyDescriptors(long param_1)
{
int iVar1;
ulong uVar2;
int8 *in_R8;
int8 uVar3;
ulong uVar4;
int8 uVar5;
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
uint local_a4;
int8 local_a0;
int1 local_98 [16];
int8 local_88;
long local_80;
ulong local_78;
long local_70;
ulong local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int1 local_48 [16];
auVar6 = JS_ToObject(param_1,*in_R8,in_R8[1]);
uVar5 = auVar6._8_8_;
local_a0 = auVar6._0_8_;
if (auVar6._8_4_ != 6) {
iVar1 = JS_GetOwnPropertyNamesInternal(param_1,&local_80,&local_a4,local_a0,3);
auVar6._8_8_ = local_98._8_8_;
auVar6._0_8_ = local_98._0_8_;
if (iVar1 == 0) {
auVar7 = JS_NewObjectProtoClass
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x10),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x18),1);
auVar6._8_8_ = local_98._8_8_;
auVar6._0_8_ = local_98._0_8_;
uVar2 = auVar7._0_8_ >> 0x20;
local_98 = auVar7;
if (auVar7._8_4_ != 6) {
local_78 = (ulong)local_a4;
local_88 = uVar5;
local_68 = uVar2;
if (local_78 != 0) {
local_70 = local_80;
local_60 = local_a0;
uVar4 = 0;
do {
local_98 = auVar7;
auVar7 = __JS_AtomToValue(param_1,*(int4 *)(local_70 + 4 + uVar4 * 8),0);
uVar2 = local_68;
uVar5 = local_88;
auVar6 = local_98;
if (auVar7._8_4_ == 6) goto LAB_00170a7f;
local_58 = local_60;
local_50 = local_88;
local_48 = auVar7;
auVar8 = js_object_getOwnPropertyDescriptor(param_1);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar7._0_8_,auVar7._8_8_);
auVar7 = local_98;
if (auVar8._8_4_ != 3) {
uVar2 = local_68;
uVar5 = local_88;
auVar6 = local_98;
if (auVar8._8_4_ == 6) goto LAB_00170a7f;
iVar1 = JS_DefinePropertyValue
(param_1,local_98._0_8_,local_98._8_8_,
*(int4 *)(local_70 + 4 + uVar4 * 8),auVar8._0_8_,auVar8._8_8_
,0x4007);
uVar2 = local_68;
uVar5 = local_88;
auVar7 = local_98;
auVar6 = local_98;
if (iVar1 < 0) goto LAB_00170a7f;
}
uVar4 = uVar4 + 1;
} while (local_78 != uVar4);
}
local_98 = auVar7;
js_free_prop_enum(param_1,local_80,local_78);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_a0,local_88);
uVar4 = local_98._0_8_ & 0xffffffff00000000;
uVar2 = local_98._0_8_ & 0xffffffff;
goto LAB_00170abb;
}
}
else {
uVar2 = 0;
local_98 = ZEXT816(3) << 0x40;
}
LAB_00170a7f:
uVar3 = local_98._8_8_;
uVar4 = local_98._0_8_;
local_98 = auVar6;
js_free_prop_enum(param_1,local_80,local_a4);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_a0,uVar5);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar4 & 0xffffffff | uVar2 << 0x20,uVar3);
}
local_98._8_8_ = 6;
uVar2 = 0;
uVar4 = 0;
LAB_00170abb:
auVar7._0_8_ = uVar2 | uVar4;
auVar7._8_8_ = local_98._8_8_;
return auVar7;
}
| |
52,315 | my_thread_destory_thr_mutex | eloqsql/mysys/my_thr_init.c | static void my_thread_destory_thr_mutex(struct st_my_thread_var *var)
{
mysql_mutex_destroy(&var->mutex);
mysql_cond_destroy(&var->suspend);
} | O3 | c | my_thread_destory_thr_mutex:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x40(%rdi), %r14
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0xa1b6b
leaq 0x2e44b6(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x48(%rax)
movq $0x0, 0x80(%rbx)
movq %r14, %rdi
callq 0x290c0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
jne 0xa1b8c
addq $0x8, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x29260
leaq 0x2e447d(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x68(%rax)
movq $0x0, 0x38(%rbx)
jmp 0xa1b7c
| my_thread_destory_thr_mutex:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea r14, [rdi+40h]
mov rdi, [rdi+80h]
test rdi, rdi
jz short loc_A1B6B
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+48h]
mov qword ptr [rbx+80h], 0
loc_A1B6B:
mov rdi, r14
call _pthread_mutex_destroy
mov rdi, [rbx+38h]
test rdi, rdi
jnz short loc_A1B8C
loc_A1B7C:
add rbx, 8
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_cond_destroy
loc_A1B8C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+68h]
mov qword ptr [rbx+38h], 0
jmp short loc_A1B7C
| long long my_thread_destory_thr_mutex(long long a1)
{
if ( *(_QWORD *)(a1 + 128) )
{
PSI_server[9]();
*(_QWORD *)(a1 + 128) = 0LL;
}
pthread_mutex_destroy(a1 + 64);
if ( *(_QWORD *)(a1 + 56) )
{
PSI_server[13]();
*(_QWORD *)(a1 + 56) = 0LL;
}
return pthread_cond_destroy(a1 + 8);
}
| my_thread_destory_thr_mutex:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R14,[RDI + 0x40]
MOV RDI,qword ptr [RDI + 0x80]
TEST RDI,RDI
JZ 0x001a1b6b
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x48]
MOV qword ptr [RBX + 0x80],0x0
LAB_001a1b6b:
MOV RDI,R14
CALL 0x001290c0
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JNZ 0x001a1b8c
LAB_001a1b7c:
ADD RBX,0x8
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00129260
LAB_001a1b8c:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x68]
MOV qword ptr [RBX + 0x38],0x0
JMP 0x001a1b7c
|
void my_thread_destory_thr_mutex(long param_1)
{
if (*(long *)(param_1 + 0x80) != 0) {
(**(code **)(PSI_server + 0x48))();
*(int8 *)(param_1 + 0x80) = 0;
}
pthread_mutex_destroy((pthread_mutex_t *)(param_1 + 0x40));
if (*(long *)(param_1 + 0x38) != 0) {
(**(code **)(PSI_server + 0x68))();
*(int8 *)(param_1 + 0x38) = 0;
}
pthread_cond_destroy((pthread_cond_t *)(param_1 + 8));
return;
}
| |
52,316 | transid_get_packed | eloqsql/storage/maria/ma_key.c | ulonglong transid_get_packed(MARIA_SHARE *share, const uchar *from)
{
ulonglong value;
uint length;
if (from[0] < MARIA_MIN_TRANSID_PACK_OFFSET)
value= (ulonglong) from[0];
else
{
value= 0;
for (length= (uint) (from[0] - MARIA_TRANSID_PACK_OFFSET),
value= (ulonglong) from[1], from+=2;
--length ;
from++)
value= (value << 8) + ((ulonglong) *from);
}
return (value >> 1) + share->state.create_trid;
} | O0 | c | transid_get_packed:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xf3, %eax
jge 0x48577
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0x485da
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
subl $0xf9, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x485d8
movq -0x18(%rbp), %rax
shlq $0x8, %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x485a6
jmp 0x485da
movq -0x18(%rbp), %rax
shrq %rax
movq -0x8(%rbp), %rcx
addq 0xe0(%rcx), %rax
popq %rbp
retq
nop
| transid_get_packed:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 0F3h
jge short loc_48577
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov [rbp+var_18], rax
jmp short loc_485DA
loc_48577:
mov [rbp+var_18], 0
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
sub eax, 0F9h
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+1]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
loc_485A6:
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
cmp eax, 0
jz short loc_485D8
mov rax, [rbp+var_18]
shl rax, 8
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_485A6
loc_485D8:
jmp short $+2
loc_485DA:
mov rax, [rbp+var_18]
shr rax, 1
mov rcx, [rbp+var_8]
add rax, [rcx+0E0h]
pop rbp
retn
| unsigned long long transid_get_packed(long long a1, unsigned __int8 *a2)
{
int v3; // [rsp+0h] [rbp-1Ch]
unsigned long long v4; // [rsp+4h] [rbp-18h]
unsigned __int8 *i; // [rsp+Ch] [rbp-10h]
if ( *a2 >= 0xF3u )
{
v3 = *a2 - 249;
v4 = a2[1];
for ( i = a2 + 2; --v3; ++i )
v4 = *i + (v4 << 8);
}
else
{
v4 = *a2;
}
return *(_QWORD *)(a1 + 224) + (v4 >> 1);
}
| transid_get_packed:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xf3
JGE 0x00148577
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001485da
LAB_00148577:
MOV qword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
SUB EAX,0xf9
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
LAB_001485a6:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JZ 0x001485d8
MOV RAX,qword ptr [RBP + -0x18]
SHL RAX,0x8
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001485a6
LAB_001485d8:
JMP 0x001485da
LAB_001485da:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x1
MOV RCX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RCX + 0xe0]
POP RBP
RET
|
long transid_get_packed(long param_1,byte *param_2)
{
int local_24;
ulong local_20;
byte *local_18;
if (*param_2 < 0xf3) {
local_20 = (ulong)*param_2;
}
else {
local_24 = *param_2 - 0xf9;
local_20 = (ulong)param_2[1];
local_18 = param_2 + 2;
while (local_24 = local_24 + -1, local_24 != 0) {
local_20 = local_20 * 0x100 + (ulong)*local_18;
local_18 = local_18 + 1;
}
}
return (local_20 >> 1) + *(long *)(param_1 + 0xe0);
}
| |
52,317 | ma_unmap_file | eloqsql/storage/maria/ma_packrec.c | void _ma_unmap_file(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
my_munmap((char*) share->file_map,
(size_t) share->mmaped_length + MEMMAP_EXTRA_MARGIN);
share->file_map= 0;
share->file_read= _ma_nommap_pread;
share->file_write= _ma_nommap_pwrite;
info->opt_flag&= ~MEMMAP_USED;
} | O0 | c | ma_unmap_file:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x5f0(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xa00(%rax), %rsi
addq $0x7, %rsi
callq 0x2a490
movq -0x10(%rbp), %rax
movq $0x0, 0x5f0(%rax)
movq -0x10(%rbp), %rax
leaq 0x2ba0(%rip), %rcx # 0x4ea30
movq %rcx, 0x6e0(%rax)
movq -0x10(%rbp), %rax
leaq 0x2d0e(%rip), %rcx # 0x4ebb0
movq %rcx, 0x6e8(%rax)
movq -0x8(%rbp), %rax
movl 0x61c(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x61c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_unmap_file:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, [rax+5F0h]
mov rax, [rbp+var_10]
mov rsi, [rax+0A00h]
add rsi, 7
call _munmap
mov rax, [rbp+var_10]
mov qword ptr [rax+5F0h], 0
mov rax, [rbp+var_10]
lea rcx, _ma_nommap_pread
mov [rax+6E0h], rcx
mov rax, [rbp+var_10]
lea rcx, _ma_nommap_pwrite
mov [rax+6E8h], rcx
mov rax, [rbp+var_8]
mov ecx, [rax+61Ch]
and ecx, 0FFFFFFDFh
mov [rax+61Ch], ecx
add rsp, 10h
pop rbp
retn
| _DWORD * ma_unmap_file(_DWORD *a1)
{
_DWORD *result; // rax
_QWORD *v2; // [rsp+0h] [rbp-10h]
v2 = *(_QWORD **)a1;
munmap(*(_QWORD *)(*(_QWORD *)a1 + 1520LL), *(_QWORD *)(*(_QWORD *)a1 + 2560LL) + 7LL);
v2[190] = 0LL;
v2[220] = ma_nommap_pread;
v2[221] = ma_nommap_pwrite;
result = a1;
a1[391] &= ~0x20u;
return result;
}
| _ma_unmap_file:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x5f0]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0xa00]
ADD RSI,0x7
CALL 0x0012a490
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x5f0],0x0
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x14ea30]
MOV qword ptr [RAX + 0x6e0],RCX
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x14ebb0]
MOV qword ptr [RAX + 0x6e8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x61c]
AND ECX,0xffffffdf
MOV dword ptr [RAX + 0x61c],ECX
ADD RSP,0x10
POP RBP
RET
|
void _ma_unmap_file(long *param_1)
{
long lVar1;
lVar1 = *param_1;
munmap(*(void **)(lVar1 + 0x5f0),*(long *)(lVar1 + 0xa00) + 7);
*(int8 *)(lVar1 + 0x5f0) = 0;
*(code **)(lVar1 + 0x6e0) = _ma_nommap_pread;
*(code **)(lVar1 + 0x6e8) = _ma_nommap_pwrite;
*(uint *)((long)param_1 + 0x61c) = *(uint *)((long)param_1 + 0x61c) & 0xffffffdf;
return;
}
| |
52,318 | google::protobuf::compiler::csharp::PrimitiveFieldGenerator::GenerateSerializationCode(google::protobuf::io::Printer*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/csharp/csharp_primitive_field.cc | void PrimitiveFieldGenerator::GenerateSerializationCode(io::Printer* printer) {
printer->Print(
variables_,
"if ($has_property_check$) {\n"
" output.WriteRawTag($tag_bytes$);\n"
" output.Write$capitalized_type_name$($property_name$);\n"
"}\n");
} | O0 | cpp | google::protobuf::compiler::csharp::PrimitiveFieldGenerator::GenerateSerializationCode(google::protobuf::io::Printer*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x20, %rsi
leaq 0x3413c2(%rip), %rdx # 0x3ad885
callq 0x3235f0
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf8compiler6csharp23PrimitiveFieldGenerator25GenerateSerializationCodeEPNS0_2io7PrinterE:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rsi, [rsp+18h+var_8]
mov rdi, [rsp+18h+var_10]
add rsi, 20h ; ' '
lea rdx, aIfHasPropertyC_4; "if ($has_property_check$) {\n output.W"...
call _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
add rsp, 18h
retn
| GenerateSerializationCode:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x8]
ADD RSI,0x20
LEA RDX,[0x4ad885]
CALL 0x004235f0
ADD RSP,0x18
RET
|
/* google::protobuf::compiler::csharp::PrimitiveFieldGenerator::GenerateSerializationCode(google::protobuf::io::Printer*)
*/
void __thiscall
google::protobuf::compiler::csharp::PrimitiveFieldGenerator::GenerateSerializationCode
(PrimitiveFieldGenerator *this,Printer *param_1)
{
io::Printer::Print(param_1,(map *)(this + 0x20),
"if ($has_property_check$) {\n output.WriteRawTag($tag_bytes$);\n output.Write$capitalized_type_name$($property_name$);\n}\n"
);
return;
}
| ||
52,319 | rtree_delete | eloqsql/storage/myisam/rt_index.c | int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
{
uint page_size;
stPageList ReinsertList;
my_off_t old_root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
DBUG_ENTER("rtree_delete");
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
DBUG_RETURN(-1); /* purecov: inspected */
}
DBUG_PRINT("rtree", ("starting deletion at root page: %lu",
(ulong) old_root));
ReinsertList.pages = NULL;
ReinsertList.n_pages = 0;
ReinsertList.m_pages = 0;
switch (rtree_delete_req(info, keyinfo, key, key_length, old_root,
&page_size, &ReinsertList, 0))
{
case 2: /* empty */
{
info->s->state.key_root[keynr] = HA_OFFSET_ERROR;
DBUG_RETURN(0);
}
case 0: /* deleted */
{
uint nod_flag;
ulong i;
for (i = 0; i < ReinsertList.n_pages; ++i)
{
uchar *page_buf;
uchar *k;
uchar *last;
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
{
my_errno = HA_ERR_OUT_OF_MEM;
goto err1;
}
if (!_mi_fetch_keypage(info, keyinfo, ReinsertList.pages[i].offs,
DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
DBUG_PRINT("rtree", ("reinserting keys from "
"page: %lu level: %d nod_flag: %u",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level, nod_flag));
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
last = rt_PAGE_END(page_buf);
for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
{
int res;
if ((res= rtree_insert_level(info, keynr, k, key_length,
ReinsertList.pages[i].level)) == -1)
{
my_afree((uchar*)page_buf);
goto err1;
}
if (res)
{
ulong j;
DBUG_PRINT("rtree", ("root has been split, adjust levels"));
for (j= i; j < ReinsertList.n_pages; j++)
{
ReinsertList.pages[j].level++;
DBUG_PRINT("rtree", ("keys from page: %lu now level: %d",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level));
}
}
}
my_afree((uchar*)page_buf);
if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs,
DFLT_INIT_HITS))
goto err1;
}
if (ReinsertList.pages)
my_free(ReinsertList.pages);
/* check for redundant root (not leaf, 1 child) and eliminate */
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
goto err1;
if (!_mi_fetch_keypage(info, keyinfo, old_root, DFLT_INIT_HITS,
info->buff, 0))
goto err1;
nod_flag = mi_test_if_nod(info->buff);
page_size = mi_getint(info->buff);
if (nod_flag && (page_size == 2 + key_length + nod_flag))
{
my_off_t new_root = _mi_kpos(nod_flag,
rt_PAGE_FIRST_KEY(info->buff, nod_flag));
if (_mi_dispose(info, keyinfo, old_root, DFLT_INIT_HITS))
goto err1;
info->s->state.key_root[keynr] = new_root;
}
info->update= HA_STATE_DELETED;
DBUG_RETURN(0);
err1:
DBUG_RETURN(-1); /* purecov: inspected */
}
case 1: /* not found */
{
my_errno = HA_ERR_KEY_NOT_FOUND;
DBUG_RETURN(-1); /* purecov: inspected */
}
default:
case -1: /* error */
{
DBUG_RETURN(-1); /* purecov: inspected */
}
}
} | O3 | c | rtree_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r14d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movl %esi, -0x3c(%rbp)
movl %esi, %ebx
movq 0x98(%rax), %rcx
movq (%rcx,%rbx,8), %r8
cmpq $-0x1, %r8
je 0xa560a
imulq $0x70, %rbx, %r13
addq 0x218(%rax), %r13
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x84(%rbp), %r9
movq %rdi, -0x38(%rbp)
movq %r13, %rsi
movl %r14d, %ecx
pushq $0x0
pushq %rax
callq 0xa5757
addq $0x10, %rsp
cmpl $0x2, %eax
je 0xa5630
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0xa5620
testl %eax, %eax
jne 0xa571a
movq %rbx, -0x48(%rbp)
movq -0xa0(%rbp), %r12
movq -0x90(%rbp), %rbx
testq %r12, %r12
movq %r14, -0x70(%rbp)
je 0xa5656
movl %r14d, %eax
movq %rax, -0x80(%rbp)
xorl %r14d, %r14d
movq %rbx, -0x60(%rbp)
movq -0x38(%rbp), %rdi
movq %r13, -0x78(%rbp)
movq %rbx, -0x50(%rbp)
movzwl 0xe(%r13), %eax
movq %rsp, %r15
addl $0xf, %eax
andl $-0x10, %eax
subq %rax, %r15
movq %r15, %rsp
movq %r14, %rax
shlq $0x4, %rax
movq %rax, -0x58(%rbp)
movq 0x8(%rbx,%rax), %rdx
movq %r13, %rsi
movl $0x3, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x9eb84
testq %rax, %rax
je 0xa5615
movq %r14, -0x68(%rbp)
movzbl (%r15), %ebx
xorl %eax, %eax
testb %bl, %bl
movq -0x38(%rbp), %rdi
jns 0xa5545
movq (%rdi), %rax
movl 0x17c(%rax), %eax
movl %eax, %r13d
leaq (%r15,%r13), %r14
addq $0x2, %r14
movzbl 0x1(%r15), %eax
andl $0x7f, %ebx
shll $0x8, %ebx
orq %rax, %rbx
addq %r15, %rbx
cmpq %rbx, %r14
jae 0xa55c8
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
leaq (%rax,%rcx), %r15
movl (%r15), %r8d
movl -0x3c(%rbp), %esi
movq %r14, %rdx
movq -0x70(%rbp), %rcx
callq 0xa51bd
testl %eax, %eax
je 0xa55a7
cmpl $-0x1, %eax
je 0xa564e
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
incl (%rax)
incq %rcx
addq $0x10, %rax
cmpq %r12, %rcx
jb 0xa5599
movq %r13, %rax
testl %r13d, %r13d
movq -0x38(%rbp), %rdi
jne 0xa55bc
movq (%rdi), %rax
movl 0x178(%rax), %eax
addq -0x80(%rbp), %r14
addq %rax, %r14
cmpq %rbx, %r14
jb 0xa5572
movq -0x50(%rbp), %rbx
movq -0x58(%rbp), %rax
addq %rbx, %rax
addq $0x8, %rax
movq (%rax), %rdx
movq -0x78(%rbp), %r13
movq %r13, %rsi
movl $0x3, %ecx
callq 0x9ed03
testl %eax, %eax
jne 0xa5615
movq -0x68(%rbp), %r14
incq %r14
addq $0x10, -0x60(%rbp)
cmpq %r12, %r14
movq -0x38(%rbp), %rdi
jne 0xa54ea
jmp 0xa565f
callq 0xc14ee
movl $0x89, (%rax)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0xa571a
callq 0xc14ee
movl $0x78, (%rax)
jmp 0xa571a
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movq $-0x1, (%rax,%rbx,8)
xorl %r12d, %r12d
jmp 0xa571a
movl %eax, %r12d
jmp 0xa571a
testq %rbx, %rbx
movq -0x38(%rbp), %rdi
je 0xa566b
movq %rbx, %rdi
callq 0xbf54e
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x98(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %r14
cmpq $-0x1, %r14
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
je 0xa571a
movq 0x100(%rdi), %r8
movq %rdi, %rbx
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0x9eb84
testq %rax, %rax
je 0xa571a
movq 0x100(%rbx), %rax
movzbl (%rax), %ecx
testb %cl, %cl
js 0xa56cc
movl $0x8, 0x1d0(%rbx)
jmp 0xa5646
movq (%rbx), %rdx
movl 0x17c(%rdx), %edi
testq %rdi, %rdi
je 0xa56bd
andl $0x7f, %ecx
shll $0x8, %ecx
movzbl 0x1(%rax), %edx
orl %ecx, %edx
movq -0x70(%rbp), %rcx
addl %edi, %ecx
addl $0x2, %ecx
cmpl %ecx, %edx
jne 0xa56bd
leaq (%rax,%rdi), %rsi
addq $0x2, %rsi
callq 0x9f4fe
movq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
callq 0x9ed03
testl %eax, %eax
je 0xa573b
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa5752
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x98(%rax), %rax
movq -0x48(%rbp), %rcx
movq %r15, (%rax,%rcx,8)
jmp 0xa56bd
callq 0x2a280
| rtree_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14d, ecx
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_3C], esi
mov ebx, esi
mov rcx, [rax+98h]
mov r8, [rcx+rbx*8]
cmp r8, 0FFFFFFFFFFFFFFFFh
jz loc_A560A
imul r13, rbx, 70h ; 'p'
add r13, [rax+218h]
xorps xmm0, xmm0
lea rax, [rbp+var_A0]
movaps xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
lea r9, [rbp+var_84]
mov [rbp+var_38], rdi
mov rsi, r13
mov ecx, r14d
push 0
push rax
call rtree_delete_req
add rsp, 10h
cmp eax, 2
jz loc_A5630
mov r12d, 0FFFFFFFFh
cmp eax, 1
jz loc_A5620
test eax, eax
jnz loc_A571A
mov [rbp+var_48], rbx
mov r12, [rbp+var_A0]
mov rbx, [rbp+var_90]
test r12, r12
mov [rbp+var_70], r14
jz loc_A5656
mov eax, r14d
mov [rbp+var_80], rax
xor r14d, r14d
mov [rbp+var_60], rbx
mov rdi, [rbp+var_38]
mov [rbp+var_78], r13
mov [rbp+var_50], rbx
loc_A54EA:
movzx eax, word ptr [r13+0Eh]
mov r15, rsp
add eax, 0Fh
and eax, 0FFFFFFF0h
sub r15, rax
mov rsp, r15
mov rax, r14
shl rax, 4
mov [rbp+var_58], rax
mov rdx, [rbx+rax+8]
mov rsi, r13
mov ecx, 3
mov r8, r15
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_A5615
mov [rbp+var_68], r14
movzx ebx, byte ptr [r15]
xor eax, eax
test bl, bl
mov rdi, [rbp+var_38]
jns short loc_A5545
mov rax, [rdi]
mov eax, [rax+17Ch]
loc_A5545:
mov r13d, eax
lea r14, [r15+r13]
add r14, 2
movzx eax, byte ptr [r15+1]
and ebx, 7Fh
shl ebx, 8
or rbx, rax
add rbx, r15
cmp r14, rbx
jnb short loc_A55C8
mov rax, [rbp+var_50]
mov rcx, [rbp+var_58]
lea r15, [rax+rcx]
loc_A5572:
mov r8d, [r15]
mov esi, [rbp+var_3C]
mov rdx, r14
mov rcx, [rbp+var_70]
call rtree_insert_level
test eax, eax
jz short loc_A55A7
cmp eax, 0FFFFFFFFh
jz loc_A564E
mov rax, [rbp+var_60]
mov rcx, [rbp+var_68]
loc_A5599:
inc dword ptr [rax]
inc rcx
add rax, 10h
cmp rcx, r12
jb short loc_A5599
loc_A55A7:
mov rax, r13
test r13d, r13d
mov rdi, [rbp+var_38]
jnz short loc_A55BC
mov rax, [rdi]
mov eax, [rax+178h]
loc_A55BC:
add r14, [rbp+var_80]
add r14, rax
cmp r14, rbx
jb short loc_A5572
loc_A55C8:
mov rbx, [rbp+var_50]
mov rax, [rbp+var_58]
add rax, rbx
add rax, 8
mov rdx, [rax]
mov r13, [rbp+var_78]
mov rsi, r13
mov ecx, 3
call _mi_dispose
test eax, eax
jnz short loc_A5615
mov r14, [rbp+var_68]
inc r14
add [rbp+var_60], 10h
cmp r14, r12
mov rdi, [rbp+var_38]
jnz loc_A54EA
jmp short loc_A565F
loc_A560A:
call _my_thread_var
mov dword ptr [rax], 89h
loc_A5615:
mov r12d, 0FFFFFFFFh
jmp loc_A571A
loc_A5620:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
jmp loc_A571A
loc_A5630:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rax, [rax+98h]
mov qword ptr [rax+rbx*8], 0FFFFFFFFFFFFFFFFh
loc_A5646:
xor r12d, r12d
jmp loc_A571A
loc_A564E:
mov r12d, eax
jmp loc_A571A
loc_A5656:
test rbx, rbx
mov rdi, [rbp+var_38]
jz short loc_A566B
loc_A565F:
mov rdi, rbx
call my_free
mov rdi, [rbp+var_38]
loc_A566B:
mov rax, [rdi]
mov rax, [rax+98h]
mov rcx, [rbp+var_48]
mov r14, [rax+rcx*8]
cmp r14, 0FFFFFFFFFFFFFFFFh
mov r12d, 0FFFFFFFFh
jz loc_A571A
mov r8, [rdi+100h]
mov rbx, rdi
mov rsi, r13
mov rdx, r14
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz short loc_A571A
mov rax, [rbx+100h]
movzx ecx, byte ptr [rax]
test cl, cl
js short loc_A56CC
loc_A56BD:
mov dword ptr [rbx+1D0h], 8
jmp loc_A5646
loc_A56CC:
mov rdx, [rbx]
mov edi, [rdx+17Ch]
test rdi, rdi
jz short loc_A56BD
and ecx, 7Fh
shl ecx, 8
movzx edx, byte ptr [rax+1]
or edx, ecx
mov rcx, [rbp+var_70]
add ecx, edi
add ecx, 2
cmp edx, ecx
jnz short loc_A56BD
lea rsi, [rax+rdi]
add rsi, 2
call _mi_kpos
mov r15, rax
mov rdi, rbx
mov rsi, r13
mov rdx, r14
mov ecx, 3
call _mi_dispose
test eax, eax
jz short loc_A573B
loc_A571A:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_A5752
mov eax, r12d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A573B:
mov rax, [rbx]
mov rax, [rax+98h]
mov rcx, [rbp+var_48]
mov [rax+rcx*8], r15
jmp loc_A56BD
loc_A5752:
call ___stack_chk_fail
| long long rtree_delete(_QWORD *a1, unsigned int a2, int a3, unsigned int a4)
{
long long v4; // r14
long long v5; // rax
long long v6; // r8
long long v7; // r13
int v8; // eax
unsigned int v9; // r12d
unsigned long long v10; // r12
_DWORD *v11; // rbx
unsigned long long v12; // r14
_QWORD *v13; // rdi
char *v14; // r15
unsigned int v15; // eax
long long *v16; // rdi
long long v17; // r13
unsigned long long v18; // r14
char *v19; // rbx
int *v20; // r15
int inserted; // eax
_DWORD *v22; // rax
unsigned long long v23; // rcx
long long v24; // rax
_QWORD *v25; // rdi
long long v26; // rax
long long v27; // r14
_DWORD *v28; // rbx
char *v29; // rax
long long v30; // rdi
unsigned long long v31; // r15
__int128 v33; // [rsp+0h] [rbp-A0h] BYREF
_DWORD *v34; // [rsp+10h] [rbp-90h]
char v35; // [rsp+1Ch] [rbp-84h] BYREF
long long v36; // [rsp+20h] [rbp-80h]
long long v37; // [rsp+28h] [rbp-78h]
long long v38; // [rsp+30h] [rbp-70h]
unsigned long long v39; // [rsp+38h] [rbp-68h]
_DWORD *v40; // [rsp+40h] [rbp-60h]
long long v41; // [rsp+48h] [rbp-58h]
_DWORD *v42; // [rsp+50h] [rbp-50h]
long long v43; // [rsp+58h] [rbp-48h]
unsigned int v44; // [rsp+64h] [rbp-3Ch]
_QWORD *v45; // [rsp+68h] [rbp-38h]
unsigned long long v46; // [rsp+70h] [rbp-30h]
v4 = a4;
v46 = __readfsqword(0x28u);
v5 = *a1;
v44 = a2;
v6 = *(_QWORD *)(*(_QWORD *)(v5 + 152) + 8LL * a2);
if ( v6 == -1 )
{
*(_DWORD *)my_thread_var(a1) = 137;
return (unsigned int)-1;
}
v7 = *(_QWORD *)(v5 + 536) + 112LL * a2;
v33 = 0LL;
v34 = 0LL;
v45 = a1;
v8 = rtree_delete_req((_DWORD)a1, v7, a3, a4, v6, (unsigned int)&v35, (long long)&v33, 0);
if ( v8 == 2 )
{
*(_QWORD *)(*(_QWORD *)(*v45 + 152LL) + 8LL * a2) = -1LL;
return 0;
}
v9 = -1;
if ( v8 == 1 )
{
*(_DWORD *)my_thread_var(a1) = 120;
return v9;
}
if ( !v8 )
{
v43 = a2;
v10 = v33;
v11 = v34;
v38 = v4;
if ( (_QWORD)v33 )
{
v36 = (unsigned int)v4;
v12 = 0LL;
v40 = v34;
v13 = v45;
v37 = v7;
v42 = v34;
while ( 1 )
{
v14 = (char *)&v33 - ((*(unsigned __int16 *)(v7 + 14) + 15) & 0xFFFFFFF0);
v41 = 16 * v12;
if ( !mi_fetch_keypage(v13, v7, *(_QWORD *)&v11[4 * v12 + 2]) )
break;
v39 = v12;
v15 = 0;
v16 = v45;
if ( *v14 < 0 )
v15 = *(_DWORD *)(*v45 + 380LL);
v17 = v15;
v18 = (unsigned long long)&v14[v15 + 2];
v19 = &v14[(unsigned __int8)v14[1] | (unsigned long long)((unsigned __int8)(*v14 & 0x7F) << 8)];
if ( v18 < (unsigned long long)v19 )
{
v20 = &v42[(unsigned long long)v41 / 4];
do
{
inserted = rtree_insert_level(v16, v44, v18, v38, *v20);
if ( inserted )
{
if ( inserted == -1 )
return (unsigned int)-1;
v22 = v40;
v23 = v39;
do
{
++*v22;
++v23;
v22 += 4;
}
while ( v23 < v10 );
}
v24 = v17;
v16 = v45;
if ( !(_DWORD)v17 )
v24 = *(unsigned int *)(*v45 + 376LL);
v18 += v24 + v36;
}
while ( v18 < (unsigned long long)v19 );
}
v11 = v42;
v7 = v37;
if ( (unsigned int)mi_dispose(v16, v37, *(_QWORD *)&v42[(unsigned long long)v41 / 4 + 2], 3u) )
break;
v12 = v39 + 1;
v40 += 4;
v13 = v45;
if ( v39 + 1 == v10 )
goto LABEL_29;
}
return (unsigned int)-1;
}
v25 = v45;
if ( v34 )
{
LABEL_29:
my_free(v11);
v25 = v45;
}
v26 = *(_QWORD *)(*v25 + 152LL);
v27 = *(_QWORD *)(v26 + 8 * v43);
v9 = -1;
if ( v27 != -1 )
{
v28 = v25;
if ( mi_fetch_keypage(v25, v7, *(_QWORD *)(v26 + 8 * v43)) )
{
v29 = (char *)v25[32];
if ( *v29 < 0 )
{
v30 = *(unsigned int *)(*v25 + 380LL);
if ( *(_DWORD *)(*(_QWORD *)v28 + 380LL) )
{
if ( (((*v29 & 0x7F) << 8) | (unsigned __int8)v29[1]) == (_DWORD)v30 + (_DWORD)v38 + 2 )
{
v31 = mi_kpos(v30, (long long)&v29[v30 + 2]);
if ( (unsigned int)mi_dispose(v28, v7, v27, 3u) )
return v9;
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)v28 + 152LL) + 8 * v43) = v31;
}
}
}
v28[116] = 8;
return 0;
}
}
}
return v9;
}
| rtree_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV dword ptr [RBP + -0x3c],ESI
MOV EBX,ESI
MOV RCX,qword ptr [RAX + 0x98]
MOV R8,qword ptr [RCX + RBX*0x8]
CMP R8,-0x1
JZ 0x001a560a
IMUL R13,RBX,0x70
ADD R13,qword ptr [RAX + 0x218]
XORPS XMM0,XMM0
LEA RAX,[RBP + -0xa0]
MOVAPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
LEA R9,[RBP + -0x84]
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R13
MOV ECX,R14D
PUSH 0x0
PUSH RAX
CALL 0x001a5757
ADD RSP,0x10
CMP EAX,0x2
JZ 0x001a5630
MOV R12D,0xffffffff
CMP EAX,0x1
JZ 0x001a5620
TEST EAX,EAX
JNZ 0x001a571a
MOV qword ptr [RBP + -0x48],RBX
MOV R12,qword ptr [RBP + -0xa0]
MOV RBX,qword ptr [RBP + -0x90]
TEST R12,R12
MOV qword ptr [RBP + -0x70],R14
JZ 0x001a5656
MOV EAX,R14D
MOV qword ptr [RBP + -0x80],RAX
XOR R14D,R14D
MOV qword ptr [RBP + -0x60],RBX
MOV RDI,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x78],R13
MOV qword ptr [RBP + -0x50],RBX
LAB_001a54ea:
MOVZX EAX,word ptr [R13 + 0xe]
MOV R15,RSP
ADD EAX,0xf
AND EAX,0xfffffff0
SUB R15,RAX
MOV RSP,R15
MOV RAX,R14
SHL RAX,0x4
MOV qword ptr [RBP + -0x58],RAX
MOV RDX,qword ptr [RBX + RAX*0x1 + 0x8]
MOV RSI,R13
MOV ECX,0x3
MOV R8,R15
XOR R9D,R9D
CALL 0x0019eb84
TEST RAX,RAX
JZ 0x001a5615
MOV qword ptr [RBP + -0x68],R14
MOVZX EBX,byte ptr [R15]
XOR EAX,EAX
TEST BL,BL
MOV RDI,qword ptr [RBP + -0x38]
JNS 0x001a5545
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x17c]
LAB_001a5545:
MOV R13D,EAX
LEA R14,[R15 + R13*0x1]
ADD R14,0x2
MOVZX EAX,byte ptr [R15 + 0x1]
AND EBX,0x7f
SHL EBX,0x8
OR RBX,RAX
ADD RBX,R15
CMP R14,RBX
JNC 0x001a55c8
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
LEA R15,[RAX + RCX*0x1]
LAB_001a5572:
MOV R8D,dword ptr [R15]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x70]
CALL 0x001a51bd
TEST EAX,EAX
JZ 0x001a55a7
CMP EAX,-0x1
JZ 0x001a564e
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
LAB_001a5599:
INC dword ptr [RAX]
INC RCX
ADD RAX,0x10
CMP RCX,R12
JC 0x001a5599
LAB_001a55a7:
MOV RAX,R13
TEST R13D,R13D
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x001a55bc
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x178]
LAB_001a55bc:
ADD R14,qword ptr [RBP + -0x80]
ADD R14,RAX
CMP R14,RBX
JC 0x001a5572
LAB_001a55c8:
MOV RBX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RBX
ADD RAX,0x8
MOV RDX,qword ptr [RAX]
MOV R13,qword ptr [RBP + -0x78]
MOV RSI,R13
MOV ECX,0x3
CALL 0x0019ed03
TEST EAX,EAX
JNZ 0x001a5615
MOV R14,qword ptr [RBP + -0x68]
INC R14
ADD qword ptr [RBP + -0x60],0x10
CMP R14,R12
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x001a54ea
JMP 0x001a565f
LAB_001a560a:
CALL 0x001c14ee
MOV dword ptr [RAX],0x89
LAB_001a5615:
MOV R12D,0xffffffff
JMP 0x001a571a
LAB_001a5620:
CALL 0x001c14ee
MOV dword ptr [RAX],0x78
JMP 0x001a571a
LAB_001a5630:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RAX + RBX*0x8],-0x1
LAB_001a5646:
XOR R12D,R12D
JMP 0x001a571a
LAB_001a564e:
MOV R12D,EAX
JMP 0x001a571a
LAB_001a5656:
TEST RBX,RBX
MOV RDI,qword ptr [RBP + -0x38]
JZ 0x001a566b
LAB_001a565f:
MOV RDI,RBX
CALL 0x001bf54e
MOV RDI,qword ptr [RBP + -0x38]
LAB_001a566b:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RBP + -0x48]
MOV R14,qword ptr [RAX + RCX*0x8]
CMP R14,-0x1
MOV R12D,0xffffffff
JZ 0x001a571a
MOV R8,qword ptr [RDI + 0x100]
MOV RBX,RDI
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
XOR R9D,R9D
CALL 0x0019eb84
TEST RAX,RAX
JZ 0x001a571a
MOV RAX,qword ptr [RBX + 0x100]
MOVZX ECX,byte ptr [RAX]
TEST CL,CL
JS 0x001a56cc
LAB_001a56bd:
MOV dword ptr [RBX + 0x1d0],0x8
JMP 0x001a5646
LAB_001a56cc:
MOV RDX,qword ptr [RBX]
MOV EDI,dword ptr [RDX + 0x17c]
TEST RDI,RDI
JZ 0x001a56bd
AND ECX,0x7f
SHL ECX,0x8
MOVZX EDX,byte ptr [RAX + 0x1]
OR EDX,ECX
MOV RCX,qword ptr [RBP + -0x70]
ADD ECX,EDI
ADD ECX,0x2
CMP EDX,ECX
JNZ 0x001a56bd
LEA RSI,[RAX + RDI*0x1]
ADD RSI,0x2
CALL 0x0019f4fe
MOV R15,RAX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
CALL 0x0019ed03
TEST EAX,EAX
JZ 0x001a573b
LAB_001a571a:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a5752
MOV EAX,R12D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a573b:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + RCX*0x8],R15
JMP 0x001a56bd
LAB_001a5752:
CALL 0x0012a280
|
int8 rtree_delete(long *param_1,uint param_2,int8 param_3,uint param_4)
{
byte bVar1;
byte bVar2;
int4 uVar3;
ulong uVar4;
uint uVar5;
long *plVar6;
ulong *puVar7;
int iVar8;
uint uVar9;
long lVar10;
int *piVar11;
int4 *puVar12;
long lVar13;
int8 uVar14;
ulong uVar15;
int8 uVar16;
long lVar17;
ulong uVar18;
byte *pbVar19;
ulong *puVar20;
long in_FS_OFFSET;
ulong local_a8 [2];
int *local_98;
int1 local_8c [4];
ulong local_88;
long local_80;
ulong local_78;
ulong local_70;
int *local_68;
long local_60;
int *local_58;
ulong local_50;
uint local_44;
long *local_40;
long local_38;
puVar20 = local_a8;
uVar18 = (ulong)param_4;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar15 = (ulong)param_2;
lVar10 = *(long *)(*(long *)(*param_1 + 0x98) + uVar15 * 8);
local_44 = param_2;
if (lVar10 == -1) {
puVar12 = (int4 *)_my_thread_var();
*puVar12 = 0x89;
LAB_001a5615:
uVar16 = 0xffffffff;
goto LAB_001a571a;
}
lVar17 = uVar15 * 0x70 + *(long *)(*param_1 + 0x218);
local_a8[0] = 0;
local_a8[1] = 0;
local_98 = (int *)0x0;
local_40 = param_1;
iVar8 = rtree_delete_req(param_1,lVar17,param_3,uVar18,lVar10,local_8c,local_a8,0);
uVar4 = local_a8[0];
puVar20 = local_a8;
if (iVar8 == 2) {
*(int8 *)(*(long *)(*local_40 + 0x98) + uVar15 * 8) = 0xffffffffffffffff;
puVar20 = local_a8;
}
else {
uVar16 = 0xffffffff;
if (iVar8 == 1) {
puVar12 = (int4 *)_my_thread_var();
*puVar12 = 0x78;
goto LAB_001a571a;
}
puVar20 = local_a8;
if (iVar8 != 0) goto LAB_001a571a;
piVar11 = local_98;
local_78 = uVar18;
local_50 = uVar15;
if (local_a8[0] == 0) {
puVar20 = local_a8;
puVar7 = local_a8;
if (local_98 != (int *)0x0) goto LAB_001a565f;
}
else {
local_88 = (ulong)param_4;
uVar15 = 0;
local_68 = local_98;
local_58 = local_98;
puVar20 = local_a8;
local_80 = lVar17;
do {
plVar6 = local_40;
puVar20 = (ulong *)((long)puVar20 + -(ulong)(*(ushort *)(lVar17 + 0xe) + 0xf & 0xfffffff0));
local_60 = uVar15 * 0x10;
uVar16 = *(int8 *)(piVar11 + uVar15 * 4 + 2);
*(byte *)((long)puVar20 + -8) = 0x21;
*(byte *)((long)puVar20 + -7) = 0x55;
*(byte *)((long)puVar20 + -6) = 0x1a;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
lVar10 = _mi_fetch_keypage(plVar6,lVar17,uVar16,3,puVar20,0);
if (lVar10 == 0) goto LAB_001a5615;
local_70 = uVar15;
bVar1 = *(byte *)puVar20;
uVar9 = 0;
if ((char)bVar1 < '\0') {
uVar9 = *(uint *)(*local_40 + 0x17c);
}
pbVar19 = (byte *)((long)puVar20 + (ulong)uVar9 + 2);
bVar2 = *(byte *)((long)puVar20 + 1);
if (pbVar19 < (byte *)((long)puVar20 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2))) {
puVar12 = (int4 *)((long)local_58 + local_60);
do {
plVar6 = local_40;
uVar5 = local_44;
uVar15 = local_78;
uVar3 = *puVar12;
*(byte *)((long)puVar20 + -8) = 0x84;
*(byte *)((long)puVar20 + -7) = 0x55;
*(byte *)((long)puVar20 + -6) = 0x1a;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
iVar8 = rtree_insert_level(plVar6,uVar5,pbVar19,uVar15,uVar3);
if (iVar8 != 0) {
piVar11 = local_68;
uVar15 = local_70;
if (iVar8 == -1) {
uVar16 = 0xffffffff;
goto LAB_001a571a;
}
do {
*piVar11 = *piVar11 + 1;
uVar15 = uVar15 + 1;
piVar11 = piVar11 + 4;
} while (uVar15 < uVar4);
}
uVar15 = (ulong)uVar9;
if (uVar9 == 0) {
uVar15 = (ulong)*(uint *)(*local_40 + 0x178);
}
pbVar19 = pbVar19 + uVar15 + local_88;
} while (pbVar19 < (byte *)((long)puVar20 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2))
);
}
plVar6 = local_40;
piVar11 = local_58;
lVar17 = local_80;
uVar16 = *(int8 *)((long)local_58 + local_60 + 8);
*(byte *)((long)puVar20 + -8) = 0xeb;
*(byte *)((long)puVar20 + -7) = 0x55;
*(byte *)((long)puVar20 + -6) = 0x1a;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
iVar8 = _mi_dispose(plVar6,lVar17,uVar16,3);
if (iVar8 != 0) goto LAB_001a5615;
uVar15 = local_70 + 1;
local_68 = local_68 + 4;
} while (uVar15 != uVar4);
LAB_001a565f:
*(byte *)((long)puVar20 + -8) = 0x67;
*(byte *)((long)puVar20 + -7) = 0x56;
*(byte *)((long)puVar20 + -6) = 0x1a;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
my_free(piVar11);
puVar7 = puVar20;
}
puVar20 = puVar7;
plVar6 = local_40;
lVar10 = *(long *)(*(long *)(*local_40 + 0x98) + local_50 * 8);
uVar16 = 0xffffffff;
if (lVar10 == -1) goto LAB_001a571a;
lVar13 = local_40[0x20];
*(int8 *)((long)puVar20 + -8) = 0x1a56aa;
lVar13 = _mi_fetch_keypage(plVar6,lVar17,lVar10,3,lVar13,0);
if (lVar13 == 0) goto LAB_001a571a;
pbVar19 = (byte *)plVar6[0x20];
if ((char)*pbVar19 < '\0') {
uVar15 = (ulong)*(uint *)(*plVar6 + 0x17c);
if ((uVar15 != 0) &&
(((uint)pbVar19[1] | (*pbVar19 & 0x7f) << 8) ==
(int)local_78 + *(uint *)(*plVar6 + 0x17c) + 2)) {
*(int8 *)((long)puVar20 + -8) = 0x1a5700;
uVar14 = _mi_kpos(uVar15,pbVar19 + uVar15 + 2);
*(int8 *)((long)puVar20 + -8) = 0x1a5716;
iVar8 = _mi_dispose(plVar6,lVar17,lVar10,3);
if (iVar8 != 0) goto LAB_001a571a;
*(int8 *)(*(long *)(*plVar6 + 0x98) + local_50 * 8) = uVar14;
}
}
*(int4 *)(plVar6 + 0x3a) = 8;
}
uVar16 = 0;
LAB_001a571a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)puVar20 + -8) = rtree_delete_req;
__stack_chk_fail();
}
return uVar16;
}
| |
52,320 | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_NON_NULL(1)
void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
{
static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
"internal error: not enough precision");
JSON_ASSERT(std::isfinite(value));
JSON_ASSERT(value > 0);
// If the neighbors (and boundaries) of 'value' are always computed for double-precision
// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
// decimal representations are not exactly "short".
//
// The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
// and since sprintf promotes floats to doubles, I think this is exactly what 'std::to_chars'
// does.
// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
// representation using the corresponding std::from_chars function recovers value exactly". That
// indicates that single precision floating-point numbers should be recovered using
// 'std::strtof'.
//
// NB: If the neighbors are computed for single-precision numbers, there is a single float
// (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
// value is off by 1 ulp.
#if 0 // NOLINT(readability-avoid-unconditional-preprocessor-if)
const boundaries w = compute_boundaries(static_cast<double>(value));
#else
const boundaries w = compute_boundaries(value);
#endif
grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
} | O2 | cpp | void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %xmm0, %rax
btrq $0x3f, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
cmpq %rcx, %rax
jge 0x6c5df
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x6c5fb
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x6c7b5
movq 0x10(%r12), %rcx
movl 0x18(%r12), %r8d
movups (%r12), %xmm0
movups 0x20(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x6c8fd
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x237f1(%rip), %rdi # 0x8fdd7
leaq 0x20c9f(%rip), %rdx # 0x8d28c
leaq 0x26361(%rip), %rcx # 0x92955
movl $0x4589, %esi # imm = 0x4589
jmp 0x6c615
leaq 0x237d5(%rip), %rdi # 0x8fdd7
leaq 0x20c83(%rip), %rdx # 0x8d28c
leaq 0x2645e(%rip), %rcx # 0x92a6e
movl $0x458a, %esi # imm = 0x458A
xorl %eax, %eax
callq 0x20af0
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2IdEEvPcRiS5_T_:
push r15
push r14
push r12
push rbx
sub rsp, 58h
movq rax, xmm0
btr rax, 3Fh ; '?'
mov rcx, 7FF0000000000000h
cmp rax, rcx
jge short loc_6C5DF
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jbe short loc_6C5FB
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r12, [rsp+78h+var_50]
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double)
mov rcx, [r12+10h]
mov r8d, [r12+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+20h]
movups [rsp+78h+var_68], xmm1
movups [rsp+78h+var_78], xmm0
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl6grisu2EPcRiS4_NS2_5diyfpES5_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(char *,int &,int &,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
loc_6C5DF:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aStdIsfiniteVal; "std::isfinite(value)"
mov esi, 4589h
jmp short loc_6C615
loc_6C5FB:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aValue0; "value > 0"
mov esi, 458Ah
loc_6C615:
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(
long long a1,
long long a2,
long long a3,
double a4)
{
long long v5; // r9
char *v7; // rsi
int v8; // edx
int v9; // ecx
int v10; // r8d
int v11; // r9d
_QWORD v12[3]; // [rsp+28h] [rbp-50h] BYREF
unsigned int v13; // [rsp+40h] [rbp-38h]
long long v14; // [rsp+48h] [rbp-30h]
long long v15; // [rsp+50h] [rbp-28h]
if ( (*(_QWORD *)&a4 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
{
v7 = (_BYTE *)(&stru_4580 + 9);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17801LL,
"GGML_ASSERT(%s) failed",
"std::isfinite(value)");
}
else
{
if ( a4 > 0.0 )
{
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(v12);
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2(
a1,
a2,
a3,
v12[2],
v13,
v5,
v12[0],
v12[1],
v14,
v15);
}
v7 = (_BYTE *)(&stru_4580 + 10);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17802LL,
"GGML_ASSERT(%s) failed",
"value > 0");
}
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v7,
v8,
v9,
v10,
v11);
}
| grisu2<double>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOVQ RAX,XMM0
BTR RAX,0x3f
MOV RCX,0x7ff0000000000000
CMP RAX,RCX
JGE 0x0016c5df
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JBE 0x0016c5fb
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R12,[RSP + 0x28]
MOV RDI,R12
CALL 0x0016c7b5
MOV RCX,qword ptr [R12 + 0x10]
MOV R8D,dword ptr [R12 + 0x18]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x20]
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0016c8fd
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0016c5df:
LEA RDI,[0x18fdd7]
LEA RDX,[0x18d28c]
LEA RCX,[0x192955]
MOV ESI,0x4589
JMP 0x0016c615
LAB_0016c5fb:
LEA RDI,[0x18fdd7]
LEA RDX,[0x18d28c]
LEA RCX,[0x192a6e]
MOV ESI,0x458a
LAB_0016c615:
XOR EAX,EAX
CALL 0x00120af0
|
/* void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>(char*, int&, int&, double) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2<double>
(char *param_1,int *param_2,int *param_3,double param_4)
{
char *pcVar1;
int8 uVar2;
int8 in_R9;
int4 local_50 [2];
int4 uStack_48;
int8 local_40;
int4 local_38;
int4 local_30;
int4 uStack_28;
if ((ulong)ABS(param_4) < 0x7ff0000000000000) {
if (0.0 < param_4) {
compute_boundaries<double>((dtoa_impl *)local_50,param_4);
grisu2(param_1,param_2,param_3,local_40,local_38,in_R9,local_50[0],uStack_48,local_30,
uStack_28);
return;
}
pcVar1 = "value > 0";
uVar2 = 0x458a;
}
else {
pcVar1 = "std::isfinite(value)";
uVar2 = 0x4589;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar2,
"GGML_ASSERT(%s) failed",pcVar1);
}
| |
52,321 | reset_simple_key_cache_counters | eloqsql/mysys/mf_keycache.c | static
int reset_simple_key_cache_counters(const char *name __attribute__((unused)),
SIMPLE_KEY_CACHE_CB *keycache)
{
DBUG_ENTER("reset_simple_key_cache_counters");
if (!keycache->key_cache_inited)
{
DBUG_PRINT("info", ("Key cache %s not initialized.", name));
DBUG_RETURN(0);
}
DBUG_PRINT("info", ("Resetting counters for key cache %s.", name));
keycache->global_blocks_changed= 0; /* Key_blocks_not_flushed */
keycache->global_cache_r_requests= 0; /* Key_read_requests */
keycache->global_cache_read= 0; /* Key_reads */
keycache->global_cache_w_requests= 0; /* Key_write_requests */
keycache->global_cache_write= 0; /* Key_writes */
DBUG_RETURN(0);
} | O0 | c | reset_simple_key_cache_counters:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xe8a34
jmp 0xe8a27
jmp 0xe8a29
jmp 0xe8a2b
movl $0x0, -0x4(%rbp)
jmp 0xe8a8a
jmp 0xe8a36
jmp 0xe8a38
movq -0x18(%rbp), %rax
movq $0x0, 0x138(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x150(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x158(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x140(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x148(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
| reset_simple_key_cache_counters:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp byte ptr [rax], 0
jnz short loc_E8A34
jmp short $+2
loc_E8A27:
jmp short $+2
loc_E8A29:
jmp short $+2
loc_E8A2B:
mov [rbp+var_4], 0
jmp short loc_E8A8A
loc_E8A34:
jmp short $+2
loc_E8A36:
jmp short $+2
loc_E8A38:
mov rax, [rbp+var_18]
mov qword ptr [rax+138h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+150h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+158h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+140h], 0
mov rax, [rbp+var_18]
mov qword ptr [rax+148h], 0
mov [rbp+var_4], 0
loc_E8A8A:
mov eax, [rbp+var_4]
pop rbp
retn
| long long reset_simple_key_cache_counters(long long a1, long long a2)
{
if ( *(_BYTE *)a2 )
{
*(_QWORD *)(a2 + 312) = 0LL;
*(_QWORD *)(a2 + 336) = 0LL;
*(_QWORD *)(a2 + 344) = 0LL;
*(_QWORD *)(a2 + 320) = 0LL;
*(_QWORD *)(a2 + 328) = 0LL;
}
return 0LL;
}
| reset_simple_key_cache_counters:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX],0x0
JNZ 0x001e8a34
JMP 0x001e8a27
LAB_001e8a27:
JMP 0x001e8a29
LAB_001e8a29:
JMP 0x001e8a2b
LAB_001e8a2b:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e8a8a
LAB_001e8a34:
JMP 0x001e8a36
LAB_001e8a36:
JMP 0x001e8a38
LAB_001e8a38:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x138],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x150],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x158],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x140],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x148],0x0
MOV dword ptr [RBP + -0x4],0x0
LAB_001e8a8a:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 reset_simple_key_cache_counters(int8 param_1,char *param_2)
{
if (*param_2 != '\0') {
param_2[0x138] = '\0';
param_2[0x139] = '\0';
param_2[0x13a] = '\0';
param_2[0x13b] = '\0';
param_2[0x13c] = '\0';
param_2[0x13d] = '\0';
param_2[0x13e] = '\0';
param_2[0x13f] = '\0';
param_2[0x150] = '\0';
param_2[0x151] = '\0';
param_2[0x152] = '\0';
param_2[0x153] = '\0';
param_2[0x154] = '\0';
param_2[0x155] = '\0';
param_2[0x156] = '\0';
param_2[0x157] = '\0';
param_2[0x158] = '\0';
param_2[0x159] = '\0';
param_2[0x15a] = '\0';
param_2[0x15b] = '\0';
param_2[0x15c] = '\0';
param_2[0x15d] = '\0';
param_2[0x15e] = '\0';
param_2[0x15f] = '\0';
param_2[0x140] = '\0';
param_2[0x141] = '\0';
param_2[0x142] = '\0';
param_2[0x143] = '\0';
param_2[0x144] = '\0';
param_2[0x145] = '\0';
param_2[0x146] = '\0';
param_2[0x147] = '\0';
param_2[0x148] = '\0';
param_2[0x149] = '\0';
param_2[0x14a] = '\0';
param_2[0x14b] = '\0';
param_2[0x14c] = '\0';
param_2[0x14d] = '\0';
param_2[0x14e] = '\0';
param_2[0x14f] = '\0';
}
return 0;
}
| |
52,322 | QuaternionSlerp | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)
{
Quaternion result = { 0 };
#if !defined(EPSILON)
#define EPSILON 0.000001f
#endif
float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w;
if (cosHalfTheta < 0)
{
q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w;
cosHalfTheta = -cosHalfTheta;
}
if (fabsf(cosHalfTheta) >= 1.0f) result = q1;
else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount);
else
{
float halfTheta = acosf(cosHalfTheta);
float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta);
if (fabsf(sinHalfTheta) < EPSILON)
{
result.x = (q1.x*0.5f + q2.x*0.5f);
result.y = (q1.y*0.5f + q2.y*0.5f);
result.z = (q1.z*0.5f + q2.z*0.5f);
result.w = (q1.w*0.5f + q2.w*0.5f);
}
else
{
float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta;
float ratioB = sinf(amount*halfTheta)/sinHalfTheta;
result.x = (q1.x*ratioA + q2.x*ratioB);
result.y = (q1.y*ratioA + q2.y*ratioB);
result.z = (q1.z*ratioA + q2.z*ratioB);
result.w = (q1.w*ratioA + q2.w*ratioB);
}
}
return result;
} | O2 | c | QuaternionSlerp:
movaps %xmm0, %xmm5
movaps %xmm1, %xmm0
shufps $0x55, %xmm1, %xmm0 # xmm0 = xmm0[1,1],xmm1[1,1]
movaps %xmm3, %xmm8
shufps $0x55, %xmm3, %xmm8 # xmm8 = xmm8[1,1],xmm3[1,1]
movaps %xmm5, %xmm7
mulps %xmm2, %xmm7
shufps $0x55, %xmm7, %xmm7 # xmm7 = xmm7[1,1,1,1]
movaps %xmm5, %xmm6
mulss %xmm2, %xmm6
addss %xmm7, %xmm6
movaps %xmm1, %xmm7
mulss %xmm3, %xmm7
addss %xmm6, %xmm7
mulss %xmm0, %xmm8
addss %xmm7, %xmm8
movaps 0x5baf1(%rip), %xmm6 # 0xb5140
movaps %xmm8, %xmm0
xorps %xmm6, %xmm0
ucomiss %xmm8, %xmm0
maxss %xmm8, %xmm0
jbe 0x59667
xorps %xmm6, %xmm2
xorps %xmm6, %xmm3
subq $0x78, %rsp
movaps 0x6048e(%rip), %xmm6 # 0xb9b00
andps %xmm0, %xmm6
ucomiss 0x60020(%rip), %xmm6 # 0xb969c
jae 0x597b3
ucomiss 0x69e5b(%rip), %xmm0 # 0xc34e4
jbe 0x5969b
movaps %xmm5, %xmm0
callq 0x59592
movaps %xmm0, %xmm5
jmp 0x597b3
movss %xmm4, 0xc(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm3, 0x30(%rsp)
movaps %xmm5, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm0, 0x10(%rsp)
callq 0x9590
movss %xmm0, 0x8(%rsp)
movaps 0x10(%rsp), %xmm1
mulss %xmm1, %xmm1
movss 0x5ffc6(%rip), %xmm3 # 0xb969c
movaps %xmm3, %xmm0
subss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x596eb
sqrtss %xmm0, %xmm2
jmp 0x596fb
callq 0x99e0
movss 0x5ffa4(%rip), %xmm3 # 0xb969c
movaps %xmm0, %xmm2
movaps 0x603fe(%rip), %xmm0 # 0xb9b00
andps %xmm2, %xmm0
movss 0x69dd3(%rip), %xmm1 # 0xc34e0
ucomiss %xmm0, %xmm1
movss 0xc(%rsp), %xmm1
jbe 0x59744
movaps 0x5ba31(%rip), %xmm0 # 0xb5150
movaps 0x20(%rsp), %xmm1
mulps %xmm0, %xmm1
movaps 0x40(%rsp), %xmm5
mulps %xmm0, %xmm5
addps %xmm1, %xmm5
movaps 0x30(%rsp), %xmm2
mulps %xmm0, %xmm2
movaps 0x50(%rsp), %xmm1
mulps %xmm0, %xmm1
jmp 0x597b0
subss %xmm1, %xmm3
mulss 0x8(%rsp), %xmm3
movaps %xmm3, %xmm0
movaps %xmm2, 0x10(%rsp)
callq 0x9410
divss 0x10(%rsp), %xmm0
movaps %xmm0, 0x60(%rsp)
movss 0x8(%rsp), %xmm0
mulss 0xc(%rsp), %xmm0
callq 0x9410
divss 0x10(%rsp), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
movaps 0x20(%rsp), %xmm1
mulps %xmm0, %xmm1
movaps 0x60(%rsp), %xmm2
shufps $0x0, %xmm2, %xmm2 # xmm2 = xmm2[0,0,0,0]
movaps 0x40(%rsp), %xmm5
mulps %xmm2, %xmm5
movaps %xmm2, %xmm3
addps %xmm1, %xmm5
movaps 0x30(%rsp), %xmm2
mulps %xmm0, %xmm2
movaps 0x50(%rsp), %xmm1
mulps %xmm3, %xmm1
addps %xmm2, %xmm1
movaps %xmm5, %xmm0
addq $0x78, %rsp
retq
| QuaternionSlerp:
movaps xmm5, xmm0
movaps xmm0, xmm1
shufps xmm0, xmm1, 55h ; 'U'
movaps xmm8, xmm3
shufps xmm8, xmm3, 55h ; 'U'
movaps xmm7, xmm5
mulps xmm7, xmm2
shufps xmm7, xmm7, 55h ; 'U'
movaps xmm6, xmm5
mulss xmm6, xmm2
addss xmm6, xmm7
movaps xmm7, xmm1
mulss xmm7, xmm3
addss xmm7, xmm6
mulss xmm8, xmm0
addss xmm8, xmm7
movaps xmm6, cs:xmmword_B5140
movaps xmm0, xmm8
xorps xmm0, xmm6
ucomiss xmm0, xmm8
maxss xmm0, xmm8
jbe short loc_59667
xorps xmm2, xmm6
xorps xmm3, xmm6
loc_59667:
sub rsp, 78h
movaps xmm6, cs:xmmword_B9B00
andps xmm6, xmm0
ucomiss xmm6, cs:dword_B969C
jnb loc_597B3
ucomiss xmm0, cs:dword_C34E4
jbe short loc_5969B
movaps xmm0, xmm5
call QuaternionNlerp
movaps xmm5, xmm0
jmp loc_597B3
loc_5969B:
movss [rsp+78h+var_6C], xmm4
movaps [rsp+78h+var_58], xmm2
movaps [rsp+78h+var_48], xmm3
movaps [rsp+78h+var_38], xmm5
movaps [rsp+78h+var_28], xmm1
movaps [rsp+78h+var_68], xmm0
call _acosf
movss [rsp+78h+var_70], xmm0
movaps xmm1, [rsp+78h+var_68]
mulss xmm1, xmm1
movss xmm3, cs:dword_B969C
movaps xmm0, xmm3
subss xmm0, xmm1
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jb short loc_596EB
sqrtss xmm2, xmm0
jmp short loc_596FB
loc_596EB:
call _sqrtf
movss xmm3, cs:dword_B969C
movaps xmm2, xmm0
loc_596FB:
movaps xmm0, cs:xmmword_B9B00
andps xmm0, xmm2
movss xmm1, cs:dword_C34E0
ucomiss xmm1, xmm0
movss xmm1, [rsp+78h+var_6C]
jbe short loc_59744
movaps xmm0, cs:xmmword_B5150
movaps xmm1, [rsp+78h+var_58]
mulps xmm1, xmm0
movaps xmm5, [rsp+78h+var_38]
mulps xmm5, xmm0
addps xmm5, xmm1
movaps xmm2, [rsp+78h+var_48]
mulps xmm2, xmm0
movaps xmm1, [rsp+78h+var_28]
mulps xmm1, xmm0
jmp short loc_597B0
loc_59744:
subss xmm3, xmm1
mulss xmm3, [rsp+78h+var_70]
movaps xmm0, xmm3
movaps [rsp+78h+var_68], xmm2
call _sinf
divss xmm0, dword ptr [rsp+78h+var_68]
movaps [rsp+78h+var_18], xmm0
movss xmm0, [rsp+78h+var_70]
mulss xmm0, [rsp+78h+var_6C]
call _sinf
divss xmm0, dword ptr [rsp+78h+var_68]
shufps xmm0, xmm0, 0
movaps xmm1, [rsp+78h+var_58]
mulps xmm1, xmm0
movaps xmm2, [rsp+78h+var_18]
shufps xmm2, xmm2, 0
movaps xmm5, [rsp+78h+var_38]
mulps xmm5, xmm2
movaps xmm3, xmm2
addps xmm5, xmm1
movaps xmm2, [rsp+78h+var_48]
mulps xmm2, xmm0
movaps xmm1, [rsp+78h+var_28]
mulps xmm1, xmm3
loc_597B0:
addps xmm1, xmm2
loc_597B3:
movaps xmm0, xmm5
add rsp, 78h
retn
| __m128 QuaternionSlerp(__m128 a1, __m128 a2, __m128 a3, __m128 a4, __m128 a5)
{
__m128 v5; // xmm5
__m128 v6; // xmm7
float v7; // xmm8_4
float v8; // xmm0_4
__int128 v9; // xmm3
float v10; // xmm0_4
float v11; // xmm2_4
double v12; // xmm0_8
__m128 v13; // xmm0
__m128 v14; // xmm0
float v16; // [rsp+0h] [rbp-70h]
float v17; // [rsp+4h] [rbp-6Ch]
float v18; // [rsp+8h] [rbp-68h]
__m128 v19; // [rsp+18h] [rbp-58h]
__m128 v20; // [rsp+38h] [rbp-38h]
__m128 v21; // [rsp+58h] [rbp-18h]
v5 = a1;
v6 = _mm_mul_ps(a1, a3);
v7 = (float)(_mm_shuffle_ps(a4, a4, 85).m128_f32[0] * _mm_shuffle_ps(a2, a2, 85).m128_f32[0])
+ (float)((float)(a2.m128_f32[0] * a4.m128_f32[0])
+ (float)((float)(a1.m128_f32[0] * a3.m128_f32[0]) + _mm_shuffle_ps(v6, v6, 85).m128_f32[0]));
v8 = fmaxf(-v7, v7);
if ( (float)-v7 > v7 )
{
a3 = _mm_xor_ps(a3, (__m128)xmmword_B5140);
a4 = _mm_xor_ps(a4, (__m128)xmmword_B5140);
}
if ( fabs(v8) < 1.0 )
{
if ( v8 <= 0.94999999 )
{
v17 = a5.m128_f32[0];
v19 = a3;
v20 = v5;
v18 = v8;
v16 = acosf();
v9 = 0x3F800000u;
v10 = 1.0 - (float)(v18 * v18);
if ( v10 < 0.0 )
{
v12 = sqrtf();
v9 = 0x3F800000u;
v11 = *(float *)&v12;
}
else
{
v11 = fsqrt(v10);
}
if ( fabs(v11) >= 0.000001 )
{
v13.m128_u64[1] = *((_QWORD *)&v9 + 1);
*(double *)v13.m128_u64 = sinf((float)(*(float *)&v9 - v17) * v16);
v13.m128_f32[0] = v13.m128_f32[0] / v11;
v21 = v13;
v14 = (__m128)LODWORD(v16);
*(double *)v14.m128_u64 = sinf(v16 * v17);
v14.m128_f32[0] = v14.m128_f32[0] / v11;
return _mm_add_ps(_mm_mul_ps(v20, _mm_shuffle_ps(v21, v21, 0)), _mm_mul_ps(v19, _mm_shuffle_ps(v14, v14, 0)));
}
else
{
return _mm_add_ps(_mm_mul_ps(v20, (__m128)xmmword_B5150), _mm_mul_ps(v19, (__m128)xmmword_B5150));
}
}
else
{
return QuaternionNlerp(v5, a2, a3, a4, a5);
}
}
return v5;
}
| QuaternionSlerp:
MOVAPS XMM5,XMM0
MOVAPS XMM0,XMM1
SHUFPS XMM0,XMM1,0x55
MOVAPS XMM8,XMM3
SHUFPS XMM8,XMM3,0x55
MOVAPS XMM7,XMM5
MULPS XMM7,XMM2
SHUFPS XMM7,XMM7,0x55
MOVAPS XMM6,XMM5
MULSS XMM6,XMM2
ADDSS XMM6,XMM7
MOVAPS XMM7,XMM1
MULSS XMM7,XMM3
ADDSS XMM7,XMM6
MULSS XMM8,XMM0
ADDSS XMM8,XMM7
MOVAPS XMM6,xmmword ptr [0x001b5140]
MOVAPS XMM0,XMM8
XORPS XMM0,XMM6
UCOMISS XMM0,XMM8
MAXSS XMM0,XMM8
JBE 0x00159667
XORPS XMM2,XMM6
XORPS XMM3,XMM6
LAB_00159667:
SUB RSP,0x78
MOVAPS XMM6,xmmword ptr [0x001b9b00]
ANDPS XMM6,XMM0
UCOMISS XMM6,dword ptr [0x001b969c]
JNC 0x001597b3
UCOMISS XMM0,dword ptr [0x001c34e4]
JBE 0x0015969b
MOVAPS XMM0,XMM5
CALL 0x00159592
MOVAPS XMM5,XMM0
JMP 0x001597b3
LAB_0015969b:
MOVSS dword ptr [RSP + 0xc],XMM4
MOVAPS xmmword ptr [RSP + 0x20],XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM3
MOVAPS xmmword ptr [RSP + 0x40],XMM5
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM0
CALL 0x00109590
MOVSS dword ptr [RSP + 0x8],XMM0
MOVAPS XMM1,xmmword ptr [RSP + 0x10]
MULSS XMM1,XMM1
MOVSS XMM3,dword ptr [0x001b969c]
MOVAPS XMM0,XMM3
SUBSS XMM0,XMM1
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JC 0x001596eb
SQRTSS XMM2,XMM0
JMP 0x001596fb
LAB_001596eb:
CALL 0x001099e0
MOVSS XMM3,dword ptr [0x001b969c]
MOVAPS XMM2,XMM0
LAB_001596fb:
MOVAPS XMM0,xmmword ptr [0x001b9b00]
ANDPS XMM0,XMM2
MOVSS XMM1,dword ptr [0x001c34e0]
UCOMISS XMM1,XMM0
MOVSS XMM1,dword ptr [RSP + 0xc]
JBE 0x00159744
MOVAPS XMM0,xmmword ptr [0x001b5150]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MULPS XMM1,XMM0
MOVAPS XMM5,xmmword ptr [RSP + 0x40]
MULPS XMM5,XMM0
ADDPS XMM5,XMM1
MOVAPS XMM2,xmmword ptr [RSP + 0x30]
MULPS XMM2,XMM0
MOVAPS XMM1,xmmword ptr [RSP + 0x50]
MULPS XMM1,XMM0
JMP 0x001597b0
LAB_00159744:
SUBSS XMM3,XMM1
MULSS XMM3,dword ptr [RSP + 0x8]
MOVAPS XMM0,XMM3
MOVAPS xmmword ptr [RSP + 0x10],XMM2
CALL 0x00109410
DIVSS XMM0,dword ptr [RSP + 0x10]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVSS XMM0,dword ptr [RSP + 0x8]
MULSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00109410
DIVSS XMM0,dword ptr [RSP + 0x10]
SHUFPS XMM0,XMM0,0x0
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MULPS XMM1,XMM0
MOVAPS XMM2,xmmword ptr [RSP + 0x60]
SHUFPS XMM2,XMM2,0x0
MOVAPS XMM5,xmmword ptr [RSP + 0x40]
MULPS XMM5,XMM2
MOVAPS XMM3,XMM2
ADDPS XMM5,XMM1
MOVAPS XMM2,xmmword ptr [RSP + 0x30]
MULPS XMM2,XMM0
MOVAPS XMM1,xmmword ptr [RSP + 0x50]
MULPS XMM1,XMM3
LAB_001597b0:
ADDPS XMM1,XMM2
LAB_001597b3:
MOVAPS XMM0,XMM5
ADD RSP,0x78
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8
QuaternionSlerp(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
float param_5)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
fVar6 = (float)((ulong)param_3 >> 0x20);
fVar5 = (float)param_3;
fVar4 = (float)((ulong)param_1 >> 0x20);
fVar1 = (float)param_1;
fVar7 = (float)((ulong)param_4 >> 0x20) * (float)((ulong)param_2 >> 0x20) +
(float)param_2 * (float)param_4 + fVar1 * fVar5 + fVar4 * fVar6;
if (fVar7 < (float)((uint)fVar7 ^ _DAT_001b5140)) {
fVar5 = (float)((uint)fVar5 ^ _DAT_001b5140);
fVar6 = (float)((uint)fVar6 ^ _UNK_001b5144);
fVar7 = (float)((uint)fVar7 ^ _DAT_001b5140);
}
if ((float)(_DAT_001b9b00 & (uint)fVar7) < DAT_001b969c) {
if (fVar7 <= _DAT_001c34e4) {
fVar2 = acosf(fVar7);
fVar7 = DAT_001b969c - fVar7 * fVar7;
if (fVar7 < 0.0) {
fVar7 = sqrtf(fVar7);
}
else {
fVar7 = SQRT(fVar7);
}
if (DAT_001c34e0 <= (float)(_DAT_001b9b00 & (uint)fVar7)) {
fVar3 = sinf((DAT_001b969c - param_5) * fVar2);
fVar2 = sinf(fVar2 * param_5);
param_1 = CONCAT44(fVar4 * (fVar3 / fVar7) + fVar6 * (fVar2 / fVar7),
fVar1 * (fVar3 / fVar7) + fVar5 * (fVar2 / fVar7));
}
else {
param_1 = CONCAT44(fVar4 * _UNK_001b5154 + fVar6 * _UNK_001b5154,
fVar1 * _DAT_001b5150 + fVar5 * _DAT_001b5150);
}
}
else {
param_1 = QuaternionNlerp(fVar1);
}
}
return param_1;
}
| |
52,323 | plutovg_span_buffer_copy | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-rasterize.c | void plutovg_span_buffer_copy(plutovg_span_buffer_t* span_buffer, const plutovg_span_buffer_t* source)
{
plutovg_array_clear(span_buffer->spans);
plutovg_array_append(span_buffer->spans, source->spans);
span_buffer->x = source->x;
span_buffer->y = source->y;
span_buffer->w = source->w;
span_buffer->h = source->h;
} | O1 | c | plutovg_span_buffer_copy:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
cmpq $0x0, (%rsi)
je 0xce80
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0xce80
movl 0xc(%rbx), %edx
cmpl %edx, %eax
jle 0xce5e
testl %edx, %edx
movl $0x8, %ecx
cmovnel %edx, %ecx
movl %ecx, %r15d
leal (%r15,%r15), %ecx
cmpl %eax, %r15d
jl 0xce3c
movq (%rbx), %rdi
movl %r15d, %esi
shlq $0x4, %rsi
callq 0x31f0
movq %rax, (%rbx)
movl %r15d, 0xc(%rbx)
movslq 0x8(%rbx), %rdi
shlq $0x4, %rdi
addq (%rbx), %rdi
movq (%r14), %rsi
movslq 0x8(%r14), %rdx
shlq $0x4, %rdx
callq 0x3190
movl 0x8(%r14), %eax
addl %eax, 0x8(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x14(%r14), %eax
movl %eax, 0x14(%rbx)
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movl 0x1c(%r14), %eax
movl %eax, 0x1c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
| plutovg_span_buffer_copy:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov dword ptr [rdi+8], 0
cmp qword ptr [rsi], 0
jz short loc_CE80
mov eax, [r14+8]
test eax, eax
jle short loc_CE80
mov edx, [rbx+0Ch]
cmp eax, edx
jle short loc_CE5E
test edx, edx
mov ecx, 8
cmovnz ecx, edx
loc_CE3C:
mov r15d, ecx
lea ecx, [r15+r15]
cmp r15d, eax
jl short loc_CE3C
mov rdi, [rbx]
mov esi, r15d
shl rsi, 4
call _realloc
mov [rbx], rax
mov [rbx+0Ch], r15d
loc_CE5E:
movsxd rdi, dword ptr [rbx+8]
shl rdi, 4
add rdi, [rbx]
mov rsi, [r14]
movsxd rdx, dword ptr [r14+8]
shl rdx, 4
call _memcpy
mov eax, [r14+8]
add [rbx+8], eax
loc_CE80:
mov eax, [r14+10h]
mov [rbx+10h], eax
mov eax, [r14+14h]
mov [rbx+14h], eax
mov eax, [r14+18h]
mov [rbx+18h], eax
mov eax, [r14+1Ch]
mov [rbx+1Ch], eax
pop rbx
pop r14
pop r15
retn
| long long plutovg_span_buffer_copy(long long a1, long long a2)
{
int v2; // eax
long long v3; // rdx
long long v4; // rcx
int v5; // r15d
long long result; // rax
*(_DWORD *)(a1 + 8) = 0;
if ( *(_QWORD *)a2 )
{
v2 = *(_DWORD *)(a2 + 8);
if ( v2 > 0 )
{
v3 = *(unsigned int *)(a1 + 12);
if ( v2 > (int)v3 )
{
LODWORD(v4) = 8;
if ( (_DWORD)v3 )
LODWORD(v4) = *(_DWORD *)(a1 + 12);
do
{
v5 = v4;
v4 = (unsigned int)(2 * v4);
}
while ( v5 < v2 );
*(_QWORD *)a1 = realloc(*(_QWORD *)a1, 16LL * (unsigned int)v5, v3, v4);
*(_DWORD *)(a1 + 12) = v5;
}
memcpy(*(_QWORD *)a1 + 16LL * *(int *)(a1 + 8), *(_QWORD *)a2, 16LL * *(int *)(a2 + 8));
*(_DWORD *)(a1 + 8) += *(_DWORD *)(a2 + 8);
}
}
*(_DWORD *)(a1 + 16) = *(_DWORD *)(a2 + 16);
*(_DWORD *)(a1 + 20) = *(_DWORD *)(a2 + 20);
*(_DWORD *)(a1 + 24) = *(_DWORD *)(a2 + 24);
result = *(unsigned int *)(a2 + 28);
*(_DWORD *)(a1 + 28) = result;
return result;
}
| plutovg_span_buffer_copy:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV dword ptr [RDI + 0x8],0x0
CMP qword ptr [RSI],0x0
JZ 0x0010ce80
MOV EAX,dword ptr [R14 + 0x8]
TEST EAX,EAX
JLE 0x0010ce80
MOV EDX,dword ptr [RBX + 0xc]
CMP EAX,EDX
JLE 0x0010ce5e
TEST EDX,EDX
MOV ECX,0x8
CMOVNZ ECX,EDX
LAB_0010ce3c:
MOV R15D,ECX
LEA ECX,[R15 + R15*0x1]
CMP R15D,EAX
JL 0x0010ce3c
MOV RDI,qword ptr [RBX]
MOV ESI,R15D
SHL RSI,0x4
CALL 0x001031f0
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0xc],R15D
LAB_0010ce5e:
MOVSXD RDI,dword ptr [RBX + 0x8]
SHL RDI,0x4
ADD RDI,qword ptr [RBX]
MOV RSI,qword ptr [R14]
MOVSXD RDX,dword ptr [R14 + 0x8]
SHL RDX,0x4
CALL 0x00103190
MOV EAX,dword ptr [R14 + 0x8]
ADD dword ptr [RBX + 0x8],EAX
LAB_0010ce80:
MOV EAX,dword ptr [R14 + 0x10]
MOV dword ptr [RBX + 0x10],EAX
MOV EAX,dword ptr [R14 + 0x14]
MOV dword ptr [RBX + 0x14],EAX
MOV EAX,dword ptr [R14 + 0x18]
MOV dword ptr [RBX + 0x18],EAX
MOV EAX,dword ptr [R14 + 0x1c]
MOV dword ptr [RBX + 0x1c],EAX
POP RBX
POP R14
POP R15
RET
|
void plutovg_span_buffer_copy(long *param_1,long *param_2)
{
int iVar1;
uint uVar2;
void *pvVar3;
uint uVar4;
*(int4 *)(param_1 + 1) = 0;
if ((*param_2 != 0) && (iVar1 = (int)param_2[1], 0 < iVar1)) {
uVar4 = *(uint *)((long)param_1 + 0xc);
if ((int)uVar4 < iVar1) {
uVar2 = 8;
if (uVar4 != 0) {
uVar2 = uVar4;
}
do {
uVar4 = uVar2;
uVar2 = uVar4 * 2;
} while ((int)uVar4 < iVar1);
pvVar3 = realloc((void *)*param_1,(ulong)uVar4 << 4);
*param_1 = (long)pvVar3;
*(uint *)((long)param_1 + 0xc) = uVar4;
}
memcpy((void *)((long)(int)param_1[1] * 0x10 + *param_1),(void *)*param_2,
(long)(int)param_2[1] << 4);
*(int *)(param_1 + 1) = (int)param_1[1] + (int)param_2[1];
}
*(int *)(param_1 + 2) = (int)param_2[2];
*(int4 *)((long)param_1 + 0x14) = *(int4 *)((long)param_2 + 0x14);
*(int *)(param_1 + 3) = (int)param_2[3];
*(int4 *)((long)param_1 + 0x1c) = *(int4 *)((long)param_2 + 0x1c);
return;
}
| |
52,324 | lunasvg::SVGTextElement::layout(lunasvg::SVGLayoutState&) | dmazzella[P]pylunasvg/lunasvg/source/svgtextelement.cpp | void SVGTextElement::layout(SVGLayoutState& state)
{
SVGTextPositioningElement::layout(state);
SVGTextFragmentsBuilder(m_text, m_fragments).build(this);
} | O1 | cpp | lunasvg::SVGTextElement::layout(lunasvg::SVGLayoutState&):
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
callq 0xff68
leaq 0x1e0(%rbx), %rax
leaq 0x1c8(%rbx), %rcx
leaq 0x20(%rsp), %rdx
movq %rax, -0x18(%rdx)
movq %rcx, -0x10(%rdx)
xorl %eax, %eax
movl %eax, (%rdx)
movq %rax, 0x8(%rdx)
movq %rdx, 0x10(%rdx)
movq %rdx, 0x18(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdx)
movups %xmm0, 0x30(%rdx)
movups %xmm0, 0x40(%rdx)
movq %rax, 0x1e8(%rbx)
movq 0x1e0(%rbx), %rcx
movl %eax, (%rcx)
movq 0x1c8(%rbx), %rax
cmpq %rax, 0x1d0(%rbx)
je 0x22368
movq %rax, 0x1d0(%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x20f92
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x2238c
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0xa320
leaq 0x18(%rsp), %rdi
callq 0x22ce0
addq $0x70, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x22a44
movq %rbx, %rdi
callq 0xa5c0
nop
| _ZN7lunasvg14SVGTextElement6layoutERNS_14SVGLayoutStateE:
push rbx
sub rsp, 70h
mov rbx, rdi
call _ZN7lunasvg10SVGElement6layoutERNS_14SVGLayoutStateE; lunasvg::SVGElement::layout(lunasvg::SVGLayoutState &)
lea rax, [rbx+1E0h]
lea rcx, [rbx+1C8h]
lea rdx, [rsp+78h+var_58]
mov [rdx-18h], rax
mov [rdx-10h], rcx
xor eax, eax
mov [rdx], eax
mov [rdx+8], rax
mov [rdx+10h], rdx
mov [rdx+18h], rdx
xorps xmm0, xmm0
movups xmmword ptr [rdx+20h], xmm0
movups xmmword ptr [rdx+30h], xmm0
movups xmmword ptr [rdx+40h], xmm0
mov [rbx+1E8h], rax
mov rcx, [rbx+1E0h]
mov [rcx], eax
mov rax, [rbx+1C8h]
cmp [rbx+1D0h], rax
jz short loc_22368
mov [rbx+1D0h], rax
loc_22368:
lea rdi, [rsp+78h+var_70]; this
mov rsi, rbx; lunasvg::SVGTextElement *
call _ZN7lunasvg23SVGTextFragmentsBuilder5buildEPKNS_14SVGTextElementE; lunasvg::SVGTextFragmentsBuilder::build(lunasvg::SVGTextElement const*)
mov rdi, [rsp+78h+var_30]; void *
test rdi, rdi
jz short loc_2238C
mov rsi, [rsp+78h+var_20]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2238C:
lea rdi, [rsp+78h+var_60]
call _ZNSt8_Rb_treeImSt4pairIKmN7lunasvg20SVGCharacterPositionEESt10_Select1stIS4_ESt4lessImESaIS4_EED2Ev; std::_Rb_tree<ulong,std::pair<ulong const,lunasvg::SVGCharacterPosition>,std::_Select1st<std::pair<ulong const,lunasvg::SVGCharacterPosition>>,std::less<ulong>,std::allocator<std::pair<ulong const,lunasvg::SVGCharacterPosition>>>::~_Rb_tree()
add rsp, 70h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN7lunasvg23SVGTextFragmentsBuilderD2Ev; lunasvg::SVGTextFragmentsBuilder::~SVGTextFragmentsBuilder()
mov rdi, rbx
call __Unwind_Resume
| long long lunasvg::SVGTextElement::layout(lunasvg::SVGTextElement *this, lunasvg::SVGLayoutState *a2)
{
long long v2; // rax
long long *v4[2]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v5[8]; // [rsp+18h] [rbp-60h] BYREF
int v6; // [rsp+20h] [rbp-58h] BYREF
long long v7; // [rsp+28h] [rbp-50h]
int *v8; // [rsp+30h] [rbp-48h]
int *v9; // [rsp+38h] [rbp-40h]
__int128 v10; // [rsp+40h] [rbp-38h]
__int128 v11; // [rsp+50h] [rbp-28h]
__int128 v12; // [rsp+60h] [rbp-18h]
lunasvg::SVGElement::layout(this, a2);
v4[0] = (long long *)((char *)this + 480);
v4[1] = (long long *)((char *)this + 456);
v6 = 0;
v7 = 0LL;
v8 = &v6;
v9 = &v6;
v10 = 0LL;
v11 = 0LL;
v12 = 0LL;
*((_QWORD *)this + 61) = 0LL;
**((_DWORD **)this + 60) = 0;
v2 = *((_QWORD *)this + 57);
if ( *((_QWORD *)this + 58) != v2 )
*((_QWORD *)this + 58) = v2;
lunasvg::SVGTextFragmentsBuilder::build(v4, this);
if ( *((_QWORD *)&v10 + 1) )
operator delete(*((void **)&v10 + 1), *((_QWORD *)&v11 + 1) - *((_QWORD *)&v10 + 1));
return std::_Rb_tree<unsigned long,std::pair<unsigned long const,lunasvg::SVGCharacterPosition>,std::_Select1st<std::pair<unsigned long const,lunasvg::SVGCharacterPosition>>,std::less<unsigned long>,std::allocator<std::pair<unsigned long const,lunasvg::SVGCharacterPosition>>>::~_Rb_tree(v5);
}
| layout:
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
CALL 0x0010ff68
LEA RAX,[RBX + 0x1e0]
LEA RCX,[RBX + 0x1c8]
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX + -0x18],RAX
MOV qword ptr [RDX + -0x10],RCX
XOR EAX,EAX
MOV dword ptr [RDX],EAX
MOV qword ptr [RDX + 0x8],RAX
MOV qword ptr [RDX + 0x10],RDX
MOV qword ptr [RDX + 0x18],RDX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX + 0x20],XMM0
MOVUPS xmmword ptr [RDX + 0x30],XMM0
MOVUPS xmmword ptr [RDX + 0x40],XMM0
MOV qword ptr [RBX + 0x1e8],RAX
MOV RCX,qword ptr [RBX + 0x1e0]
MOV dword ptr [RCX],EAX
MOV RAX,qword ptr [RBX + 0x1c8]
CMP qword ptr [RBX + 0x1d0],RAX
JZ 0x00122368
MOV qword ptr [RBX + 0x1d0],RAX
LAB_00122368:
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
CALL 0x00120f92
LAB_00122375:
MOV RDI,qword ptr [RSP + 0x48]
TEST RDI,RDI
JZ 0x0012238c
MOV RSI,qword ptr [RSP + 0x58]
SUB RSI,RDI
CALL 0x0010a320
LAB_0012238c:
LEA RDI,[RSP + 0x18]
CALL 0x00122ce0
ADD RSP,0x70
POP RBX
RET
|
/* lunasvg::SVGTextElement::layout(lunasvg::SVGLayoutState&) */
void __thiscall lunasvg::SVGTextElement::layout(SVGTextElement *this,SVGLayoutState *param_1)
{
SVGTextElement *local_70;
SVGTextElement *local_68;
_Rb_tree<unsigned_long,std::pair<unsigned_long_const,lunasvg::SVGCharacterPosition>,std::_Select1st<std::pair<unsigned_long_const,lunasvg::SVGCharacterPosition>>,std::less<unsigned_long>,std::allocator<std::pair<unsigned_long_const,lunasvg::SVGCharacterPosition>>>
local_60 [8];
int4 local_58 [2];
int8 local_50;
int4 *local_48;
int4 *local_40;
int8 local_38;
void *pvStack_30;
int8 local_28;
long lStack_20;
int8 local_18;
int8 uStack_10;
SVGElement::layout((SVGElement *)this,param_1);
local_70 = this + 0x1e0;
local_68 = this + 0x1c8;
local_48 = local_58;
local_58[0] = 0;
local_50 = 0;
local_38 = 0;
pvStack_30 = (void *)0x0;
local_28 = 0;
lStack_20 = 0;
local_18 = 0;
uStack_10 = 0;
*(int8 *)(this + 0x1e8) = 0;
**(int4 **)(this + 0x1e0) = 0;
if (*(long *)(this + 0x1d0) != *(long *)(this + 0x1c8)) {
*(long *)(this + 0x1d0) = *(long *)(this + 0x1c8);
}
/* try { // try from 00122368 to 00122374 has its CatchHandler @ 0012239c */
local_40 = local_48;
SVGTextFragmentsBuilder::build((SVGTextFragmentsBuilder *)&local_70,this);
if (pvStack_30 != (void *)0x0) {
operator_delete(pvStack_30,lStack_20 - (long)pvStack_30);
}
std::
_Rb_tree<unsigned_long,std::pair<unsigned_long_const,lunasvg::SVGCharacterPosition>,std::_Select1st<std::pair<unsigned_long_const,lunasvg::SVGCharacterPosition>>,std::less<unsigned_long>,std::allocator<std::pair<unsigned_long_const,lunasvg::SVGCharacterPosition>>>
::~_Rb_tree(local_60);
return;
}
| |
52,325 | lock_io_cache | eloqsql/mysys/mf_iocache.c | static int lock_io_cache(IO_CACHE *cache, my_off_t pos)
{
IO_CACHE_SHARE *cshare= cache->share;
DBUG_ENTER("lock_io_cache");
/* Enter the lock. */
mysql_mutex_lock(&cshare->mutex);
cshare->running_threads--;
DBUG_PRINT("io_cache_share", ("%s: %p pos: %lu running: %u",
(cache == cshare->source_cache) ?
"writer" : "reader", cache, (ulong) pos,
cshare->running_threads));
if (cshare->source_cache)
{
/* A write cache is synchronized to the read caches. */
if (cache == cshare->source_cache)
{
/* The writer waits until all readers are here. */
while (cshare->running_threads)
{
DBUG_PRINT("io_cache_share", ("writer waits in lock"));
mysql_cond_wait(&cshare->cond_writer, &cshare->mutex);
}
DBUG_PRINT("io_cache_share", ("writer awoke, going to copy"));
/* Stay locked. Leave the lock later by unlock_io_cache(). */
DBUG_RETURN(1);
}
/* The last thread wakes the writer. */
if (!cshare->running_threads)
{
DBUG_PRINT("io_cache_share", ("waking writer"));
mysql_cond_signal(&cshare->cond_writer);
}
/*
Readers wait until the data is copied from the writer. Another
reason to stop waiting is the removal of the write thread. If this
happens, we leave the lock with old data in the buffer.
*/
while ((!cshare->read_end || (cshare->pos_in_file < pos)) &&
cshare->source_cache)
{
DBUG_PRINT("io_cache_share", ("reader waits in lock"));
mysql_cond_wait(&cshare->cond, &cshare->mutex);
}
/*
If the writer was removed from the share while this thread was
asleep, we need to simulate an EOF condition. The writer cannot
reset the share variables as they might still be in use by readers
of the last block. When we awake here then because the last
joining thread signalled us. If the writer is not the last, it
will not signal. So it is safe to clear the buffer here.
*/
if (!cshare->read_end || (cshare->pos_in_file < pos))
{
DBUG_PRINT("io_cache_share", ("reader found writer removed. EOF"));
cshare->read_end= cshare->buffer; /* Empty buffer. */
cshare->error= 0; /* EOF is not an error. */
}
}
else
{
/*
There are read caches only. The last thread arriving in
lock_io_cache() continues with a locked cache and reads the block.
*/
if (!cshare->running_threads)
{
DBUG_PRINT("io_cache_share", ("last thread joined, going to read"));
/* Stay locked. Leave the lock later by unlock_io_cache(). */
DBUG_RETURN(1);
}
/*
All other threads wait until the requested block is read by the
last thread arriving. Another reason to stop waiting is the
removal of a thread. If this leads to all threads being in the
lock, we have to continue also. The first of the awaken threads
will then do the read.
*/
while ((!cshare->read_end || (cshare->pos_in_file < pos)) &&
cshare->running_threads)
{
DBUG_PRINT("io_cache_share", ("reader waits in lock"));
mysql_cond_wait(&cshare->cond, &cshare->mutex);
}
/* If the block is not yet read, continue with a locked cache and read. */
if (!cshare->read_end || (cshare->pos_in_file < pos))
{
DBUG_PRINT("io_cache_share", ("reader awoke, going to read"));
/* Stay locked. Leave the lock later by unlock_io_cache(). */
DBUG_RETURN(1);
}
/* Another thread did read the block already. */
}
DBUG_PRINT("io_cache_share", ("reader awoke, going to process %u bytes",
(uint) (cshare->read_end ? (size_t)
(cshare->read_end - cshare->buffer) :
0)));
/*
Leave the lock. Do not call unlock_io_cache() later. The thread that
filled the buffer did this and marked all threads as running.
*/
mysql_mutex_unlock(&cshare->mutex);
DBUG_RETURN(0);
} | O3 | c | lock_io_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x98(%rdi), %rbx
cmpq $0x0, 0x40(%rbx)
jne 0x99eec
movq %rbx, %rdi
callq 0x291e0
movl 0xd8(%rbx), %eax
decl %eax
movl %eax, 0xd8(%rbx)
movq 0xc0(%rbx), %rcx
testq %rcx, %rcx
je 0x99dff
cmpq %r15, %rcx
je 0x99e9f
testl %eax, %eax
jne 0x99da6
leaq 0x80(%rbx), %r15
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
jne 0x99f1a
movq %r15, %rdi
callq 0x29570
leaq 0x48(%rbx), %r15
leaq 0x44677(%rip), %r12 # 0xde428
cmpq $0x0, 0xd0(%rbx)
je 0x99dc8
cmpq %r14, 0xb8(%rbx)
jae 0x99e75
cmpq $0x0, 0xc0(%rbx)
je 0x99e5d
cmpq $0x0, 0x78(%rbx)
jne 0x99dea
movq %r15, %rdi
movq %rbx, %rsi
callq 0x29400
jmp 0x99db1
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x406, %ecx # imm = 0x406
callq 0x2f16c
jmp 0x99db1
movl $0x1, %r15d
testl %eax, %eax
je 0x99e8d
leaq 0x48(%rbx), %r12
leaq 0x44610(%rip), %r13 # 0xde428
cmpq $0x0, 0xd0(%rbx)
je 0x99e2b
cmpq %r14, 0xb8(%rbx)
jae 0x99e75
cmpl $0x0, 0xd8(%rbx)
je 0x99e8d
cmpq $0x0, 0x78(%rbx)
jne 0x99e48
movq %r12, %rdi
movq %rbx, %rsi
callq 0x29400
jmp 0x99e18
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movl $0x430, %ecx # imm = 0x430
callq 0x2f16c
jmp 0x99e18
movq 0xc8(%rbx), %rax
movq %rax, 0xd0(%rbx)
movl $0x0, 0xe0(%rbx)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
jne 0x99f05
movq %rbx, %rdi
callq 0x291b0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r15d
testl %eax, %eax
je 0x99e8d
leaq 0x80(%rbx), %r14
leaq 0x44571(%rip), %r12 # 0xde428
cmpq $0x0, 0xb0(%rbx)
jne 0x99ed7
movq %r14, %rdi
movq %rbx, %rsi
callq 0x29400
cmpl $0x0, 0xd8(%rbx)
jne 0x99eb7
jmp 0x99e8d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl $0x3ee, %ecx # imm = 0x3EE
callq 0x2f16c
jmp 0x99ecc
leaq 0x44535(%rip), %rsi # 0xde428
movq %rbx, %rdi
movl $0x3dd, %edx # imm = 0x3DD
callq 0x2ee5b
jmp 0x99d5c
leaq 0x2ef154(%rip), %rax # 0x389060
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x99e82
leaq 0x2ef13f(%rip), %rax # 0x389060
movq (%rax), %rax
callq *0x170(%rax)
jmp 0x99d9e
| lock_io_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov r15, rdi
mov rbx, [rdi+98h]
cmp qword ptr [rbx+40h], 0
jnz loc_99EEC
mov rdi, rbx
call _pthread_mutex_lock
loc_99D5C:
mov eax, [rbx+0D8h]
dec eax
mov [rbx+0D8h], eax
mov rcx, [rbx+0C0h]
test rcx, rcx
jz loc_99DFF
cmp rcx, r15
jz loc_99E9F
test eax, eax
jnz short loc_99DA6
lea r15, [rbx+80h]
mov rdi, [rbx+0B0h]
test rdi, rdi
jnz loc_99F1A
loc_99D9E:
mov rdi, r15
call _pthread_cond_signal
loc_99DA6:
lea r15, [rbx+48h]
lea r12, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
loc_99DB1:
cmp qword ptr [rbx+0D0h], 0
jz short loc_99DC8
cmp [rbx+0B8h], r14
jnb loc_99E75
loc_99DC8:
cmp qword ptr [rbx+0C0h], 0
jz loc_99E5D
cmp qword ptr [rbx+78h], 0
jnz short loc_99DEA
mov rdi, r15
mov rsi, rbx
call _pthread_cond_wait
jmp short loc_99DB1
loc_99DEA:
mov rdi, r15
mov rsi, rbx
mov rdx, r12
mov ecx, 406h
call psi_cond_wait
jmp short loc_99DB1
loc_99DFF:
mov r15d, 1
test eax, eax
jz loc_99E8D
lea r12, [rbx+48h]
lea r13, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
loc_99E18:
cmp qword ptr [rbx+0D0h], 0
jz short loc_99E2B
cmp [rbx+0B8h], r14
jnb short loc_99E75
loc_99E2B:
cmp dword ptr [rbx+0D8h], 0
jz short loc_99E8D
cmp qword ptr [rbx+78h], 0
jnz short loc_99E48
mov rdi, r12
mov rsi, rbx
call _pthread_cond_wait
jmp short loc_99E18
loc_99E48:
mov rdi, r12
mov rsi, rbx
mov rdx, r13
mov ecx, 430h
call psi_cond_wait
jmp short loc_99E18
loc_99E5D:
mov rax, [rbx+0C8h]
mov [rbx+0D0h], rax
mov dword ptr [rbx+0E0h], 0
loc_99E75:
mov rdi, [rbx+40h]
test rdi, rdi
jnz loc_99F05
loc_99E82:
mov rdi, rbx
call _pthread_mutex_unlock
xor r15d, r15d
loc_99E8D:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_99E9F:
mov r15d, 1
test eax, eax
jz short loc_99E8D
lea r14, [rbx+80h]
lea r12, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
loc_99EB7:
cmp qword ptr [rbx+0B0h], 0
jnz short loc_99ED7
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
loc_99ECC:
cmp dword ptr [rbx+0D8h], 0
jnz short loc_99EB7
jmp short loc_99E8D
loc_99ED7:
mov rdi, r14
mov rsi, rbx
mov rdx, r12
mov ecx, 3EEh
call psi_cond_wait
jmp short loc_99ECC
loc_99EEC:
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rbx
mov edx, 3DDh
call psi_mutex_lock
jmp loc_99D5C
loc_99F05:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_99E82
loc_99F1A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp loc_99D9E
| long long lock_io_cache(long long a1, unsigned long long a2)
{
long long v2; // rbx
int v3; // eax
long long v4; // rcx
long long v5; // rdi
unsigned int v6; // r15d
long long v7; // rdi
v2 = *(_QWORD *)(a1 + 152);
if ( *(_QWORD *)(v2 + 64) )
psi_mutex_lock(
*(_QWORD *)(a1 + 152),
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x3DDu);
else
pthread_mutex_lock(*(_QWORD *)(a1 + 152));
v3 = *(_DWORD *)(v2 + 216) - 1;
*(_DWORD *)(v2 + 216) = v3;
v4 = *(_QWORD *)(v2 + 192);
if ( !v4 )
{
v6 = 1;
if ( !v3 )
return v6;
while ( !*(_QWORD *)(v2 + 208) || *(_QWORD *)(v2 + 184) < a2 )
{
if ( !*(_DWORD *)(v2 + 216) )
return v6;
if ( *(_QWORD *)(v2 + 120) )
psi_cond_wait(v2 + 72, v2, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x430u);
else
pthread_cond_wait(v2 + 72, v2);
}
goto LABEL_23;
}
if ( v4 != a1 )
{
if ( !v3 )
{
v5 = *(_QWORD *)(v2 + 176);
if ( v5 )
((void ( *)(long long))PSI_server[46])(v5);
pthread_cond_signal(v2 + 128);
}
while ( !*(_QWORD *)(v2 + 208) || *(_QWORD *)(v2 + 184) < a2 )
{
if ( !*(_QWORD *)(v2 + 192) )
{
*(_QWORD *)(v2 + 208) = *(_QWORD *)(v2 + 200);
*(_DWORD *)(v2 + 224) = 0;
break;
}
if ( *(_QWORD *)(v2 + 120) )
psi_cond_wait(v2 + 72, v2, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x406u);
else
pthread_cond_wait(v2 + 72, v2);
}
LABEL_23:
v7 = *(_QWORD *)(v2 + 64);
if ( v7 )
((void ( *)(long long))PSI_server[44])(v7);
pthread_mutex_unlock(v2);
return 0;
}
v6 = 1;
if ( v3 )
{
do
{
if ( *(_QWORD *)(v2 + 176) )
psi_cond_wait(v2 + 128, v2, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x3EEu);
else
pthread_cond_wait(v2 + 128, v2);
}
while ( *(_DWORD *)(v2 + 216) );
}
return v6;
}
| lock_io_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV R15,RDI
MOV RBX,qword ptr [RDI + 0x98]
CMP qword ptr [RBX + 0x40],0x0
JNZ 0x00199eec
MOV RDI,RBX
CALL 0x001291e0
LAB_00199d5c:
MOV EAX,dword ptr [RBX + 0xd8]
DEC EAX
MOV dword ptr [RBX + 0xd8],EAX
MOV RCX,qword ptr [RBX + 0xc0]
TEST RCX,RCX
JZ 0x00199dff
CMP RCX,R15
JZ 0x00199e9f
TEST EAX,EAX
JNZ 0x00199da6
LEA R15,[RBX + 0x80]
MOV RDI,qword ptr [RBX + 0xb0]
TEST RDI,RDI
JNZ 0x00199f1a
LAB_00199d9e:
MOV RDI,R15
CALL 0x00129570
LAB_00199da6:
LEA R15,[RBX + 0x48]
LEA R12,[0x1de428]
LAB_00199db1:
CMP qword ptr [RBX + 0xd0],0x0
JZ 0x00199dc8
CMP qword ptr [RBX + 0xb8],R14
JNC 0x00199e75
LAB_00199dc8:
CMP qword ptr [RBX + 0xc0],0x0
JZ 0x00199e5d
CMP qword ptr [RBX + 0x78],0x0
JNZ 0x00199dea
MOV RDI,R15
MOV RSI,RBX
CALL 0x00129400
JMP 0x00199db1
LAB_00199dea:
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
MOV ECX,0x406
CALL 0x0012f16c
JMP 0x00199db1
LAB_00199dff:
MOV R15D,0x1
TEST EAX,EAX
JZ 0x00199e8d
LEA R12,[RBX + 0x48]
LEA R13,[0x1de428]
LAB_00199e18:
CMP qword ptr [RBX + 0xd0],0x0
JZ 0x00199e2b
CMP qword ptr [RBX + 0xb8],R14
JNC 0x00199e75
LAB_00199e2b:
CMP dword ptr [RBX + 0xd8],0x0
JZ 0x00199e8d
CMP qword ptr [RBX + 0x78],0x0
JNZ 0x00199e48
MOV RDI,R12
MOV RSI,RBX
CALL 0x00129400
JMP 0x00199e18
LAB_00199e48:
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R13
MOV ECX,0x430
CALL 0x0012f16c
JMP 0x00199e18
LAB_00199e5d:
MOV RAX,qword ptr [RBX + 0xc8]
MOV qword ptr [RBX + 0xd0],RAX
MOV dword ptr [RBX + 0xe0],0x0
LAB_00199e75:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JNZ 0x00199f05
LAB_00199e82:
MOV RDI,RBX
CALL 0x001291b0
XOR R15D,R15D
LAB_00199e8d:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00199e9f:
MOV R15D,0x1
TEST EAX,EAX
JZ 0x00199e8d
LEA R14,[RBX + 0x80]
LEA R12,[0x1de428]
LAB_00199eb7:
CMP qword ptr [RBX + 0xb0],0x0
JNZ 0x00199ed7
MOV RDI,R14
MOV RSI,RBX
CALL 0x00129400
LAB_00199ecc:
CMP dword ptr [RBX + 0xd8],0x0
JNZ 0x00199eb7
JMP 0x00199e8d
LAB_00199ed7:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R12
MOV ECX,0x3ee
CALL 0x0012f16c
JMP 0x00199ecc
LAB_00199eec:
LEA RSI,[0x1de428]
MOV RDI,RBX
MOV EDX,0x3dd
CALL 0x0012ee5b
JMP 0x00199d5c
LAB_00199f05:
LEA RAX,[0x489060]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00199e82
LAB_00199f1a:
LEA RAX,[0x489060]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x00199d9e
|
int8 lock_io_cache(long param_1,ulong param_2)
{
pthread_mutex_t *__mutex;
int iVar1;
int8 uVar2;
__mutex = *(pthread_mutex_t **)(param_1 + 0x98);
if (*(long *)((long)__mutex + 0x40) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x3dd);
}
iVar1 = *(int *)((long)__mutex + 0xd8) + -1;
*(int *)((long)__mutex + 0xd8) = iVar1;
if (*(long *)((long)__mutex + 0xc0) == 0) {
uVar2 = 1;
if (iVar1 != 0) {
while( true ) {
if ((*(long *)((long)__mutex + 0xd0) != 0) && (param_2 <= *(ulong *)((long)__mutex + 0xb8)))
goto LAB_00199e75;
if (*(int *)((long)__mutex + 0xd8) == 0) break;
if (__mutex[3].__align == 0) {
pthread_cond_wait((pthread_cond_t *)((long)__mutex + 0x48),__mutex);
}
else {
psi_cond_wait((pthread_cond_t *)((long)__mutex + 0x48),__mutex,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x430);
}
}
}
}
else if (*(long *)((long)__mutex + 0xc0) == param_1) {
uVar2 = 1;
if (iVar1 != 0) {
do {
if (*(long *)((long)__mutex + 0xb0) == 0) {
pthread_cond_wait((pthread_cond_t *)((long)__mutex + 0x80),__mutex);
}
else {
psi_cond_wait((pthread_cond_t *)((long)__mutex + 0x80),__mutex,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x3ee);
}
} while (*(int *)((long)__mutex + 0xd8) != 0);
}
}
else {
if (iVar1 == 0) {
if (*(long *)((long)__mutex + 0xb0) != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal((pthread_cond_t *)((long)__mutex + 0x80));
}
while( true ) {
if ((*(long *)((long)__mutex + 0xd0) != 0) && (param_2 <= *(ulong *)((long)__mutex + 0xb8)))
goto LAB_00199e75;
if (*(long *)((long)__mutex + 0xc0) == 0) break;
if (__mutex[3].__align == 0) {
pthread_cond_wait((pthread_cond_t *)((long)__mutex + 0x48),__mutex);
}
else {
psi_cond_wait((pthread_cond_t *)((long)__mutex + 0x48),__mutex,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x406);
}
}
*(long *)((long)__mutex + 0xd0) = __mutex[5].__align;
*(int4 *)((long)__mutex + 0xe0) = 0;
LAB_00199e75:
if (*(long *)((long)__mutex + 0x40) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
uVar2 = 0;
}
return uVar2;
}
| |
52,326 | testing::internal::FilePath::Normalize() | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-filepath.cc | void FilePath::Normalize() {
auto out = pathname_.begin();
auto i = pathname_.cbegin();
#ifdef GTEST_OS_WINDOWS
// UNC paths are treated specially
if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {
*(out++) = kPathSeparator;
*(out++) = kPathSeparator;
}
#endif
while (i != pathname_.end()) {
const char character = *i;
if (!IsPathSeparator(character)) {
*(out++) = character;
} else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
*(out++) = kPathSeparator;
}
++i;
}
pathname_.erase(out, pathname_.end());
} | O0 | cpp | testing::internal::FilePath::Normalize():
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xebdf0
movq 0x10(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0xebe20
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rdi
callq 0xebe90
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xebe50
xorb $-0x1, %al
testb $0x1, %al
jne 0xbfe0e
jmp 0xbfef3
leaq 0x70(%rsp), %rdi
callq 0x43ab0
movb (%rax), %al
movb %al, 0x67(%rsp)
movsbl 0x67(%rsp), %edi
callq 0xbf090
testb $0x1, %al
jne 0xbfe5a
movb 0x67(%rsp), %al
movb %al, 0xf(%rsp)
leaq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xebee0
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xebf20
movb 0xf(%rsp), %cl
movb %cl, (%rax)
jmp 0xbfee4
movq 0x10(%rsp), %rdi
callq 0xebdf0
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xebf30
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0xbfeba
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0xebf70
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xebf20
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0xbfec4
jmp 0xbfee2
leaq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xebee0
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xebf20
movb $0x2f, (%rax)
jmp 0xbfee4
leaq 0x70(%rsp), %rdi
callq 0x43ac0
jmp 0xbfde5
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xec080
movq 0x10(%rsp), %rdi
callq 0xebe90
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xec080
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xebfb0
movq %rax, 0x18(%rsp)
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN7testing8internal8FilePath9NormalizeEv:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov rdi, [rsp+88h+var_8]
mov [rsp+88h+var_78], rdi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov rdi, [rsp+88h+var_78]
mov [rsp+88h+var_10], rax
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6cbeginEv; std::string::cbegin(void)
mov [rsp+88h+var_18], rax
loc_BFDE5:
mov rdi, [rsp+88h+var_78]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov qword ptr [rsp+88h+var_20], rax
lea rdi, [rsp+88h+var_18]
lea rsi, [rsp+88h+var_20]; char
call _ZN9__gnu_cxxeqIPKcPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEQrQT_T0__XeqfL0p_fL0p0_RSt14convertible_toIbEEEEbRKNS_17__normal_iteratorISA_T1_EERKNSD_ISB_SE_EE
xor al, 0FFh
test al, 1
jnz short loc_BFE0E
jmp loc_BFEF3
loc_BFE0E:
lea rdi, [rsp+88h+var_18]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator*(void)
mov al, [rax]
mov [rsp+88h+var_21], al
movsx edi, [rsp+88h+var_21]; this
call _ZN7testing8internalL15IsPathSeparatorEc; testing::internal::IsPathSeparator(char)
test al, 1
jnz short loc_BFE5A
mov al, [rsp+88h+var_21]
mov [rsp+88h+var_79], al
lea rdi, [rsp+88h+var_10]
xor esi, esi
call _ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEi; __gnu_cxx::__normal_iterator<char *,std::string>::operator++(int)
mov [rsp+88h+var_30], rax
lea rdi, [rsp+88h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
mov cl, [rsp+88h+var_79]
mov [rax], cl
jmp loc_BFEE4
loc_BFE5A:
mov rdi, [rsp+88h+var_78]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rsp+88h+var_38], rax
lea rdi, [rsp+88h+var_10]
lea rsi, [rsp+88h+var_38]
call _ZN9__gnu_cxxeqIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
mov cl, al
mov al, 1
test cl, 1
mov [rsp+88h+var_7A], al
jnz short loc_BFEBA
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_48], rax
mov rdi, [rsp+88h+var_48]
mov esi, 1
call _ZSt4prevIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEET_SA_NSt15iterator_traitsISA_E15difference_typeE; std::prev<__gnu_cxx::__normal_iterator<char *,std::string>>(__gnu_cxx::__normal_iterator<char *,std::string>,std::iterator_traits<__gnu_cxx::__normal_iterator<char *,std::string>>::difference_type)
mov [rsp+88h+var_40], rax
lea rdi, [rsp+88h+var_40]
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rsp+88h+var_7A], al
loc_BFEBA:
mov al, [rsp+88h+var_7A]
test al, 1
jnz short loc_BFEC4
jmp short loc_BFEE2
loc_BFEC4:
lea rdi, [rsp+88h+var_10]
xor esi, esi
call _ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEi; __gnu_cxx::__normal_iterator<char *,std::string>::operator++(int)
mov [rsp+88h+var_50], rax
lea rdi, [rsp+88h+var_50]
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
mov byte ptr [rax], 2Fh ; '/'
loc_BFEE2:
jmp short $+2
loc_BFEE4:
lea rdi, [rsp+88h+var_18]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char const*,std::string>::operator++(void)
jmp loc_BFDE5
loc_BFEF3:
lea rdi, [rsp+88h+var_58]
lea rsi, [rsp+88h+var_10]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
mov rdi, [rsp+88h+var_78]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rsp+88h+var_68], rax
lea rdi, [rsp+88h+var_60]
lea rsi, [rsp+88h+var_68]
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
mov rdi, [rsp+88h+var_78]
mov rsi, [rsp+88h+var_58]
mov rdx, [rsp+88h+var_60]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5eraseEN9__gnu_cxx17__normal_iteratorIPKcS4_EES9_; std::string::erase(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>)
mov [rsp+88h+var_70], rax
add rsp, 88h
retn
| long long testing::internal::FilePath::Normalize(testing::internal::FilePath *this)
{
bool v2; // [rsp+Eh] [rbp-7Ah]
char v3; // [rsp+Fh] [rbp-79h]
long long v4; // [rsp+20h] [rbp-68h] BYREF
long long v5; // [rsp+28h] [rbp-60h] BYREF
long long v6; // [rsp+30h] [rbp-58h] BYREF
_QWORD v7[2]; // [rsp+38h] [rbp-50h] BYREF
long long v8; // [rsp+48h] [rbp-40h] BYREF
long long v9; // [rsp+50h] [rbp-38h] BYREF
long long v10; // [rsp+58h] [rbp-30h] BYREF
char v11; // [rsp+67h] [rbp-21h]
char v12[8]; // [rsp+68h] [rbp-20h] BYREF
long long i; // [rsp+70h] [rbp-18h] BYREF
_QWORD v14[2]; // [rsp+78h] [rbp-10h] BYREF
v14[1] = this;
v14[0] = ((long long (*)(void))std::string::begin)();
for ( i = std::string::cbegin(this); ; __gnu_cxx::__normal_iterator<char const*,std::string>::operator++(&i) )
{
*(_QWORD *)v12 = std::string::end(this);
if ( (ZN9__gnu_cxxeqIPKcPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEQrQT_T0__XeqfL0p_fL0p0_RSt14convertible_toIbEEEEbRKNS_17__normal_iteratorISA_T1_EERKNSD_ISB_SE_EE(
&i,
v12) & 1) != 0 )
break;
v11 = *(_BYTE *)__gnu_cxx::__normal_iterator<char const*,std::string>::operator*((long long)&i);
if ( testing::internal::IsPathSeparator((testing::internal *)(unsigned int)v11) )
{
v9 = std::string::begin(this);
v2 = 1;
if ( (__gnu_cxx::operator==<char *,std::string>(v14, &v9) & 1) == 0 )
{
v7[1] = v14[0];
v8 = std::prev<__gnu_cxx::__normal_iterator<char *,std::string>>(v14[0], 1LL);
v2 = *(_BYTE *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v8) != 47;
}
if ( v2 )
{
v7[0] = __gnu_cxx::__normal_iterator<char *,std::string>::operator++(v14, 0LL);
*(_BYTE *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(v7) = 47;
}
}
else
{
v3 = v11;
v10 = __gnu_cxx::__normal_iterator<char *,std::string>::operator++(v14, 0LL);
*(_BYTE *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v10) = v3;
}
}
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *>(&v6, v14);
v4 = std::string::end(this);
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *>(&v5, &v4);
return std::string::erase(this, v6, v5);
}
| Normalize:
SUB RSP,0x88
MOV qword ptr [RSP + 0x80],RDI
MOV RDI,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x001ebdf0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x78],RAX
CALL 0x001ebe20
MOV qword ptr [RSP + 0x70],RAX
LAB_001bfde5:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001ebe90
MOV qword ptr [RSP + 0x68],RAX
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x68]
CALL 0x001ebe50
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bfe0e
JMP 0x001bfef3
LAB_001bfe0e:
LEA RDI,[RSP + 0x70]
CALL 0x00143ab0
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0x67],AL
MOVSX EDI,byte ptr [RSP + 0x67]
CALL 0x001bf090
TEST AL,0x1
JNZ 0x001bfe5a
MOV AL,byte ptr [RSP + 0x67]
MOV byte ptr [RSP + 0xf],AL
LEA RDI,[RSP + 0x78]
XOR ESI,ESI
CALL 0x001ebee0
MOV qword ptr [RSP + 0x58],RAX
LEA RDI,[RSP + 0x58]
CALL 0x001ebf20
MOV CL,byte ptr [RSP + 0xf]
MOV byte ptr [RAX],CL
JMP 0x001bfee4
LAB_001bfe5a:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001ebdf0
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x50]
CALL 0x001ebf30
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0xe],AL
JNZ 0x001bfeba
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,0x1
CALL 0x001ebf70
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x48]
CALL 0x001ebf20
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RSP + 0xe],AL
LAB_001bfeba:
MOV AL,byte ptr [RSP + 0xe]
TEST AL,0x1
JNZ 0x001bfec4
JMP 0x001bfee2
LAB_001bfec4:
LEA RDI,[RSP + 0x78]
XOR ESI,ESI
CALL 0x001ebee0
MOV qword ptr [RSP + 0x38],RAX
LEA RDI,[RSP + 0x38]
CALL 0x001ebf20
MOV byte ptr [RAX],0x2f
LAB_001bfee2:
JMP 0x001bfee4
LAB_001bfee4:
LEA RDI,[RSP + 0x70]
CALL 0x00143ac0
JMP 0x001bfde5
LAB_001bfef3:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x78]
CALL 0x001ec080
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001ebe90
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x20]
CALL 0x001ec080
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x001ebfb0
MOV qword ptr [RSP + 0x18],RAX
ADD RSP,0x88
RET
|
/* testing::internal::FilePath::Normalize() */
void __thiscall testing::internal::FilePath::Normalize(FilePath *this)
{
char cVar1;
byte bVar2;
char *pcVar3;
ulong uVar4;
int1 *puVar5;
bool bVar6;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
char local_21;
int8 local_20;
int8 local_18;
int8 local_10;
FilePath *local_8;
local_8 = this;
local_10 = std::__cxx11::string::begin((string *)this);
local_18 = std::__cxx11::string::cbegin((string *)this);
while( true ) {
local_20 = std::__cxx11::string::end((string *)this);
bVar2 = _ZN9__gnu_cxxeqIPKcPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEQrQT_T0__XeqfL0p_fL0p0_RSt14convertible_toIbEEEEbRKNS_17__normal_iteratorISA_T1_EERKNSD_ISB_SE_EE
(&local_18);
if (((bVar2 ^ 0xff) & 1) == 0) break;
pcVar3 = (char *)__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator*
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_18);
local_21 = *pcVar3;
uVar4 = IsPathSeparator(local_21);
cVar1 = local_21;
if ((uVar4 & 1) == 0) {
local_30 = __gnu_cxx::__normal_iterator<char*,std::__cxx11::string>::operator++
((__normal_iterator<char*,std::__cxx11::string> *)&local_10,0);
pcVar3 = (char *)__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>::operator*
((__normal_iterator<char*,std::__cxx11::string> *)&local_30);
*pcVar3 = cVar1;
}
else {
local_38 = std::__cxx11::string::begin((string *)this);
bVar2 = _ZN9__gnu_cxxeqIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_QrqXeqcldtfp_4baseEcldtfp0_4baseERSt14convertible_toIbEE
(&local_10);
bVar6 = true;
if ((bVar2 & 1) == 0) {
local_48 = local_10;
local_40 = std::prev<__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>>(local_10);
pcVar3 = (char *)__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>::operator*
((__normal_iterator<char*,std::__cxx11::string> *)&local_40);
bVar6 = *pcVar3 != '/';
}
if (bVar6) {
local_50 = __gnu_cxx::__normal_iterator<char*,std::__cxx11::string>::operator++
((__normal_iterator<char*,std::__cxx11::string> *)&local_10,0);
puVar5 = (int1 *)
__gnu_cxx::__normal_iterator<char*,std::__cxx11::string>::operator*
((__normal_iterator<char*,std::__cxx11::string> *)&local_50);
*puVar5 = 0x2f;
}
}
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator++
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_18);
}
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::__normal_iterator<char*>
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_58,
(__normal_iterator *)&local_10);
local_68 = std::__cxx11::string::end((string *)this);
__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::__normal_iterator<char*>
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_60,
(__normal_iterator *)&local_68);
std::__cxx11::string::erase((string *)this,local_58,local_60);
return;
}
| |
52,327 | rlLoadComputeShaderProgram | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rlgl.h | unsigned int rlLoadComputeShaderProgram(unsigned int shaderId)
{
unsigned int program = 0;
#if defined(GRAPHICS_API_OPENGL_43)
GLint success = 0;
program = glCreateProgram();
glAttachShader(program, shaderId);
glLinkProgram(program);
// NOTE: All uniform variables are intitialised to 0 when a program links
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (success == GL_FALSE)
{
TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program);
int maxLength = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength > 0)
{
int length = 0;
char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
glGetProgramInfoLog(program, maxLength, &length, log);
TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log);
RL_FREE(log);
}
glDeleteProgram(program);
program = 0;
}
else
{
// Get the size of compiled shader program (not available on OpenGL ES 2.0)
// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero
//GLint binarySize = 0;
//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program);
}
#else
TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43");
#endif
return program;
} | O3 | c | rlLoadComputeShaderProgram:
pushq %rax
leaq 0x79aa8(%rip), %rsi # 0xdf4cc
movl $0x4, %edi
xorl %eax, %eax
callq 0xb9e53
xorl %eax, %eax
popq %rcx
retq
| rlLoadComputeShaderProgram:
push rax
lea rsi, aShaderComputeS; "SHADER: Compute shaders not enabled. De"...
mov edi, 4
xor eax, eax
call TraceLog
xor eax, eax
pop rcx
retn
| long long rlLoadComputeShaderProgram(long long a1, long long a2, int a3, int a4, int a5, int a6)
{
TraceLog(4, (unsigned int)"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", a3, a4, a5, a6);
return 0LL;
}
| rlLoadComputeShaderProgram:
PUSH RAX
LEA RSI,[0x1df4cc]
MOV EDI,0x4
XOR EAX,EAX
CALL 0x001b9e53
XOR EAX,EAX
POP RCX
RET
|
int8 rlLoadComputeShaderProgram(void)
{
TraceLog(4,"SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43");
return 0;
}
| |
52,328 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3]>(char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3]) | monkey531[P]llama/common/./json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3]>(char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x18310
movq %rax, %r12
movq (%r14), %rdi
callq 0x18310
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18a30
movq %rbx, %rdi
movq %r15, %rsi
callq 0x18cb0
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x18cb0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x713cd
movq (%r13), %rsi
incq %rsi
callq 0x186a0
movq %r14, %rdi
callq 0x18b90
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_:
push r15
push r14
push r13
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov r12, rax
mov rdi, [r14]
call _strlen
add r12, rax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_713CD
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_713CD:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // r12
long long v5; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
v5 = strlen(*a3);
std::string::reserve(a1, v5 + v4);
std::string::append(a1, a2);
std::string::append(a1, *a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[26],char_const*>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,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
MOV RDI,RSI
CALL 0x00118310
MOV R12,RAX
MOV RDI,qword ptr [R14]
CALL 0x00118310
ADD R12,RAX
LAB_00171388:
MOV RDI,RBX
MOV RSI,R12
CALL 0x00118a30
MOV RDI,RBX
MOV RSI,R15
CALL 0x00118cb0
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x00118cb0
LAB_001713a9:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [26], char const*>(char const (&) [26], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(*param_2);
/* try { // try from 00171388 to 001713a8 has its CatchHandler @ 001713b6 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this);
return this;
}
| |
52,329 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3]>(char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3]) | monkey531[P]llama/common/./json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [3]>(char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [3]):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x63319
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20a40
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x63340
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d78
movq %r14, %rdi
callq 0x20b90
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
mov rdx, rcx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEA12_cEEEmPKcDpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<std::string,char [12]>(char const*,std::string,char [12] const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA6_KcJS8_RA12_S9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
long long a1,
long long a2,
long long a3,
long long a4)
{
long long v6; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v6 = nlohmann::json_abi_v3_11_3::detail::concat_length<std::string,char [12]>(a2, a3, a4);
std::string::reserve(a1, v6);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA6_KcJS8_RA12_S9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_(
a1,
a2,
a3,
a4);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_001632cd:
MOV RDI,RSI
MOV RSI,RDX
MOV RDX,RCX
CALL 0x00163319
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00120a40
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00163340
LAB_001632f7:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [6], std::__cxx11::string, char const (&) [12]>(char const (&) [6], std::__cxx11::string&&,
char const (&) [12]) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(detail *this,char *param_1,string *param_2,char *param_3)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 001632cd to 001632f6 has its CatchHandler @ 00163306 */
concat_length<std::__cxx11::string,char[12]>(param_1,param_2,param_3);
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA6_KcJS8_RA12_S9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSF_OSG_DpOT1_
(this,param_1,param_2,param_3);
return this;
}
| |
52,330 | minja::CommentTemplateToken::~CommentTemplateToken() | monkey531[P]llama/common/minja.hpp | CommentTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, const std::string& t) : TemplateToken(Type::Comment, location, pre, post), text(t) {} | O3 | cpp | minja::CommentTemplateToken::~CommentTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0xac167(%rip), %rax # 0x154290
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xa8148
movq (%rax), %rsi
incq %rsi
callq 0x1dc50
leaq 0xac189(%rip), %rax # 0x1542d8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa8164
callq 0x50ba8
movl $0x50, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1dc50
| _ZN5minja20CommentTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja20CommentTemplateTokenE; `vtable for'minja::CommentTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+30h]; void *
lea rax, [rbx+40h]
cmp rdi, rax
jz short loc_A8148
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A8148:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_A8164
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A8164:
mov esi, 50h ; 'P'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::CommentTemplateToken::~CommentTemplateToken(minja::CommentTemplateToken *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::CommentTemplateToken + 2;
v2 = (char *)*((_QWORD *)this + 6);
if ( v2 != (char *)this + 64 )
operator delete(v2, *((_QWORD *)this + 8) + 1LL);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x50uLL);
}
| ~CommentTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x254290]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x30]
LEA RAX,[RBX + 0x40]
CMP RDI,RAX
JZ 0x001a8148
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011dc50
LAB_001a8148:
LEA RAX,[0x2542d8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x001a8164
CALL 0x00150ba8
LAB_001a8164:
MOV ESI,0x50
MOV RDI,RBX
POP RBX
JMP 0x0011dc50
|
/* minja::CommentTemplateToken::~CommentTemplateToken() */
void __thiscall minja::CommentTemplateToken::~CommentTemplateToken(CommentTemplateToken *this)
{
*(int ***)this = &PTR__CommentTemplateToken_002542a0;
if (*(CommentTemplateToken **)(this + 0x30) != this + 0x40) {
operator_delete(*(CommentTemplateToken **)(this + 0x30),*(long *)(this + 0x40) + 1);
}
*(int ***)this = &PTR__TemplateToken_002542e8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x50);
return;
}
| |
52,331 | ps_fetch_datetime | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static
void ps_fetch_datetime(MYSQL_BIND *r_param, const MYSQL_FIELD * field,
unsigned char **row)
{
MYSQL_TIME *t= (MYSQL_TIME *)r_param->buffer;
unsigned int len= net_field_length(row);
switch (r_param->buffer_type) {
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_DATE:
convert_to_datetime(t, row, len, field->type);
break;
case MYSQL_TYPE_TIME:
convert_to_datetime(t, row, len, field->type);
t->year= t->day= t->month= 0;
break;
case MYSQL_TYPE_YEAR:
{
MYSQL_TIME tm;
convert_to_datetime(&tm, row, len, field->type);
shortstore(r_param->buffer, tm.year);
break;
}
default:
{
char dtbuffer[60];
MYSQL_TIME tm;
size_t length;
convert_to_datetime(&tm, row, len, field->type);
switch(field->type) {
case MYSQL_TYPE_DATE:
length= sprintf(dtbuffer, "%04u-%02u-%02u", tm.year, tm.month, tm.day);
break;
case MYSQL_TYPE_TIME:
length= sprintf(dtbuffer, "%s%02u:%02u:%02u", (tm.neg ? "-" : ""), tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
length= sprintf(dtbuffer, "%04u-%02u-%02u %02u:%02u:%02u", tm.year, tm.month, tm.day, tm.hour, tm.minute, tm.second);
if (field->decimals && field->decimals <= 6)
{
char ms[8];
sprintf(ms, ".%06lu", tm.second_part);
if (field->decimals < 6)
ms[field->decimals + 1]= 0;
length+= strlen(ms);
strcat(dtbuffer, ms);
}
break;
default:
dtbuffer[0]= 0;
length= 0;
break;
}
convert_froma_string(r_param, dtbuffer, length);
break;
}
}
(*row) += len;
} | O3 | c | ps_fetch_datetime:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rdi), %r13
movq %rdx, %rdi
callq 0x1cd19
movq %rax, %r14
movl 0x60(%r15), %eax
addl $-0x7, %eax
cmpl $0x6, %eax
ja 0x2cd08
leaq 0xed91(%rip), %rcx # 0x3ba78
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x2d8dd
jmp 0x2cf07
movl 0x70(%r12), %r13d
leaq -0xa0(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
callq 0x2d8dd
addl $-0x7, %r13d
cmpl $0x5, %r13d
ja 0x2cef1
leaq 0xed5d(%rip), %rax # 0x3ba94
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl -0x94(%rbp), %r11d
movl -0x90(%rbp), %r13d
movl -0x8c(%rbp), %r10d
leaq 0xd4b4(%rip), %rcx # 0x3a22b
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r11
pushq -0xa8(%rbp)
callq 0x17360
addq $0x20, %rsp
jmp 0x2ce45
movl 0x70(%r12), %ecx
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x2d8dd
movl $0x0, 0x8(%r13)
movq $0x0, (%r13)
jmp 0x2cf07
movl 0x70(%r12), %ecx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x2d8dd
movl (%r12), %eax
movq 0x10(%r15), %rcx
movb %al, (%rcx)
movq 0x10(%r15), %rcx
movb %ah, 0x1(%rcx)
jmp 0x2cf07
cmpb $0x0, -0x80(%rbp)
leaq 0xe4d5(%rip), %rax # 0x3b2d6
leaq 0xe0f9(%rip), %r8 # 0x3af01
cmoveq %rax, %r8
movl -0x94(%rbp), %r9d
movl -0x90(%rbp), %r10d
movl -0x8c(%rbp), %r11d
leaq 0xd421(%rip), %rcx # 0x3a249
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x17360
addq $0x10, %rsp
movslq %eax, %r13
movl 0x68(%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x2cef8
movq -0x88(%rbp), %r8
leaq 0xe307(%rip), %rcx # 0x3b16d
leaq -0x78(%rbp), %rdi
movl $0x8, %edx
movl $0x1, %esi
xorl %eax, %eax
callq 0x17360
movl 0x68(%r12), %eax
cmpq $0x5, %rax
ja 0x2ce8f
leaq -0x78(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x17250
addq %rax, %r13
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movq %r12, %rsi
callq 0x175b0
jmp 0x2cef8
movl -0xa0(%rbp), %r8d
movl -0x9c(%rbp), %r9d
movl -0x98(%rbp), %r10d
subq $0x8, %rsp
leaq 0xd34b(%rip), %rcx # 0x3a21c
leaq -0x70(%rbp), %rdi
movl $0x3c, %edx
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
callq 0x17360
addq $0x10, %rsp
movslq %eax, %r13
jmp 0x2cef8
movb $0x0, -0x70(%rbp)
xorl %r13d, %r13d
leaq -0x70(%rbp), %rsi
movq %r15, %rdi
movq %r13, %rdx
callq 0x2d40d
movl %r14d, %eax
addq %rax, (%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x2cf2e
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17690
| ps_fetch_datetime:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdx
mov r12, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13, [rdi+10h]
mov rdi, rdx
call net_field_length
mov r14, rax
mov eax, [r15+60h]
add eax, 0FFFFFFF9h; switch 7 cases
cmp eax, 6
ja short def_2CCEE; jumptable 000000000002CCEE default case, cases 8,9
lea rcx, jpt_2CCEE
movsxd rax, ds:(jpt_2CCEE - 3BA78h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_2CCF0:
mov ecx, [r12+70h]; jumptable 000000000002CCEE cases 7,10,12
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
jmp loc_2CF07
def_2CCEE:
mov r13d, [r12+70h]; jumptable 000000000002CCEE default case, cases 8,9
lea rdi, [rbp+var_A0]
mov rsi, rbx
mov edx, r14d
mov ecx, r13d
call convert_to_datetime
add r13d, 0FFFFFFF9h; switch 6 cases
cmp r13d, 5
ja def_2CD3E; jumptable 000000000002CD3E default case, cases 8,9
lea rax, jpt_2CD3E
movsxd rcx, ds:(jpt_2CD3E - 3BA94h)[rax+r13*4]
add rcx, rax
jmp rcx; switch jump
loc_2CD40:
mov r8d, [rbp+var_A0]; jumptable 000000000002CD3E cases 7,12
mov r9d, [rbp+var_9C]
mov eax, [rbp+var_98]
mov [rbp+var_A8], rax
mov r11d, [rbp+var_94]
mov r13d, [rbp+var_90]
mov r10d, [rbp+var_8C]
lea rcx, a04u02u02u02u02; "%04u-%02u-%02u %02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
push r13
push r11
push [rbp+var_A8]
call ___sprintf_chk
add rsp, 20h
jmp loc_2CE45
loc_2CDA1:
mov ecx, [r12+70h]; jumptable 000000000002CCEE case 11
mov rdi, r13
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov dword ptr [r13+8], 0
mov qword ptr [r13+0], 0
jmp loc_2CF07
loc_2CDC9:
mov ecx, [r12+70h]; jumptable 000000000002CCEE case 13
lea r12, [rbp+var_70]
mov rdi, r12
mov rsi, rbx
mov edx, r14d
call convert_to_datetime
mov eax, [r12]
mov rcx, [r15+10h]
mov [rcx], al
mov rcx, [r15+10h]
mov [rcx+1], ah
jmp loc_2CF07
loc_2CDF6:
cmp [rbp+var_80], 0; jumptable 000000000002CD3E case 11
lea rax, asc_3B2D4+2; ""
lea r8, a555+5; "-"
cmovz r8, rax
mov r9d, [rbp+var_94]
mov r10d, [rbp+var_90]
mov r11d, [rbp+var_8C]
lea rcx, aS02u02u02u; "%s%02u:%02u:%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r11
push r10
call ___sprintf_chk
add rsp, 10h
loc_2CE45:
movsxd r13, eax
mov eax, [r12+68h]
dec eax
cmp eax, 5
ja loc_2CEF8
mov r8, [rbp+var_88]
lea rcx, a06lu; ".%06lu"
lea rdi, [rbp+var_78]
mov edx, 8
mov esi, 1
xor eax, eax
call ___sprintf_chk
mov eax, [r12+68h]
cmp rax, 5
ja short loc_2CE8F
lea rcx, [rbp+var_78]
mov byte ptr [rax+rcx+1], 0
loc_2CE8F:
lea r12, [rbp+var_78]
mov rdi, r12
call _strlen
add r13, rax
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov rsi, r12
call ___strcat_chk
jmp short loc_2CEF8
loc_2CEB1:
mov r8d, [rbp+var_A0]; jumptable 000000000002CD3E case 10
mov r9d, [rbp+var_9C]
mov r10d, [rbp+var_98]
sub rsp, 8
lea rcx, a04u02u02u; "%04u-%02u-%02u"
lea rdi, [rbp+var_70]
mov edx, 3Ch ; '<'
mov esi, 1
xor eax, eax
push r10
call ___sprintf_chk
add rsp, 10h
movsxd r13, eax
jmp short loc_2CEF8
def_2CD3E:
mov [rbp+var_70], 0; jumptable 000000000002CD3E default case, cases 8,9
xor r13d, r13d
loc_2CEF8:
lea rsi, [rbp+var_70]
mov rdi, r15
mov rdx, r13
call convert_froma_string
loc_2CF07:
mov eax, r14d
add [rbx], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_2CF2E
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2CF2E:
call ___stack_chk_fail
| unsigned long long ps_fetch_datetime(long long a1, long long a2, unsigned __int8 **a3)
{
long long v4; // r13
unsigned int v5; // r14d
unsigned int v6; // r13d
int v7; // eax
char v8; // ah
const char *v9; // r8
long long v10; // r13
long long v11; // rdx
_BYTE *v12; // rcx
unsigned long long v13; // rax
int v15; // [rsp+10h] [rbp-A0h] BYREF
int v16; // [rsp+14h] [rbp-9Ch]
int v17; // [rsp+18h] [rbp-98h]
int v18; // [rsp+1Ch] [rbp-94h]
int v19; // [rsp+20h] [rbp-90h]
int v20; // [rsp+24h] [rbp-8Ch]
long long v21; // [rsp+28h] [rbp-88h]
char v22; // [rsp+30h] [rbp-80h]
_BYTE v23[8]; // [rsp+38h] [rbp-78h] BYREF
_BYTE v24[64]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v25; // [rsp+80h] [rbp-30h]
v25 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 16);
v5 = net_field_length(a3);
switch ( *(_DWORD *)(a1 + 96) )
{
case 7:
case 0xA:
case 0xC:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
break;
case 0xB:
convert_to_datetime(v4, a3, v5, *(unsigned int *)(a2 + 112));
*(_DWORD *)(v4 + 8) = 0;
*(_QWORD *)v4 = 0LL;
break;
case 0xD:
convert_to_datetime(v24, a3, v5, *(unsigned int *)(a2 + 112));
v8 = v24[1];
**(_BYTE **)(a1 + 16) = v24[0];
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 1LL) = v8;
break;
default:
v6 = *(_DWORD *)(a2 + 112);
convert_to_datetime(&v15, a3, v5, v6);
switch ( v6 )
{
case 7u:
case 0xCu:
v7 = __sprintf_chk(v24, 1LL, 60LL, "%04u-%02u-%02u %02u:%02u:%02u", v15, v16, v17, v18, v19, v20);
goto LABEL_10;
case 0xAu:
v10 = (int)__sprintf_chk(v24, 1LL, 60LL, "%04u-%02u-%02u", v15, v16, v17);
break;
case 0xBu:
v9 = "-";
if ( !v22 )
v9 = "";
v7 = __sprintf_chk(v24, 1LL, 60LL, "%s%02u:%02u:%02u", v9, v18, v19, v20);
LABEL_10:
v10 = v7;
if ( (unsigned int)(*(_DWORD *)(a2 + 104) - 1) <= 5 )
{
__sprintf_chk(v23, 1LL, 8LL, ".%06lu", v21);
v13 = *(unsigned int *)(a2 + 104);
if ( v13 <= 5 )
{
v12 = v23;
v23[v13 + 1] = 0;
}
v10 += strlen(v23, 1LL, v11, v12);
__strcat_chk(v24, v23, 60LL);
}
break;
default:
v24[0] = 0;
v10 = 0LL;
break;
}
convert_froma_string(a1, v24, v10);
break;
}
*a3 += v5;
return __readfsqword(0x28u);
}
| ps_fetch_datetime:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDX
MOV R12,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13,qword ptr [RDI + 0x10]
MOV RDI,RDX
CALL 0x0011cd19
MOV R14,RAX
MOV EAX,dword ptr [R15 + 0x60]
ADD EAX,-0x7
CMP EAX,0x6
JA 0x0012cd08
LEA RCX,[0x13ba78]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x0012d8dd
JMP 0x0012cf07
caseD_8:
MOV R13D,dword ptr [R12 + 0x70]
LEA RDI,[RBP + -0xa0]
MOV RSI,RBX
MOV EDX,R14D
MOV ECX,R13D
CALL 0x0012d8dd
ADD R13D,-0x7
CMP R13D,0x5
JA 0x0012cef1
LEA RAX,[0x13ba94]
MOVSXD RCX,dword ptr [RAX + R13*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_7:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV EAX,dword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0xa8],RAX
MOV R11D,dword ptr [RBP + -0x94]
MOV R13D,dword ptr [RBP + -0x90]
MOV R10D,dword ptr [RBP + -0x8c]
LEA RCX,[0x13a22b]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
PUSH R13
PUSH R11
PUSH qword ptr [RBP + -0xa8]
CALL 0x00117360
ADD RSP,0x20
JMP 0x0012ce45
caseD_b:
MOV ECX,dword ptr [R12 + 0x70]
MOV RDI,R13
MOV RSI,RBX
MOV EDX,R14D
CALL 0x0012d8dd
MOV dword ptr [R13 + 0x8],0x0
MOV qword ptr [R13],0x0
JMP 0x0012cf07
caseD_d:
MOV ECX,dword ptr [R12 + 0x70]
LEA R12,[RBP + -0x70]
MOV RDI,R12
MOV RSI,RBX
MOV EDX,R14D
CALL 0x0012d8dd
MOV EAX,dword ptr [R12]
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX],AL
MOV RCX,qword ptr [R15 + 0x10]
MOV byte ptr [RCX + 0x1],AH
JMP 0x0012cf07
caseD_b:
CMP byte ptr [RBP + -0x80],0x0
LEA RAX,[0x13b2d6]
LEA R8,[0x13af01]
CMOVZ R8,RAX
MOV R9D,dword ptr [RBP + -0x94]
MOV R10D,dword ptr [RBP + -0x90]
MOV R11D,dword ptr [RBP + -0x8c]
LEA RCX,[0x13a249]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R11
PUSH R10
CALL 0x00117360
ADD RSP,0x10
LAB_0012ce45:
MOVSXD R13,EAX
MOV EAX,dword ptr [R12 + 0x68]
DEC EAX
CMP EAX,0x5
JA 0x0012cef8
MOV R8,qword ptr [RBP + -0x88]
LEA RCX,[0x13b16d]
LEA RDI,[RBP + -0x78]
MOV EDX,0x8
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00117360
MOV EAX,dword ptr [R12 + 0x68]
CMP RAX,0x5
JA 0x0012ce8f
LEA RCX,[RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
LAB_0012ce8f:
LEA R12,[RBP + -0x78]
MOV RDI,R12
CALL 0x00117250
ADD R13,RAX
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV RSI,R12
CALL 0x001175b0
JMP 0x0012cef8
caseD_a:
MOV R8D,dword ptr [RBP + -0xa0]
MOV R9D,dword ptr [RBP + -0x9c]
MOV R10D,dword ptr [RBP + -0x98]
SUB RSP,0x8
LEA RCX,[0x13a21c]
LEA RDI,[RBP + -0x70]
MOV EDX,0x3c
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
CALL 0x00117360
ADD RSP,0x10
MOVSXD R13,EAX
JMP 0x0012cef8
caseD_8:
MOV byte ptr [RBP + -0x70],0x0
XOR R13D,R13D
LAB_0012cef8:
LEA RSI,[RBP + -0x70]
MOV RDI,R15
MOV RDX,R13
CALL 0x0012d40d
LAB_0012cf07:
MOV EAX,R14D
ADD qword ptr [RBX],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0012cf2e
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012cf2e:
CALL 0x00117690
|
void ps_fetch_datetime(long param_1,long param_2,long *param_3)
{
int4 uVar1;
int8 *puVar2;
uint uVar3;
int iVar4;
size_t sVar5;
int *puVar6;
long lVar7;
long in_FS_OFFSET;
int4 local_a8;
int4 local_a4;
int4 local_a0;
int4 local_9c;
int4 local_98;
int4 local_94;
int8 local_90;
char local_88;
char local_80;
int1 auStack_7f [7];
uint local_78 [16];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
puVar2 = *(int8 **)(param_1 + 0x10);
uVar3 = net_field_length(param_3);
switch(*(int4 *)(param_1 + 0x60)) {
case 7:
case 10:
case 0xc:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
break;
default:
uVar1 = *(int4 *)(param_2 + 0x70);
convert_to_datetime(&local_a8,param_3,uVar3,uVar1);
switch(uVar1) {
case 7:
case 0xc:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u %02u:%02u:%02u",local_a8,local_a4,
local_a0,local_9c,local_98,local_94);
goto LAB_0012ce45;
default:
local_78[0] = local_78[0] & 0xffffff00;
lVar7 = 0;
break;
case 10:
iVar4 = __sprintf_chk(local_78,1,0x3c,"%04u-%02u-%02u",local_a8,local_a4,local_a0);
lVar7 = (long)iVar4;
break;
case 0xb:
puVar6 = &DAT_0013af01;
if (local_88 == '\0') {
puVar6 = &DAT_0013b2d6;
}
iVar4 = __sprintf_chk(local_78,1,0x3c,"%s%02u:%02u:%02u",puVar6,local_9c,local_98,local_94);
LAB_0012ce45:
lVar7 = (long)iVar4;
if (*(int *)(param_2 + 0x68) - 1U < 6) {
__sprintf_chk(&local_80,1,8,".%06lu",local_90);
if ((ulong)*(uint *)(param_2 + 0x68) < 6) {
auStack_7f[*(uint *)(param_2 + 0x68)] = 0;
}
sVar5 = strlen(&local_80);
lVar7 = lVar7 + sVar5;
__strcat_chk(local_78,&local_80,0x3c);
}
}
convert_froma_string(param_1,local_78,lVar7);
break;
case 0xb:
convert_to_datetime(puVar2,param_3,uVar3,*(int4 *)(param_2 + 0x70));
*(int4 *)(puVar2 + 1) = 0;
*puVar2 = 0;
break;
case 0xd:
convert_to_datetime(local_78,param_3,uVar3,*(int4 *)(param_2 + 0x70));
**(int1 **)(param_1 + 0x10) = (char)local_78[0];
*(char *)(*(long *)(param_1 + 0x10) + 1) = (char)(local_78[0] >> 8);
}
*param_3 = *param_3 + (ulong)uVar3;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
52,332 | my_mb_wc_utf8mb4_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O0 | c | my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x5bc86
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x5bf03
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jge 0x5bcb3
movzbl -0x21(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
cmpl $0xc2, %eax
jge 0x5bcca
movl $0x0, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
cmpl $0xe0, %eax
jge 0x5bd40
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0x5bcef
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x5bf03
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jl 0x5bd0d
movl $0x0, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
andl $0x1f, %eax
movslq %eax, %rcx
shlq $0x6, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x5bdfc
movq -0x18(%rbp), %rax
addq $0x3, %rax
cmpq -0x20(%rbp), %rax
jbe 0x5bd69
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x5bf03
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x5bda7
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x5bda7
movzbl -0x21(%rbp), %eax
cmpl $0xe1, %eax
jge 0x5bdb3
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0xa0, %eax
jge 0x5bdb3
movl $0x0, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
shlq $0xc, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x3, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
cmpl $0xf5, %eax
jge 0x5bef4
movq -0x18(%rbp), %rax
addq $0x4, %rax
cmpq -0x20(%rbp), %rax
jbe 0x5be25
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x5bf03
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x5be8f
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x5be8f
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x5be8f
movzbl -0x21(%rbp), %eax
cmpl $0xf1, %eax
jge 0x5be75
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x90, %eax
jl 0x5be8f
movzbl -0x21(%rbp), %eax
cmpl $0xf3, %eax
jle 0x5be98
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x8f, %eax
jle 0x5be98
movl $0x0, -0x4(%rbp)
jmp 0x5bf03
movzbl -0x21(%rbp), %eax
andl $0x7, %eax
movslq %eax, %rcx
shlq $0x12, %rcx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0xc, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cltq
shlq $0x6, %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cltq
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x5bf03
jmp 0x5bef6
jmp 0x5bef8
jmp 0x5befa
jmp 0x5befc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_mb_wc_utf8mb4_quick:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_5BC86
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_5BF03
loc_5BC86:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 80h
jge short loc_5BCB3
movzx eax, [rbp+var_21]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 1
jmp loc_5BF03
loc_5BCB3:
movzx eax, [rbp+var_21]
cmp eax, 0C2h
jge short loc_5BCCA
mov [rbp+var_4], 0
jmp loc_5BF03
loc_5BCCA:
movzx eax, [rbp+var_21]
cmp eax, 0E0h
jge short loc_5BD40
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_20]
jbe short loc_5BCEF
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_5BF03
loc_5BCEF:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jl short loc_5BD0D
mov [rbp+var_4], 0
jmp loc_5BF03
loc_5BD0D:
movzx eax, [rbp+var_21]
and eax, 1Fh
movsxd rcx, eax
shl rcx, 6
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 2
jmp loc_5BF03
loc_5BD40:
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge loc_5BDFC
mov rax, [rbp+var_18]
add rax, 3
cmp rax, [rbp+var_20]
jbe short loc_5BD69
mov [rbp+var_4], 0FFFFFF99h
jmp loc_5BF03
loc_5BD69:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_5BDA7
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_5BDA7
movzx eax, [rbp+var_21]
cmp eax, 0E1h
jge short loc_5BDB3
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 0A0h
jge short loc_5BDB3
loc_5BDA7:
mov [rbp+var_4], 0
jmp loc_5BF03
loc_5BDB3:
movzx eax, [rbp+var_21]
and eax, 0Fh
movsxd rcx, eax
shl rcx, 0Ch
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 3
jmp loc_5BF03
loc_5BDFC:
movzx eax, [rbp+var_21]
cmp eax, 0F5h
jge loc_5BEF4
mov rax, [rbp+var_18]
add rax, 4
cmp rax, [rbp+var_20]
jbe short loc_5BE25
mov [rbp+var_4], 0FFFFFF98h
jmp loc_5BF03
loc_5BE25:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_5BE8F
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_5BE8F
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_5BE8F
movzx eax, [rbp+var_21]
cmp eax, 0F1h
jge short loc_5BE75
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 90h
jl short loc_5BE8F
loc_5BE75:
movzx eax, [rbp+var_21]
cmp eax, 0F3h
jle short loc_5BE98
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 8Fh
jle short loc_5BE98
loc_5BE8F:
mov [rbp+var_4], 0
jmp short loc_5BF03
loc_5BE98:
movzx eax, [rbp+var_21]
and eax, 7
movsxd rcx, eax
shl rcx, 12h
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cdqe
shl rax, 0Ch
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cdqe
shl rax, 6
or rcx, rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cdqe
or rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 4
jmp short loc_5BF03
loc_5BEF4:
jmp short $+2
loc_5BEF6:
jmp short $+2
loc_5BEF8:
jmp short $+2
loc_5BEFA:
jmp short $+2
loc_5BEFC:
mov [rbp+var_4], 0
loc_5BF03:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_mb_wc_utf8mb4_quick(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
unsigned __int8 v4; // [rsp+1h] [rbp-21h]
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( *a2 >= 0x80u )
{
if ( v4 >= 0xC2u )
{
if ( v4 >= 0xE0u )
{
if ( v4 >= 0xF0u )
{
if ( v4 >= 0xF5u )
{
return 0;
}
else if ( (unsigned long long)(a2 + 4) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64
&& (a2[2] ^ 0x80) < 64
&& (a2[3] ^ 0x80) < 64
&& (v4 >= 0xF1u || a2[1] >= 0x90u)
&& (v4 <= 0xF3u || a2[1] <= 0x8Fu) )
{
*a1 = a2[3] ^ 0x80u | ((long long)(a2[2] ^ 0x80u) << 6) | ((long long)(a2[1] ^ 0x80u) << 12) | ((unsigned long long)(v4 & 7) << 18);
return 4;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-104;
}
}
else if ( (unsigned long long)(a2 + 3) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 && (a2[2] ^ 0x80) < 64 && (v4 >= 0xE1u || a2[1] >= 0xA0u) )
{
*a1 = a2[2] ^ 0x80u | ((long long)(a2[1] ^ 0x80u) << 6) | ((unsigned long long)(v4 & 0xF) << 12);
return 3;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-103;
}
}
else if ( (unsigned long long)(a2 + 2) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64 )
{
*a1 = a2[1] ^ 0x80u | ((unsigned long long)(v4 & 0x1F) << 6);
return 2;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a1 = v4;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JC 0x0015bc86
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0015bf03
LAB_0015bc86:
MOV RAX,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x21],AL
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0x80
JGE 0x0015bcb3
MOVZX EAX,byte ptr [RBP + -0x21]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0015bf03
LAB_0015bcb3:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xc2
JGE 0x0015bcca
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015bf03
LAB_0015bcca:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe0
JGE 0x0015bd40
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0015bcef
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0015bf03
LAB_0015bcef:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JL 0x0015bd0d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015bf03
LAB_0015bd0d:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x1f
MOVSXD RCX,EAX
SHL RCX,0x6
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015bf03
LAB_0015bd40:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf0
JGE 0x0015bdfc
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0015bd69
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x0015bf03
LAB_0015bd69:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0015bda7
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0015bda7
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xe1
JGE 0x0015bdb3
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0xa0
JGE 0x0015bdb3
LAB_0015bda7:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015bf03
LAB_0015bdb3:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0xf
MOVSXD RCX,EAX
SHL RCX,0xc
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0015bf03
LAB_0015bdfc:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf5
JGE 0x0015bef4
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0015be25
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x0015bf03
LAB_0015be25:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0015be8f
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0015be8f
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CMP EAX,0x40
JGE 0x0015be8f
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf1
JGE 0x0015be75
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x90
JL 0x0015be8f
LAB_0015be75:
MOVZX EAX,byte ptr [RBP + -0x21]
CMP EAX,0xf3
JLE 0x0015be98
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x8f
JLE 0x0015be98
LAB_0015be8f:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015bf03
LAB_0015be98:
MOVZX EAX,byte ptr [RBP + -0x21]
AND EAX,0x7
MOVSXD RCX,EAX
SHL RCX,0x12
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
XOR EAX,0x80
CDQE
SHL RAX,0xc
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
XOR EAX,0x80
CDQE
SHL RAX,0x6
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
XOR EAX,0x80
CDQE
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0015bf03
LAB_0015bef4:
JMP 0x0015bef6
LAB_0015bef6:
JMP 0x0015bef8
LAB_0015bef8:
JMP 0x0015befa
LAB_0015befa:
JMP 0x0015befc
LAB_0015befc:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015bf03:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
int4 local_c;
if (param_2 < param_3) {
bVar1 = *param_2;
if (bVar1 < 0x80) {
*param_1 = (ulong)bVar1;
local_c = 1;
}
else if (bVar1 < 0xc2) {
local_c = 0;
}
else if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
local_c = 0xffffff9a;
}
else if ((param_2[1] ^ 0x80) < 0x40) {
*param_1 = (long)(int)(bVar1 & 0x1f) << 6 | (long)(int)(param_2[1] ^ 0x80);
local_c = 2;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
local_c = 0xffffff99;
}
else if ((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((0xe0 < bVar1 || (0x9f < param_2[1])))) {
*param_1 = (long)(int)(bVar1 & 0xf) << 0xc | (long)(int)(param_2[1] ^ 0x80) << 6 |
(long)(int)(param_2[2] ^ 0x80);
local_c = 3;
}
else {
local_c = 0;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
local_c = 0xffffff98;
}
else if ((((((param_2[1] ^ 0x80) < 0x40) && ((param_2[2] ^ 0x80) < 0x40)) &&
((param_2[3] ^ 0x80) < 0x40)) && ((0xf0 < bVar1 || (0x8f < param_2[1])))) &&
((bVar1 < 0xf4 || (param_2[1] < 0x90)))) {
*param_1 = (long)(int)(bVar1 & 7) << 0x12 | (long)(int)(param_2[1] ^ 0x80) << 0xc |
(long)(int)(param_2[2] ^ 0x80) << 6 | (long)(int)(param_2[3] ^ 0x80);
local_c = 4;
}
else {
local_c = 0;
}
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
52,333 | my_mb_wc_utf8mb4_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0x4782f
movzbl (%rsi), %ecx
testb %cl, %cl
js 0x47828
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0x4782f
cmpb $-0x3e, %cl
jae 0x47831
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x47867
leaq 0x2(%rsi), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %r8
ja 0x4782f
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
movl $0x0, %eax
cmpb $0x3f, %dl
ja 0x4782f
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0x47823
cmpb $-0x11, %cl
ja 0x478c9
leaq 0x3(%rsi), %r8
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %r8
ja 0x4782f
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0x4782d
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0x4782d
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
movl $0x0, %eax
testb %r9b, %r8b
jne 0x4782f
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0x47823
cmpb $-0xc, %cl
ja 0x4782d
leaq 0x4(%rsi), %r8
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %r8
ja 0x4782f
movzbl 0x1(%rsi), %r8d
cmpb $-0x41, %r8b
jg 0x4782d
movzbl 0x2(%rsi), %edx
cmpb $-0x41, %dl
jg 0x4782d
movzbl 0x3(%rsi), %esi
cmpb $-0x41, %sil
jg 0x4782d
cmpl $0xf0, %ecx
sete %al
cmpb $-0x70, %r8b
setb %r9b
testb %r9b, %al
jne 0x4782d
cmpl $0xf4, %ecx
sete %r9b
cmpb $-0x70, %r8b
setae %r10b
movl $0x0, %eax
testb %r10b, %r9b
jne 0x4782f
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r8d
shll $0xc, %r8d
orl %ecx, %r8d
andl $0x3f, %edx
shll $0x6, %edx
orl %r8d, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x4, %eax
jmp 0x478c1
| my_mb_wc_utf8mb4_quick:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_4782F
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_47828
mov eax, 1
loc_47823:
mov [rdi], rcx
jmp short loc_4782F
loc_47828:
cmp cl, 0C2h
jnb short loc_47831
loc_4782D:
xor eax, eax
loc_4782F:
pop rbp
retn
loc_47831:
cmp cl, 0DFh
ja short loc_47867
lea r8, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp r8, rdx
ja short loc_4782F
movzx edx, byte ptr [rsi+1]
xor edx, 80h
mov eax, 0
cmp dl, 3Fh ; '?'
ja short loc_4782F
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_47823
loc_47867:
cmp cl, 0EFh
ja short loc_478C9
lea r8, [rsi+3]
mov eax, 0FFFFFF99h
cmp r8, rdx
ja short loc_4782F
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_4782D
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_4782D
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
mov eax, 0
test r8b, r9b
jnz short loc_4782F
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
loc_478C1:
mov rcx, rsi
jmp loc_47823
loc_478C9:
cmp cl, 0F4h
ja loc_4782D
lea r8, [rsi+4]
mov eax, 0FFFFFF98h
cmp r8, rdx
ja loc_4782F
movzx r8d, byte ptr [rsi+1]
cmp r8b, 0BFh
jg loc_4782D
movzx edx, byte ptr [rsi+2]
cmp dl, 0BFh
jg loc_4782D
movzx esi, byte ptr [rsi+3]
cmp sil, 0BFh
jg loc_4782D
cmp ecx, 0F0h
setz al
cmp r8b, 90h
setb r9b
test al, r9b
jnz loc_4782D
cmp ecx, 0F4h
setz r9b
cmp r8b, 90h
setnb r10b
mov eax, 0
test r9b, r10b
jnz loc_4782F
and ecx, 7
shl ecx, 12h
and r8d, 3Fh
shl r8d, 0Ch
or r8d, ecx
and edx, 3Fh
shl edx, 6
or edx, r8d
and esi, 3Fh
or rsi, rdx
mov eax, 4
jmp loc_478C1
| long long my_mb_wc_utf8mb4_quick(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rcx
char v5; // dl
char v6; // si
unsigned long long v7; // rsi
char v8; // r8
char v9; // dl
char v10; // si
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (v4 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_4:
*a1 = v4;
return result;
}
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
if ( (unsigned __int8)v4 > 0xEFu )
{
if ( (unsigned __int8)v4 <= 0xF4u )
{
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v8 = a2[1];
if ( v8 <= -65 )
{
v9 = a2[2];
if ( v9 <= -65 )
{
v10 = a2[3];
if ( v10 <= -65 && ((unsigned __int8)v8 >= 0x90u || (_DWORD)v4 != 240) )
{
result = 0LL;
if ( (unsigned __int8)v8 >= 0x90u && (_DWORD)v4 == 244 )
return result;
v7 = ((v4 & 7) << 18) | ((unsigned __int8)(v8 & 0x3F) << 12) | ((unsigned __int8)(v9 & 0x3F) << 6) | v10 & 0x3F;
result = 4LL;
LABEL_18:
v4 = v7;
goto LABEL_4;
}
}
}
}
}
else
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v5 = a2[1];
if ( v5 <= -65 )
{
v6 = a2[2];
if ( v6 <= -65 )
{
result = 0LL;
if ( (unsigned __int8)v5 < 0xA0u && (_DWORD)v4 == 224 )
return result;
v7 = (unsigned __int16)((_WORD)v4 << 12) | ((unsigned __int8)(v5 & 0x3F) << 6) | (unsigned long long)(v6 & 0x3F);
result = 3LL;
goto LABEL_18;
}
}
}
return 0LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
{
result = 0LL;
if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v4 = a2[1] ^ 0x80 | ((unsigned __int8)(v4 & 0x1F) << 6);
result = 2LL;
goto LABEL_4;
}
}
return result;
}
| my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x0014782f
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x00147828
MOV EAX,0x1
LAB_00147823:
MOV qword ptr [RDI],RCX
JMP 0x0014782f
LAB_00147828:
CMP CL,0xc2
JNC 0x00147831
LAB_0014782d:
XOR EAX,EAX
LAB_0014782f:
POP RBP
RET
LAB_00147831:
CMP CL,0xdf
JA 0x00147867
LEA R8,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP R8,RDX
JA 0x0014782f
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
MOV EAX,0x0
CMP DL,0x3f
JA 0x0014782f
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x00147823
LAB_00147867:
CMP CL,0xef
JA 0x001478c9
LEA R8,[RSI + 0x3]
MOV EAX,0xffffff99
CMP R8,RDX
JA 0x0014782f
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x0014782d
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x0014782d
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
MOV EAX,0x0
TEST R8B,R9B
JNZ 0x0014782f
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
LAB_001478c1:
MOV RCX,RSI
JMP 0x00147823
LAB_001478c9:
CMP CL,0xf4
JA 0x0014782d
LEA R8,[RSI + 0x4]
MOV EAX,0xffffff98
CMP R8,RDX
JA 0x0014782f
MOVZX R8D,byte ptr [RSI + 0x1]
CMP R8B,0xbf
JG 0x0014782d
MOVZX EDX,byte ptr [RSI + 0x2]
CMP DL,0xbf
JG 0x0014782d
MOVZX ESI,byte ptr [RSI + 0x3]
CMP SIL,0xbf
JG 0x0014782d
CMP ECX,0xf0
SETZ AL
CMP R8B,0x90
SETC R9B
TEST AL,R9B
JNZ 0x0014782d
CMP ECX,0xf4
SETZ R9B
CMP R8B,0x90
SETNC R10B
MOV EAX,0x0
TEST R9B,R10B
JNZ 0x0014782f
AND ECX,0x7
SHL ECX,0x12
AND R8D,0x3f
SHL R8D,0xc
OR R8D,ECX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,R8D
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x4
JMP 0x001478c1
|
int8 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
uVar5 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (0xc1 < bVar1) {
uVar4 = (uint)bVar1;
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar5 = (ulong)((uVar4 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
goto LAB_00147823;
}
if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
bVar2 = param_2[1];
if (((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) {
if (uVar4 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc;
uVar3 = 3;
LAB_001478c1:
uVar5 = (ulong)uVar4;
goto LAB_00147823;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar1 = param_2[1];
if (((((char)bVar1 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) &&
(uVar4 != 0xf0 || 0x8f < bVar1)) {
if (uVar4 == 0xf4 && 0x8f < bVar1) {
return 0;
}
uVar4 = param_2[3] & 0x3f |
(param_2[2] & 0x3f) << 6 | (bVar1 & 0x3f) << 0xc | (uVar4 & 7) << 0x12;
uVar3 = 4;
goto LAB_001478c1;
}
}
}
uVar3 = 0;
}
else {
uVar3 = 1;
LAB_00147823:
*param_1 = uVar5;
}
return uVar3;
}
| |
52,334 | check_mb_ujis | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_ujis(const char *start, const char *end)
{
if (*(uchar*)start < 0x80) {
return 0; /* invalid ujis character */
}
if (valid_ujis(*(start)) && valid_ujis(*((start)+1))) {
return 2;
}
if (valid_ujis_ss2(*(start)) && valid_ujis_kata(*((start)+1))) {
return 2;
}
if (valid_ujis_ss3(*(start)) && (end-start) > 2 && valid_ujis(*((start)+1)) && valid_ujis(*((start)+2))) {
return 3;
}
return 0;
} | O0 | c | check_mb_ujis:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x80, %eax
jge 0x5d886
movl $0x0, -0x4(%rbp)
jmp 0x5d9ba
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
andl $0xff, %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x5d8e6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5d8e6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
andl $0xff, %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x5d8e6
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5d8e6
movl $0x2, -0x4(%rbp)
jmp 0x5d9ba
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0x8e, %eax
jne 0x5d930
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
andl $0xff, %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x5d930
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xdf, %eax
jg 0x5d930
movl $0x2, -0x4(%rbp)
jmp 0x5d9ba
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0xff, %eax
cmpl $0x8f, %eax
jne 0x5d9b3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jle 0x5d9b3
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %ecx
andl $0xff, %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x5d9b3
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5d9b3
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %ecx
andl $0xff, %ecx
movl $0xa1, %eax
cmpl %ecx, %eax
jg 0x5d9b3
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
andl $0xff, %eax
cmpl $0xfe, %eax
jg 0x5d9b3
movl $0x3, -0x4(%rbp)
jmp 0x5d9ba
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
| check_mb_ujis:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp eax, 80h
jge short loc_5D886
mov [rbp+var_4], 0
jmp loc_5D9BA
loc_5D886:
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax]
and ecx, 0FFh
mov eax, 0A1h
cmp eax, ecx
jg short loc_5D8E6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5D8E6
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax+1]
and ecx, 0FFh
mov eax, 0A1h
cmp eax, ecx
jg short loc_5D8E6
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5D8E6
mov [rbp+var_4], 2
jmp loc_5D9BA
loc_5D8E6:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 8Eh
jnz short loc_5D930
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax+1]
and ecx, 0FFh
mov eax, 0A1h
cmp eax, ecx
jg short loc_5D930
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0DFh
jg short loc_5D930
mov [rbp+var_4], 2
jmp loc_5D9BA
loc_5D930:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
and eax, 0FFh
cmp eax, 8Fh
jnz short loc_5D9B3
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
cmp rax, 2
jle short loc_5D9B3
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax+1]
and ecx, 0FFh
mov eax, 0A1h
cmp eax, ecx
jg short loc_5D9B3
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5D9B3
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax+2]
and ecx, 0FFh
mov eax, 0A1h
cmp eax, ecx
jg short loc_5D9B3
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+2]
and eax, 0FFh
cmp eax, 0FEh
jg short loc_5D9B3
mov [rbp+var_4], 3
jmp short loc_5D9BA
loc_5D9B3:
mov [rbp+var_4], 0
loc_5D9BA:
mov eax, [rbp+var_4]
pop rbp
retn
| long long check_mb_ujis(unsigned __int8 *a1, long long a2)
{
if ( *a1 >= 0x80u )
{
if ( *a1 < 0xA1u || *a1 == 255 || a1[1] < 0xA1u || a1[1] == 255 )
{
if ( *a1 == 142 && a1[1] >= 0xA1u && a1[1] <= 0xDFu )
{
return 2;
}
else if ( *a1 != 143 || a2 - (long long)a1 <= 2 || a1[1] < 0xA1u || a1[1] == 255 || a1[2] < 0xA1u || a1[2] == 255 )
{
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 0;
}
}
| check_mb_ujis:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JGE 0x0015d886
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015d9ba
LAB_0015d886:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX]
AND ECX,0xff
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0015d8e6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015d8e6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX + 0x1]
AND ECX,0xff
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0015d8e6
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015d8e6
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015d9ba
LAB_0015d8e6:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0x8e
JNZ 0x0015d930
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX + 0x1]
AND ECX,0xff
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0015d930
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xdf
JG 0x0015d930
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015d9ba
LAB_0015d930:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
AND EAX,0xff
CMP EAX,0x8f
JNZ 0x0015d9b3
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
CMP RAX,0x2
JLE 0x0015d9b3
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX + 0x1]
AND ECX,0xff
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0015d9b3
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015d9b3
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX + 0x2]
AND ECX,0xff
MOV EAX,0xa1
CMP EAX,ECX
JG 0x0015d9b3
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x2]
AND EAX,0xff
CMP EAX,0xfe
JG 0x0015d9b3
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0015d9ba
LAB_0015d9b3:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015d9ba:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 check_mb_ujis(byte *param_1,long param_2)
{
int4 local_c;
if (*param_1 < 0x80) {
local_c = 0;
}
else if ((((*param_1 < 0xa1) || (0xfe < *param_1)) || (param_1[1] < 0xa1)) || (0xfe < param_1[1]))
{
if (((*param_1 == 0x8e) && (0xa0 < param_1[1])) && (param_1[1] < 0xe0)) {
local_c = 2;
}
else if (((*param_1 == 0x8f) && (2 < param_2 - (long)param_1)) &&
((0xa0 < param_1[1] &&
(((param_1[1] < 0xff && (0xa0 < param_1[2])) && (param_1[2] < 0xff)))))) {
local_c = 3;
}
else {
local_c = 0;
}
}
else {
local_c = 2;
}
return local_c;
}
| |
52,335 | translog_new_page_header | eloqsql/storage/maria/ma_loghandler.c | static void translog_new_page_header(TRANSLOG_ADDRESS *horizon,
struct st_buffer_cursor *cursor)
{
uchar *ptr;
DBUG_ENTER("translog_new_page_header");
DBUG_ASSERT(cursor->ptr);
cursor->protected= 0;
ptr= cursor->ptr;
/* Page number */
int3store(ptr, LSN_OFFSET(*horizon) / TRANSLOG_PAGE_SIZE);
ptr+= 3;
/* File number */
int3store(ptr, LSN_FILE_NO(*horizon));
ptr+= 3;
DBUG_ASSERT(TRANSLOG_PAGE_FLAGS == (ptr - cursor->ptr));
cursor->ptr[TRANSLOG_PAGE_FLAGS]= (uchar) log_descriptor.flags;
ptr++;
if (log_descriptor.flags & TRANSLOG_PAGE_CRC)
{
#ifndef DBUG_OFF
DBUG_PRINT("info", ("write 0x11223344 CRC to " LSN_FMT,
LSN_IN_PARTS(*horizon)));
/* This will be overwritten by real CRC; This is just for debugging */
int4store(ptr, 0x11223344);
#endif
/* CRC will be put when page is finished */
ptr+= CRC_SIZE;
}
if (log_descriptor.flags & TRANSLOG_SECTOR_PROTECTION)
{
/*
translog_sector_randmo works like "random" values producer because
it is enough to have such "random" for this purpose and it will
not interfere with higher level pseudo random value generator
*/
ptr[0]= translog_sector_random++;
ptr+= TRANSLOG_PAGE_SIZE / DISK_DRIVE_SECTOR_SIZE;
}
{
size_t len= (ptr - cursor->ptr);
(*horizon)+= len; /* increasing the offset part of the address */
cursor->current_page_fill= (uint16)len;
if (!cursor->chaser)
cursor->buffer->size+= (translog_size_t)len;
}
cursor->ptr= ptr;
DBUG_PRINT("info", ("NewP buffer #%u: %p chaser: %d Size: %lu (%lu) "
"Horizon: " LSN_FMT,
(uint) cursor->buffer->buffer_no, cursor->buffer,
cursor->chaser, (ulong) cursor->buffer->size,
(ulong) (cursor->ptr - cursor->buffer->buffer),
LSN_IN_PARTS(*horizon)));
translog_check_cursor(cursor);
DBUG_VOID_RETURN;
} | O0 | c | translog_new_page_header:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x52b62
movq -0x10(%rbp), %rax
movb $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
shrq $0xd, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
shrq $0xd, %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq (%rcx), %rax
shrq $0xd, %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x52c31
movl 0x426791(%rip), %eax # 0x4793c8
movb %al, %cl
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movb %cl, 0x6(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl 0x426772(%rip), %eax # 0x4793c8
andl $0x1, %eax
cmpl $0x0, %eax
je 0x52c6a
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movl 0x426758(%rip), %eax # 0x4793c8
andl $0x2, %eax
cmpl $0x0, %eax
je 0x52c9a
movb 0xc27676(%rip), %cl # 0xc7a2f4
movb %cl, %al
addb $0x1, %al
movb %al, 0xc2766c(%rip) # 0xc7a2f4
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x37(%rax)
jne 0x52cee
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addl 0x100030(%rax), %ecx
movl %ecx, 0x100030(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x52cfc
movq -0x10(%rbp), %rdi
callq 0x529e0
jmp 0x52d07
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| translog_new_page_header:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_52B62:
mov rax, [rbp+var_10]
mov byte ptr [rax+38h], 0
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rbp+var_18], rax
mov rcx, [rbp+var_8]
mov rax, 0FFFFFFFFh
and rax, [rcx]
shr rax, 0Dh
mov cl, al
mov rax, [rbp+var_18]
mov [rax], cl
mov rcx, [rbp+var_8]
mov rax, 0FFFFFFFFh
and rax, [rcx]
shr rax, 0Dh
shr eax, 8
mov cl, al
mov rax, [rbp+var_18]
mov [rax+1], cl
mov rcx, [rbp+var_8]
mov rax, 0FFFFFFFFh
and rax, [rcx]
shr rax, 0Dh
shr rax, 10h
mov cl, al
mov rax, [rbp+var_18]
mov [rax+2], cl
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax]
sar rax, 20h
mov cl, al
mov rax, [rbp+var_18]
mov [rax], cl
mov rax, [rbp+var_8]
mov rax, [rax]
sar rax, 20h
shr eax, 8
mov cl, al
mov rax, [rbp+var_18]
mov [rax+1], cl
mov rax, [rbp+var_8]
mov rax, [rax]
sar rax, 20h
shr eax, 10h
mov cl, al
mov rax, [rbp+var_18]
mov [rax+2], cl
mov rax, [rbp+var_18]
add rax, 3
mov [rbp+var_18], rax
jmp short $+2
loc_52C31:
mov eax, cs:dword_4793C8
mov cl, al
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov [rax+6], cl
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov eax, cs:dword_4793C8
and eax, 1
cmp eax, 0
jz short loc_52C6A
mov rax, [rbp+var_18]
add rax, 4
mov [rbp+var_18], rax
loc_52C6A:
mov eax, cs:dword_4793C8
and eax, 2
cmp eax, 0
jz short loc_52C9A
mov cl, cs:translog_sector_random
mov al, cl
add al, 1
mov cs:translog_sector_random, al
mov rax, [rbp+var_18]
mov [rax], cl
mov rax, [rbp+var_18]
add rax, 10h
mov [rbp+var_18], rax
loc_52C9A:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rcx, [rcx+20h]
sub rax, rcx
mov [rbp+var_20], rax
mov rcx, [rbp+var_20]
mov rax, [rbp+var_8]
add rcx, [rax]
mov [rax], rcx
mov rax, [rbp+var_20]
mov cx, ax
mov rax, [rbp+var_10]
mov [rax+30h], cx
mov rax, [rbp+var_10]
cmp byte ptr [rax+37h], 0
jnz short loc_52CEE
mov rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_10]
mov rax, [rax+28h]
add ecx, dword ptr ds:loc_100030[rax]
mov dword ptr ds:loc_100030[rax], ecx
loc_52CEE:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+20h], rcx
jmp short $+2
loc_52CFC:
mov rdi, [rbp+var_10]
call translog_check_cursor
jmp short $+2
loc_52D07:
add rsp, 20h
pop rbp
retn
| void translog_new_page_header(_QWORD *a1, long long a2)
{
char v2; // cl
char *v3; // [rsp+0h] [rbp-20h]
_BYTE *v4; // [rsp+8h] [rbp-18h]
char *v5; // [rsp+8h] [rbp-18h]
*(_BYTE *)(a2 + 56) = 0;
v4 = *(_BYTE **)(a2 + 32);
*v4 = (unsigned long long)(unsigned int)*a1 >> 13;
v4[1] = (unsigned int)*a1 >> 21;
v4[2] = (unsigned long long)(unsigned int)*a1 >> 29;
v4 += 3;
*(_WORD *)v4 = WORD2(*a1);
v4[2] = BYTE6(*a1);
*(_BYTE *)(*(_QWORD *)(a2 + 32) + 6LL) = dword_4793C8;
v5 = v4 + 4;
if ( (dword_4793C8 & 1) != 0 )
v5 += 4;
if ( (dword_4793C8 & 2) != 0 )
{
v2 = translog_sector_random++;
*v5 = v2;
v5 += 16;
}
v3 = &v5[-*(_QWORD *)(a2 + 32)];
*a1 += v3;
*(_WORD *)(a2 + 48) = (_WORD)v3;
if ( !*(_BYTE *)(a2 + 55) )
*(_DWORD *)((char *)&loc_100030 + *(_QWORD *)(a2 + 40)) += (_DWORD)v3;
*(_QWORD *)(a2 + 32) = v5;
translog_check_cursor();
}
| translog_new_page_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x00152b62
LAB_00152b62:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
SHR RAX,0xd
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
SHR RAX,0xd
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x1],CL
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX]
SHR RAX,0xd
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
SAR RAX,0x20
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x3
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00152c31
LAB_00152c31:
MOV EAX,dword ptr [0x005793c8]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV byte ptr [RAX + 0x6],CL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [0x005793c8]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00152c6a
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
MOV qword ptr [RBP + -0x18],RAX
LAB_00152c6a:
MOV EAX,dword ptr [0x005793c8]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00152c9a
MOV CL,byte ptr [0x00d7a2f4]
MOV AL,CL
ADD AL,0x1
MOV byte ptr [0x00d7a2f4],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x10
MOV qword ptr [RBP + -0x18],RAX
LAB_00152c9a:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x8]
ADD RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV word ptr [RAX + 0x30],CX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x37],0x0
JNZ 0x00152cee
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
ADD ECX,dword ptr [RAX + 0x100030]
MOV dword ptr [RAX + 0x100030],ECX
LAB_00152cee:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x00152cfc
LAB_00152cfc:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001529e0
JMP 0x00152d07
LAB_00152d07:
ADD RSP,0x20
POP RBP
RET
|
void translog_new_page_header(ulong *param_1,long param_2)
{
int1 *puVar1;
char cVar2;
long lVar3;
char *local_20;
*(int1 *)(param_2 + 0x38) = 0;
puVar1 = *(int1 **)(param_2 + 0x20);
*puVar1 = (char)((*param_1 & 0xffffffff) >> 0xd);
puVar1[1] = (char)(((*param_1 & 0xffffffff) >> 0xd) >> 8);
puVar1[2] = (char)(((*param_1 & 0xffffffff) >> 0xd) >> 0x10);
puVar1[3] = (char)(*param_1 >> 0x20);
puVar1[4] = (char)(*param_1 >> 0x28);
puVar1[5] = (char)(*param_1 >> 0x30);
*(char *)(*(long *)(param_2 + 0x20) + 6) = (char)DAT_005793c8;
local_20 = puVar1 + 7;
if ((DAT_005793c8 & 1) != 0) {
local_20 = puVar1 + 0xb;
}
if ((DAT_005793c8 & 2) != 0) {
cVar2 = translog_sector_random + '\x01';
*local_20 = translog_sector_random;
translog_sector_random = cVar2;
local_20 = local_20 + 0x10;
}
lVar3 = (long)local_20 - *(long *)(param_2 + 0x20);
*param_1 = lVar3 + *param_1;
*(short *)(param_2 + 0x30) = (short)lVar3;
if (*(char *)(param_2 + 0x37) == '\0') {
*(int *)(Elf64_Ehdr_00100000.e_ident_pad + *(long *)(param_2 + 0x28) + 0x27) =
(int)lVar3 + *(int *)(Elf64_Ehdr_00100000.e_ident_pad + *(long *)(param_2 + 0x28) + 0x27);
}
*(char **)(param_2 + 0x20) = local_20;
translog_check_cursor(param_2);
return;
}
| |
52,336 | psi_rwlock_trywrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_trywrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_TRYWRITELOCK, file, line);
int result= rw_trywrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O3 | c | psi_rwlock_trywrlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x360e04(%rip), %r15 # 0x390ed8
movq (%r15), %rax
movq 0x90(%rdi), %rsi
leaq -0x48(%rbp), %rdi
pushq $0x3
popq %rdx
callq *0x1b0(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0xab763
movl %eax, %r14d
testq %rbx, %rbx
je 0x3010d
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1b8(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_rwlock_trywrlock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+90h]
lea rdi, [rbp+var_48]
push 3
pop rdx
call qword ptr [rax+1B0h]
mov rbx, rax
mov rdi, r14
call my_rw_trywrlock
mov r14d, eax
test rbx, rbx
jz short loc_3010D
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1B8h]
loc_3010D:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_rwlock_trywrlock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[54])(
v6,
*(_QWORD *)(a1 + 144),
3LL,
a2,
a3);
v4 = my_rw_trywrlock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[55])(v3, v4);
return v4;
}
| psi_rwlock_trywrlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x490ed8]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x90]
LEA RDI,[RBP + -0x48]
PUSH 0x3
POP RDX
CALL qword ptr [RAX + 0x1b0]
MOV RBX,RAX
MOV RDI,R14
CALL 0x001ab763
MOV R14D,EAX
TEST RBX,RBX
JZ 0x0013010d
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1b8]
LAB_0013010d:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 psi_rwlock_trywrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),3,param_2,param_3);
uVar1 = my_rw_trywrlock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
52,337 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> insert( const value_type& value )
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, value.first))
{
return {it, false};
}
}
Container::push_back(value);
return {--this->end(), true};
} | O3 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %rbp
cmpq %rbp, %rbx
je 0x7c1d4
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, 0x8(%rbx)
jne 0x7c1cb
testq %r13, %r13
je 0x7c1eb
movq (%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x186e0
testl %eax, %eax
je 0x7c1eb
addq $0x30, %rbx
cmpq %rbp, %rbx
jne 0x7c1ae
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c200
movq 0x8(%r14), %rbx
addq $-0x30, %rbx
movb $0x1, %dl
jmp 0x7c1ed
xorl %edx, %edx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
mov rbp, [rdi+8]
cmp rbx, rbp
jz short loc_7C1D4
mov r12, [r15]
mov r13, [r15+8]
loc_7C1AE:
cmp [rbx+8], r13
jnz short loc_7C1CB
test r13, r13
jz short loc_7C1EB
mov rdi, [rbx]
mov rsi, r12
mov rdx, r13
call _bcmp
test eax, eax
jz short loc_7C1EB
loc_7C1CB:
add rbx, 30h ; '0'
cmp rbx, rbp
jnz short loc_7C1AE
loc_7C1D4:
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE9push_backERKSG_; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::push_back(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFD0h
mov dl, 1
jmp short loc_7C1ED
loc_7C1EB:
xor edx, edx
loc_7C1ED:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::insert(
_QWORD *a1,
long long *a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // rbp
long long v4; // r12
long long v5; // r13
v2 = (_QWORD *)*a1;
v3 = (_QWORD *)a1[1];
if ( (_QWORD *)*a1 == v3 )
{
LABEL_7:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::push_back(
a1,
a2);
return a1[1] - 48LL;
}
else
{
v4 = *a2;
v5 = a2[1];
while ( v2[1] != v5 || v5 && (unsigned int)bcmp(*v2, v4, v5) )
{
v2 += 6;
if ( v2 == v3 )
goto LABEL_7;
}
}
return (long long)v2;
}
| insert:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP RBX,RBP
JZ 0x0017c1d4
MOV R12,qword ptr [R15]
MOV R13,qword ptr [R15 + 0x8]
LAB_0017c1ae:
CMP qword ptr [RBX + 0x8],R13
JNZ 0x0017c1cb
TEST R13,R13
JZ 0x0017c1eb
MOV RDI,qword ptr [RBX]
MOV RSI,R12
MOV RDX,R13
CALL 0x001186e0
TEST EAX,EAX
JZ 0x0017c1eb
LAB_0017c1cb:
ADD RBX,0x30
CMP RBX,RBP
JNZ 0x0017c1ae
LAB_0017c1d4:
MOV RDI,R14
MOV RSI,R15
CALL 0x0017c200
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x30
MOV DL,0x1
JMP 0x0017c1ed
LAB_0017c1eb:
XOR EDX,EDX
LAB_0017c1ed:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::insert(std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > const&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::insert(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,pair *param_1)
{
int8 *puVar1;
void *__s2;
size_t __n;
int iVar2;
int8 extraout_RDX;
int8 uVar3;
int8 *puVar4;
int1 auVar5 [16];
puVar4 = *(int8 **)this;
puVar1 = *(int8 **)(this + 8);
if (puVar4 != puVar1) {
__s2 = *(void **)param_1;
__n = *(size_t *)(param_1 + 8);
do {
if (puVar4[1] == __n) {
if (__n != 0) {
iVar2 = bcmp((void *)*puVar4,__s2,__n);
if (iVar2 != 0) goto LAB_0017c1cb;
}
uVar3 = 0;
goto LAB_0017c1ed;
}
LAB_0017c1cb:
puVar4 = puVar4 + 6;
} while (puVar4 != puVar1);
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::push_back((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,param_1);
puVar4 = (int8 *)(*(long *)(this + 8) + -0x30);
uVar3 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0017c1ed:
auVar5._8_8_ = uVar3;
auVar5._0_8_ = puVar4;
return auVar5;
}
| |
52,338 | pfs_set_thread_account_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_set_thread_account_v1(const char *user, int user_len,
const char *host, int host_len)
{
pfs_dirty_state dirty_state;
PFS_thread *pfs= my_thread_get_THR_PFS();
assert((user != NULL) || (user_len == 0));
assert(user_len >= 0);
assert((uint) user_len <= sizeof(pfs->m_username));
assert((host != NULL) || (host_len == 0));
assert(host_len >= 0);
host_len= MY_MIN(host_len, static_cast<int>(sizeof(pfs->m_hostname)));
if (unlikely(pfs == NULL))
return;
pfs->m_session_lock.allocated_to_dirty(& dirty_state);
clear_thread_account(pfs);
if (host_len > 0)
memcpy(pfs->m_hostname, host, host_len);
pfs->m_hostname_length= host_len;
if (user_len > 0)
memcpy(pfs->m_username, user, user_len);
pfs->m_username_length= user_len;
set_thread_account(pfs);
bool enabled;
bool history;
if (pfs->m_account != NULL)
{
enabled= pfs->m_account->m_enabled;
history= pfs->m_account->m_history;
}
else
{
if ((pfs->m_username_length > 0) && (pfs->m_hostname_length > 0))
{
lookup_setup_actor(pfs,
pfs->m_username, pfs->m_username_length,
pfs->m_hostname, pfs->m_hostname_length,
&enabled, &history);
}
else
{
/* There is no setting for background threads */
enabled= true;
history= true;
}
}
pfs->set_enabled(enabled);
pfs->set_history(history);
pfs->m_session_lock.dirty_to_allocated(& dirty_state);
} | O0 | cpp | pfs_set_thread_account_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x48dd0
movq %rax, -0x28(%rbp)
cmpl $0xff, -0x1c(%rbp)
jge 0x49a80
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x49a8a
movl $0xff, %eax
movl %eax, -0x30(%rbp)
jmp 0x49a8a
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x49aa7
jmp 0x49bfb
movq -0x28(%rbp), %rdi
addq $0xcd8, %rdi # imm = 0xCD8
leaq -0x20(%rbp), %rsi
callq 0x51a40
movq -0x28(%rbp), %rdi
callq 0x3cf30
cmpl $0x0, -0x1c(%rbp)
jle 0x49ae2
movq -0x28(%rbp), %rdi
addq $0xe60, %rdi # imm = 0xE60
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x26280
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xf60(%rax)
cmpl $0x0, -0xc(%rbp)
jle 0x49b0d
movq -0x28(%rbp), %rdi
addq $0xcdc, %rdi # imm = 0xCDC
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x26280
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xe5c(%rax)
movq -0x28(%rbp), %rdi
callq 0x3a6a0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x1620(%rax)
je 0x49b5f
movq -0x28(%rbp), %rax
movq 0x1620(%rax), %rax
movb 0xa6c(%rax), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movq 0x1620(%rax), %rax
movb 0xa6d(%rax), %al
andb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x49bc5
movq -0x28(%rbp), %rax
cmpl $0x0, 0xe5c(%rax)
jbe 0x49bbb
movq -0x28(%rbp), %rax
cmpl $0x0, 0xf60(%rax)
jbe 0x49bbb
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xcdc, %rsi # imm = 0xCDC
movq -0x28(%rbp), %rax
movl 0xe5c(%rax), %edx
movq -0x28(%rbp), %rcx
addq $0xe60, %rcx # imm = 0xE60
movq -0x28(%rbp), %rax
movl 0xf60(%rax), %r8d
leaq -0x29(%rbp), %r9
leaq -0x2a(%rbp), %rax
movq %rax, (%rsp)
callq 0x45290
jmp 0x49bc3
movb $0x1, -0x29(%rbp)
movb $0x1, -0x2a(%rbp)
jmp 0x49bc5
movq -0x28(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3f630
movq -0x28(%rbp), %rdi
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3f660
movq -0x28(%rbp), %rdi
addq $0xcd8, %rdi # imm = 0xCD8
leaq -0x20(%rbp), %rsi
callq 0x30e60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pfs_set_thread_account_v1:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_28], rax
cmp [rbp+var_1C], 0FFh
jge short loc_49A80
mov eax, [rbp+var_1C]
mov [rbp+var_30], eax
jmp short loc_49A8A
loc_49A80:
mov eax, 0FFh
mov [rbp+var_30], eax
jmp short $+2
loc_49A8A:
mov eax, [rbp+var_30]
mov [rbp+var_1C], eax
cmp [rbp+var_28], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_49AA7
jmp loc_49BFB
loc_49AA7:
mov rdi, [rbp+var_28]
add rdi, 0CD8h
lea rsi, [rbp+var_20]
call _ZN8pfs_lock18allocated_to_dirtyEP15pfs_dirty_state; pfs_lock::allocated_to_dirty(pfs_dirty_state *)
mov rdi, [rbp+var_28]; PFS_thread *
call _Z20clear_thread_accountP10PFS_thread; clear_thread_account(PFS_thread *)
cmp [rbp+var_1C], 0
jle short loc_49AE2
mov rdi, [rbp+var_28]
add rdi, 0E60h
mov rsi, [rbp+var_18]
movsxd rdx, [rbp+var_1C]
call _memcpy
loc_49AE2:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_28]
mov [rax+0F60h], ecx
cmp [rbp+var_C], 0
jle short loc_49B0D
mov rdi, [rbp+var_28]
add rdi, 0CDCh
mov rsi, [rbp+var_8]
movsxd rdx, [rbp+var_C]
call _memcpy
loc_49B0D:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_28]
mov [rax+0E5Ch], ecx
mov rdi, [rbp+var_28]; PFS_thread *
call _Z18set_thread_accountP10PFS_thread; set_thread_account(PFS_thread *)
mov rax, [rbp+var_28]
cmp qword ptr [rax+1620h], 0
jz short loc_49B5F
mov rax, [rbp+var_28]
mov rax, [rax+1620h]
mov al, [rax+0A6Ch]
and al, 1
mov [rbp+var_29], al
mov rax, [rbp+var_28]
mov rax, [rax+1620h]
mov al, [rax+0A6Dh]
and al, 1
mov [rbp+var_2A], al
jmp short loc_49BC5
loc_49B5F:
mov rax, [rbp+var_28]
cmp dword ptr [rax+0E5Ch], 0
jbe short loc_49BBB
mov rax, [rbp+var_28]
cmp dword ptr [rax+0F60h], 0
jbe short loc_49BBB
mov rdi, [rbp+var_28]; PFS_thread *
mov rsi, [rbp+var_28]
add rsi, 0CDCh; char *
mov rax, [rbp+var_28]
mov edx, [rax+0E5Ch]; unsigned int
mov rcx, [rbp+var_28]
add rcx, 0E60h; char *
mov rax, [rbp+var_28]
mov r8d, [rax+0F60h]; unsigned int
lea r9, [rbp+var_29]; bool *
lea rax, [rbp+var_2A]
mov [rsp+40h+var_40], rax; bool *
call _Z18lookup_setup_actorP10PFS_threadPKcjS2_jPbS3_; lookup_setup_actor(PFS_thread *,char const*,uint,char const*,uint,bool *,bool *)
jmp short loc_49BC3
loc_49BBB:
mov [rbp+var_29], 1
mov [rbp+var_2A], 1
loc_49BC3:
jmp short $+2
loc_49BC5:
mov rdi, [rbp+var_28]; this
mov al, [rbp+var_29]
and al, 1
movzx esi, al; bool
call _ZN10PFS_thread11set_enabledEb; PFS_thread::set_enabled(bool)
mov rdi, [rbp+var_28]; this
mov al, [rbp+var_2A]
and al, 1
movzx esi, al; bool
call _ZN10PFS_thread11set_historyEb; PFS_thread::set_history(bool)
mov rdi, [rbp+var_28]
add rdi, 0CD8h
lea rsi, [rbp+var_20]
call _ZN8pfs_lock18dirty_to_allocatedEPK15pfs_dirty_state; pfs_lock::dirty_to_allocated(pfs_dirty_state const*)
loc_49BFB:
add rsp, 40h
pop rbp
retn
| long long pfs_set_thread_account_v1(long long a1, int a2, long long a3, int a4)
{
long long result; // rax
unsigned int v5; // edx
int v6; // [rsp+10h] [rbp-30h]
bool v7; // [rsp+16h] [rbp-2Ah] BYREF
bool v8; // [rsp+17h] [rbp-29h] BYREF
PFS_thread *THR_PFS; // [rsp+18h] [rbp-28h]
int v10; // [rsp+20h] [rbp-20h] BYREF
int v11; // [rsp+24h] [rbp-1Ch]
long long v12; // [rsp+28h] [rbp-18h]
int v13; // [rsp+34h] [rbp-Ch]
long long v14; // [rsp+38h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a4;
THR_PFS = (PFS_thread *)my_thread_get_THR_PFS();
if ( v11 >= 255 )
v6 = 255;
else
v6 = v11;
v11 = v6;
result = THR_PFS == 0LL;
if ( THR_PFS )
{
pfs_lock::allocated_to_dirty((char *)THR_PFS + 3288, &v10);
clear_thread_account((PFS_account **)THR_PFS);
if ( v11 > 0 )
memcpy((char *)THR_PFS + 3680, v12, v11);
*((_DWORD *)THR_PFS + 984) = v11;
if ( v13 > 0 )
memcpy((char *)THR_PFS + 3292, v14, v13);
*((_DWORD *)THR_PFS + 919) = v13;
set_thread_account(THR_PFS);
if ( *((_QWORD *)THR_PFS + 708) )
{
v8 = *(_BYTE *)(*((_QWORD *)THR_PFS + 708) + 2668LL) & 1;
v7 = *(_BYTE *)(*((_QWORD *)THR_PFS + 708) + 2669LL) & 1;
}
else if ( *((_DWORD *)THR_PFS + 919) && *((_DWORD *)THR_PFS + 984) )
{
lookup_setup_actor(
THR_PFS,
(const char *)THR_PFS + 3292,
*((_DWORD *)THR_PFS + 919),
(const char *)THR_PFS + 3680,
*((_DWORD *)THR_PFS + 984),
&v8,
&v7);
}
else
{
v8 = 1;
v7 = 1;
}
PFS_thread::set_enabled(THR_PFS, v8);
PFS_thread::set_history(THR_PFS, v7);
return pfs_lock::dirty_to_allocated((PFS_thread *)((char *)THR_PFS + 3288), &v10, v5);
}
return result;
}
| pfs_set_thread_account_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
CALL 0x00148dd0
MOV qword ptr [RBP + -0x28],RAX
CMP dword ptr [RBP + -0x1c],0xff
JGE 0x00149a80
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00149a8a
LAB_00149a80:
MOV EAX,0xff
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00149a8a
LAB_00149a8a:
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x1c],EAX
CMP qword ptr [RBP + -0x28],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00149aa7
JMP 0x00149bfb
LAB_00149aa7:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xcd8
LEA RSI,[RBP + -0x20]
CALL 0x00151a40
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013cf30
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00149ae2
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xe60
MOV RSI,qword ptr [RBP + -0x18]
MOVSXD RDX,dword ptr [RBP + -0x1c]
CALL 0x00126280
LAB_00149ae2:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xf60],ECX
CMP dword ptr [RBP + -0xc],0x0
JLE 0x00149b0d
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xcdc
MOV RSI,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0xc]
CALL 0x00126280
LAB_00149b0d:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xe5c],ECX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013a6a0
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x1620],0x0
JZ 0x00149b5f
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x1620]
MOV AL,byte ptr [RAX + 0xa6c]
AND AL,0x1
MOV byte ptr [RBP + -0x29],AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x1620]
MOV AL,byte ptr [RAX + 0xa6d]
AND AL,0x1
MOV byte ptr [RBP + -0x2a],AL
JMP 0x00149bc5
LAB_00149b5f:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0xe5c],0x0
JBE 0x00149bbb
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0xf60],0x0
JBE 0x00149bbb
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0xcdc
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0xe5c]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,0xe60
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX + 0xf60]
LEA R9,[RBP + -0x29]
LEA RAX,[RBP + -0x2a]
MOV qword ptr [RSP],RAX
CALL 0x00145290
JMP 0x00149bc3
LAB_00149bbb:
MOV byte ptr [RBP + -0x29],0x1
MOV byte ptr [RBP + -0x2a],0x1
LAB_00149bc3:
JMP 0x00149bc5
LAB_00149bc5:
MOV RDI,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RBP + -0x29]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0013f630
MOV RDI,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RBP + -0x2a]
AND AL,0x1
MOVZX ESI,AL
CALL 0x0013f660
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xcd8
LEA RSI,[RBP + -0x20]
CALL 0x00130e60
LAB_00149bfb:
ADD RSP,0x40
POP RBP
RET
|
void pfs_set_thread_account_v1(void *param_1,int param_2,void *param_3,int param_4)
{
int local_38;
bool local_32;
bool local_31;
PFS_thread *local_30;
pfs_dirty_state local_28 [4];
int local_24;
void *local_20;
int local_14;
void *local_10;
local_24 = param_4;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
local_30 = (PFS_thread *)my_thread_get_THR_PFS();
if (local_24 < 0xff) {
local_38 = local_24;
}
else {
local_38 = 0xff;
}
local_24 = local_38;
if (local_30 != (PFS_thread *)0x0) {
pfs_lock::allocated_to_dirty((pfs_lock *)(local_30 + 0xcd8),local_28);
clear_thread_account(local_30);
if (0 < local_24) {
memcpy(local_30 + 0xe60,local_20,(long)local_24);
}
*(int *)(local_30 + 0xf60) = local_24;
if (0 < local_14) {
memcpy(local_30 + 0xcdc,local_10,(long)local_14);
}
*(int *)(local_30 + 0xe5c) = local_14;
set_thread_account(local_30);
if (*(long *)(local_30 + 0x1620) == 0) {
if ((*(int *)(local_30 + 0xe5c) == 0) || (*(int *)(local_30 + 0xf60) == 0)) {
local_31 = true;
local_32 = true;
}
else {
lookup_setup_actor(local_30,(char *)(local_30 + 0xcdc),*(uint *)(local_30 + 0xe5c),
(char *)(local_30 + 0xe60),*(uint *)(local_30 + 0xf60),&local_31,
&local_32);
}
}
else {
local_31 = (bool)(*(byte *)(*(long *)(local_30 + 0x1620) + 0xa6c) & 1);
local_32 = (bool)(*(byte *)(*(long *)(local_30 + 0x1620) + 0xa6d) & 1);
}
PFS_thread::set_enabled(local_30,(bool)(local_31 & 1));
PFS_thread::set_history(local_30,(bool)(local_32 & 1));
pfs_lock::dirty_to_allocated((pfs_lock *)(local_30 + 0xcd8),local_28);
}
return;
}
| |
52,339 | my_hash_sort_utf16_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf16_bin(CHARSET_INFO *cs,
const uchar *pos, size_t len, ulong *nr1, ulong *nr2)
{
size_t lengthsp= my_ci_lengthsp(cs, (const char *) pos, len);
my_hash_sort_utf16_nopad_bin(cs, pos, lengthsp, nr1, nr2);
} | O3 | c | my_hash_sort_utf16_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq 0xb8(%rdi), %rax
callq *0x18(%rax)
movq (%r14), %rcx
movq (%rbx), %rdx
testq %rax, %rax
jle 0x5bf55
addq %r15, %rax
movl %ecx, %esi
andl $0x3f, %esi
addq %rdx, %rsi
movzbl (%r15), %edi
imulq %rsi, %rdi
movq %rcx, %rsi
shlq $0x8, %rsi
addq %rdi, %rsi
xorq %rsi, %rcx
addq $0x3, %rdx
incq %r15
cmpq %rax, %r15
jb 0x5bf2c
movq %rcx, (%r14)
movq %rdx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_hash_sort_utf16_bin:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, r8
mov r14, rcx
mov r15, rsi
mov rax, [rdi+0B8h]
call qword ptr [rax+18h]
mov rcx, [r14]
mov rdx, [rbx]
test rax, rax
jle short loc_5BF55
add rax, r15
loc_5BF2C:
mov esi, ecx
and esi, 3Fh
add rsi, rdx
movzx edi, byte ptr [r15]
imul rdi, rsi
mov rsi, rcx
shl rsi, 8
add rsi, rdi
xor rcx, rsi
add rdx, 3
inc r15
cmp r15, rax
jb short loc_5BF2C
loc_5BF55:
mov [r14], rcx
mov [rbx], rdx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_hash_sort_utf16_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
unsigned __int8 *v7; // r15
long long result; // rax
long long v9; // rcx
long long v10; // rdx
v7 = a2;
result = (*(long long ( **)(long long))(*(_QWORD *)(a1 + 184) + 24LL))(a1);
v9 = *a4;
v10 = *a5;
if ( result > 0 )
{
result += (long long)a2;
do
{
v9 ^= (v10 + (v9 & 0x3F)) * *v7 + (v9 << 8);
v10 += 3LL;
++v7;
}
while ( (unsigned long long)v7 < result );
}
*a4 = v9;
*a5 = v10;
return result;
}
| my_hash_sort_utf16_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R14,RCX
MOV R15,RSI
MOV RAX,qword ptr [RDI + 0xb8]
CALL qword ptr [RAX + 0x18]
MOV RCX,qword ptr [R14]
MOV RDX,qword ptr [RBX]
TEST RAX,RAX
JLE 0x0015bf55
ADD RAX,R15
LAB_0015bf2c:
MOV ESI,ECX
AND ESI,0x3f
ADD RSI,RDX
MOVZX EDI,byte ptr [R15]
IMUL RDI,RSI
MOV RSI,RCX
SHL RSI,0x8
ADD RSI,RDI
XOR RCX,RSI
ADD RDX,0x3
INC R15
CMP R15,RAX
JC 0x0015bf2c
LAB_0015bf55:
MOV qword ptr [R14],RCX
MOV qword ptr [RBX],RDX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_hash_sort_utf16_bin
(long param_1,byte *param_2,int8 param_3,ulong *param_4,long *param_5)
{
long lVar1;
byte *pbVar2;
ulong uVar3;
long lVar4;
lVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x18))();
uVar3 = *param_4;
lVar4 = *param_5;
if (0 < lVar1) {
pbVar2 = param_2 + lVar1;
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar4);
lVar4 = lVar4 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar3;
*param_5 = lVar4;
return;
}
| |
52,340 | nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*) | ng-log[P]ng-log/src/logging.cc | LogDestination::LogDestination(LogSeverity severity, const char* base_filename)
: fileobject_(severity, base_filename), logger_(&fileobject_) {} | O3 | cpp | nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x2578c(%rip), %rax # 0x2f820
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %r14
testq %rdx, %rdx
setne 0x30(%rdi)
leaq 0x19d29(%rip), %r15 # 0x23de5
cmovneq %rdx, %r15
leaq 0x48(%rdi), %r12
movq %r12, 0x38(%rdi)
movq %r15, %rdi
callq 0x7200
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x9f14
callq 0x21a5b
leaq 0x58(%rbx), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x11b00
leaq 0x88(%rbx), %rax
movq %rax, 0x78(%rbx)
xorl %eax, %eax
movq %rax, 0x80(%rbx)
movb $0x0, 0x88(%rbx)
movq %rax, 0x98(%rbx)
movl %ebp, 0xa0(%rbx)
movaps 0x1952c(%rip), %xmm0 # 0x23650
movups %xmm0, 0xa4(%rbx)
movq %rax, 0xb8(%rbx)
callq 0x7080
movq %rax, 0xc0(%rbx)
movq %rbx, 0xc8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa154
movq %rax, %rbx
movq (%r14), %rdi
cmpq %r12, %rdi
je 0xa16b
movq (%r12), %rsi
incq %rsi
callq 0x7540
movq %rbx, %rdi
callq 0x7990
nop
| _ZN5nglog14LogDestinationC2ENS_11LogSeverityEPKc:
push rbp; Alternative name is 'nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*)'
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebp, esi
mov rbx, rdi
lea rax, off_2F820
mov [rdi], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
movups xmmword ptr [rdi+18h], xmm0
mov qword ptr [rdi+28h], 0
lea r14, [rdi+38h]
test rdx, rdx
setnz byte ptr [rdi+30h]
lea r15, asc_23DE3+2; ""
cmovnz r15, rdx
lea r12, [rdi+48h]
mov [rdi+38h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, r14; this
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
call _ZN5nglog5tools26ProgramInvocationShortNameEv; nglog::tools::ProgramInvocationShortName(void)
lea rdi, [rbx+58h]; this
lea rdx, [rsp+38h+var_29]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbx+88h]
mov [rbx+78h], rax
xor eax, eax
mov [rbx+80h], rax
mov byte ptr [rbx+88h], 0
mov [rbx+98h], rax
mov [rbx+0A0h], ebp
movaps xmm0, cs:xmmword_23650
movups xmmword ptr [rbx+0A4h], xmm0
mov [rbx+0B8h], rax
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [rbx+0C0h], rax
mov [rbx+0C8h], rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_A154:
mov rbx, rax
mov rdi, [r14]; void *
cmp rdi, r12
jz short loc_A16B
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A16B:
mov rdi, rbx
call __Unwind_Resume
| long long nglog::LogDestination::LogDestination(long long a1, int a2, char *a3)
{
nglog::tools *v3; // r14
char *v4; // r15
long long v5; // rax
long long v6; // rax
long long result; // rax
_BYTE v8[41]; // [rsp+Fh] [rbp-29h] BYREF
*(_QWORD *)a1 = off_2F820;
*(_OWORD *)(a1 + 8) = 0LL;
*(_OWORD *)(a1 + 24) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v3 = (nglog::tools *)(a1 + 56);
*(_BYTE *)(a1 + 48) = a3 != 0LL;
v4 = "";
if ( a3 )
v4 = a3;
*(_QWORD *)(a1 + 56) = a1 + 72;
v5 = strlen(v4);
std::string::_M_construct<char const*>((long long)v3, v4, (long long)&v4[v5]);
v6 = nglog::tools::ProgramInvocationShortName(v3);
std::string::basic_string<std::allocator<char>>(a1 + 88, v6, v8);
*(_QWORD *)(a1 + 120) = a1 + 136;
*(_QWORD *)(a1 + 128) = 0LL;
*(_BYTE *)(a1 + 136) = 0;
*(_QWORD *)(a1 + 152) = 0LL;
*(_DWORD *)(a1 + 160) = a2;
*(_OWORD *)(a1 + 164) = xmmword_23650;
*(_QWORD *)(a1 + 184) = 0LL;
result = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)(a1 + 88));
*(_QWORD *)(a1 + 192) = result;
*(_QWORD *)(a1 + 200) = a1;
return result;
}
| LogDestination:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBP,ESI
MOV RBX,RDI
LEA RAX,[0x12f820]
MOV qword ptr [RDI],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOV qword ptr [RDI + 0x28],0x0
LEA R14,[RDI + 0x38]
TEST RDX,RDX
SETNZ byte ptr [RDI + 0x30]
LEA R15,[0x123de5]
CMOVNZ R15,RDX
LEA R12,[RDI + 0x48]
MOV qword ptr [RDI + 0x38],R12
MOV RDI,R15
CALL 0x00107200
LEA RDX,[RAX + R15*0x1]
MOV RDI,R14
MOV RSI,R15
CALL 0x00109f14
LAB_0010a0df:
CALL 0x00121a5b
LEA RDI,[RBX + 0x58]
LAB_0010a0e8:
LEA RDX,[RSP + 0xf]
MOV RSI,RAX
CALL 0x00111b00
LAB_0010a0f5:
LEA RAX,[RBX + 0x88]
MOV qword ptr [RBX + 0x78],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x80],RAX
MOV byte ptr [RBX + 0x88],0x0
MOV qword ptr [RBX + 0x98],RAX
MOV dword ptr [RBX + 0xa0],EBP
MOVAPS XMM0,xmmword ptr [0x00123650]
MOVUPS xmmword ptr [RBX + 0xa4],XMM0
MOV qword ptr [RBX + 0xb8],RAX
CALL 0x00107080
MOV qword ptr [RBX + 0xc0],RAX
MOV qword ptr [RBX + 0xc8],RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* nglog::LogDestination::LogDestination(nglog::LogSeverity, char const*) */
void __thiscall
nglog::LogDestination::LogDestination(LogDestination *this,int4 param_2,char *param_3)
{
size_t sVar1;
char *pcVar2;
int8 uVar3;
allocator local_29;
*(int ***)this = &PTR__LogFileObject_0012f820;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
this[0x30] = (LogDestination)(param_3 != (char *)0x0);
pcVar2 = "";
if (param_3 != (char *)0x0) {
pcVar2 = param_3;
}
*(LogDestination **)(this + 0x38) = this + 0x48;
sVar1 = strlen(pcVar2);
std::__cxx11::string::_M_construct<char_const*>(this + 0x38,pcVar2,pcVar2 + sVar1);
/* try { // try from 0010a0df to 0010a0e3 has its CatchHandler @ 0010a154 */
pcVar2 = (char *)tools::ProgramInvocationShortName();
/* try { // try from 0010a0e8 to 0010a0f4 has its CatchHandler @ 0010a152 */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x58),pcVar2,&local_29);
*(LogDestination **)(this + 0x78) = this + 0x88;
*(int8 *)(this + 0x80) = 0;
this[0x88] = (LogDestination)0x0;
*(int8 *)(this + 0x98) = 0;
*(int4 *)(this + 0xa0) = param_2;
uVar3 = _UNK_00123658;
*(int8 *)(this + 0xa4) = _DAT_00123650;
*(int8 *)(this + 0xac) = uVar3;
*(int8 *)(this + 0xb8) = 0;
uVar3 = std::chrono::_V2::system_clock::now();
*(int8 *)(this + 0xc0) = uVar3;
*(LogDestination **)(this + 200) = this;
return;
}
| |
52,341 | set_prealloc_root | eloqsql/mysys/my_alloc.c | void set_prealloc_root(MEM_ROOT *root, char *ptr)
{
USED_MEM *next;
for (next=root->used; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
for (next=root->free ; next ; next=next->next)
{
if ((char*) next <= ptr && (char*) next + next->size > ptr)
{
root->pre_alloc=next;
return;
}
}
} | O3 | c | set_prealloc_root:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x5c8ee
cmpq %rsi, %rax
ja 0x5c8e9
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x5c90c
movq (%rax), %rax
jmp 0x5c8d3
movq (%rdi), %rax
testq %rax, %rax
je 0x5c910
cmpq %rsi, %rax
ja 0x5c907
movq 0x10(%rax), %rcx
addq %rax, %rcx
cmpq %rsi, %rcx
ja 0x5c90c
movq (%rax), %rax
jmp 0x5c8f1
movq %rax, 0x10(%rdi)
popq %rbp
retq
| set_prealloc_root:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
loc_5C8D3:
test rax, rax
jz short loc_5C8EE
cmp rax, rsi
ja short loc_5C8E9
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_5C90C
loc_5C8E9:
mov rax, [rax]
jmp short loc_5C8D3
loc_5C8EE:
mov rax, [rdi]
loc_5C8F1:
test rax, rax
jz short loc_5C910
cmp rax, rsi
ja short loc_5C907
mov rcx, [rax+10h]
add rcx, rax
cmp rcx, rsi
ja short loc_5C90C
loc_5C907:
mov rax, [rax]
jmp short loc_5C8F1
loc_5C90C:
mov [rdi+10h], rax
loc_5C910:
pop rbp
retn
| _QWORD * set_prealloc_root(_QWORD *a1, unsigned long long a2)
{
_QWORD *result; // rax
for ( result = (_QWORD *)a1[1]; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
{
LABEL_11:
a1[2] = result;
return result;
}
}
for ( result = (_QWORD *)*a1; result; result = (_QWORD *)*result )
{
if ( (unsigned long long)result <= a2 && (unsigned long long)result + result[2] > a2 )
goto LABEL_11;
}
return result;
}
| set_prealloc_root:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
LAB_0015c8d3:
TEST RAX,RAX
JZ 0x0015c8ee
CMP RAX,RSI
JA 0x0015c8e9
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x0015c90c
LAB_0015c8e9:
MOV RAX,qword ptr [RAX]
JMP 0x0015c8d3
LAB_0015c8ee:
MOV RAX,qword ptr [RDI]
LAB_0015c8f1:
TEST RAX,RAX
JZ 0x0015c910
CMP RAX,RSI
JA 0x0015c907
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RAX
CMP RCX,RSI
JA 0x0015c90c
LAB_0015c907:
MOV RAX,qword ptr [RAX]
JMP 0x0015c8f1
LAB_0015c90c:
MOV qword ptr [RDI + 0x10],RAX
LAB_0015c910:
POP RBP
RET
|
void set_prealloc_root(int8 *param_1,int8 *param_2)
{
int8 *puVar1;
for (puVar1 = (int8 *)param_1[1]; puVar1 != (int8 *)0x0;
puVar1 = (int8 *)*puVar1) {
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1)))
goto LAB_0015c90c;
}
puVar1 = (int8 *)*param_1;
while( true ) {
if (puVar1 == (int8 *)0x0) {
return;
}
if ((puVar1 <= param_2) && (param_2 < (int8 *)(puVar1[2] + (long)puVar1))) break;
puVar1 = (int8 *)*puVar1;
}
LAB_0015c90c:
param_1[2] = puVar1;
return;
}
| |
52,342 | blst_p2_to_affine | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e2.c | void blst_p2_to_affine(POINTonE2_affine *out, const POINTonE2 *a)
{ POINTonE2_to_affine(out, a); } | O3 | c | blst_p2_to_affine:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc0(%rsi), %rdi
leaq 0x309e3(%rip), %rsi # 0x8ccd8
movl $0x60, %edx
callq 0x70980
testq %rax, %rax
jne 0x5c319
leaq -0x138(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5c1d4
movq %r15, %r14
movl $0xc0, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22090
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| blst_p2_to_affine:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 128h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsi+0C0h]
lea rsi, BLS12_381_Rx
mov edx, 60h ; '`'
call vec_is_equal_16x
test rax, rax
jnz short loc_5C319
lea r15, [rbp+var_138]
mov rdi, r15
mov rsi, r14
call POINTonE2_from_Jacobian
mov r14, r15
loc_5C319:
mov edx, 0C0h
mov rdi, rbx
mov rsi, r14
call _memcpy
add rsp, 128h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long blst_p2_to_affine(long long a1, long long a2)
{
_BYTE v3[312]; // [rsp+8h] [rbp-138h] BYREF
if ( !vec_is_equal_16x(a2 + 192, &BLS12_381_Rx, 96LL) )
POINTonE2_from_Jacobian((long long)v3, a2);
return memcpy(a1);
}
| blst_p2_to_affine:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x128
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSI + 0xc0]
LEA RSI,[0x18ccd8]
MOV EDX,0x60
CALL 0x00170980
TEST RAX,RAX
JNZ 0x0015c319
LEA R15,[RBP + -0x138]
MOV RDI,R15
MOV RSI,R14
CALL 0x0015c1d4
MOV R14,R15
LAB_0015c319:
MOV EDX,0xc0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00122090
ADD RSP,0x128
POP RBX
POP R14
POP R15
POP RBP
RET
|
void blst_p2_to_affine(void *param_1,int1 *param_2)
{
long lVar1;
int1 *__src;
int1 local_140 [288];
lVar1 = vec_is_equal_16x(param_2 + 0xc0,&BLS12_381_Rx,0x60);
__src = param_2;
if (lVar1 == 0) {
__src = local_140;
POINTonE2_from_Jacobian(__src,param_2);
}
memcpy(param_1,__src,0xc0);
return;
}
| |
52,343 | ms3_get | eloqsql/storage/maria/libmarias3/src/marias3.c | uint8_t ms3_get(ms3_st *ms3, const char *bucket, const char *key,
uint8_t **data, size_t *length)
{
uint8_t res = 0;
struct memory_buffer_st buf;
buf.data = NULL;
buf.length = 0;
if (!ms3 || !bucket || !key || key[0] == '\0' || !data || !length)
{
return MS3_ERR_PARAMETER;
}
res = execute_request(ms3, MS3_CMD_GET, bucket, key, NULL, NULL, NULL, NULL, 0,
NULL, &buf);
*data = buf.data;
*length = buf.length;
return res;
} | O0 | c | ms3_get:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12922
cmpq $0x0, -0x18(%rbp)
je 0x12922
cmpq $0x0, -0x20(%rbp)
je 0x12922
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x12922
cmpq $0x0, -0x28(%rbp)
je 0x12922
cmpq $0x0, -0x30(%rbp)
jne 0x12928
movb $0x1, -0x1(%rbp)
jmp 0x12991
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %r9d
leaq -0x58(%rbp), %rax
movq %r9, %r8
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xa7c0
movb %al, -0x31(%rbp)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movb -0x31(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
| ms3_get:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], 0
mov [rbp+var_58], 0
mov [rbp+var_50], 0
cmp [rbp+var_10], 0
jz short loc_12922
cmp [rbp+var_18], 0
jz short loc_12922
cmp [rbp+var_20], 0
jz short loc_12922
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_12922
cmp [rbp+var_28], 0
jz short loc_12922
cmp [rbp+var_30], 0
jnz short loc_12928
loc_12922:
mov [rbp+var_1], 1
jmp short loc_12991
loc_12928:
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov esi, 3
xor eax, eax
mov r9d, eax
lea rax, [rbp+var_58]
mov r8, r9
mov [rsp+80h+var_80], 0
mov [rsp+80h+var_78], 0
mov [rsp+80h+var_70], 0
mov [rsp+80h+var_68], 0
mov [rsp+80h+var_60], rax
call _execute_request
mov [rbp+var_31], al
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rcx, [rbp+var_50]
mov rax, [rbp+var_30]
mov [rax], rcx
mov al, [rbp+var_31]
mov [rbp+var_1], al
loc_12991:
mov al, [rbp+var_1]
add rsp, 80h
pop rbp
retn
| char ms3_get(long long a1, long long a2, _BYTE *a3, _QWORD *a4, _QWORD *a5)
{
long long v6; // [rsp+28h] [rbp-58h] BYREF
long long v7; // [rsp+30h] [rbp-50h]
char v8; // [rsp+4Fh] [rbp-31h]
_QWORD *v9; // [rsp+50h] [rbp-30h]
_QWORD *v10; // [rsp+58h] [rbp-28h]
_BYTE *v11; // [rsp+60h] [rbp-20h]
long long v12; // [rsp+68h] [rbp-18h]
long long v13; // [rsp+70h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v8 = 0;
v6 = 0LL;
v7 = 0LL;
if ( !a1 || !v12 || !v11 || !*v11 || !v10 || !v9 )
return 1;
v8 = execute_request(v13, 3, v12, (_DWORD)v11, 0, 0, 0LL, 0LL, 0LL, 0LL, (long long)&v6);
*v10 = v6;
*v9 = v7;
return v8;
}
| ms3_get:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x50],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00112922
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00112922
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00112922
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00112922
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00112922
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00112928
LAB_00112922:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00112991
LAB_00112928:
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV ESI,0x3
XOR EAX,EAX
MOV R9D,EAX
LEA RAX,[RBP + -0x58]
MOV R8,R9
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],RAX
CALL 0x0010a7c0
MOV byte ptr [RBP + -0x31],AL
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
MOV AL,byte ptr [RBP + -0x31]
MOV byte ptr [RBP + -0x1],AL
LAB_00112991:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x80
POP RBP
RET
|
int1 ms3_get(long param_1,long param_2,char *param_3,int8 *param_4,int8 *param_5)
{
int8 local_60;
int8 local_58;
int1 local_39;
int8 *local_38;
int8 *local_30;
char *local_28;
long local_20;
long local_18;
int1 local_9;
local_39 = 0;
local_60 = 0;
local_58 = 0;
if ((((param_1 == 0) || (param_2 == 0)) || (param_3 == (char *)0x0)) ||
(((*param_3 == '\0' || (param_4 == (int8 *)0x0)) || (param_5 == (int8 *)0x0)))) {
local_9 = 1;
}
else {
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_9 = execute_request(param_1,3,param_2,param_3,0,0,0,0,0,0,&local_60);
*local_30 = local_60;
*local_38 = local_58;
}
return local_9;
}
| |
52,344 | my_caseup_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_toupper_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_caseup_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
testq %rdx, %rdx
jle 0x49d7d
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
leaq (%rsi,%rax), %r14
addq %r15, -0x38(%rbp)
movq %r13, %rdi
leaq -0x40(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq *-0x58(%rbp)
testl %eax, %eax
jle 0x49d7d
movl %eax, %ebx
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rax
cmpq (%rax), %rsi
ja 0x49d5f
movq 0x8(%rax), %rax
movq %rsi, %rcx
shrq $0x8, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x49d5f
movzbl %sil, %ecx
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,4), %esi
movq %rsi, -0x40(%rbp)
movq %r13, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq *-0x48(%rbp)
cmpl %eax, %ebx
jne 0x49d7d
movl %ebx, %eax
addq %rax, %r12
addq %rax, %r15
cmpq %r14, %r12
jb 0x49d19
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_caseup_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_38], r8
mov [rbp+var_30], rdx
test rdx, rdx
jle loc_49D7D
mov r15, rcx
mov r12, rsi
mov r13, rdi
mov rax, [rdi+78h]
mov [rbp+var_50], rax
mov rax, [rdi+0B8h]
mov rcx, [rax+28h]
mov [rbp+var_58], rcx
mov rax, [rax+30h]
mov [rbp+var_48], rax
mov rax, [rbp+var_30]
lea r14, [rsi+rax]
add [rbp+var_38], r15
loc_49D19:
mov rdi, r13
lea rsi, [rbp+var_40]
mov rdx, r12
mov rcx, r14
call [rbp+var_58]
test eax, eax
jle short loc_49D7D
mov ebx, eax
mov rsi, [rbp+var_40]
mov rax, [rbp+var_50]
cmp rsi, [rax]
ja short loc_49D5F
mov rax, [rax+8]
mov rcx, rsi
shr rcx, 8
mov rax, [rax+rcx*8]
test rax, rax
jz short loc_49D5F
movzx ecx, sil
lea rcx, [rcx+rcx*2]
mov esi, [rax+rcx*4]
mov [rbp+var_40], rsi
loc_49D5F:
mov rdi, r13
mov rdx, r15
mov rcx, [rbp+var_38]
call [rbp+var_48]
cmp ebx, eax
jnz short loc_49D7D
mov eax, ebx
add r12, rax
add r15, rax
cmp r12, r14
jb short loc_49D19
loc_49D7D:
mov rax, [rbp+var_30]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_caseup_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
long long v5; // r15
unsigned long long v6; // r12
long long v7; // rax
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rsi
long long v12; // rax
long long ( *v14)(long long, unsigned long long *, unsigned long long, unsigned long long); // [rsp+8h] [rbp-58h]
unsigned long long *v15; // [rsp+10h] [rbp-50h]
unsigned int ( *v16)(long long, unsigned long long, long long, long long); // [rsp+18h] [rbp-48h]
unsigned long long v17; // [rsp+20h] [rbp-40h] BYREF
long long v18; // [rsp+28h] [rbp-38h]
long long v19; // [rsp+30h] [rbp-30h]
v18 = a5;
v19 = a3;
if ( a3 > 0 )
{
v5 = a4;
v6 = a2;
v15 = *(unsigned long long **)(a1 + 120);
v7 = *(_QWORD *)(a1 + 184);
v14 = *(long long ( **)(long long, unsigned long long *, unsigned long long, unsigned long long))(v7 + 40);
v16 = *(unsigned int ( **)(long long, unsigned long long, long long, long long))(v7 + 48);
v8 = a2 + v19;
v18 += a4;
do
{
v9 = v14(a1, &v17, v6, v8);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v17;
if ( v17 <= *v15 )
{
v12 = *(_QWORD *)(v15[1] + 8 * (v17 >> 8));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v17);
v17 = v11;
}
}
if ( v10 != v16(a1, v11, v5, v18) )
break;
v6 += v10;
v5 += v10;
}
while ( v6 < v8 );
}
return v19;
}
| my_caseup_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],R8
MOV qword ptr [RBP + -0x30],RDX
TEST RDX,RDX
JLE 0x00149d7d
MOV R15,RCX
MOV R12,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RCX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RCX
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA R14,[RSI + RAX*0x1]
ADD qword ptr [RBP + -0x38],R15
LAB_00149d19:
MOV RDI,R13
LEA RSI,[RBP + -0x40]
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RBP + -0x58]
TEST EAX,EAX
JLE 0x00149d7d
MOV EBX,EAX
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x50]
CMP RSI,qword ptr [RAX]
JA 0x00149d5f
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,RSI
SHR RCX,0x8
MOV RAX,qword ptr [RAX + RCX*0x8]
TEST RAX,RAX
JZ 0x00149d5f
MOVZX ECX,SIL
LEA RCX,[RCX + RCX*0x2]
MOV ESI,dword ptr [RAX + RCX*0x4]
MOV qword ptr [RBP + -0x40],RSI
LAB_00149d5f:
MOV RDI,R13
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL qword ptr [RBP + -0x48]
CMP EBX,EAX
JNZ 0x00149d7d
MOV EAX,EBX
ADD R12,RAX
ADD R15,RAX
CMP R12,R14
JC 0x00149d19
LAB_00149d7d:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
ulong uVar1;
ulong *puVar2;
code *pcVar3;
code *pcVar4;
long lVar5;
uint uVar6;
uint uVar7;
ulong local_48;
long local_40;
long local_38;
local_38 = param_3;
if (0 < param_3) {
puVar2 = *(ulong **)(param_1 + 0x78);
pcVar3 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar4 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar1 = param_2 + param_3;
local_40 = param_5 + param_4;
do {
uVar6 = (*pcVar3)(param_1,&local_48,param_2,uVar1);
if ((int)uVar6 < 1) {
return local_38;
}
if ((local_48 <= *puVar2) && (lVar5 = *(long *)(puVar2[1] + (local_48 >> 8) * 8), lVar5 != 0))
{
local_48 = (ulong)*(uint *)(lVar5 + (local_48 & 0xff) * 0xc);
}
uVar7 = (*pcVar4)(param_1,local_48,param_4,local_40);
if (uVar6 != uVar7) {
return local_38;
}
param_2 = param_2 + uVar6;
param_4 = param_4 + (ulong)uVar6;
} while (param_2 < uVar1);
}
return local_38;
}
| |
52,345 | fill_uchar | eloqsql/strings/ctype.c | static int fill_uchar(uchar *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uchar) strtoul(b,NULL,16);
}
return 0;
} | O0 | c | fill_uchar:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x6c946
jmp 0x6c872
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x6c89e
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0xf1e4(%rip), %rdi # 0x7ba73
callq 0x240f0
cmpq $0x0, %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x6c8a7
jmp 0x6c8b7
jmp 0x6c8a9
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6c872
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x6c8ed
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0xf197(%rip), %rdi # 0x7ba73
callq 0x240f0
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x6c8f6
jmp 0x6c906
jmp 0x6c8f8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x6c8bf
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x6c918
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x6c91a
jmp 0x6c946
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x24350
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6c862
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| fill_uchar:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_6C862:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_40]
jnb loc_6C946
jmp short $+2
loc_6C872:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_6C89E
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_7BA73; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
mov [rbp+var_41], al
loc_6C89E:
mov al, [rbp+var_41]
test al, 1
jnz short loc_6C8A7
jmp short loc_6C8B7
loc_6C8A7:
jmp short $+2
loc_6C8A9:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_6C872
loc_6C8B7:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
loc_6C8BF:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_42], al
jnb short loc_6C8ED
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_7BA73; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
xor al, 0FFh
mov [rbp+var_42], al
loc_6C8ED:
mov al, [rbp+var_42]
test al, 1
jnz short loc_6C8F6
jmp short loc_6C906
loc_6C8F6:
jmp short $+2
loc_6C8F8:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_6C8BF
loc_6C906:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_6C918
mov eax, [rbp+var_24]
cmp eax, [rbp+var_C]
jbe short loc_6C91A
loc_6C918:
jmp short loc_6C946
loc_6C91A:
mov rdi, [rbp+var_38]
xor eax, eax
mov esi, eax
mov edx, 10h
call ___isoc23_strtoul
mov dl, al
mov rax, [rbp+var_8]
mov ecx, [rbp+var_24]
mov [rax+rcx], dl
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_6C862
loc_6C946:
xor eax, eax
add rsp, 50h
pop rbp
retn
| long long fill_uchar(long long a1, unsigned int a2, char *a3, long long a4)
{
char v5; // [rsp+Eh] [rbp-42h]
bool v6; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
char *v8; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned int v10; // [rsp+2Ch] [rbp-24h]
v10 = 0;
v7 = (unsigned long long)&a3[a4];
v9 = a3;
while ( (unsigned long long)v9 < v7 )
{
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v9 < v7 )
v6 = strchr(" \t\r\n", (unsigned int)*v9) != 0;
if ( !v6 )
break;
++v9;
}
v8 = v9;
while ( 1 )
{
v5 = 0;
if ( (unsigned long long)v9 < v7 )
v5 = ~(strchr(" \t\r\n", (unsigned int)*v9) != 0);
if ( (v5 & 1) == 0 )
break;
++v9;
}
if ( v9 == v8 || v10 > a2 )
break;
*(_BYTE *)(a1 + v10++) = __isoc23_strtoul(v8, 0LL, 16LL);
}
return 0LL;
}
| fill_uchar:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_0016c862:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0016c946
JMP 0x0016c872
LAB_0016c872:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x41],AL
JNC 0x0016c89e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x17ba73]
CALL 0x001240f0
CMP RAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_0016c89e:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x0016c8a7
JMP 0x0016c8b7
LAB_0016c8a7:
JMP 0x0016c8a9
LAB_0016c8a9:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0016c872
LAB_0016c8b7:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
LAB_0016c8bf:
MOV RCX,qword ptr [RBP + -0x30]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x42],AL
JNC 0x0016c8ed
MOV RAX,qword ptr [RBP + -0x30]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x17ba73]
CALL 0x001240f0
CMP RAX,0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x42],AL
LAB_0016c8ed:
MOV AL,byte ptr [RBP + -0x42]
TEST AL,0x1
JNZ 0x0016c8f6
JMP 0x0016c906
LAB_0016c8f6:
JMP 0x0016c8f8
LAB_0016c8f8:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0016c8bf
LAB_0016c906:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x0016c918
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0xc]
JBE 0x0016c91a
LAB_0016c918:
JMP 0x0016c946
LAB_0016c91a:
MOV RDI,qword ptr [RBP + -0x38]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x10
CALL 0x00124350
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x24]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0016c862
LAB_0016c946:
XOR EAX,EAX
ADD RSP,0x50
POP RBP
RET
|
int8 fill_uchar(long param_1,uint param_2,char *param_3,long param_4)
{
char *pcVar1;
int1 uVar2;
char *pcVar3;
char *pcVar4;
bool bVar5;
char *local_38;
uint local_2c;
local_2c = 0;
pcVar3 = param_3 + param_4;
local_38 = param_3;
while( true ) {
if (pcVar3 <= local_38) {
return 0;
}
while( true ) {
pcVar1 = local_38;
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 != (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
while( true ) {
bVar5 = false;
if (local_38 < pcVar3) {
pcVar4 = strchr(" \t\r\n",(int)*local_38);
bVar5 = pcVar4 == (char *)0x0;
}
if (!bVar5) break;
local_38 = local_38 + 1;
}
if (local_38 == pcVar1) break;
if (param_2 < local_2c) {
return 0;
}
uVar2 = __isoc23_strtoul(pcVar1,0,0x10);
*(int1 *)(param_1 + (ulong)local_2c) = uVar2;
local_2c = local_2c + 1;
}
return 0;
}
| |
52,346 | 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);
} | O3 | c | maria_rtree_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r12
movq $0x0, -0x30(%rbp)
movb $0x1, %al
testq %rsi, %rsi
je 0x74d4b
movq %rsi, %r15
movq %rdi, %rbx
movq 0x118(%r12), %r13
movq 0x8(%rsi), %rax
movzbl 0xa5(%rax), %r14d
movq (%r13,%r14,8), %rax
leaq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
callq 0x743be
cmpl $-0x1, %eax
movb $0x1, %al
je 0x74d4b
leaq (,%r14,8), %rdx
addq %r13, %rdx
cmpb $0x0, 0x7e7(%r12)
movq -0x38(%rbp), %rcx
je 0x74d18
leaq -0x30(%rbp), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %r8
callq 0x5a6cd
testl %eax, %eax
setne %r14b
movq (%r12), %rsi
jmp 0x74d31
movq %rcx, (%rdx)
cmpb $0x0, 0x67e(%rbx)
je 0x74d2c
movq %rbx, %rdi
callq 0x42daa
xorl %esi, %esi
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x416f0
movq 0x8(%rbx), %rax
movq $0x0, 0x90(%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| maria_rtree_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, [rdi]
mov [rbp+var_30], 0
mov al, 1
test rsi, rsi
jz loc_74D4B
mov r15, rsi
mov rbx, rdi
mov r13, [r12+118h]
mov rax, [rsi+8]
movzx r14d, byte ptr [rax+0A5h]
mov rax, [r13+r14*8+0]
lea rcx, [rbp+var_38]
mov [rcx], rax
mov edx, 0FFFFFFFFh
call maria_rtree_insert_level
cmp eax, 0FFFFFFFFh
mov al, 1
jz short loc_74D4B
lea rdx, ds:0[r14*8]
add rdx, r13
cmp byte ptr [r12+7E7h], 0
mov rcx, [rbp+var_38]
jz short loc_74D18
lea r12, [rbp+var_30]
mov rdi, rbx
mov rsi, r15
mov r8, r12
call _ma_write_undo_key_insert
test eax, eax
setnz r14b
mov rsi, [r12]
jmp short loc_74D31
loc_74D18:
mov [rdx], rcx
cmp byte ptr [rbx+67Eh], 0
jz short loc_74D2C
mov rdi, rbx
call _ma_unlock_key_del
loc_74D2C:
xor esi, esi
xor r14d, r14d
loc_74D31:
mov rdi, rbx
call _ma_unpin_all_pages
mov rax, [rbx+8]
mov qword ptr [rax+90h], 0
mov rax, r14
loc_74D4B:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char maria_rtree_insert(long long a1, long long a2)
{
long long v2; // r12
char result; // al
long long v4; // r13
long long v5; // r14
bool v6; // zf
_QWORD *v7; // rdx
bool v8; // r14
int v9; // esi
long long v10; // [rsp+8h] [rbp-38h] BYREF
_QWORD v11[6]; // [rsp+10h] [rbp-30h] BYREF
v2 = *(_QWORD *)a1;
v11[0] = 0LL;
result = 1;
if ( a2 )
{
v4 = *(_QWORD *)(v2 + 280);
v5 = *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + 165LL);
v10 = *(_QWORD *)(v4 + 8 * v5);
v6 = (unsigned int)maria_rtree_insert_level((long long *)a1, a2, 0xFFFFFFFF, &v10) == -1;
result = 1;
if ( !v6 )
{
v7 = (_QWORD *)(v4 + 8 * v5);
if ( *(_BYTE *)(v2 + 2023) )
{
v8 = (unsigned int)ma_write_undo_key_insert((long long *)a1, a2, (long long)v7, v10, (unsigned long long)v11) != 0;
v9 = v11[0];
}
else
{
*v7 = v10;
if ( *(_BYTE *)(a1 + 1662) )
ma_unlock_key_del((_BYTE *)a1);
v9 = 0;
v8 = 0;
}
ma_unpin_all_pages(a1, v9);
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 144LL) = 0LL;
return v8;
}
}
return result;
}
| maria_rtree_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,qword ptr [RDI]
MOV qword ptr [RBP + -0x30],0x0
MOV AL,0x1
TEST RSI,RSI
JZ 0x00174d4b
MOV R15,RSI
MOV RBX,RDI
MOV R13,qword ptr [R12 + 0x118]
MOV RAX,qword ptr [RSI + 0x8]
MOVZX R14D,byte ptr [RAX + 0xa5]
MOV RAX,qword ptr [R13 + R14*0x8]
LEA RCX,[RBP + -0x38]
MOV qword ptr [RCX],RAX
MOV EDX,0xffffffff
CALL 0x001743be
CMP EAX,-0x1
MOV AL,0x1
JZ 0x00174d4b
LEA RDX,[R14*0x8]
ADD RDX,R13
CMP byte ptr [R12 + 0x7e7],0x0
MOV RCX,qword ptr [RBP + -0x38]
JZ 0x00174d18
LEA R12,[RBP + -0x30]
MOV RDI,RBX
MOV RSI,R15
MOV R8,R12
CALL 0x0015a6cd
TEST EAX,EAX
SETNZ R14B
MOV RSI,qword ptr [R12]
JMP 0x00174d31
LAB_00174d18:
MOV qword ptr [RDX],RCX
CMP byte ptr [RBX + 0x67e],0x0
JZ 0x00174d2c
MOV RDI,RBX
CALL 0x00142daa
LAB_00174d2c:
XOR ESI,ESI
XOR R14D,R14D
LAB_00174d31:
MOV RDI,RBX
CALL 0x001416f0
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RAX + 0x90],0x0
MOV RAX,R14
LAB_00174d4b:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool maria_rtree_insert(long *param_1,long param_2)
{
long lVar1;
long lVar2;
int iVar3;
int8 *puVar4;
int8 uVar5;
ulong uVar6;
bool bVar7;
int8 local_38;
lVar1 = *param_1;
local_38 = 0;
bVar7 = true;
if (param_2 != 0) {
lVar2 = *(long *)(lVar1 + 0x118);
uVar6 = (ulong)*(byte *)(*(long *)(param_2 + 8) + 0xa5);
uVar5 = *(int8 *)(lVar2 + uVar6 * 8);
iVar3 = maria_rtree_insert_level(param_1,param_2,0xffffffff);
bVar7 = true;
if (iVar3 != -1) {
puVar4 = (int8 *)(uVar6 * 8 + lVar2);
if (*(char *)(lVar1 + 0x7e7) == '\0') {
*puVar4 = uVar5;
if (*(char *)((long)param_1 + 0x67e) != '\0') {
_ma_unlock_key_del(param_1);
}
uVar5 = 0;
bVar7 = false;
}
else {
iVar3 = _ma_write_undo_key_insert(param_1,param_2,puVar4,uVar5,&local_38);
bVar7 = iVar3 != 0;
uVar5 = local_38;
}
_ma_unpin_all_pages(param_1,uVar5);
*(int8 *)(param_1[1] + 0x90) = 0;
}
}
return bVar7;
}
| |
52,347 | testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL
? Int32FromEnvOrDie(kTestTotalShards, -1)
: -1;
const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL
? Int32FromEnvOrDie(kTestShardIndex, -1)
: -1;
const PositiveAndNegativeUnitTestFilter gtest_flag_filter(
GTEST_FLAG_GET(filter));
const UnitTestFilter disable_test_filter(kDisableTestFilter);
// num_runnable_tests are the number of tests that will
// run across all shards (i.e., match filter and are not disabled).
// num_selected_tests are the number of tests to be run on
// this shard.
int num_runnable_tests = 0;
int num_selected_tests = 0;
for (auto* test_suite : test_suites_) {
const std::string& test_suite_name = test_suite->name();
test_suite->set_should_run(false);
for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
TestInfo* const test_info = test_suite->test_info_list()[j];
const std::string test_name(test_info->name());
// A test is disabled if test suite name or test name matches
// kDisableTestFilter.
const bool is_disabled =
disable_test_filter.MatchesName(test_suite_name) ||
disable_test_filter.MatchesName(test_name);
test_info->is_disabled_ = is_disabled;
const bool matches_filter =
gtest_flag_filter.MatchesTest(test_suite_name, test_name);
test_info->matches_filter_ = matches_filter;
const bool is_runnable =
(GTEST_FLAG_GET(also_run_disabled_tests) || !is_disabled) &&
matches_filter;
const bool is_in_another_shard =
shard_tests != IGNORE_SHARDING_PROTOCOL &&
!ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
test_info->is_in_another_shard_ = is_in_another_shard;
const bool is_selected = is_runnable && !is_in_another_shard;
num_runnable_tests += is_runnable;
num_selected_tests += is_selected;
test_info->should_run_ = is_selected;
test_suite->set_should_run(test_suite->should_run() || is_selected);
}
}
return num_selected_tests;
} | O1 | cpp | testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp # imm = 0x168
movl %esi, %r15d
movq %rdi, %r14
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
testl %esi, %esi
jne 0x325dc
leaq 0xeb02(%rip), %rdi # 0x410d0
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x2698d
movl %eax, 0x10(%rsp)
testl %r15d, %r15d
jne 0x325f6
leaq 0xeb08(%rip), %rdi # 0x410f0
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x2698d
movl %eax, 0x14(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x1f99c
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xeb3d(%rip), %rsi # 0x41150
leaq 0xeb4d(%rip), %rdx # 0x41167
leaq 0x18(%rsp), %rdi
callq 0xfdfe
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1f6f6
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3264f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0xb8(%r14), %rbx
movq 0xc0(%r14), %rax
movq %rax, 0x68(%rsp)
cmpq %rax, %rbx
je 0x327ef
movq $0x0, 0x38(%rsp)
xorl %r14d, %r14d
movl %r15d, 0x40(%rsp)
movq (%rbx), %r12
movq 0x8(%r12), %rsi
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x3518c
movq %rbx, 0x70(%rsp)
movb $0x0, 0x70(%r12)
movq 0x30(%r12), %rax
cmpq %rax, 0x38(%r12)
je 0x327bd
xorl %ebp, %ebp
leaq 0x48(%rsp), %rbx
movl %r14d, 0x44(%rsp)
movq (%rax,%rbp,8), %r13
movq 0x20(%r13), %rsi
movq %rbx, %rdi
leaq 0xf(%rsp), %rdx
callq 0x3518c
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1f804
movb $0x1, %r14b
testb %al, %al
jne 0x326f5
leaq 0x78(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f804
movl %eax, %r14d
movb %r14b, 0x81(%r13)
leaq 0xc8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %rbx, %rdx
callq 0x1fe50
movl %eax, %ebx
movb %al, 0x82(%r13)
xorb $0x1, %r14b
orb 0x412b70e(%rip), %r14b # 0x415de33
cmpl $0x1, %r15d
jne 0x32730
xorl %r15d, %r15d
jmp 0x32742
movq 0x38(%rsp), %rax
cltd
idivl 0x10(%rsp)
cmpl 0x14(%rsp), %edx
setne %r15b
andb %r14b, %bl
movb %r15b, 0x83(%r13)
xorb $0x1, %r15b
andb %bl, %r15b
movb %r15b, 0x80(%r13)
orb %r15b, 0x70(%r12)
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x3277b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x94c0
movzbl %bl, %eax
movq 0x38(%rsp), %rcx
addl %eax, %ecx
movq %rcx, 0x38(%rsp)
movzbl %r15b, %eax
movl 0x44(%rsp), %r14d
addl %eax, %r14d
incq %rbp
movq 0x30(%r12), %rax
movq 0x38(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %rbp
movl 0x40(%rsp), %r15d
leaq 0x48(%rsp), %rbx
jb 0x326b5
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x327d9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x70(%rsp), %rbx
addq $0x8, %rbx
cmpq 0x68(%rsp), %rbx
jne 0x3267c
jmp 0x327f2
xorl %r14d, %r14d
leaq 0x90(%rsp), %rdi
callq 0x3a35e
leaq 0x78(%rsp), %rdi
callq 0x3538e
leaq 0x118(%rsp), %rbx
leaq 0x130(%rsp), %rdi
callq 0x3a35e
movq %rbx, %rdi
callq 0x3538e
leaq 0xe0(%rsp), %rdi
callq 0x3a35e
leaq 0xc8(%rsp), %rdi
callq 0x3538e
movl %r14d, %eax
addq $0x168, %rsp # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x328d9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x328d9
movq %rax, %rbx
jmp 0x328d9
movq %rax, %rbx
jmp 0x328c2
jmp 0x32887
movq %rax, %rbx
jmp 0x328a6
movq %rax, %rbx
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x328a6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x328c2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x94c0
leaq 0x90(%rsp), %rdi
callq 0x3a35e
leaq 0x78(%rsp), %rdi
callq 0x3538e
leaq 0xc8(%rsp), %rdi
callq 0x1ff92
movq %rbx, %rdi
callq 0x99a0
| _ZN7testing8internal12UnitTestImpl11FilterTestsENS1_18ReactionToShardingE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 168h
mov r15d, esi
mov r14, rdi
mov dword ptr [rsp+198h+var_188+4], 0FFFFFFFFh
mov dword ptr [rsp+198h+var_188], 0FFFFFFFFh
test esi, esi
jnz short loc_325DC
lea rdi, _ZN7testingL16kTestTotalShardsE; "GTEST_TOTAL_SHARDS"
mov esi, 0FFFFFFFFh; char *
call _ZN7testing8internal17Int32FromEnvOrDieEPKci; testing::internal::Int32FromEnvOrDie(char const*,int)
mov dword ptr [rsp+198h+var_188], eax; __int64
loc_325DC:
test r15d, r15d
jnz short loc_325F6
lea rdi, _ZN7testingL15kTestShardIndexE; "GTEST_SHARD_INDEX"
mov esi, 0FFFFFFFFh; char *
call _ZN7testing8internal17Int32FromEnvOrDieEPKci; testing::internal::Int32FromEnvOrDie(char const*,int)
mov dword ptr [rsp+198h+var_188+4], eax
loc_325F6:
lea rdi, [rsp+198h+var_D0]
call _ZN7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilterC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::PositiveAndNegativeUnitTestFilter::PositiveAndNegativeUnitTestFilter(std::string const&)
lea rax, [rsp+198h+var_170]
mov [rax-10h], rax
lea rsi, _ZN7testingL18kDisableTestFilterE; "DISABLED_*:*/DISABLED_*"
lea rdx, _ZN7testingL18kDisableTestFilterE+17h; ""
lea rdi, [rsp+198h+var_180]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+198h+var_120]
lea rsi, [rsp+198h+var_180]
call _ZN7testing8internal12_GLOBAL__N_114UnitTestFilterC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::UnitTestFilter::UnitTestFilter(std::string const&)
mov rdi, [rsp+198h+var_180]; void *
lea rax, [rsp+198h+var_170]
cmp rdi, rax
jz short loc_3264F
mov rsi, [rsp+198h+var_170]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3264F:
mov rbx, [r14+0B8h]
mov rax, [r14+0C0h]
mov [rsp+198h+var_130], rax
cmp rbx, rax
jz loc_327EF
mov [rsp+198h+var_160], 0
xor r14d, r14d
mov [rsp+198h+var_158], r15d
loc_3267C:
mov r12, [rbx]
mov rsi, [r12+8]
lea rdi, [rsp+198h+var_180]
lea rdx, [rsp+198h+var_150]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov [rsp+198h+var_128], rbx
mov byte ptr [r12+70h], 0
mov rax, [r12+30h]
cmp [r12+38h], rax
jz loc_327BD
xor ebp, ebp
lea rbx, [rsp+198h+var_150]
loc_326B5:
mov [rsp+198h+var_154], r14d
mov r13, [rax+rbp*8]
mov rsi, [r13+20h]
mov rdi, rbx
lea rdx, [rsp+198h+var_189]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+198h+var_120]
lea rsi, [rsp+198h+var_180]
call _ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(std::string const&)
mov r14b, 1
test al, al
jnz short loc_326F5
lea rdi, [rsp+198h+var_120]
mov rsi, rbx
call _ZNK7testing8internal12_GLOBAL__N_114UnitTestFilter11MatchesNameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(std::string const&)
mov r14d, eax
loc_326F5:
mov [r13+81h], r14b
lea rdi, [rsp+198h+var_D0]; int
lea rsi, [rsp+198h+var_180]; int
mov rdx, rbx; int
call _ZNK7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilter11MatchesTestERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_; testing::internal::`anonymous namespace'::PositiveAndNegativeUnitTestFilter::MatchesTest(std::string const&,std::string const&)
mov ebx, eax
mov [r13+82h], al
xor r14b, 1
or r14b, cs:_ZN7testing35FLAGS_gtest_also_run_disabled_testsE; testing::FLAGS_gtest_also_run_disabled_tests
cmp r15d, 1
jnz short loc_32730
xor r15d, r15d
jmp short loc_32742
loc_32730:
mov rax, [rsp+198h+var_160]
cdq
idiv dword ptr [rsp+198h+var_188]
cmp edx, dword ptr [rsp+198h+var_188+4]
setnz r15b
loc_32742:
and bl, r14b
mov [r13+83h], r15b
xor r15b, 1
and r15b, bl
mov [r13+80h], r15b
or [r12+70h], r15b
mov rdi, [rsp+198h+var_150]; void *
lea rax, [rsp+198h+var_140]
cmp rdi, rax
jz short loc_3277B
mov rsi, [rsp+198h+var_140]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3277B:
movzx eax, bl
mov rcx, [rsp+198h+var_160]
add ecx, eax
mov [rsp+198h+var_160], rcx
movzx eax, r15b
mov r14d, [rsp+198h+var_154]
add r14d, eax
inc rbp
mov rax, [r12+30h]
mov rcx, [r12+38h]
sub rcx, rax
sar rcx, 3
cmp rbp, rcx
mov r15d, [rsp+198h+var_158]
lea rbx, [rsp+198h+var_150]
jb loc_326B5
loc_327BD:
mov rdi, [rsp+198h+var_180]; void *
lea rax, [rsp+198h+var_170]
cmp rdi, rax
jz short loc_327D9
mov rsi, [rsp+198h+var_170]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_327D9:
mov rbx, [rsp+198h+var_128]
add rbx, 8
cmp rbx, [rsp+198h+var_130]
jnz loc_3267C
jmp short loc_327F2
loc_327EF:
xor r14d, r14d
loc_327F2:
lea rdi, [rsp+198h+var_108]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
lea rdi, [rsp+198h+var_120]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rbx, [rsp+198h+var_80]
lea rdi, [rsp+198h+var_68]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
mov rdi, rbx; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+198h+var_B8]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
lea rdi, [rsp+198h+var_D0]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov eax, r14d
add rsp, 168h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
lea rax, [rsp+arg_20]
cmp rdi, rax
jz short loc_328D9
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_328D9
mov rbx, rax
jmp short loc_328D9
mov rbx, rax
jmp short loc_328C2
jmp short loc_32887
mov rbx, rax
jmp short loc_328A6
loc_32887:
mov rbx, rax
mov rdi, [rsp+arg_40]; void *
lea rax, [rsp+arg_50]
cmp rdi, rax
jz short loc_328A6
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_328A6:
mov rdi, [rsp+arg_10]; void *
lea rax, [rsp+arg_20]
cmp rdi, rax
jz short loc_328C2
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_328C2:
lea rdi, [rsp+arg_88]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_SaIS5_ENSt8__detail9_IdentityESt8equal_toIS5_ESt4hashIS5_ENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb1ELb1ELb1EEEED2Ev; std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable()
lea rdi, [rsp+arg_70]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_328D9:
lea rdi, [rsp+arg_C0]; this
call _ZN7testing8internal12_GLOBAL__N_133PositiveAndNegativeUnitTestFilterD2Ev; testing::internal::`anonymous namespace'::PositiveAndNegativeUnitTestFilter::~PositiveAndNegativeUnitTestFilter()
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::UnitTestImpl::FilterTests(long long a1, int a2)
{
int v2; // r15d
long long *v3; // rbx
unsigned int v4; // r14d
long long v5; // r12
long long v6; // rax
unsigned long long v7; // rbp
long long v8; // r13
char v9; // r14
char v10; // bl
char v11; // r14
bool v12; // r15
unsigned __int8 v13; // bl
unsigned __int8 v14; // r15
char v16; // [rsp+Fh] [rbp-189h] BYREF
long long v17; // [rsp+10h] [rbp-188h]
void *v18[2]; // [rsp+18h] [rbp-180h] BYREF
_QWORD v19[2]; // [rsp+28h] [rbp-170h] BYREF
long long v20; // [rsp+38h] [rbp-160h]
int v21; // [rsp+40h] [rbp-158h]
unsigned int v22; // [rsp+44h] [rbp-154h]
void *v23[2]; // [rsp+48h] [rbp-150h] BYREF
long long v24; // [rsp+58h] [rbp-140h] BYREF
long long *v25; // [rsp+68h] [rbp-130h]
long long *v26; // [rsp+70h] [rbp-128h]
long long v27[3]; // [rsp+78h] [rbp-120h] BYREF
_BYTE v28[56]; // [rsp+90h] [rbp-108h] BYREF
long long v29[3]; // [rsp+C8h] [rbp-D0h] BYREF
_BYTE v30[56]; // [rsp+E0h] [rbp-B8h] BYREF
_BYTE v31[24]; // [rsp+118h] [rbp-80h] BYREF
_BYTE v32[104]; // [rsp+130h] [rbp-68h] BYREF
v2 = a2;
v17 = -1LL;
if ( !a2 )
{
LODWORD(v17) = testing::internal::Int32FromEnvOrDie(
(testing::internal *)"GTEST_TOTAL_SHARDS",
(const char *)0xFFFFFFFFLL);
HIDWORD(v17) = testing::internal::Int32FromEnvOrDie(
(testing::internal *)"GTEST_SHARD_INDEX",
(const char *)0xFFFFFFFFLL);
}
testing::internal::`anonymous namespace'::PositiveAndNegativeUnitTestFilter::PositiveAndNegativeUnitTestFilter((long long)v29);
v18[0] = v19;
std::string::_M_construct<char const*>(v18, "DISABLED_*:*/DISABLED_*", (long long)"");
testing::internal::`anonymous namespace'::UnitTestFilter::UnitTestFilter((long long)v27, (long long)v18);
if ( v18[0] != v19 )
operator delete(v18[0], v19[0] + 1LL);
v3 = *(long long **)(a1 + 184);
v25 = *(long long **)(a1 + 192);
if ( v3 == v25 )
{
v4 = 0;
}
else
{
v20 = 0LL;
v4 = 0;
v21 = a2;
do
{
v5 = *v3;
std::string::basic_string<std::allocator<char>>(v18, *(_QWORD *)(*v3 + 8), v23);
v26 = v3;
*(_BYTE *)(v5 + 112) = 0;
v6 = *(_QWORD *)(v5 + 48);
if ( *(_QWORD *)(v5 + 56) != v6 )
{
v7 = 0LL;
do
{
v22 = v4;
v8 = *(_QWORD *)(v6 + 8 * v7);
std::string::basic_string<std::allocator<char>>(v23, *(_QWORD *)(v8 + 32), &v16);
v9 = 1;
if ( !testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(v27, (long long)v18) )
v9 = testing::internal::`anonymous namespace'::UnitTestFilter::MatchesName(v27, (long long)v23);
*(_BYTE *)(v8 + 129) = v9;
v10 = testing::internal::`anonymous namespace'::PositiveAndNegativeUnitTestFilter::MatchesTest(
v29,
(long long)v18,
v23);
*(_BYTE *)(v8 + 130) = v10;
v11 = testing::FLAGS_gtest_also_run_disabled_tests | v9 ^ 1;
v12 = v2 != 1 && (int)v20 % (int)v17 != HIDWORD(v17);
v13 = v11 & v10;
*(_BYTE *)(v8 + 131) = v12;
v14 = v13 & !v12;
*(_BYTE *)(v8 + 128) = v14;
*(_BYTE *)(v5 + 112) |= v14;
if ( v23[0] != &v24 )
operator delete(v23[0], v24 + 1);
v20 = v13 + (unsigned int)v20;
v4 = v14 + v22;
++v7;
v6 = *(_QWORD *)(v5 + 48);
v2 = v21;
}
while ( v7 < (*(_QWORD *)(v5 + 56) - v6) >> 3 );
}
if ( v18[0] != v19 )
operator delete(v18[0], v19[0] + 1LL);
v3 = v26 + 1;
}
while ( v26 + 1 != v25 );
}
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable(v28);
std::vector<std::string>::~vector(v27);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable(v32);
std::vector<std::string>::~vector(v31);
std::_Hashtable<std::string,std::string,std::allocator<std::string>,std::__detail::_Identity,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>::~_Hashtable(v30);
std::vector<std::string>::~vector(v29);
return v4;
}
| FilterTests:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x168
MOV R15D,ESI
MOV R14,RDI
MOV dword ptr [RSP + 0x14],0xffffffff
MOV dword ptr [RSP + 0x10],0xffffffff
TEST ESI,ESI
JNZ 0x001325dc
LEA RDI,[0x1410d0]
MOV ESI,0xffffffff
CALL 0x0012698d
MOV dword ptr [RSP + 0x10],EAX
LAB_001325dc:
TEST R15D,R15D
JNZ 0x001325f6
LEA RDI,[0x1410f0]
MOV ESI,0xffffffff
CALL 0x0012698d
MOV dword ptr [RSP + 0x14],EAX
LAB_001325f6:
LEA RDI,[RSP + 0xc8]
CALL 0x0011f99c
LEA RAX,[RSP + 0x28]
MOV qword ptr [RAX + -0x10],RAX
LAB_0013260c:
LEA RSI,[0x141150]
LEA RDX,[0x141167]
LEA RDI,[RSP + 0x18]
CALL 0x0010fdfe
LAB_00132624:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x18]
CALL 0x0011f6f6
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x0013264f
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x001094c0
LAB_0013264f:
MOV RBX,qword ptr [R14 + 0xb8]
MOV RAX,qword ptr [R14 + 0xc0]
MOV qword ptr [RSP + 0x68],RAX
CMP RBX,RAX
JZ 0x001327ef
MOV qword ptr [RSP + 0x38],0x0
XOR R14D,R14D
MOV dword ptr [RSP + 0x40],R15D
LAB_0013267c:
MOV R12,qword ptr [RBX]
MOV RSI,qword ptr [R12 + 0x8]
LAB_00132684:
LEA RDI,[RSP + 0x18]
LEA RDX,[RSP + 0x48]
CALL 0x0013518c
MOV qword ptr [RSP + 0x70],RBX
MOV byte ptr [R12 + 0x70],0x0
MOV RAX,qword ptr [R12 + 0x30]
CMP qword ptr [R12 + 0x38],RAX
JZ 0x001327bd
XOR EBP,EBP
LEA RBX,[RSP + 0x48]
LAB_001326b5:
MOV dword ptr [RSP + 0x44],R14D
MOV R13,qword ptr [RAX + RBP*0x8]
MOV RSI,qword ptr [R13 + 0x20]
LAB_001326c2:
MOV RDI,RBX
LEA RDX,[RSP + 0xf]
CALL 0x0013518c
LAB_001326cf:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x18]
CALL 0x0011f804
MOV R14B,0x1
TEST AL,AL
JNZ 0x001326f5
LEA RDI,[RSP + 0x78]
MOV RSI,RBX
CALL 0x0011f804
MOV R14D,EAX
LAB_001326f5:
MOV byte ptr [R13 + 0x81],R14B
LAB_001326fc:
LEA RDI,[RSP + 0xc8]
LEA RSI,[RSP + 0x18]
MOV RDX,RBX
CALL 0x0011fe50
LAB_00132711:
MOV EBX,EAX
MOV byte ptr [R13 + 0x82],AL
XOR R14B,0x1
OR R14B,byte ptr [0x0425de33]
CMP R15D,0x1
JNZ 0x00132730
XOR R15D,R15D
JMP 0x00132742
LAB_00132730:
MOV RAX,qword ptr [RSP + 0x38]
CDQ
IDIV dword ptr [RSP + 0x10]
CMP EDX,dword ptr [RSP + 0x14]
SETNZ R15B
LAB_00132742:
AND BL,R14B
MOV byte ptr [R13 + 0x83],R15B
XOR R15B,0x1
AND R15B,BL
MOV byte ptr [R13 + 0x80],R15B
OR byte ptr [R12 + 0x70],R15B
MOV RDI,qword ptr [RSP + 0x48]
LEA RAX,[RSP + 0x58]
CMP RDI,RAX
JZ 0x0013277b
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001094c0
LAB_0013277b:
MOVZX EAX,BL
MOV RCX,qword ptr [RSP + 0x38]
ADD ECX,EAX
MOV qword ptr [RSP + 0x38],RCX
MOVZX EAX,R15B
MOV R14D,dword ptr [RSP + 0x44]
ADD R14D,EAX
INC RBP
MOV RAX,qword ptr [R12 + 0x30]
MOV RCX,qword ptr [R12 + 0x38]
SUB RCX,RAX
SAR RCX,0x3
CMP RBP,RCX
MOV R15D,dword ptr [RSP + 0x40]
LEA RBX,[RSP + 0x48]
JC 0x001326b5
LAB_001327bd:
MOV RDI,qword ptr [RSP + 0x18]
LEA RAX,[RSP + 0x28]
CMP RDI,RAX
JZ 0x001327d9
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x001094c0
LAB_001327d9:
MOV RBX,qword ptr [RSP + 0x70]
ADD RBX,0x8
CMP RBX,qword ptr [RSP + 0x68]
JNZ 0x0013267c
JMP 0x001327f2
LAB_001327ef:
XOR R14D,R14D
LAB_001327f2:
LEA RDI,[RSP + 0x90]
CALL 0x0013a35e
LEA RDI,[RSP + 0x78]
CALL 0x0013538e
LEA RBX,[RSP + 0x118]
LEA RDI,[RSP + 0x130]
CALL 0x0013a35e
MOV RDI,RBX
CALL 0x0013538e
LEA RDI,[RSP + 0xe0]
CALL 0x0013a35e
LEA RDI,[RSP + 0xc8]
CALL 0x0013538e
MOV EAX,R14D
ADD RSP,0x168
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::UnitTestImpl::FilterTests(testing::internal::UnitTestImpl::ReactionToSharding)
*/
int __thiscall testing::internal::UnitTestImpl::FilterTests(UnitTestImpl *this,string *param_2)
{
long lVar1;
char cVar2;
byte bVar3;
byte bVar4;
long lVar5;
long *plVar6;
ulong uVar7;
uint uVar8;
int iVar9;
ulong uVar10;
bool bVar11;
allocator local_189;
int local_188;
int local_184;
long *local_180 [2];
long local_170 [2];
ulong local_160;
uint local_158;
int local_154;
long *local_150 [2];
long local_140 [2];
long *local_130;
long *local_128;
UnitTestFilter local_120 [24];
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
local_108 [56];
PositiveAndNegativeUnitTestFilter local_d0 [24];
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
local_b8 [56];
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_80 [24];
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
local_68 [56];
uVar8 = (uint)param_2;
uVar10 = (ulong)param_2 & 0xffffffff;
local_184 = -1;
local_188 = -1;
if (uVar8 == 0) {
local_188 = Int32FromEnvOrDie("GTEST_TOTAL_SHARDS",-1);
param_2 = (string *)0xffffffff;
local_184 = Int32FromEnvOrDie("GTEST_SHARD_INDEX",-1);
}
(anonymous_namespace)::PositiveAndNegativeUnitTestFilter::PositiveAndNegativeUnitTestFilter
(local_d0,param_2);
local_180[0] = local_170;
/* try { // try from 0013260c to 00132623 has its CatchHandler @ 00132876 */
std::__cxx11::string::_M_construct<char_const*>(local_180,"DISABLED_*:*/DISABLED_*","");
/* try { // try from 00132624 to 00132632 has its CatchHandler @ 00132855 */
(anonymous_namespace)::UnitTestFilter::UnitTestFilter(local_120,(string *)local_180);
if (local_180[0] != local_170) {
operator_delete(local_180[0],local_170[0] + 1);
}
plVar6 = *(long **)(this + 0xb8);
local_130 = *(long **)(this + 0xc0);
if (plVar6 == local_130) {
iVar9 = 0;
}
else {
local_160 = 0;
iVar9 = 0;
local_158 = uVar8;
do {
lVar1 = *plVar6;
/* try { // try from 00132684 to 00132692 has its CatchHandler @ 0013287b */
std::__cxx11::string::string<std::allocator<char>>
((string *)local_180,*(char **)(lVar1 + 8),(allocator *)local_150);
*(int1 *)(lVar1 + 0x70) = 0;
lVar5 = *(long *)(lVar1 + 0x30);
local_128 = plVar6;
if (*(long *)(lVar1 + 0x38) != lVar5) {
uVar7 = 0;
do {
lVar5 = *(long *)(lVar5 + uVar7 * 8);
/* try { // try from 001326c2 to 001326ce has its CatchHandler @ 00132882 */
local_154 = iVar9;
std::__cxx11::string::string<std::allocator<char>>
((string *)local_150,*(char **)(lVar5 + 0x20),&local_189);
/* try { // try from 001326cf to 001326f1 has its CatchHandler @ 00132887 */
cVar2 = (anonymous_namespace)::UnitTestFilter::MatchesName(local_120,(string *)local_180);
bVar3 = 1;
if (cVar2 == '\0') {
bVar3 = (anonymous_namespace)::UnitTestFilter::MatchesName
(local_120,(string *)local_150);
}
*(byte *)(lVar5 + 0x81) = bVar3;
/* try { // try from 001326fc to 00132710 has its CatchHandler @ 00132880 */
bVar4 = (anonymous_namespace)::PositiveAndNegativeUnitTestFilter::MatchesTest
(local_d0,(string *)local_180,(string *)local_150);
*(byte *)(lVar5 + 0x82) = bVar4;
if ((int)uVar10 == 1) {
bVar11 = false;
}
else {
bVar11 = (int)((long)((ulong)(uint)((int)local_160 >> 0x1f) << 0x20 |
local_160 & 0xffffffff) % (long)local_188) != local_184;
}
bVar4 = bVar4 & (bVar3 ^ 1 | FLAGS_gtest_also_run_disabled_tests);
*(bool *)(lVar5 + 0x83) = bVar11;
bVar3 = (bVar11 ^ 1U) & bVar4;
*(byte *)(lVar5 + 0x80) = bVar3;
*(byte *)(lVar1 + 0x70) = *(byte *)(lVar1 + 0x70) | bVar3;
if (local_150[0] != local_140) {
operator_delete(local_150[0],local_140[0] + 1);
}
local_160 = (ulong)((int)local_160 + (uint)bVar4);
iVar9 = local_154 + (uint)bVar3;
uVar7 = uVar7 + 1;
lVar5 = *(long *)(lVar1 + 0x30);
uVar10 = (ulong)local_158;
} while (uVar7 < (ulong)(*(long *)(lVar1 + 0x38) - lVar5 >> 3));
}
if (local_180[0] != local_170) {
operator_delete(local_180[0],local_170[0] + 1);
}
plVar6 = local_128 + 1;
} while (plVar6 != local_130);
}
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable(local_108);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_120);
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable(local_68);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_80);
std::
_Hashtable<std::__cxx11::string,std::__cxx11::string,std::allocator<std::__cxx11::string>,std::__detail::_Identity,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,true,true>>
::~_Hashtable(local_b8);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_d0);
return iVar9;
}
| |
52,348 | blst_sk_inverse | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c | void blst_sk_inverse(pow256 ret, const pow256 a)
{
const union {
long one;
char little;
} is_endian = { 1 };
if (((size_t)a|(size_t)ret)%sizeof(limb_t) == 0 && is_endian.little) {
limb_t *out = (limb_t *)ret;
mul_mont_sparse_256(out, (const limb_t *)a, BLS12_381_rRR,
BLS12_381_r, r0);
reciprocal_fr(out, out);
from_mont_256(out, out, BLS12_381_r, r0);
} else {
vec256 out;
limbs_from_le_bytes(out, a, 32);
mul_mont_sparse_256(out, out, BLS12_381_rRR, BLS12_381_r, r0);
reciprocal_fr(out, out);
from_mont_256(out, out, BLS12_381_r, r0);
le_bytes_from_limbs(ret, out, 32);
vec_zero(out, sizeof(out));
}
} | O3 | c | blst_sk_inverse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movabsq $-0x100000001, %r14 # imm = 0xFFFFFFFEFFFFFFFF
movl %esi, %eax
orl %ebx, %eax
testb $0x7, %al
je 0x63562
movl $0x1f, %eax
xorl %ecx, %ecx
shlq $0x8, %rcx
movzbl (%rsi,%rax), %edx
orq %rdx, %rcx
movq %rax, %rdx
andq $-0x8, %rdx
movq %rcx, -0x40(%rbp,%rdx)
addq $-0x1, %rax
jb 0x634b7
leaq 0x276e5(%rip), %rdx # 0x8abc0
leaq 0x271ce(%rip), %r15 # 0x8a6b0
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x74000
movq %r12, %rdi
movq %r12, %rsi
callq 0x6073e
movq %r12, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x74420
cmpq %rbx, %r12
je 0x6353d
xorl %eax, %eax
movq -0x40(%rbp,%rax,8), %rdx
xorl %ecx, %ecx
movb %dl, (%rbx,%rcx)
incq %rcx
shrq $0x8, %rdx
cmpq $0x8, %rcx
jne 0x63521
incq %rax
addq %rcx, %rbx
cmpq $0x4, %rax
jne 0x6351a
xorl %eax, %eax
movq $0x0, -0x40(%rbp,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x6353f
leaq -0x40(%rbp), %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27657(%rip), %rdx # 0x8abc0
leaq 0x27140(%rip), %r15 # 0x8a6b0
movq %rbx, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x74000
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x6073e
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x74420
| blst_sk_inverse:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 20h
mov rbx, rdi
mov r14, 0FFFFFFFEFFFFFFFFh
mov eax, esi
or eax, ebx
test al, 7
jz loc_63562
mov eax, 1Fh
xor ecx, ecx
loc_634B7:
shl rcx, 8
movzx edx, byte ptr [rsi+rax]
or rcx, rdx
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFF8h
mov [rbp+rdx+var_40], rcx
add rax, 0FFFFFFFFFFFFFFFFh
jb short loc_634B7
lea rdx, BLS12_381_rRR
lea r15, BLS12_381_r
lea r12, [rbp+var_40]
mov rdi, r12
mov rsi, r12
mov rcx, r15
mov r8, r14
call mul_mont_sparse_256
mov rdi, r12
mov rsi, r12
call reciprocal_fr
mov rdi, r12
mov rsi, r12
mov rdx, r15
mov rcx, r14
call from_mont_256
cmp r12, rbx
jz short loc_6353D
xor eax, eax
loc_6351A:
mov rdx, [rbp+rax*8+var_40]
xor ecx, ecx
loc_63521:
mov [rbx+rcx], dl
inc rcx
shr rdx, 8
cmp rcx, 8
jnz short loc_63521
inc rax
add rbx, rcx
cmp rax, 4
jnz short loc_6351A
loc_6353D:
xor eax, eax
loc_6353F:
mov [rbp+rax*8+var_40], 0
inc rax
cmp rax, 4
jnz short loc_6353F
lea rax, [rbp+var_40]
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_63562:
lea rdx, BLS12_381_rRR
lea r15, BLS12_381_r
mov rdi, rbx
mov rcx, r15
mov r8, r14
call mul_mont_sparse_256
mov rdi, rbx
mov rsi, rbx
call reciprocal_fr
mov rdi, rbx
mov rsi, rbx
mov rdx, r15
mov rcx, r14
add rsp, 20h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp from_mont_256
| _QWORD * blst_sk_inverse(_QWORD *a1, long long a2)
{
_QWORD *v2; // rbx
long long v3; // rax
unsigned long long v4; // rcx
long long i; // rax
unsigned long long v7; // rdx
long long j; // rcx
long long k; // rax
_QWORD v11[8]; // [rsp+0h] [rbp-40h] BYREF
v2 = a1;
if ( (((unsigned __int8)a1 | (unsigned __int8)a2) & 7) != 0 )
{
v3 = 31LL;
v4 = 0LL;
do
{
v4 = *(unsigned __int8 *)(a2 + v3) | (v4 << 8);
*(_QWORD *)((char *)v11 + (v3 & 0xFFFFFFFFFFFFFFF8LL)) = v4;
}
while ( v3-- != 0 );
mul_mont_sparse_256(v11, v11, &BLS12_381_rRR, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
reciprocal_fr((long long)v11, (long long)v11);
from_mont_256(v11, v11, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
if ( v11 != a1 )
{
for ( i = 0LL; i != 4; ++i )
{
v7 = v11[i];
for ( j = 0LL; j != 8; ++j )
{
*((_BYTE *)v2 + j) = v7;
v7 >>= 8;
}
++v2;
}
}
for ( k = 0LL; k != 4; ++k )
v11[k] = 0LL;
return v11;
}
else
{
mul_mont_sparse_256(a1, a2, &BLS12_381_rRR, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
reciprocal_fr((long long)a1, (long long)a1);
return (_QWORD *)from_mont_256(a1, a1, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
}
}
| blst_sk_inverse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV R14,-0x100000001
MOV EAX,ESI
OR EAX,EBX
TEST AL,0x7
JZ 0x00163562
MOV EAX,0x1f
XOR ECX,ECX
LAB_001634b7:
SHL RCX,0x8
MOVZX EDX,byte ptr [RSI + RAX*0x1]
OR RCX,RDX
MOV RDX,RAX
AND RDX,-0x8
MOV qword ptr [RBP + RDX*0x1 + -0x40],RCX
ADD RAX,-0x1
JC 0x001634b7
LEA RDX,[0x18abc0]
LEA R15,[0x18a6b0]
LEA R12,[RBP + -0x40]
MOV RDI,R12
MOV RSI,R12
MOV RCX,R15
MOV R8,R14
CALL 0x00174000
MOV RDI,R12
MOV RSI,R12
CALL 0x0016073e
MOV RDI,R12
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00174420
CMP R12,RBX
JZ 0x0016353d
XOR EAX,EAX
LAB_0016351a:
MOV RDX,qword ptr [RBP + RAX*0x8 + -0x40]
XOR ECX,ECX
LAB_00163521:
MOV byte ptr [RBX + RCX*0x1],DL
INC RCX
SHR RDX,0x8
CMP RCX,0x8
JNZ 0x00163521
INC RAX
ADD RBX,RCX
CMP RAX,0x4
JNZ 0x0016351a
LAB_0016353d:
XOR EAX,EAX
LAB_0016353f:
MOV qword ptr [RBP + RAX*0x8 + -0x40],0x0
INC RAX
CMP RAX,0x4
JNZ 0x0016353f
LEA RAX,[RBP + -0x40]
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00163562:
LEA RDX,[0x18abc0]
LEA R15,[0x18a6b0]
MOV RDI,RBX
MOV RCX,R15
MOV R8,R14
CALL 0x00174000
MOV RDI,RBX
MOV RSI,RBX
CALL 0x0016073e
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R14
ADD RSP,0x20
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00174420
|
ulong * blst_sk_inverse(ulong *param_1,long param_2)
{
ulong uVar1;
long lVar2;
ulong *puVar3;
ulong uVar4;
long lVar5;
bool bVar6;
ulong local_48 [4];
if ((((uint)param_2 | (uint)param_1) & 7) != 0) {
uVar1 = 0x1f;
uVar4 = 0;
do {
uVar4 = uVar4 << 8 | (ulong)*(byte *)(param_2 + uVar1);
*(ulong *)((long)local_48 + (uVar1 & 0xfffffffffffffff8)) = uVar4;
bVar6 = uVar1 != 0;
uVar1 = uVar1 - 1;
} while (bVar6);
mul_mont_sparse_256(local_48,local_48,BLS12_381_rRR,BLS12_381_r,0xfffffffeffffffff);
reciprocal_fr(local_48,local_48);
from_mont_256(local_48,local_48,BLS12_381_r);
if (local_48 != param_1) {
lVar2 = 0;
do {
uVar1 = local_48[lVar2];
lVar5 = 0;
do {
*(char *)((long)param_1 + lVar5) = (char)uVar1;
lVar5 = lVar5 + 1;
uVar1 = uVar1 >> 8;
} while (lVar5 != 8);
lVar2 = lVar2 + 1;
param_1 = param_1 + 1;
} while (lVar2 != 4);
}
lVar2 = 0;
do {
local_48[lVar2] = 0;
lVar2 = lVar2 + 1;
} while (lVar2 != 4);
return local_48;
}
mul_mont_sparse_256(param_1,param_2,BLS12_381_rRR,BLS12_381_r,0xfffffffeffffffff);
reciprocal_fr(param_1,param_1);
puVar3 = (ulong *)from_mont_256(param_1,param_1,BLS12_381_r,0xfffffffeffffffff);
return puVar3;
}
| |
52,349 | ggml_new_object | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | static struct ggml_object * ggml_new_object(struct ggml_context * ctx, enum ggml_object_type type, size_t size) {
// always insert objects at the end of the context's memory pool
struct ggml_object * obj_cur = ctx->objects_end;
const size_t cur_offs = obj_cur == NULL ? 0 : obj_cur->offs;
const size_t cur_size = obj_cur == NULL ? 0 : obj_cur->size;
const size_t cur_end = cur_offs + cur_size;
// align to GGML_MEM_ALIGN
size_t size_needed = GGML_PAD(size, GGML_MEM_ALIGN);
char * const mem_buffer = ctx->mem_buffer;
struct ggml_object * const obj_new = (struct ggml_object *)(mem_buffer + cur_end);
if (cur_end + size_needed + GGML_OBJECT_SIZE > ctx->mem_size) {
GGML_LOG_WARN("%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",
__func__, cur_end + size_needed + GGML_OBJECT_SIZE, ctx->mem_size);
#ifndef NDEBUG
GGML_ABORT("not enough space in the context's memory pool");
#endif
return NULL;
}
*obj_new = (struct ggml_object) {
.offs = cur_end + GGML_OBJECT_SIZE,
.size = size_needed,
.next = NULL,
.type = type,
};
GGML_ASSERT_ALIGNED(mem_buffer + obj_new->offs);
if (obj_cur != NULL) {
obj_cur->next = obj_new;
} else {
// this is the first object in this context
ctx->objects_begin = obj_new;
}
ctx->objects_end = obj_new;
//printf("%s: inserted new object at %zu, size = %zu\n", __func__, cur_end, obj_new->size);
return obj_new;
} | O1 | c | ggml_new_object:
pushq %rax
movq 0x20(%rdi), %r9
testq %r9, %r9
je 0x1bbf5
movq (%r9), %rax
jmp 0x1bbf7
xorl %eax, %eax
testq %r9, %r9
je 0x1bc02
movq 0x8(%r9), %r10
jmp 0x1bc05
xorl %r10d, %r10d
addq %rax, %r10
addq $0xf, %rdx
andq $-0x10, %rdx
movq (%rdi), %r8
leaq (%rdx,%r10), %rcx
addq $0x20, %rcx
cmpq %r8, %rcx
ja 0x1bc6a
movq 0x8(%rdi), %rax
leaq 0x20(%r10), %rcx
movq %rcx, (%rax,%r10)
movq %rdx, 0x8(%rax,%r10)
movq $0x0, 0x10(%rax,%r10)
movl %esi, 0x18(%rax,%r10)
movl $0x0, 0x1c(%rax,%r10)
addl %eax, %ecx
testb $0xf, %cl
jne 0x1bc9e
addq %r10, %rax
leaq 0x18(%rdi), %rcx
leaq 0x10(%r9), %rdx
testq %r9, %r9
cmoveq %rcx, %rdx
movq %rax, (%rdx)
movq %rax, 0x20(%rdi)
popq %rcx
retq
leaq 0x32988(%rip), %rsi # 0x4e5f9
leaq 0x329d0(%rip), %rdx # 0x4e648
movl $0x3, %edi
xorl %eax, %eax
callq 0x17810
leaq 0x308e4(%rip), %rdi # 0x4c56f
leaq 0x329c6(%rip), %rdx # 0x4e658
movl $0x5f4, %esi # imm = 0x5F4
xorl %eax, %eax
callq 0x18ce0
leaq 0x308ca(%rip), %rdi # 0x4c56f
leaq 0x30915(%rip), %rdx # 0x4c5c1
leaq 0x329d3(%rip), %rcx # 0x4e686
movl $0x600, %esi # imm = 0x600
xorl %eax, %eax
callq 0x18ce0
| ggml_new_object:
push rax
mov r9, [rdi+20h]
test r9, r9
jz short loc_1BBF5
mov rax, [r9]
jmp short loc_1BBF7
loc_1BBF5:
xor eax, eax
loc_1BBF7:
test r9, r9
jz short loc_1BC02
mov r10, [r9+8]
jmp short loc_1BC05
loc_1BC02:
xor r10d, r10d
loc_1BC05:
add r10, rax
add rdx, 0Fh
and rdx, 0FFFFFFFFFFFFFFF0h
mov r8, [rdi]
lea rcx, [rdx+r10]
add rcx, 20h ; ' '
cmp rcx, r8
ja short loc_1BC6A
mov rax, [rdi+8]
lea rcx, [r10+20h]
mov [rax+r10], rcx
mov [rax+r10+8], rdx
mov qword ptr [rax+r10+10h], 0
mov [rax+r10+18h], esi
mov dword ptr [rax+r10+1Ch], 0
add ecx, eax
test cl, 0Fh
jnz short loc_1BC9E
add rax, r10
lea rcx, [rdi+18h]
lea rdx, [r9+10h]
test r9, r9
cmovz rdx, rcx
mov [rdx], rax
mov [rdi+20h], rax
pop rcx
retn
loc_1BC6A:
lea rsi, aSNotEnoughSpac; "%s: not enough space in the context's m"...
lea rdx, aGgmlNewObject; "ggml_new_object"
mov edi, 3
xor eax, eax
call _ggml_log_internal
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aNotEnoughSpace; "not enough space in the context's memor"...
mov esi, 5F4h
xor eax, eax
call _ggml_abort
loc_1BC9E:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aUintptrTMemBuf; "((uintptr_t) (mem_buffer + obj_new->off"...
mov esi, 600h
xor eax, eax
call _ggml_abort
| long long ggml_new_object(
long long *a1,
int a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11)
{
long long *v11; // r9
long long v12; // rax
long long v13; // r10
long long v14; // r10
unsigned long long v15; // rdx
long long v16; // r8
unsigned long long v17; // rcx
long long v18; // rax
long long result; // rax
long long *v20; // rdx
int v21; // ecx
int v22; // r8d
int v23; // r9d
v11 = (long long *)a1[4];
if ( v11 )
v12 = *v11;
else
v12 = 0LL;
if ( v11 )
v13 = v11[1];
else
v13 = 0LL;
v14 = v12 + v13;
v15 = (a3 + 15) & 0xFFFFFFFFFFFFFFF0LL;
v16 = *a1;
v17 = v15 + v14 + 32;
if ( v17 > *a1 )
{
ggml_log_internal(
3u,
(long long)"%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",
(long long)"ggml_new_object",
v17,
v16,
(long long)v11,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11);
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
1524,
(unsigned int)"not enough space in the context's memory pool",
v21,
v22,
v23);
}
v18 = a1[1];
*(_QWORD *)(v18 + v14) = v14 + 32;
*(_QWORD *)(v18 + v14 + 8) = v15;
*(_QWORD *)(v18 + v14 + 16) = 0LL;
*(_DWORD *)(v18 + v14 + 24) = a2;
*(_DWORD *)(v18 + v14 + 28) = 0;
if ( (((_BYTE)v18 + (_BYTE)v14 + 32) & 0xF) != 0 )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
1536,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0",
v16,
(_DWORD)v11);
result = v14 + v18;
v20 = v11 + 2;
if ( !v11 )
v20 = a1 + 3;
*v20 = result;
a1[4] = result;
return result;
}
| ggml_new_object:
PUSH RAX
MOV R9,qword ptr [RDI + 0x20]
TEST R9,R9
JZ 0x0011bbf5
MOV RAX,qword ptr [R9]
JMP 0x0011bbf7
LAB_0011bbf5:
XOR EAX,EAX
LAB_0011bbf7:
TEST R9,R9
JZ 0x0011bc02
MOV R10,qword ptr [R9 + 0x8]
JMP 0x0011bc05
LAB_0011bc02:
XOR R10D,R10D
LAB_0011bc05:
ADD R10,RAX
ADD RDX,0xf
AND RDX,-0x10
MOV R8,qword ptr [RDI]
LEA RCX,[RDX + R10*0x1]
ADD RCX,0x20
CMP RCX,R8
JA 0x0011bc6a
MOV RAX,qword ptr [RDI + 0x8]
LEA RCX,[R10 + 0x20]
MOV qword ptr [RAX + R10*0x1],RCX
MOV qword ptr [RAX + R10*0x1 + 0x8],RDX
MOV qword ptr [RAX + R10*0x1 + 0x10],0x0
MOV dword ptr [RAX + R10*0x1 + 0x18],ESI
MOV dword ptr [RAX + R10*0x1 + 0x1c],0x0
ADD ECX,EAX
TEST CL,0xf
JNZ 0x0011bc9e
ADD RAX,R10
LEA RCX,[RDI + 0x18]
LEA RDX,[R9 + 0x10]
TEST R9,R9
CMOVZ RDX,RCX
MOV qword ptr [RDX],RAX
MOV qword ptr [RDI + 0x20],RAX
POP RCX
RET
LAB_0011bc6a:
LEA RSI,[0x14e5f9]
LEA RDX,[0x14e648]
MOV EDI,0x3
XOR EAX,EAX
CALL 0x00117810
LEA RDI,[0x14c56f]
LEA RDX,[0x14e658]
MOV ESI,0x5f4
XOR EAX,EAX
CALL 0x00118ce0
LAB_0011bc9e:
LEA RDI,[0x14c56f]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14e686]
MOV ESI,0x600
XOR EAX,EAX
CALL 0x00118ce0
|
void ggml_new_object(ulong *param_1,int4 param_2,long param_3)
{
long *plVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
ulong *puVar5;
long lVar6;
plVar1 = (long *)param_1[4];
if (plVar1 == (long *)0x0) {
lVar3 = 0;
lVar6 = 0;
}
else {
lVar3 = *plVar1;
lVar6 = plVar1[1];
}
lVar6 = lVar6 + lVar3;
uVar4 = param_3 + 0xfU & 0xfffffffffffffff0;
if (*param_1 < uVar4 + lVar6 + 0x20) {
ggml_log_internal(3,
"%s: not enough space in the context\'s memory pool (needed %zu, available %zu)\n"
,"ggml_new_object");
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x5f4,"not enough space in the context\'s memory pool");
}
uVar2 = param_1[1];
*(long *)(uVar2 + lVar6) = lVar6 + 0x20;
*(ulong *)(uVar2 + 8 + lVar6) = uVar4;
*(int8 *)(uVar2 + 0x10 + lVar6) = 0;
*(int4 *)(uVar2 + 0x18 + lVar6) = param_2;
*(int4 *)(uVar2 + 0x1c + lVar6) = 0;
if (((int)(lVar6 + 0x20) + (int)uVar2 & 0xfU) != 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x600,"GGML_ASSERT(%s) failed",
"((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0");
}
puVar5 = (ulong *)(plVar1 + 2);
if (plVar1 == (long *)0x0) {
puVar5 = param_1 + 3;
}
*puVar5 = uVar2 + lVar6;
param_1[4] = uVar2 + lVar6;
return;
}
| |
52,350 | ggml_new_object | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | static struct ggml_object * ggml_new_object(struct ggml_context * ctx, enum ggml_object_type type, size_t size) {
// always insert objects at the end of the context's memory pool
struct ggml_object * obj_cur = ctx->objects_end;
const size_t cur_offs = obj_cur == NULL ? 0 : obj_cur->offs;
const size_t cur_size = obj_cur == NULL ? 0 : obj_cur->size;
const size_t cur_end = cur_offs + cur_size;
// align to GGML_MEM_ALIGN
size_t size_needed = GGML_PAD(size, GGML_MEM_ALIGN);
char * const mem_buffer = ctx->mem_buffer;
struct ggml_object * const obj_new = (struct ggml_object *)(mem_buffer + cur_end);
if (cur_end + size_needed + GGML_OBJECT_SIZE > ctx->mem_size) {
GGML_LOG_WARN("%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",
__func__, cur_end + size_needed + GGML_OBJECT_SIZE, ctx->mem_size);
#ifndef NDEBUG
GGML_ABORT("not enough space in the context's memory pool");
#endif
return NULL;
}
*obj_new = (struct ggml_object) {
.offs = cur_end + GGML_OBJECT_SIZE,
.size = size_needed,
.next = NULL,
.type = type,
};
GGML_ASSERT_ALIGNED(mem_buffer + obj_new->offs);
if (obj_cur != NULL) {
obj_cur->next = obj_new;
} else {
// this is the first object in this context
ctx->objects_begin = obj_new;
}
ctx->objects_end = obj_new;
//printf("%s: inserted new object at %zu, size = %zu\n", __func__, cur_end, obj_new->size);
return obj_new;
} | O3 | c | ggml_new_object:
pushq %rax
movq 0x20(%rdi), %r9
testq %r9, %r9
je 0x1a945
movq 0x8(%r9), %r10
addq (%r9), %r10
jmp 0x1a948
xorl %r10d, %r10d
addq $0xf, %rdx
andq $-0x10, %rdx
movq (%rdi), %r8
leaq (%r10,%rdx), %rcx
addq $0x20, %rcx
cmpq %r8, %rcx
ja 0x1a9a5
movq 0x8(%rdi), %rcx
leaq (%rcx,%r10), %rax
addq $0x20, %r10
movq %r10, (%rax)
movq %rdx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movl %esi, 0x18(%rax)
movl $0x0, 0x1c(%rax)
addl %r10d, %ecx
testb $0xf, %cl
jne 0x1a9d9
leaq 0x18(%rdi), %rcx
leaq 0x10(%r9), %rdx
testq %r9, %r9
cmoveq %rcx, %rdx
movq %rax, (%rdx)
movq %rax, 0x20(%rdi)
popq %rcx
retq
leaq 0x33cf1(%rip), %rsi # 0x4e69d
leaq 0x33d39(%rip), %rdx # 0x4e6ec
movl $0x3, %edi
xorl %eax, %eax
callq 0x16810
leaq 0x31c4d(%rip), %rdi # 0x4c613
leaq 0x33d2f(%rip), %rdx # 0x4e6fc
movl $0x5f4, %esi # imm = 0x5F4
xorl %eax, %eax
callq 0x17cd0
leaq 0x31c33(%rip), %rdi # 0x4c613
leaq 0x31c7e(%rip), %rdx # 0x4c665
leaq 0x33d3c(%rip), %rcx # 0x4e72a
movl $0x600, %esi # imm = 0x600
xorl %eax, %eax
callq 0x17cd0
| ggml_new_object:
push rax
mov r9, [rdi+20h]
test r9, r9
jz short loc_1A945
mov r10, [r9+8]
add r10, [r9]
jmp short loc_1A948
loc_1A945:
xor r10d, r10d
loc_1A948:
add rdx, 0Fh
and rdx, 0FFFFFFFFFFFFFFF0h
mov r8, [rdi]
lea rcx, [r10+rdx]
add rcx, 20h ; ' '
cmp rcx, r8
ja short loc_1A9A5
mov rcx, [rdi+8]
lea rax, [rcx+r10]
add r10, 20h ; ' '
mov [rax], r10
mov [rax+8], rdx
mov qword ptr [rax+10h], 0
mov [rax+18h], esi
mov dword ptr [rax+1Ch], 0
add ecx, r10d
test cl, 0Fh
jnz short loc_1A9D9
lea rcx, [rdi+18h]
lea rdx, [r9+10h]
test r9, r9
cmovz rdx, rcx
mov [rdx], rax
mov [rdi+20h], rax
pop rcx
retn
loc_1A9A5:
lea rsi, aSNotEnoughSpac; "%s: not enough space in the context's m"...
lea rdx, aGgmlNewObject; "ggml_new_object"
mov edi, 3
xor eax, eax
call _ggml_log_internal
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aNotEnoughSpace; "not enough space in the context's memor"...
mov esi, 5F4h
xor eax, eax
call _ggml_abort
loc_1A9D9:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aUintptrTMemBuf; "((uintptr_t) (mem_buffer + obj_new->off"...
mov esi, 600h
xor eax, eax
call _ggml_abort
| long long ggml_new_object(
long long *a1,
int a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11)
{
_QWORD *v11; // r9
long long v12; // r10
unsigned long long v13; // rdx
long long v14; // r8
unsigned long long v15; // rcx
long long v16; // rcx
long long result; // rax
long long v18; // r10
long long *v19; // rdx
int v20; // ecx
int v21; // r8d
int v22; // r9d
v11 = (_QWORD *)a1[4];
if ( v11 )
v12 = *v11 + v11[1];
else
v12 = 0LL;
v13 = (a3 + 15) & 0xFFFFFFFFFFFFFFF0LL;
v14 = *a1;
v15 = v12 + v13 + 32;
if ( v15 > *a1 )
{
ggml_log_internal(
3u,
(long long)"%s: not enough space in the context's memory pool (needed %zu, available %zu)\n",
(long long)"ggml_new_object",
v15,
v14,
(long long)v11,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11);
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
1524,
(unsigned int)"not enough space in the context's memory pool",
v20,
v21,
v22);
}
v16 = a1[1];
result = v16 + v12;
v18 = v12 + 32;
*(_QWORD *)result = v18;
*(_QWORD *)(result + 8) = v13;
*(_QWORD *)(result + 16) = 0LL;
*(_DWORD *)(result + 24) = a2;
*(_DWORD *)(result + 28) = 0;
if ( (((_BYTE)v18 + (_BYTE)v16) & 0xF) != 0 )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
1536,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0",
v14,
(_DWORD)v11);
v19 = v11 + 2;
if ( !v11 )
v19 = a1 + 3;
*v19 = result;
a1[4] = result;
return result;
}
| ggml_new_object:
PUSH RAX
MOV R9,qword ptr [RDI + 0x20]
TEST R9,R9
JZ 0x0011a945
MOV R10,qword ptr [R9 + 0x8]
ADD R10,qword ptr [R9]
JMP 0x0011a948
LAB_0011a945:
XOR R10D,R10D
LAB_0011a948:
ADD RDX,0xf
AND RDX,-0x10
MOV R8,qword ptr [RDI]
LEA RCX,[R10 + RDX*0x1]
ADD RCX,0x20
CMP RCX,R8
JA 0x0011a9a5
MOV RCX,qword ptr [RDI + 0x8]
LEA RAX,[RCX + R10*0x1]
ADD R10,0x20
MOV qword ptr [RAX],R10
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RAX + 0x10],0x0
MOV dword ptr [RAX + 0x18],ESI
MOV dword ptr [RAX + 0x1c],0x0
ADD ECX,R10D
TEST CL,0xf
JNZ 0x0011a9d9
LEA RCX,[RDI + 0x18]
LEA RDX,[R9 + 0x10]
TEST R9,R9
CMOVZ RDX,RCX
MOV qword ptr [RDX],RAX
MOV qword ptr [RDI + 0x20],RAX
POP RCX
RET
LAB_0011a9a5:
LEA RSI,[0x14e69d]
LEA RDX,[0x14e6ec]
MOV EDI,0x3
XOR EAX,EAX
CALL 0x00116810
LEA RDI,[0x14c613]
LEA RDX,[0x14e6fc]
MOV ESI,0x5f4
XOR EAX,EAX
CALL 0x00117cd0
LAB_0011a9d9:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14e72a]
MOV ESI,0x600
XOR EAX,EAX
CALL 0x00117cd0
|
void ggml_new_object(ulong *param_1,int4 param_2,long param_3)
{
long *plVar1;
long *plVar2;
ulong uVar3;
ulong uVar4;
ulong *puVar5;
long lVar6;
plVar2 = (long *)param_1[4];
if (plVar2 == (long *)0x0) {
lVar6 = 0;
}
else {
lVar6 = plVar2[1] + *plVar2;
}
uVar4 = param_3 + 0xfU & 0xfffffffffffffff0;
if (lVar6 + uVar4 + 0x20 <= *param_1) {
uVar3 = param_1[1];
plVar1 = (long *)(uVar3 + lVar6);
*plVar1 = lVar6 + 0x20;
plVar1[1] = uVar4;
plVar1[2] = 0;
*(int4 *)(plVar1 + 3) = param_2;
*(int4 *)((long)plVar1 + 0x1c) = 0;
if (((int)uVar3 + (int)(lVar6 + 0x20) & 0xfU) == 0) {
puVar5 = (ulong *)(plVar2 + 2);
if (plVar2 == (long *)0x0) {
puVar5 = param_1 + 3;
}
*puVar5 = (ulong)plVar1;
param_1[4] = (ulong)plVar1;
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x600,"GGML_ASSERT(%s) failed",
"((uintptr_t) (mem_buffer + obj_new->offs))%GGML_MEM_ALIGN == 0");
}
ggml_log_internal(3,
"%s: not enough space in the context\'s memory pool (needed %zu, available %zu)\n"
,"ggml_new_object");
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
0x5f4,"not enough space in the context\'s memory pool");
}
| |
52,351 | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const | monkey531[P]llama/common/minja.hpp | void dump(std::ostringstream & out, int indent = -1, int level = 0, bool to_json = false) const {
auto print_indent = [&](int level) {
if (indent > 0) {
out << "\n";
for (int i = 0, n = level * indent; i < n; ++i) out << ' ';
}
};
auto print_sub_sep = [&]() {
out << ',';
if (indent < 0) out << ' ';
else print_indent(level + 1);
};
auto string_quote = to_json ? '"' : '\'';
if (is_null()) out << "null";
else if (array_) {
out << "[";
print_indent(level + 1);
for (size_t i = 0; i < array_->size(); ++i) {
if (i) print_sub_sep();
(*array_)[i].dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "]";
} else if (object_) {
out << "{";
print_indent(level + 1);
for (auto begin = object_->begin(), it = begin; it != object_->end(); ++it) {
if (it != begin) print_sub_sep();
if (it->first.is_string()) {
dump_string(it->first, out, string_quote);
} else {
out << string_quote << it->first.dump() << string_quote;
}
out << ": ";
it->second.dump(out, indent, level + 1, to_json);
}
print_indent(level);
out << "}";
} else if (callable_) {
throw std::runtime_error("Cannot dump callable to JSON");
} else if (is_boolean() && !to_json) {
out << (this->to_bool() ? "True" : "False");
} else if (is_string() && !to_json) {
dump_string(primitive_, out, string_quote);
} else {
out << primitive_.dump();
}
} | O2 | cpp | minja::Value::dump(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int, bool) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %edx, (%rax)
leaq 0x8(%rsp), %rdx
movl %ecx, (%rdx)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rsi, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
xorl %r15d, %r15d
testl %r8d, %r8d
sete %bpl
callq 0x7f972
testb %al, %al
je 0x7f6aa
leaq 0x523ec(%rip), %rsi # 0xd1a91
jmp 0x7f8f5
cmpq $0x0, 0x10(%rbx)
je 0x7f74d
leaq 0x531ab(%rip), %rsi # 0xd2867
movq %r14, %rdi
callq 0x26c10
movl 0x8(%rsp), %esi
incl %esi
leaq 0x18(%rsp), %rdi
callq 0x7f992
xorl %r13d, %r13d
movl %r12d, %eax
pushq $0x50
popq %r12
movzbl %al, %ebp
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r15
jae 0x7f733
testq %r15, %r15
je 0x7f712
leaq 0x48(%rsp), %rdi
callq 0x7f9de
movq 0x10(%rbx), %rax
movq (%rax), %rdi
addq %r13, %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
incl %ecx
movq %r14, %rsi
movl %ebp, %r8d
callq 0x7f646
incq %r15
addq $0x50, %r13
jmp 0x7f6e4
movl 0x8(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x7f992
leaq 0x50a6d(%rip), %rsi # 0xd01b5
jmp 0x7f8f5
movb %bpl, %r15b
leal (%r15,%r15,4), %ebp
addl $0x22, %ebp
cmpq $0x0, 0x20(%rbx)
je 0x7f880
leaq 0x519f0(%rip), %rsi # 0xd1159
movq %r14, %rdi
callq 0x26c10
movl 0x8(%rsp), %esi
incl %esi
leaq 0x18(%rsp), %rdi
callq 0x7f992
movq 0x20(%rbx), %rax
movq (%rax), %r15
xorl %r13d, %r13d
movsbl %bpl, %ebp
movl %r12d, %ecx
leaq 0x530dd(%rip), %r12 # 0xd2876
movzbl %cl, %ecx
movl %ecx, 0x14(%rsp)
movl %ebp, 0x10(%rsp)
cmpq 0x8(%rax), %r15
je 0x7f869
testq %r13, %r13
je 0x7f7bd
leaq 0x48(%rsp), %rdi
callq 0x7f9de
cmpb $0x3, (%r15)
jne 0x7f7d2
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7fa14
jmp 0x7f832
movq %r14, %rdi
movq %r13, %r14
movq %rbx, %r13
movq %rdi, %rbx
movl %ebp, %esi
callq 0x26e60
movq %rax, %rbp
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7956c
movq %rbp, %rdi
movl 0x10(%rsp), %ebp
leaq 0x28(%rsp), %rsi
callq 0x26ab0
movq %rax, %rdi
movl %ebp, %esi
callq 0x26e60
leaq 0x28(%rsp), %rdi
callq 0x27998
movq %rbx, %rax
movq %r13, %rbx
movq %r14, %r13
movq %rax, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x26c10
leaq 0x10(%r15), %rdi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
incl %ecx
movq %r14, %rsi
movl 0x14(%rsp), %r8d
callq 0x7f646
addq $0x60, %r15
movq 0x20(%rbx), %rax
addq $-0x60, %r13
jmp 0x7f7a4
movl 0x8(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x7f992
leaq 0x560a1(%rip), %rsi # 0xd591f
jmp 0x7f8f5
cmpq $0x0, 0x30(%rbx)
jne 0x7f91d
movb 0x40(%rbx), %al
cmpb $0x4, %al
setne %cl
orb %r12b, %cl
je 0x7f8d9
addq $0x40, %rbx
cmpb $0x3, %al
setne %al
orb %r12b, %al
je 0x7f90c
leaq 0x28(%rsp), %r15
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7956c
movq %r14, %rdi
movq %r15, %rsi
callq 0x26ab0
leaq 0x28(%rsp), %rdi
callq 0x27998
jmp 0x7f8fd
movq %rbx, %rdi
callq 0x7f0e0
leaq 0x51890(%rip), %rcx # 0xd1178
leaq 0x5188e(%rip), %rsi # 0xd117d
testb %al, %al
cmovneq %rcx, %rsi
movq %r14, %rdi
callq 0x26c10
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movsbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7fa14
jmp 0x7f8fd
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r14
leaq 0x5182c(%rip), %rsi # 0xd115b
movq %rax, %rdi
callq 0x26420
movq 0xa16b2(%rip), %rsi # 0x120ff0
movq 0xa1613(%rip), %rdx # 0x120f58
movq %r14, %rdi
callq 0x275b0
jmp 0x7f95c
movq %rax, %rbx
movq %r14, %rdi
callq 0x268f0
jmp 0x7f969
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27998
movq %rbx, %rdi
callq 0x27660
nop
| _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov r14, rsi
mov rbx, rdi
lea rax, [rsp+98h+var_8C]
mov [rax], edx
lea rdx, [rsp+98h+var_90]
mov [rdx], ecx
lea rcx, [rsp+98h+var_80]
mov [rcx], rax
mov [rcx+8], rsi
mov [rsp+98h+var_50], rsi
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_40], rcx
mov [rsp+98h+var_38], rdx
xor r15d, r15d
test r8d, r8d
setz bpl
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_7F6AA
lea rsi, aOnNull_0+5; "null"
jmp loc_7F8F5
loc_7F6AA:
cmp qword ptr [rbx+10h], 0
jz loc_7F74D
lea rsi, aBytes+9; "["
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+98h+var_90]
inc esi
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
xor r13d, r13d
mov eax, r12d
push 50h ; 'P'
pop r12
movzx ebp, al
xor r15d, r15d
loc_7F6E4:
mov rax, [rbx+10h]
mov rdi, [rax]
mov rax, [rax+8]
sub rax, rdi
cqo
idiv r12
cmp r15, rax
jnb short loc_7F733
test r15, r15
jz short loc_7F712
lea rdi, [rsp+98h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
mov rax, [rbx+10h]
mov rdi, [rax]
loc_7F712:
add rdi, r13; this
mov edx, [rsp+98h+var_8C]
mov ecx, [rsp+98h+var_90]
inc ecx
mov rsi, r14
mov r8d, ebp
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
inc r15
add r13, 50h ; 'P'
jmp short loc_7F6E4
loc_7F733:
mov esi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
lea rsi, asc_D01B4+1; "]"
jmp loc_7F8F5
loc_7F74D:
mov r15b, bpl
lea ebp, [r15+r15*4]
add ebp, 22h ; '"'
cmp qword ptr [rbx+20h], 0
jz loc_7F880
lea rsi, asc_D1159; "{"
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov esi, [rsp+98h+var_90]
inc esi
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
mov rax, [rbx+20h]
mov r15, [rax]
xor r13d, r13d
movsx ebp, bpl
mov ecx, r12d
lea r12, aSubtype+9; ": "
movzx ecx, cl
mov [rsp+98h+var_84], ecx
mov [rsp+98h+var_88], ebp
loc_7F7A4:
cmp r15, [rax+8]
jz loc_7F869
test r13, r13
jz short loc_7F7BD
lea rdi, [rsp+98h+var_50]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUlvE_clEv; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(void)#1}::operator()(void)
loc_7F7BD:
cmp byte ptr [r15], 3
jnz short loc_7F7D2
mov rdi, r15
mov rsi, r14
mov edx, ebp
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,std::ostringstream &,char)
jmp short loc_7F832
loc_7F7D2:
mov rdi, r14
mov r14, r13
mov r13, rbx
mov rbx, rdi
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov rbp, rax
lea rdi, [rsp+98h+var_70]
mov rsi, r15
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
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, rbp
mov ebp, [rsp+98h+var_88]
lea rsi, [rsp+98h+var_70]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rdi, rax
mov esi, ebp
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
mov rbx, r13
mov r13, r14
mov r14, rax
loc_7F832:
mov rdi, r14
mov rsi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rdi, [r15+10h]
mov edx, [rsp+98h+var_8C]
mov ecx, [rsp+98h+var_90]
inc ecx
mov rsi, r14
mov r8d, [rsp+98h+var_84]
call _ZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiib; minja::Value::dump(std::ostringstream &,int,int,bool)
add r15, 60h ; '`'
mov rax, [rbx+20h]
add r13, 0FFFFFFFFFFFFFFA0h
jmp loc_7F7A4
loc_7F869:
mov esi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_80]
call _ZZNK5minja5Value4dumpERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEEiibENKUliE_clEi; minja::Value::dump(std::ostringstream &,int,int,bool)::{lambda(int)#1}::operator()(int)
lea rsi, aNT020+17h; "}"
jmp short loc_7F8F5
loc_7F880:
cmp qword ptr [rbx+30h], 0
jnz loc_7F91D
mov al, [rbx+40h]
cmp al, 4
setnz cl
or cl, r12b
jz short loc_7F8D9
add rbx, 40h ; '@'
cmp al, 3
setnz al
or al, r12b
jz short loc_7F90C
lea r15, [rsp+98h+var_70]
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
mov rdi, r15
mov rsi, rbx
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, r14
mov rsi, r15
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7F8FD
loc_7F8D9:
mov rdi, rbx; this
call _ZNK5minja5Value7to_boolEv; minja::Value::to_bool(void)
lea rcx, aTrue_0; "True"
lea rsi, aFalse; "False"
test al, al
cmovnz rsi, rcx
loc_7F8F5:
mov rdi, r14
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_7F8FD:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7F90C:
movsx edx, bpl
mov rdi, rbx
mov rsi, r14
call _ZN5minja5Value11dump_stringERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEERNS6_19basic_ostringstreamIcS9_SA_EEc; minja::Value::dump_string(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,std::ostringstream &,char)
jmp short loc_7F8FD
loc_7F91D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aCannotDumpCall; "Cannot dump callable to JSON"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_7F95C
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7F969
loc_7F95C:
mov rbx, rax
lea rdi, [rsp+98h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_7F969:
mov rdi, rbx
call __Unwind_Resume
| void minja::Value::dump(long long a1, long long a2, unsigned int a3, unsigned int a4, int a5)
{
unsigned __int8 v5; // r12
long long v6; // r14
long long v7; // rbx
bool v8; // bp
char *v9; // rsi
long long v10; // r13
unsigned long long i; // r15
long long *v12; // rax
long long v13; // rdi
bool v14; // r15
unsigned int v15; // ebp
_BYTE **v16; // rax
_BYTE *v17; // r15
long long v18; // r13
long long v19; // rdi
long long v20; // r14
long long v21; // r13
long long v22; // rbx
long long v23; // rbp
long long v24; // rdi
long long v25; // rax
long long v26; // rax
char v27; // al
long long v28; // rbx
std::runtime_error *exception; // r14
unsigned int v30; // [rsp+8h] [rbp-90h] BYREF
unsigned int v31; // [rsp+Ch] [rbp-8Ch] BYREF
unsigned int v32; // [rsp+10h] [rbp-88h]
unsigned int v33; // [rsp+14h] [rbp-84h]
_QWORD v34[2]; // [rsp+18h] [rbp-80h] BYREF
_BYTE v35[32]; // [rsp+28h] [rbp-70h] BYREF
_QWORD v36[10]; // [rsp+48h] [rbp-50h] BYREF
v5 = a5;
v6 = a2;
v7 = a1;
v31 = a3;
v30 = a4;
v34[0] = &v31;
v34[1] = a2;
v36[0] = a2;
v36[1] = &v31;
v36[2] = v34;
v36[3] = &v30;
v8 = a5 == 0;
if ( (unsigned __int8)minja::Value::is_null((minja::Value *)a1) )
{
v9 = "null";
LABEL_26:
std::operator<<<std::char_traits<char>>(v6, v9);
return;
}
if ( *(_QWORD *)(a1 + 16) )
{
std::operator<<<std::char_traits<char>>(a2, "[");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30 + 1);
v10 = 0LL;
for ( i = 0LL; ; ++i )
{
v12 = *(long long **)(v7 + 16);
v13 = *v12;
if ( i >= (v12[1] - *v12) / 80 )
break;
if ( i )
{
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v36);
v13 = **(_QWORD **)(v7 + 16);
}
minja::Value::dump(v10 + v13, a2, v31, v30 + 1, v5);
v10 += 80LL;
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30);
v9 = "]";
goto LABEL_26;
}
v14 = v8;
LOBYTE(v15) = 5 * v8 + 34;
if ( *(_QWORD *)(a1 + 32) )
{
std::operator<<<std::char_traits<char>>(a2, "{");
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30 + 1);
v16 = *(_BYTE ***)(a1 + 32);
v17 = *v16;
v18 = 0LL;
v15 = (char)v15;
v33 = v5;
v32 = (char)v15;
while ( v17 != v16[1] )
{
if ( v18 )
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(void)#1}::operator()(v36);
if ( *v17 == 3 )
{
minja::Value::dump_string(v17, v6, v15);
}
else
{
v19 = v6;
v20 = v18;
v21 = v7;
v22 = v19;
v23 = std::operator<<<std::char_traits<char>>(v19, 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>::dump(
(long long)v35,
(long long)v17,
-1,
32,
0,
0);
v24 = v23;
v15 = v32;
v25 = std::operator<<<char>(v24, v35);
std::operator<<<std::char_traits<char>>(v25, v15);
std::string::~string(v35);
v26 = v22;
v7 = v21;
v18 = v20;
v6 = v26;
}
std::operator<<<std::char_traits<char>>(v6, ": ");
minja::Value::dump(v17 + 16, v6, v31, v30 + 1, v33);
v17 += 96;
v16 = *(_BYTE ***)(v7 + 32);
v18 -= 96LL;
}
minja::Value::dump(std::ostringstream &,int,int,bool)const::{lambda(int)#1}::operator()(v34, v30);
v9 = "}";
goto LABEL_26;
}
if ( *(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Cannot dump callable to JSON");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v27 = *(_BYTE *)(a1 + 64);
if ( !(v5 | (v27 != 4)) )
{
v9 = "False";
if ( (unsigned __int8)minja::Value::to_bool((minja::Value *)a1) )
v9 = "True";
goto LABEL_26;
}
v28 = a1 + 64;
if ( v5 | (v27 != 3) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v35,
v28,
-1,
32,
0,
0);
std::operator<<<char>(a2, v35);
std::string::~string(v35);
}
else
{
minja::Value::dump_string(v28, a2, (unsigned int)(char)(5 * v14 + 34));
}
}
| dump:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RSP + 0xc]
MOV dword ptr [RAX],EDX
LEA RDX,[RSP + 0x8]
MOV dword ptr [RDX],ECX
LEA RCX,[RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV qword ptr [RCX + 0x8],RSI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x60],RDX
XOR R15D,R15D
TEST R8D,R8D
SETZ BPL
CALL 0x0017f972
TEST AL,AL
JZ 0x0017f6aa
LEA RSI,[0x1d1a91]
JMP 0x0017f8f5
LAB_0017f6aa:
CMP qword ptr [RBX + 0x10],0x0
JZ 0x0017f74d
LEA RSI,[0x1d2867]
MOV RDI,R14
CALL 0x00126c10
MOV ESI,dword ptr [RSP + 0x8]
INC ESI
LEA RDI,[RSP + 0x18]
CALL 0x0017f992
XOR R13D,R13D
MOV EAX,R12D
PUSH 0x50
POP R12
MOVZX EBP,AL
XOR R15D,R15D
LAB_0017f6e4:
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,RDI
CQO
IDIV R12
CMP R15,RAX
JNC 0x0017f733
TEST R15,R15
JZ 0x0017f712
LEA RDI,[RSP + 0x48]
CALL 0x0017f9de
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX]
LAB_0017f712:
ADD RDI,R13
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x8]
INC ECX
MOV RSI,R14
MOV R8D,EBP
CALL 0x0017f646
INC R15
ADD R13,0x50
JMP 0x0017f6e4
LAB_0017f733:
MOV ESI,dword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x18]
CALL 0x0017f992
LEA RSI,[0x1d01b5]
JMP 0x0017f8f5
LAB_0017f74d:
MOV R15B,BPL
LEA EBP,[R15 + R15*0x4]
ADD EBP,0x22
CMP qword ptr [RBX + 0x20],0x0
JZ 0x0017f880
LEA RSI,[0x1d1159]
MOV RDI,R14
CALL 0x00126c10
MOV ESI,dword ptr [RSP + 0x8]
INC ESI
LEA RDI,[RSP + 0x18]
CALL 0x0017f992
MOV RAX,qword ptr [RBX + 0x20]
MOV R15,qword ptr [RAX]
XOR R13D,R13D
MOVSX EBP,BPL
MOV ECX,R12D
LEA R12,[0x1d2876]
MOVZX ECX,CL
MOV dword ptr [RSP + 0x14],ECX
MOV dword ptr [RSP + 0x10],EBP
LAB_0017f7a4:
CMP R15,qword ptr [RAX + 0x8]
JZ 0x0017f869
TEST R13,R13
JZ 0x0017f7bd
LEA RDI,[RSP + 0x48]
CALL 0x0017f9de
LAB_0017f7bd:
CMP byte ptr [R15],0x3
JNZ 0x0017f7d2
MOV RDI,R15
MOV RSI,R14
MOV EDX,EBP
CALL 0x0017fa14
JMP 0x0017f832
LAB_0017f7d2:
MOV RDI,R14
MOV R14,R13
MOV R13,RBX
MOV RBX,RDI
MOV ESI,EBP
CALL 0x00126e60
MOV RBP,RAX
LEA RDI,[RSP + 0x28]
MOV RSI,R15
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0017956c
LAB_0017f801:
MOV RDI,RBP
MOV EBP,dword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x28]
CALL 0x00126ab0
MOV RDI,RAX
MOV ESI,EBP
CALL 0x00126e60
LAB_0017f81c:
LEA RDI,[RSP + 0x28]
CALL 0x00127998
MOV RAX,RBX
MOV RBX,R13
MOV R13,R14
MOV R14,RAX
LAB_0017f832:
MOV RDI,R14
MOV RSI,R12
CALL 0x00126c10
LEA RDI,[R15 + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x8]
INC ECX
MOV RSI,R14
MOV R8D,dword ptr [RSP + 0x14]
CALL 0x0017f646
ADD R15,0x60
MOV RAX,qword ptr [RBX + 0x20]
ADD R13,-0x60
JMP 0x0017f7a4
LAB_0017f869:
MOV ESI,dword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x18]
CALL 0x0017f992
LEA RSI,[0x1d591f]
JMP 0x0017f8f5
LAB_0017f880:
CMP qword ptr [RBX + 0x30],0x0
JNZ 0x0017f91d
MOV AL,byte ptr [RBX + 0x40]
CMP AL,0x4
SETNZ CL
OR CL,R12B
JZ 0x0017f8d9
ADD RBX,0x40
CMP AL,0x3
SETNZ AL
OR AL,R12B
JZ 0x0017f90c
LEA R15,[RSP + 0x28]
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
MOV RDI,R15
MOV RSI,RBX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0017956c
LAB_0017f8c2:
MOV RDI,R14
MOV RSI,R15
CALL 0x00126ab0
LAB_0017f8cd:
LEA RDI,[RSP + 0x28]
CALL 0x00127998
JMP 0x0017f8fd
LAB_0017f8d9:
MOV RDI,RBX
CALL 0x0017f0e0
LEA RCX,[0x1d1178]
LEA RSI,[0x1d117d]
TEST AL,AL
CMOVNZ RSI,RCX
LAB_0017f8f5:
MOV RDI,R14
CALL 0x00126c10
LAB_0017f8fd:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017f90c:
MOVSX EDX,BPL
MOV RDI,RBX
MOV RSI,R14
CALL 0x0017fa14
JMP 0x0017f8fd
LAB_0017f91d:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R14,RAX
LAB_0017f928:
LEA RSI,[0x1d115b]
MOV RDI,RAX
CALL 0x00126420
LAB_0017f937:
MOV RSI,qword ptr [0x00220ff0]
MOV RDX,qword ptr [0x00220f58]
MOV RDI,R14
CALL 0x001275b0
|
/* minja::Value::dump(std::__cxx11::ostringstream&, int, int, bool) const */
void __thiscall
minja::Value::dump(Value *this,ostringstream *param_1,int param_2,int param_3,bool param_4)
{
char cVar1;
int8 *puVar2;
ostream *poVar3;
runtime_error *this_00;
int iVar4;
char *pcVar5;
long lVar6;
int7 in_register_00000081;
long lVar7;
ulong uVar8;
int local_90;
int local_8c;
int local_88;
uint local_84;
int *local_80;
ostringstream *local_78;
string local_70 [32];
ostringstream *local_50;
int *local_48;
int **local_40;
int *local_38;
local_80 = &local_8c;
local_38 = &local_90;
local_40 = &local_80;
local_90 = param_3;
local_8c = param_2;
local_78 = param_1;
local_50 = param_1;
local_48 = local_80;
cVar1 = is_null(this);
if (cVar1 == '\0') {
if (*(long *)(this + 0x10) == 0) {
cVar1 = ((int)CONCAT71(in_register_00000081,param_4) == 0) * '\x05' + '\"';
if (*(long *)(this + 0x20) == 0) {
if (*(long *)(this + 0x30) != 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017f928 to 0017f936 has its CatchHandler @ 0017f94f */
std::runtime_error::runtime_error(this_00,"Cannot dump callable to JSON");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00220ff0,PTR__runtime_error_00220f58);
}
if (this[0x40] != (Value)0x4 || param_4) {
if (this[0x40] != (Value)0x3 || param_4) {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_70,this + 0x40,0xffffffffffffffff,0x20,0,0);
/* try { // try from 0017f8c2 to 0017f8cc has its CatchHandler @ 0017f94d */
std::operator<<((ostream *)param_1,local_70);
std::__cxx11::string::~string(local_70);
return;
}
dump_string(this + 0x40,param_1,cVar1);
return;
}
cVar1 = to_bool(this);
pcVar5 = "False";
if (cVar1 != '\0') {
pcVar5 = "True";
}
}
else {
std::operator<<((ostream *)param_1,"{");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90 + 1);
puVar2 = *(int8 **)(this + 0x20);
lVar7 = 0;
iVar4 = (int)cVar1;
local_84 = (uint)param_4;
local_88 = iVar4;
for (pcVar5 = (char *)*puVar2; pcVar5 != (char *)puVar2[1]; pcVar5 = pcVar5 + 0x60) {
if (lVar7 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
}
if (*pcVar5 == '\x03') {
dump_string(pcVar5,param_1,(char)iVar4);
}
else {
poVar3 = std::operator<<((ostream *)param_1,(char)iVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_70,pcVar5,0xffffffffffffffff,0x20,0,0);
iVar4 = local_88;
/* try { // try from 0017f801 to 0017f81b has its CatchHandler @ 0017f95c */
poVar3 = std::operator<<(poVar3,local_70);
std::operator<<(poVar3,(char)iVar4);
std::__cxx11::string::~string(local_70);
}
std::operator<<((ostream *)param_1,": ");
dump((Value *)(pcVar5 + 0x10),param_1,local_8c,local_90 + 1,SUB41(local_84,0));
puVar2 = *(int8 **)(this + 0x20);
lVar7 = lVar7 + -0x60;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90);
pcVar5 = "}";
}
}
else {
std::operator<<((ostream *)param_1,"[");
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90 + 1);
lVar7 = 0;
for (uVar8 = 0; lVar6 = **(long **)(this + 0x10),
uVar8 < (ulong)(((*(long **)(this + 0x10))[1] - lVar6) / 0x50); uVar8 = uVar8 + 1) {
if (uVar8 != 0) {
const::{lambda()#1}::operator()((_lambda___1_ *)&local_50);
lVar6 = **(long **)(this + 0x10);
}
dump((Value *)(lVar6 + lVar7),param_1,local_8c,local_90 + 1,param_4);
lVar7 = lVar7 + 0x50;
}
const::{lambda(int)#1}::operator()((_lambda_int__1_ *)&local_80,local_90);
pcVar5 = "]";
}
}
else {
pcVar5 = "null";
}
std::operator<<((ostream *)param_1,pcVar5);
return;
}
| |
52,352 | translog_deassign_id_from_share | eloqsql/storage/maria/ma_loghandler.c | void translog_deassign_id_from_share(MARIA_SHARE *share)
{
DBUG_PRINT("info", ("id_to_share: %p id %u -> 0",
share, share->id));
/*
We don't need any mutex as we are called only when closing the last
instance of the table or at the end of REPAIR: no writes can be
happening. But a Checkpoint may be reading share->id, so we require this
mutex:
*/
mysql_mutex_assert_owner(&share->intern_lock);
my_atomic_storeptr((void **)&id_to_share[share->id], 0);
share->id= 0;
/* useless but safety: */
share->lsn_of_file_id= LSN_IMPOSSIBLE;
} | O3 | c | translog_deassign_id_from_share:
pushq %rbp
movq %rsp, %rbp
movq 0xb9f1c2(%rip), %rax # 0xc0b7c8
movzwl 0x620(%rdi), %ecx
xorl %edx, %edx
xchgq %rdx, (%rax,%rcx,8)
movw $0x0, 0x620(%rdi)
movq $0x0, 0xc10(%rdi)
popq %rbp
retq
| translog_deassign_id_from_share:
push rbp
mov rbp, rsp
mov rax, cs:id_to_share
movzx ecx, word ptr [rdi+620h]
xor edx, edx
xchg rdx, [rax+rcx*8]
mov word ptr [rdi+620h], 0
mov qword ptr [rdi+0C10h], 0
pop rbp
retn
| long long translog_deassign_id_from_share(long long a1)
{
long long result; // rax
result = id_to_share;
_InterlockedExchange64((volatile long long *)(id_to_share + 8LL * *(unsigned __int16 *)(a1 + 1568)), 0LL);
*(_WORD *)(a1 + 1568) = 0;
*(_QWORD *)(a1 + 3088) = 0LL;
return result;
}
| translog_deassign_id_from_share:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [0x00d0b7c8]
MOVZX ECX,word ptr [RDI + 0x620]
XOR EDX,EDX
XCHG qword ptr [RAX + RCX*0x8],RDX
MOV word ptr [RDI + 0x620],0x0
MOV qword ptr [RDI + 0xc10],0x0
POP RBP
RET
|
void translog_deassign_id_from_share(long param_1)
{
LOCK();
*(int8 *)(id_to_share + (ulong)*(ushort *)(param_1 + 0x620) * 8) = 0;
UNLOCK();
*(int2 *)(param_1 + 0x620) = 0;
*(int8 *)(param_1 + 0xc10) = 0;
return;
}
| |
52,353 | mi_keylength | eloqsql/storage/myisam/mi_search.c | uint _mi_keylength(MI_KEYDEF *keyinfo, register uchar *key)
{
reg1 HA_KEYSEG *keyseg;
uchar *start;
if (! (keyinfo->flag & (HA_VAR_LENGTH_KEY | HA_BINARY_PACK_KEY)))
return (keyinfo->keylength);
start=key;
for (keyseg=keyinfo->seg ; keyseg->type ; keyseg++)
{
if (keyseg->flag & HA_NULL_PART)
if (!*key++)
continue;
if (keyseg->flag & (HA_SPACE_PACK | HA_BLOB_PART | HA_VAR_LENGTH_PART))
{
uint length;
get_key_length(length,key);
key+=length;
}
else
key+= keyseg->length;
}
return((uint) (key-start)+keyseg->length);
} | O3 | c | mi_keylength:
testb $0x28, 0xa(%rdi)
je 0x86f28
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rax
cmpb $0x0, 0x18(%rax)
je 0x86f2d
movq %rsi, %rcx
movzwl 0x12(%rax), %edx
testb $0x10, %dl
je 0x86ee5
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
je 0x86f19
testb $0x29, %dl
je 0x86efd
movzbl (%rcx), %edx
cmpq $0xff, %rdx
je 0x86f03
movl $0x1, %edi
jmp 0x86f13
movzwl 0x14(%rax), %edx
jmp 0x86f16
movzwl 0x1(%rcx), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movl $0x3, %edi
addq %rdi, %rcx
addq %rdx, %rcx
leaq 0x20(%rax), %rdx
cmpb $0x0, 0x38(%rax)
movq %rdx, %rax
jne 0x86ed3
jmp 0x86f33
movzwl 0x12(%rdi), %eax
retq
movq %rsi, %rcx
movq %rax, %rdx
subl %esi, %ecx
movzwl 0x14(%rdx), %eax
addl %ecx, %eax
popq %rbp
retq
| _mi_keylength:
test byte ptr [rdi+0Ah], 28h
jz short loc_86F28
push rbp
mov rbp, rsp
mov rax, [rdi+28h]
cmp byte ptr [rax+18h], 0
jz short loc_86F2D
mov rcx, rsi
loc_86ED3:
movzx edx, word ptr [rax+12h]
test dl, 10h
jz short loc_86EE5
cmp byte ptr [rcx], 0
lea rcx, [rcx+1]
jz short loc_86F19
loc_86EE5:
test dl, 29h
jz short loc_86EFD
movzx edx, byte ptr [rcx]
cmp rdx, 0FFh
jz short loc_86F03
mov edi, 1
jmp short loc_86F13
loc_86EFD:
movzx edx, word ptr [rax+14h]
jmp short loc_86F16
loc_86F03:
movzx edx, word ptr [rcx+1]
rol dx, 8
movzx edx, dx
mov edi, 3
loc_86F13:
add rcx, rdi
loc_86F16:
add rcx, rdx
loc_86F19:
lea rdx, [rax+20h]
cmp byte ptr [rax+38h], 0
mov rax, rdx
jnz short loc_86ED3
jmp short loc_86F33
loc_86F28:
movzx eax, word ptr [rdi+12h]
retn
loc_86F2D:
mov rcx, rsi
mov rdx, rax
loc_86F33:
sub ecx, esi
movzx eax, word ptr [rdx+14h]
add eax, ecx
pop rbp
retn
| long long mi_keylength(long long a1, unsigned __int8 *a2)
{
long long v2; // rax
unsigned __int8 *v3; // rcx
__int16 v4; // dx
bool v5; // zf
long long v6; // rdx
long long v7; // rdi
long long v8; // rdx
if ( (*(_BYTE *)(a1 + 10) & 0x28) == 0 )
return *(unsigned __int16 *)(a1 + 18);
v2 = *(_QWORD *)(a1 + 40);
if ( *(_BYTE *)(v2 + 24) )
{
v3 = a2;
do
{
v4 = *(_WORD *)(v2 + 18);
if ( (v4 & 0x10) == 0 || (v5 = *v3 == 0, ++v3, !v5) )
{
if ( (v4 & 0x29) != 0 )
{
v6 = *v3;
if ( v6 == 255 )
{
v6 = (unsigned __int16)__ROL2__(*(_WORD *)(v3 + 1), 8);
v7 = 3LL;
}
else
{
v7 = 1LL;
}
v3 += v7;
}
else
{
v6 = *(unsigned __int16 *)(v2 + 20);
}
v3 += v6;
}
v8 = v2 + 32;
v5 = *(_BYTE *)(v2 + 56) == 0;
v2 += 32LL;
}
while ( !v5 );
}
else
{
LODWORD(v3) = (_DWORD)a2;
v8 = *(_QWORD *)(a1 + 40);
}
return (_DWORD)v3 - (_DWORD)a2 + (unsigned int)*(unsigned __int16 *)(v8 + 20);
}
| _mi_keylength:
TEST byte ptr [RDI + 0xa],0x28
JZ 0x00186f28
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x28]
CMP byte ptr [RAX + 0x18],0x0
JZ 0x00186f2d
MOV RCX,RSI
LAB_00186ed3:
MOVZX EDX,word ptr [RAX + 0x12]
TEST DL,0x10
JZ 0x00186ee5
CMP byte ptr [RCX],0x0
LEA RCX,[RCX + 0x1]
JZ 0x00186f19
LAB_00186ee5:
TEST DL,0x29
JZ 0x00186efd
MOVZX EDX,byte ptr [RCX]
CMP RDX,0xff
JZ 0x00186f03
MOV EDI,0x1
JMP 0x00186f13
LAB_00186efd:
MOVZX EDX,word ptr [RAX + 0x14]
JMP 0x00186f16
LAB_00186f03:
MOVZX EDX,word ptr [RCX + 0x1]
ROL DX,0x8
MOVZX EDX,DX
MOV EDI,0x3
LAB_00186f13:
ADD RCX,RDI
LAB_00186f16:
ADD RCX,RDX
LAB_00186f19:
LEA RDX,[RAX + 0x20]
CMP byte ptr [RAX + 0x38],0x0
MOV RAX,RDX
JNZ 0x00186ed3
JMP 0x00186f33
LAB_00186f28:
MOVZX EAX,word ptr [RDI + 0x12]
RET
LAB_00186f2d:
MOV RCX,RSI
MOV RDX,RAX
LAB_00186f33:
SUB ECX,ESI
MOVZX EAX,word ptr [RDX + 0x14]
ADD EAX,ECX
POP RBP
RET
|
uint _mi_keylength(long param_1,byte *param_2)
{
char cVar1;
byte bVar2;
long lVar3;
ulong uVar4;
int iVar5;
long lVar6;
iVar5 = (int)param_2;
if ((*(byte *)(param_1 + 10) & 0x28) == 0) {
return (uint)*(ushort *)(param_1 + 0x12);
}
cVar1 = *(char *)(*(long *)(param_1 + 0x28) + 0x18);
lVar3 = *(long *)(param_1 + 0x28);
while (cVar1 != '\0') {
if (((*(ushort *)(lVar3 + 0x12) & 0x10) == 0) ||
(bVar2 = *param_2, param_2 = param_2 + 1, bVar2 != 0)) {
if ((*(ushort *)(lVar3 + 0x12) & 0x29) == 0) {
uVar4 = (ulong)*(ushort *)(lVar3 + 0x14);
}
else {
uVar4 = (ulong)*param_2;
if (uVar4 == 0xff) {
uVar4 = (ulong)(ushort)(*(ushort *)(param_2 + 1) << 8 | *(ushort *)(param_2 + 1) >> 8);
lVar6 = 3;
}
else {
lVar6 = 1;
}
param_2 = param_2 + lVar6;
}
param_2 = param_2 + uVar4;
}
cVar1 = *(char *)(lVar3 + 0x38);
lVar3 = lVar3 + 0x20;
}
return (uint)*(ushort *)(lVar3 + 0x14) + ((int)param_2 - iVar5);
}
| |
52,354 | my_wc_mb_bin | eloqsql/strings/ctype-bin.c | int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 256)
{
s[0]= (char) wc;
return 1;
}
return MY_CS_ILUNI;
} | O3 | c | my_wc_mb_bin:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xabccb
xorl %eax, %eax
cmpq $0xff, %rsi
ja 0xabccb
movb %sil, (%rdx)
movl $0x1, %eax
popq %rbp
retq
| my_wc_mb_bin:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_ABCCB
xor eax, eax
cmp rsi, 0FFh
ja short loc_ABCCB
mov [rdx], sil
mov eax, 1
loc_ABCCB:
pop rbp
retn
| long long my_wc_mb_bin(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
result = 0LL;
if ( a2 <= 0xFF )
{
*a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_bin:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001abccb
XOR EAX,EAX
CMP RSI,0xff
JA 0x001abccb
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_001abccb:
POP RBP
RET
|
int8 my_wc_mb_bin(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9b;
if ((param_3 < param_4) && (uVar1 = 0, param_2 < 0x100)) {
*param_3 = (char)param_2;
uVar1 = 1;
}
return uVar1;
}
| |
52,355 | stbtt__get_subr | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h | static stbtt__buf stbtt__get_subr(stbtt__buf idx, int n)
{
int count = stbtt__cff_index_count(&idx);
int bias = 107;
if (count >= 33900)
bias = 32768;
else if (count >= 1240)
bias = 1131;
n += bias;
if (n < 0 || n >= count)
return stbtt__new_buf(NULL, 0);
return stbtt__cff_index_get(idx, n);
} | O0 | c | stbtt__get_subr:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5c520
movl %eax, -0x28(%rbp)
movl $0x6b, -0x2c(%rbp)
cmpl $0x846c, -0x28(%rbp) # imm = 0x846C
jl 0x5c2a8
movl $0x8000, -0x2c(%rbp) # imm = 0x8000
jmp 0x5c2ba
cmpl $0x4d8, -0x28(%rbp) # imm = 0x4D8
jl 0x5c2b8
movl $0x46b, -0x2c(%rbp) # imm = 0x46B
jmp 0x5c2ba
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x5c2d1
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x5c2e7
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x58910
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x5c2ff
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x58c30
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| stbtt__get_subr:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_20], rdi
mov [rbp+var_18], rsi
mov [rbp+var_24], edx
lea rdi, [rbp+var_20]
call stbtt__cff_index_count
mov [rbp+var_28], eax
mov [rbp+var_2C], 6Bh ; 'k'
cmp [rbp+var_28], 846Ch
jl short loc_5C2A8
mov [rbp+var_2C], 8000h
jmp short loc_5C2BA
loc_5C2A8:
cmp [rbp+var_28], 4D8h
jl short loc_5C2B8
mov [rbp+var_2C], 46Bh
loc_5C2B8:
jmp short $+2
loc_5C2BA:
mov eax, [rbp+var_2C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jl short loc_5C2D1
mov eax, [rbp+var_24]
cmp eax, [rbp+var_28]
jl short loc_5C2E7
loc_5C2D1:
xor eax, eax
mov esi, eax
mov rdi, rsi
call stbtt__new_buf
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp short loc_5C2FF
loc_5C2E7:
mov edx, [rbp+var_24]
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
call stbtt__cff_index_get
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
loc_5C2FF:
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long stbtt__get_subr(long long a1, long long a2, int a3)
{
long long v3; // rdx
long long v4; // rdx
int v6; // [rsp+4h] [rbp-2Ch]
int v7; // [rsp+8h] [rbp-28h]
int v9; // [rsp+Ch] [rbp-24h]
long long v10; // [rsp+10h] [rbp-20h] BYREF
long long v11; // [rsp+18h] [rbp-18h]
long long v12; // [rsp+20h] [rbp-10h]
long long v13; // [rsp+28h] [rbp-8h]
v10 = a1;
v11 = a2;
v7 = stbtt__cff_index_count(&v10);
v6 = 107;
if ( v7 < 33900 )
{
if ( v7 >= 1240 )
v6 = 1131;
}
else
{
v6 = 0x8000;
}
v9 = a3 + v6;
if ( v9 >= 0 && v9 < v7 )
{
v12 = stbtt__cff_index_get(v10, v11, v9);
v13 = v4;
}
else
{
v12 = stbtt__new_buf(0LL, 0LL);
v13 = v3;
}
return v12;
}
| stbtt__get_subr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x24],EDX
LEA RDI,[RBP + -0x20]
CALL 0x0015c520
MOV dword ptr [RBP + -0x28],EAX
MOV dword ptr [RBP + -0x2c],0x6b
CMP dword ptr [RBP + -0x28],0x846c
JL 0x0015c2a8
MOV dword ptr [RBP + -0x2c],0x8000
JMP 0x0015c2ba
LAB_0015c2a8:
CMP dword ptr [RBP + -0x28],0x4d8
JL 0x0015c2b8
MOV dword ptr [RBP + -0x2c],0x46b
LAB_0015c2b8:
JMP 0x0015c2ba
LAB_0015c2ba:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JL 0x0015c2d1
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x28]
JL 0x0015c2e7
LAB_0015c2d1:
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00158910
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x0015c2ff
LAB_0015c2e7:
MOV EDX,dword ptr [RBP + -0x24]
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00158c30
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
LAB_0015c2ff:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] stbtt__get_subr(int8 param_1,int8 param_2,int param_3)
{
int iVar1;
int1 auVar2 [16];
int local_34;
int8 local_28;
int8 local_20;
local_28 = param_1;
local_20 = param_2;
iVar1 = stbtt__cff_index_count(&local_28);
local_34 = 0x6b;
if (iVar1 < 0x846c) {
if (0x4d7 < iVar1) {
local_34 = 0x46b;
}
}
else {
local_34 = 0x8000;
}
local_34 = local_34 + param_3;
if ((local_34 < 0) || (iVar1 <= local_34)) {
auVar2 = stbtt__new_buf(0);
}
else {
auVar2 = stbtt__cff_index_get(local_28,local_20,local_34);
}
return auVar2;
}
| |
52,356 | google::protobuf::internal::ExtensionSet::AddMessage(int, unsigned char, google::protobuf::MessageLite const&, google::protobuf::FieldDescriptor const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc | MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
const MessageLite& prototype,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->type = type;
GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
extension->is_repeated = true;
extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
} else {
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE);
}
// RepeatedPtrField<MessageLite> does not know how to Add() since it cannot
// allocate an abstract object, so we have to be tricky.
MessageLite* result = reinterpret_cast<internal::RepeatedPtrFieldBase*>(
extension->repeated_message_value)
->AddFromCleared<GenericTypeHandler<MessageLite>>();
if (result == nullptr) {
result = prototype.New(arena_);
extension->repeated_message_value->AddAllocated(result);
}
return result;
} | O0 | cpp | google::protobuf::internal::ExtensionSet::AddMessage(int, unsigned char, google::protobuf::MessageLite const&, google::protobuf::FieldDescriptor const*):
subq $0x208, %rsp # imm = 0x208
movb %dl, %al
movq %rdi, 0x150(%rsp)
movl %esi, 0x14c(%rsp)
movb %al, 0x14b(%rsp)
movq %rcx, 0x140(%rsp)
movq %r8, 0x138(%rsp)
movq 0x150(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movl 0x14c(%rsp), %esi
movq 0x138(%rsp), %rdx
leaq 0x130(%rsp), %rcx
callq 0x215b20
testb $0x1, %al
jne 0x2259b1
jmp 0x225d69
movb 0x14b(%rsp), %cl
movq 0x130(%rsp), %rax
movb %cl, 0x8(%rax)
xorl %eax, %eax
testb $0x1, %al
jne 0x2259ce
jmp 0x225a97
movq 0x130(%rsp), %rax
movzbl 0x8(%rax), %edi
callq 0x2155e0
movb $0x0, 0xf7(%rsp)
cmpl $0xa, %eax
jne 0x2259ee
jmp 0x225a47
leaq 0x1c4c73(%rip), %rdx # 0x3ea668
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movl $0x3, %esi
movl $0x324, %ecx # imm = 0x324
callq 0x19a670
movq 0x40(%rsp), %rdi
movb $0x1, 0xf7(%rsp)
leaq 0x1c55c6(%rip), %rsi # 0x3eafeb
callq 0x199f30
movq %rax, 0x48(%rsp)
jmp 0x225a31
movq 0x48(%rsp), %rsi
leaq 0xe3(%rsp), %rdi
callq 0x19a0e0
jmp 0x225a45
jmp 0x225a47
testb $0x1, 0xf7(%rsp)
jne 0x225a53
jmp 0x225a60
leaq 0xf8(%rsp), %rdi
callq 0x19a6b0
jmp 0x2259c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
testb $0x1, 0xf7(%rsp)
jne 0x225a85
jmp 0x225a92
leaq 0xf8(%rsp), %rdi
callq 0x19a6b0
jmp 0x225f5b
movq 0x50(%rsp), %rax
movq 0x130(%rsp), %rcx
movb $0x1, 0x9(%rcx)
movq (%rax), %rax
movq %rax, 0x158(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x160(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x168(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x170(%rsp)
cmpq $0x0, 0x170(%rsp)
jne 0x225b50
movl $0x18, %edi
callq 0x8c1d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x2368e0
jmp 0x225b3e
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
callq 0x8fb70
movq 0x188(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x225f68
movq 0x38(%rsp), %rax
movq %rax, 0x178(%rsp)
jmp 0x225d51
movq 0x170(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x198(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rax, 0x1e8(%rsp)
movq $0x18, 0x1e0(%rsp)
movq $0x8, 0x1d8(%rsp)
leaq 0x10dac(%rip), %rax # 0x236940
movq %rax, 0x1d0(%rsp)
leaq 0x2d81dd(%rip), %rax # 0x4fdd80
movq %rax, 0x1c8(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jne 0x225bf2
movq 0x28(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x1d8(%rsp), %rdx
movq 0x1c8(%rsp), %rcx
callq 0x155c30
movq %rax, 0x1f0(%rsp)
jmp 0x225d27
cmpq $0x8, 0x1d8(%rsp)
ja 0x225c6b
movq 0x1e0(%rsp), %rdi
callq 0x155ce0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x1c8(%rsp), %rdx
callq 0x167380
movq %rax, 0x1b8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq 0x1b8(%rsp), %rcx
movq 0x1c0(%rsp), %rax
movq %rcx, (%rax)
movq 0x1d0(%rsp), %rcx
movq 0x1c0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x1b8(%rsp), %rax
movq %rax, 0x1f0(%rsp)
jmp 0x225d27
movq 0x28(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
addq 0x1d8(%rsp), %rsi
subq $0x8, %rsi
movq 0x1c8(%rsp), %rdx
callq 0x167380
movq %rax, 0x1a8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq 0x1a8(%rsp), %rcx
movq 0x1d8(%rsp), %rax
movq %rcx, 0x200(%rsp)
movq %rax, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
addq 0x1f8(%rsp), %rax
subq $0x1, %rax
movq 0x1f8(%rsp), %rcx
xorq $-0x1, %rcx
addq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rcx
movq 0x1b0(%rsp), %rax
movq %rcx, (%rax)
movq 0x1d0(%rsp), %rcx
movq 0x1b0(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x1a0(%rsp), %rax
movq %rax, 0x1f0(%rsp)
movq 0x20(%rsp), %rax
movq 0x1f0(%rsp), %rdi
movq %rax, 0x190(%rsp)
leaq 0x190(%rsp), %rsi
callq 0x236910
movq %rax, 0x178(%rsp)
movq 0x178(%rsp), %rcx
movq 0x130(%rsp), %rax
movq %rcx, (%rax)
jmp 0x225f01
jmp 0x225d6b
xorl %eax, %eax
testb $0x1, %al
jne 0x225d76
jmp 0x225e46
movq 0x130(%rsp), %rax
movb 0x9(%rax), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb $0x0, 0xa7(%rsp)
cmpl $0x0, %eax
jne 0x225d9d
jmp 0x225df6
leaq 0x1c48c4(%rip), %rdx # 0x3ea668
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x329, %ecx # imm = 0x329
callq 0x19a670
movq 0x10(%rsp), %rdi
movb $0x1, 0xa7(%rsp)
leaq 0x1c4c17(%rip), %rsi # 0x3ea9eb
callq 0x199f30
movq %rax, 0x18(%rsp)
jmp 0x225de0
movq 0x18(%rsp), %rsi
leaq 0xa6(%rsp), %rdi
callq 0x19a0e0
jmp 0x225df4
jmp 0x225df6
testb $0x1, 0xa7(%rsp)
jne 0x225e02
jmp 0x225e0f
leaq 0xa8(%rsp), %rdi
callq 0x19a6b0
jmp 0x225d6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x225e34
jmp 0x225e41
leaq 0xa8(%rsp), %rdi
callq 0x19a6b0
jmp 0x225f5b
jmp 0x225e48
xorl %eax, %eax
testb $0x1, %al
jne 0x225e53
jmp 0x225eff
movq 0x130(%rsp), %rax
movzbl 0x8(%rax), %edi
callq 0x2155e0
movb $0x0, 0x67(%rsp)
cmpl $0xa, %eax
jne 0x225e70
jmp 0x225ebe
leaq 0x1c47f1(%rip), %rdx # 0x3ea668
leaq 0x68(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $0x329, %ecx # imm = 0x329
callq 0x19a670
movq (%rsp), %rdi
movb $0x1, 0x67(%rsp)
leaq 0x1c50f9(%rip), %rsi # 0x3eaf98
callq 0x199f30
movq %rax, 0x8(%rsp)
jmp 0x225eab
movq 0x8(%rsp), %rsi
leaq 0x66(%rsp), %rdi
callq 0x19a0e0
jmp 0x225ebc
jmp 0x225ebe
testb $0x1, 0x67(%rsp)
jne 0x225ec7
jmp 0x225ed1
leaq 0x68(%rsp), %rdi
callq 0x19a6b0
jmp 0x225e48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x225ef3
jmp 0x225efd
leaq 0x68(%rsp), %rdi
callq 0x19a6b0
jmp 0x225f5b
jmp 0x225f01
movq 0x130(%rsp), %rax
movq (%rax), %rdi
callq 0x233130
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x225f4e
movq 0x50(%rsp), %rax
movq 0x140(%rsp), %rdi
movq (%rax), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, 0x58(%rsp)
movq 0x130(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rsi
callq 0x2331a0
movq 0x58(%rsp), %rax
addq $0x208, %rsp # imm = 0x208
retq
movq 0xe8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x90db0
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf8internal12ExtensionSet10AddMessageEihRKNS0_11MessageLiteEPKNS0_15FieldDescriptorE:
sub rsp, 208h
mov al, dl
mov [rsp+208h+var_BC+4], rdi
mov dword ptr [rsp+208h+var_BC], esi
mov [rsp+208h+var_BD], al
mov [rsp+208h+var_C8], rcx
mov [rsp+208h+var_D0], r8
mov rdi, [rsp+208h+var_BC+4]; this
mov [rsp+208h+var_1B8], rdi
mov esi, dword ptr [rsp+208h+var_BC]; unsigned __int8
mov rdx, [rsp+208h+var_D0]; google::protobuf::FieldDescriptor *
lea rcx, [rsp+208h+var_D8]; google::protobuf::internal::ExtensionSet::Extension **
call _ZN6google8protobuf8internal12ExtensionSet17MaybeNewExtensionEiPKNS0_15FieldDescriptorEPPNS2_9ExtensionE; google::protobuf::internal::ExtensionSet::MaybeNewExtension(int,google::protobuf::FieldDescriptor const*,google::protobuf::internal::ExtensionSet::Extension **)
test al, 1
jnz short loc_2259B1
jmp loc_225D69
loc_2259B1:
mov cl, [rsp+208h+var_BD]
mov rax, [rsp+208h+var_D8]
mov [rax+8], cl
loc_2259C3:
xor eax, eax
test al, 1
jnz short loc_2259CE
jmp loc_225A97
loc_2259CE:
mov rax, [rsp+208h+var_D8]
movzx edi, byte ptr [rax+8]; this
call _ZN6google8protobuf8internal12_GLOBAL__N_18cpp_typeEh; google::protobuf::internal::`anonymous namespace'::cpp_type(uchar)
mov [rsp+208h+var_111], 0
cmp eax, 0Ah
jnz short loc_2259EE
jmp short loc_225A47
loc_2259EE:
lea rdx, aWorkspaceLlm4b_47; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+208h+var_110]
mov [rsp+208h+var_1C8], rdi
mov esi, 3
mov ecx, 324h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+208h+var_1C8]
mov [rsp+208h+var_111], 1
lea rsi, aCheckFailedCpp_18; "CHECK failed: (cpp_type(extension->type"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+208h+var_1C0], rax
jmp short $+2
loc_225A31:
mov rsi, [rsp+208h+var_1C0]
lea rdi, [rsp+208h+var_125]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_225A45:
jmp short $+2
loc_225A47:
test [rsp+208h+var_111], 1
jnz short loc_225A53
jmp short loc_225A60
loc_225A53:
lea rdi, [rsp+208h+var_110]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_225A60:
jmp loc_2259C3
mov rcx, rax
mov eax, edx
mov [rsp+arg_E0], rcx
mov [rsp+arg_DC], eax
test [rsp+arg_EF], 1
jnz short loc_225A85
jmp short loc_225A92
loc_225A85:
lea rdi, [rsp+arg_F0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_225A92:
jmp loc_225F5B
loc_225A97:
mov rax, [rsp+208h+var_1B8]
mov rcx, [rsp+208h+var_D8]
mov byte ptr [rcx+9], 1
mov rax, [rax]
mov [rsp+208h+var_B0], rax
mov rax, [rsp+208h+var_B0]
mov [rsp+208h+var_A8], rax
mov rax, [rsp+208h+var_A8]
mov [rsp+208h+var_A0], rax
mov rax, [rsp+208h+var_A0]
mov [rsp+208h+var_98], rax
cmp [rsp+208h+var_98], 0
jnz short loc_225B50
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
mov rax, rdi
mov [rsp+208h+var_1D0], rax
xor eax, eax
mov esi, eax
call _ZN6google8protobuf16RepeatedPtrFieldINS0_11MessageLiteEEC2EPNS0_5ArenaE; google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::RepeatedPtrField(google::protobuf::Arena *)
jmp short loc_225B3E
mov rdi, [rsp+arg_30]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_180], rcx
mov [rsp+arg_17C], eax
call __ZdlPv; operator delete(void *)
mov rax, [rsp+arg_180]
mov [rsp+arg_28], rax
jmp loc_225F68
loc_225B3E:
mov rax, [rsp+208h+var_1D0]
mov [rsp+208h+var_90], rax
jmp loc_225D51
loc_225B50:
mov rax, [rsp+208h+var_98]
mov [rsp+208h+var_70], rax
mov rax, [rsp+208h+var_70]
mov [rsp+208h+var_1E8], rax
mov [rsp+208h+var_20], rax
mov [rsp+208h+var_28], 18h
mov [rsp+208h+var_30], 8
lea rax, _ZN6google8protobuf8internal21arena_destruct_objectINS0_16RepeatedPtrFieldINS0_11MessageLiteEEEEEvPv; google::protobuf::internal::arena_destruct_object<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>(void *)
mov [rsp+208h+var_38], rax
lea rax, _ZTIN6google8protobuf16RepeatedPtrFieldINS0_11MessageLiteEEE; `typeinfo for'google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>
mov [rsp+208h+var_40], rax
mov rax, [rsp+208h+var_20]
mov [rsp+208h+var_1E0], rax
cmp [rsp+208h+var_38], 0
jnz short loc_225BF2
mov rdi, [rsp+208h+var_1E0]; this
mov rsi, [rsp+208h+var_28]; unsigned __int64
mov rdx, [rsp+208h+var_30]; unsigned __int64
mov rcx, [rsp+208h+var_40]; type_info *
call _ZN6google8protobuf5Arena23AllocateAlignedWithHookEmmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithHook(ulong,ulong,std::type_info const*)
mov [rsp+208h+var_18], rax
jmp loc_225D27
loc_225BF2:
cmp [rsp+208h+var_30], 8
ja short loc_225C6B
mov rdi, [rsp+208h+var_28]; this
call _ZN6google8protobuf8internal10AlignUpTo8Em; google::protobuf::internal::AlignUpTo8(ulong)
mov rdi, [rsp+208h+var_1E0]; this
mov rsi, rax; unsigned __int64
mov rdx, [rsp+208h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+208h+var_50], rax
mov [rsp+208h+var_48], rdx
mov rcx, [rsp+208h+var_50]
mov rax, [rsp+208h+var_48]
mov [rax], rcx
mov rcx, [rsp+208h+var_38]
mov rax, [rsp+208h+var_48]
mov [rax+8], rcx
mov rax, [rsp+208h+var_50]
mov [rsp+208h+var_18], rax
jmp loc_225D27
loc_225C6B:
mov rdi, [rsp+208h+var_1E0]; this
mov rsi, [rsp+208h+var_28]
add rsi, [rsp+208h+var_30]
sub rsi, 8; unsigned __int64
mov rdx, [rsp+208h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+208h+var_60], rax
mov [rsp+208h+var_58], rdx
mov rcx, [rsp+208h+var_60]
mov rax, [rsp+208h+var_30]
mov [rsp+208h+var_8], rcx
mov [rsp+208h+var_10], rax
mov rax, [rsp+208h+var_8]
add rax, [rsp+208h+var_10]
sub rax, 1
mov rcx, [rsp+208h+var_10]
xor rcx, 0FFFFFFFFFFFFFFFFh
add rcx, 1
and rax, rcx
mov [rsp+208h+var_68], rax
mov rcx, [rsp+208h+var_68]
mov rax, [rsp+208h+var_58]
mov [rax], rcx
mov rcx, [rsp+208h+var_38]
mov rax, [rsp+208h+var_58]
mov [rax+8], rcx
mov rax, [rsp+208h+var_68]
mov [rsp+208h+var_18], rax
loc_225D27:
mov rax, [rsp+208h+var_1E8]
mov rdi, [rsp+208h+var_18]
mov [rsp+208h+var_78], rax
lea rsi, [rsp+208h+var_78]
call _ZN6google8protobuf5Arena14InternalHelperINS0_16RepeatedPtrFieldINS0_11MessageLiteEEEE9ConstructIJPS1_EEEPS5_PvDpOT_; google::protobuf::Arena::InternalHelper<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>::Construct<google::protobuf::Arena*>(void *,google::protobuf::Arena* &&)
mov [rsp+208h+var_90], rax
loc_225D51:
mov rcx, [rsp+208h+var_90]
mov rax, [rsp+208h+var_D8]
mov [rax], rcx
jmp loc_225F01
loc_225D69:
jmp short $+2
loc_225D6B:
xor eax, eax
test al, 1
jnz short loc_225D76
jmp loc_225E46
loc_225D76:
mov rax, [rsp+208h+var_D8]
mov dl, [rax+9]
mov eax, 1
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rsp+208h+var_161], 0
cmp eax, 0
jnz short loc_225D9D
jmp short loc_225DF6
loc_225D9D:
lea rdx, aWorkspaceLlm4b_47; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+208h+var_160]
mov [rsp+208h+var_1F8], rdi
mov esi, 3
mov ecx, 329h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+208h+var_1F8]
mov [rsp+208h+var_161], 1
lea rsi, aCheckFailedExt_2; "CHECK failed: ((*extension).is_repeated"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+208h+var_1F0], rax
jmp short $+2
loc_225DE0:
mov rsi, [rsp+208h+var_1F0]
lea rdi, [rsp+208h+var_162]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_225DF4:
jmp short $+2
loc_225DF6:
test [rsp+208h+var_161], 1
jnz short loc_225E02
jmp short loc_225E0F
loc_225E02:
lea rdi, [rsp+208h+var_160]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_225E0F:
jmp loc_225D6B
mov rcx, rax
mov eax, edx
mov [rsp+arg_E0], rcx
mov [rsp+arg_DC], eax
test [rsp+arg_9F], 1
jnz short loc_225E34
jmp short loc_225E41
loc_225E34:
lea rdi, [rsp+arg_A0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_225E41:
jmp loc_225F5B
loc_225E46:
jmp short $+2
loc_225E48:
xor eax, eax
test al, 1
jnz short loc_225E53
jmp loc_225EFF
loc_225E53:
mov rax, [rsp+208h+var_D8]
movzx edi, byte ptr [rax+8]; this
call _ZN6google8protobuf8internal12_GLOBAL__N_18cpp_typeEh; google::protobuf::internal::`anonymous namespace'::cpp_type(uchar)
mov [rsp+208h+var_1A1], 0
cmp eax, 0Ah
jnz short loc_225E70
jmp short loc_225EBE
loc_225E70:
lea rdx, aWorkspaceLlm4b_47; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+208h+var_1A0]
mov [rsp+208h+var_208], rdi
mov esi, 3
mov ecx, 329h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+208h+var_208]
mov [rsp+208h+var_1A1], 1
lea rsi, aCheckFailedCpp_17; "CHECK failed: (cpp_type((*extension).ty"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+208h+var_200], rax
jmp short $+2
loc_225EAB:
mov rsi, [rsp+208h+var_200]
lea rdi, [rsp+208h+var_1A2]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_225EBC:
jmp short $+2
loc_225EBE:
test [rsp+208h+var_1A1], 1
jnz short loc_225EC7
jmp short loc_225ED1
loc_225EC7:
lea rdi, [rsp+208h+var_1A0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_225ED1:
jmp loc_225E48
mov rcx, rax
mov eax, edx
mov [rsp+arg_E0], rcx
mov [rsp+arg_DC], eax
test [rsp+arg_5F], 1
jnz short loc_225EF3
jmp short loc_225EFD
loc_225EF3:
lea rdi, [rsp+arg_60]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_225EFD:
jmp short loc_225F5B
loc_225EFF:
jmp short $+2
loc_225F01:
mov rax, [rsp+208h+var_D8]
mov rdi, [rax]
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase14AddFromClearedINS1_18GenericTypeHandlerINS0_11MessageLiteEEEEEPNT_4TypeEv; google::protobuf::internal::RepeatedPtrFieldBase::AddFromCleared<google::protobuf::internal::GenericTypeHandler<google::protobuf::MessageLite>>(void)
mov [rsp+208h+var_1B0], rax
cmp [rsp+208h+var_1B0], 0
jnz short loc_225F4E
mov rax, [rsp+208h+var_1B8]
mov rdi, [rsp+208h+var_C8]
mov rsi, [rax]
mov rax, [rdi]
call qword ptr [rax+18h]
mov [rsp+208h+var_1B0], rax
mov rax, [rsp+208h+var_D8]
mov rdi, [rax]
mov rsi, [rsp+208h+var_1B0]
call _ZN6google8protobuf16RepeatedPtrFieldINS0_11MessageLiteEE12AddAllocatedEPS2_; google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::AddAllocated(google::protobuf::MessageLite*)
loc_225F4E:
mov rax, [rsp+208h+var_1B0]
add rsp, 208h
retn
loc_225F5B:
mov rax, [rsp+arg_E0]
mov [rsp+arg_28], rax
loc_225F68:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long google::protobuf::internal::ExtensionSet::AddMessage(
google::protobuf::Arena **this,
int a2,
char a3,
const google::protobuf::MessageLite *a4,
const google::protobuf::FieldDescriptor *a5)
{
unsigned long long v5; // rax
long long *v6; // rdx
google::protobuf::Arena *v8; // [rsp+20h] [rbp-1E8h]
google::protobuf::Arena *v9; // [rsp+28h] [rbp-1E0h]
long long v10; // [rsp+38h] [rbp-1D0h]
long long v11; // [rsp+58h] [rbp-1B0h]
google::protobuf::internal::ExtensionSet::Extension *v12[2]; // [rsp+130h] [rbp-D8h] BYREF
const google::protobuf::MessageLite *v13; // [rsp+140h] [rbp-C8h]
char v14; // [rsp+14Bh] [rbp-BDh]
_DWORD v15[3]; // [rsp+14Ch] [rbp-BCh]
google::protobuf::Arena *v16; // [rsp+158h] [rbp-B0h]
google::protobuf::Arena *v17; // [rsp+160h] [rbp-A8h]
google::protobuf::Arena *v18; // [rsp+168h] [rbp-A0h]
google::protobuf::Arena *v19; // [rsp+170h] [rbp-98h]
long long v20; // [rsp+178h] [rbp-90h]
_QWORD v21[2]; // [rsp+190h] [rbp-78h] BYREF
long long AlignedWithCleanup; // [rsp+1B8h] [rbp-50h]
long long *v23; // [rsp+1C0h] [rbp-48h]
type_info *v24; // [rsp+1C8h] [rbp-40h]
long long ( *v25)(); // [rsp+1D0h] [rbp-38h]
unsigned long long v26; // [rsp+1D8h] [rbp-30h]
google::protobuf::internal *v27; // [rsp+1E0h] [rbp-28h]
google::protobuf::Arena *v28; // [rsp+1E8h] [rbp-20h]
unsigned long long AlignedWithHook; // [rsp+1F0h] [rbp-18h]
*(_QWORD *)&v15[1] = this;
v15[0] = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
if ( (google::protobuf::internal::ExtensionSet::MaybeNewExtension(
(google::protobuf::internal::ExtensionSet *)this,
a2,
a5,
v12) & 1) != 0 )
{
*((_BYTE *)v12[0] + 8) = v14;
*((_BYTE *)v12[0] + 9) = 1;
v16 = *this;
v17 = v16;
v18 = v16;
v19 = v16;
if ( v16 )
{
v21[1] = v19;
v8 = v19;
v28 = v19;
v27 = (google::protobuf::internal *)&qword_18;
v26 = 8LL;
v25 = google::protobuf::internal::arena_destruct_object<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>;
v24 = (type_info *)&`typeinfo for'google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>;
v9 = v19;
if ( google::protobuf::internal::arena_destruct_object<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>> )
{
v5 = google::protobuf::internal::AlignUpTo8(v27);
AlignedWithCleanup = google::protobuf::Arena::AllocateAlignedWithCleanup(v9, v5, v24);
v23 = v6;
*v6 = AlignedWithCleanup;
v23[1] = (long long)v25;
AlignedWithHook = AlignedWithCleanup;
}
else
{
AlignedWithHook = google::protobuf::Arena::AllocateAlignedWithHook(v19, v27, v26, v24);
}
v21[0] = v8;
v20 = google::protobuf::Arena::InternalHelper<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>::Construct<google::protobuf::Arena*>(
AlignedWithHook,
v21);
}
else
{
v10 = operator new(0x18uLL);
google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::RepeatedPtrField(v10, 0LL);
v20 = v10;
}
*(_QWORD *)v12[0] = v20;
}
v11 = google::protobuf::internal::RepeatedPtrFieldBase::AddFromCleared<google::protobuf::internal::GenericTypeHandler<google::protobuf::MessageLite>>(*(_QWORD *)v12[0]);
if ( !v11 )
{
v11 = (*(long long ( **)(const google::protobuf::MessageLite *, google::protobuf::Arena *))(*(_QWORD *)v13 + 24LL))(
v13,
*this);
google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::AddAllocated(*(_QWORD *)v12[0], v11);
}
return v11;
}
| |||
52,357 | google::protobuf::internal::ExtensionSet::AddMessage(int, unsigned char, google::protobuf::MessageLite const&, google::protobuf::FieldDescriptor const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc | MessageLite* ExtensionSet::AddMessage(int number, FieldType type,
const MessageLite& prototype,
const FieldDescriptor* descriptor) {
Extension* extension;
if (MaybeNewExtension(number, descriptor, &extension)) {
extension->type = type;
GOOGLE_DCHECK_EQ(cpp_type(extension->type), WireFormatLite::CPPTYPE_MESSAGE);
extension->is_repeated = true;
extension->repeated_message_value =
Arena::CreateMessage<RepeatedPtrField<MessageLite>>(arena_);
} else {
GOOGLE_DCHECK_TYPE(*extension, REPEATED_FIELD, MESSAGE);
}
// RepeatedPtrField<MessageLite> does not know how to Add() since it cannot
// allocate an abstract object, so we have to be tricky.
MessageLite* result = reinterpret_cast<internal::RepeatedPtrFieldBase*>(
extension->repeated_message_value)
->AddFromCleared<GenericTypeHandler<MessageLite>>();
if (result == nullptr) {
result = prototype.New(arena_);
extension->repeated_message_value->AddAllocated(result);
}
return result;
} | O3 | cpp | google::protobuf::internal::ExtensionSet::AddMessage(int, unsigned char, google::protobuf::MessageLite const&, google::protobuf::FieldDescriptor const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r12
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r15
callq 0xb6af0
movq %rax, %r14
movq %r12, 0x10(%rax)
testb $0x1, %dl
je 0xb58c1
movb %bpl, 0x8(%r14)
movb $0x1, 0x9(%r14)
movq (%r15), %r12
testq %r12, %r12
je 0xb58c6
leaq 0x156576(%rip), %rdx # 0x20be10
movl $0x18, %esi
movq %r12, %rdi
callq 0x78480
movq %rax, (%rdx)
leaq 0x5b45(%rip), %rcx # 0xbb3f6
movq %rcx, 0x8(%rdx)
movq %r12, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
jmp 0xb58de
movq (%r14), %rax
jmp 0xb58e1
movl $0x18, %edi
callq 0x2d270
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%r14)
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0xb5902
movslq 0x8(%rax), %rdx
cmpl (%rcx), %edx
jge 0xb5902
leal 0x1(%rdx), %esi
movl %esi, 0x8(%rax)
movq 0x8(%rcx,%rdx,8), %r12
testq %r12, %r12
jne 0xb591c
movq (%r15), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %rax, %r12
movq (%r14), %rdi
movq %rax, %rsi
callq 0xbb3fc
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN6google8protobuf8internal12ExtensionSet10AddMessageEihRKNS0_11MessageLiteEPKNS0_15FieldDescriptorE:
push rbp
push r15
push r14
push r12
push rbx
mov r12, r8
mov rbx, rcx
mov ebp, edx
mov r15, rdi
call _ZN6google8protobuf8internal12ExtensionSet6InsertEi; google::protobuf::internal::ExtensionSet::Insert(int)
mov r14, rax
mov [rax+10h], r12
test dl, 1
jz short loc_B58C1
mov [r14+8], bpl
mov byte ptr [r14+9], 1
mov r12, [r15]
test r12, r12
jz short loc_B58C6
lea rdx, _ZTIN6google8protobuf16RepeatedPtrFieldINS0_11MessageLiteEEE; type_info *
mov esi, 18h; unsigned __int64
mov rdi, r12; this
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rdx], rax
lea rcx, _ZN6google8protobuf8internal21arena_destruct_objectINS0_16RepeatedPtrFieldINS0_11MessageLiteEEEEEvPv; google::protobuf::internal::arena_destruct_object<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>(void *)
mov [rdx+8], rcx
mov [rax], r12
xorps xmm0, xmm0
movups xmmword ptr [rax+8], xmm0
jmp short loc_B58DE
loc_B58C1:
mov rax, [r14]
jmp short loc_B58E1
loc_B58C6:
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
loc_B58DE:
mov [r14], rax
loc_B58E1:
mov rcx, [rax+10h]
test rcx, rcx
jz short loc_B5902
movsxd rdx, dword ptr [rax+8]
cmp edx, [rcx]
jge short loc_B5902
lea esi, [rdx+1]
mov [rax+8], esi
mov r12, [rcx+rdx*8+8]
test r12, r12
jnz short loc_B591C
loc_B5902:
mov rsi, [r15]
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+18h]
mov r12, rax
mov rdi, [r14]
mov rsi, rax
call _ZN6google8protobuf8internal20RepeatedPtrFieldBase20AddAllocatedInternalINS0_16RepeatedPtrFieldINS0_11MessageLiteEE11TypeHandlerEEEvPNT_4TypeESt17integral_constantIbLb0EE; google::protobuf::internal::RepeatedPtrFieldBase::AddAllocatedInternal<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::TypeHandler>(google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::TypeHandler::Type *,std::integral_constant<bool,false>)
loc_B591C:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long google::protobuf::internal::ExtensionSet::AddMessage(
google::protobuf::internal::ExtensionSet *this,
int a2,
char a3,
const google::protobuf::MessageLite *a4,
const google::protobuf::FieldDescriptor *a5)
{
long long v8; // rax
_QWORD *v9; // r14
char v10; // dl
long long v11; // r12
long long AlignedWithCleanup; // rax
long long *v13; // rdx
_DWORD *v14; // rcx
long long v15; // rdx
long long v16; // r12
v8 = google::protobuf::internal::ExtensionSet::Insert(this, a2);
v9 = (_QWORD *)v8;
*(_QWORD *)(v8 + 16) = a5;
if ( (v10 & 1) != 0 )
{
*(_BYTE *)(v8 + 8) = a3;
*(_BYTE *)(v8 + 9) = 1;
v11 = *(_QWORD *)this;
if ( *(_QWORD *)this )
{
AlignedWithCleanup = google::protobuf::Arena::AllocateAlignedWithCleanup(
*(google::protobuf::Arena **)this,
0x18uLL,
(const type_info *)&`typeinfo for'google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>);
*v13 = AlignedWithCleanup;
v13[1] = (long long)google::protobuf::internal::arena_destruct_object<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>;
*(_QWORD *)AlignedWithCleanup = v11;
*(_OWORD *)(AlignedWithCleanup + 8) = 0LL;
}
else
{
AlignedWithCleanup = operator new(0x18uLL);
*(_OWORD *)AlignedWithCleanup = 0LL;
*(_QWORD *)(AlignedWithCleanup + 16) = 0LL;
}
*v9 = AlignedWithCleanup;
}
else
{
AlignedWithCleanup = *(_QWORD *)v8;
}
v14 = *(_DWORD **)(AlignedWithCleanup + 16);
if ( !v14
|| (v15 = *(int *)(AlignedWithCleanup + 8), (int)v15 >= *v14)
|| (*(_DWORD *)(AlignedWithCleanup + 8) = v15 + 1, (v16 = *(_QWORD *)&v14[2 * v15 + 2]) == 0) )
{
v16 = (*(long long ( **)(const google::protobuf::MessageLite *, _QWORD))(*(_QWORD *)a4 + 24LL))(
a4,
*(_QWORD *)this);
google::protobuf::internal::RepeatedPtrFieldBase::AddAllocatedInternal<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::TypeHandler>(
*v9,
v16);
}
return v16;
}
| AddMessage:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R12,R8
MOV RBX,RCX
MOV EBP,EDX
MOV R15,RDI
CALL 0x001b6af0
MOV R14,RAX
MOV qword ptr [RAX + 0x10],R12
TEST DL,0x1
JZ 0x001b58c1
MOV byte ptr [R14 + 0x8],BPL
MOV byte ptr [R14 + 0x9],0x1
MOV R12,qword ptr [R15]
TEST R12,R12
JZ 0x001b58c6
LEA RDX,[0x30be10]
MOV ESI,0x18
MOV RDI,R12
CALL 0x00178480
MOV qword ptr [RDX],RAX
LEA RCX,[0x1bb3f6]
MOV qword ptr [RDX + 0x8],RCX
MOV qword ptr [RAX],R12
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x8],XMM0
JMP 0x001b58de
LAB_001b58c1:
MOV RAX,qword ptr [R14]
JMP 0x001b58e1
LAB_001b58c6:
MOV EDI,0x18
CALL 0x0012d270
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
LAB_001b58de:
MOV qword ptr [R14],RAX
LAB_001b58e1:
MOV RCX,qword ptr [RAX + 0x10]
TEST RCX,RCX
JZ 0x001b5902
MOVSXD RDX,dword ptr [RAX + 0x8]
CMP EDX,dword ptr [RCX]
JGE 0x001b5902
LEA ESI,[RDX + 0x1]
MOV dword ptr [RAX + 0x8],ESI
MOV R12,qword ptr [RCX + RDX*0x8 + 0x8]
TEST R12,R12
JNZ 0x001b591c
LAB_001b5902:
MOV RSI,qword ptr [R15]
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x18]
MOV R12,RAX
MOV RDI,qword ptr [R14]
MOV RSI,RAX
CALL 0x001bb3fc
LAB_001b591c:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::internal::ExtensionSet::AddMessage(int, unsigned char,
google::protobuf::MessageLite const&, google::protobuf::FieldDescriptor const*) */
long __thiscall
google::protobuf::internal::ExtensionSet::AddMessage
(ExtensionSet *this,int param_1,uchar param_2,MessageLite *param_3,
FieldDescriptor *param_4)
{
int iVar1;
ulong uVar2;
int *piVar3;
int8 *puVar4;
ulong *puVar5;
long lVar6;
int1 auVar7 [16];
auVar7 = Insert(this,param_1);
puVar4 = auVar7._0_8_;
puVar4[2] = param_4;
if ((auVar7 & (int1 [16])0x1) == (int1 [16])0x0) {
puVar5 = (ulong *)*puVar4;
}
else {
*(uchar *)(puVar4 + 1) = param_2;
*(int1 *)((long)puVar4 + 9) = 1;
uVar2 = *(ulong *)this;
if (uVar2 == 0) {
puVar5 = (ulong *)operator_new(0x18);
*puVar5 = 0;
puVar5[1] = 0;
puVar5[2] = 0;
}
else {
auVar7 = Arena::AllocateAlignedWithCleanup(uVar2,(type_info *)0x18);
puVar5 = auVar7._0_8_;
*auVar7._8_8_ = puVar5;
auVar7._8_8_[1] =
arena_destruct_object<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>>;
*puVar5 = uVar2;
puVar5[1] = 0;
puVar5[2] = 0;
}
*puVar4 = puVar5;
}
piVar3 = (int *)puVar5[2];
if (piVar3 != (int *)0x0) {
iVar1 = (int)puVar5[1];
if (iVar1 < *piVar3) {
*(int *)(puVar5 + 1) = iVar1 + 1;
if (*(long *)(piVar3 + (long)iVar1 * 2 + 2) != 0) {
return *(long *)(piVar3 + (long)iVar1 * 2 + 2);
}
}
}
lVar6 = (**(code **)(*(long *)param_3 + 0x18))(param_3,*(int8 *)this);
RepeatedPtrFieldBase::
AddAllocatedInternal<google::protobuf::RepeatedPtrField<google::protobuf::MessageLite>::TypeHandler>
(*puVar4,lVar6);
return lVar6;
}
| |
52,358 | tinfl_decompress_mem_to_callback | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size,
tinfl_put_buf_func_ptr pPut_buf_func,
void *pPut_buf_user, int flags) {
int result = 0;
tinfl_decompressor decomp;
mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
size_t in_buf_ofs = 0, dict_ofs = 0;
if (!pDict)
return TINFL_STATUS_FAILED;
tinfl_init(&decomp);
for (;;) {
size_t in_buf_size = *pIn_buf_size - in_buf_ofs,
dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
tinfl_status status =
tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs,
&in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
(flags & ~(TINFL_FLAG_HAS_MORE_INPUT |
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
in_buf_ofs += in_buf_size;
if ((dst_buf_size) &&
(!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
break;
if (status != TINFL_STATUS_HAS_MORE_OUTPUT) {
result = (status == TINFL_STATUS_DONE);
break;
}
dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
}
MZ_FREE(pDict);
*pIn_buf_size = in_buf_ofs;
return result;
} | O0 | c | tinfl_decompress_mem_to_callback:
subq $0x2b68, %rsp # imm = 0x2B68
movq %rdi, 0x2b58(%rsp)
movq %rsi, 0x2b50(%rsp)
movq %rdx, 0x2b48(%rsp)
movq %rcx, 0x2b40(%rsp)
movl %r8d, 0x2b3c(%rsp)
movl $0x0, 0x2b38(%rsp)
movl $0x8000, %edi # imm = 0x8000
callq 0xba00
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0xfdc13
movl $0xffffffff, 0x2b64(%rsp) # imm = 0xFFFFFFFF
jmp 0xfdd24
jmp 0xfdc15
movl $0x0, 0x40(%rsp)
jmp 0xfdc1f
movq 0x2b50(%rsp), %rax
movq (%rax), %rax
subq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x8000, %eax # imm = 0x8000
subq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x2b58(%rsp), %rsi
addq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rcx
movq 0x38(%rsp), %r8
addq 0x28(%rsp), %r8
movl 0x2b3c(%rsp), %eax
andl $-0x7, %eax
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %r9
movl %eax, (%rsp)
callq 0xf5ce0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xfdcc5
movq 0x2b48(%rsp), %rax
movq 0x38(%rsp), %rdi
addq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl %ecx, %esi
movq 0x2b40(%rsp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xfdcc5
jmp 0xfdcfc
cmpl $0x2, 0x14(%rsp)
je 0xfdce2
cmpl $0x0, 0x14(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2b38(%rsp)
jmp 0xfdcfc
movq 0x28(%rsp), %rax
addq 0x18(%rsp), %rax
andq $0x7fff, %rax # imm = 0x7FFF
movq %rax, 0x28(%rsp)
jmp 0xfdc1f
movq 0x38(%rsp), %rdi
callq 0xb900
movq 0x30(%rsp), %rcx
movq 0x2b50(%rsp), %rax
movq %rcx, (%rax)
movl 0x2b38(%rsp), %eax
movl %eax, 0x2b64(%rsp)
movl 0x2b64(%rsp), %eax
addq $0x2b68, %rsp # imm = 0x2B68
retq
nopw %cs:(%rax,%rax)
| tinfl_decompress_mem_to_callback:
sub rsp, 2B68h
mov [rsp+2B68h+var_10], rdi
mov [rsp+2B68h+var_18], rsi
mov [rsp+2B68h+var_20], rdx
mov [rsp+2B68h+var_28], rcx
mov [rsp+2B68h+var_2C], r8d
mov [rsp+2B68h+var_30], 0
mov edi, 8000h
call _malloc
mov [rsp+2B68h+var_2B30], rax
mov [rsp+2B68h+var_2B38], 0
mov [rsp+2B68h+var_2B40], 0
cmp [rsp+2B68h+var_2B30], 0
jnz short loc_FDC13
mov [rsp+2B68h+var_4], 0FFFFFFFFh
jmp loc_FDD24
loc_FDC13:
jmp short $+2
loc_FDC15:
mov [rsp+2B68h+var_2B28], 0
jmp short $+2
loc_FDC1F:
mov rax, [rsp+2B68h+var_18]
mov rax, [rax]
sub rax, [rsp+2B68h+var_2B38]
mov [rsp+2B68h+var_2B48], rax
mov eax, 8000h
sub rax, [rsp+2B68h+var_2B40]
mov [rsp+2B68h+var_2B50], rax
mov rsi, [rsp+2B68h+var_10]
add rsi, [rsp+2B68h+var_2B38]
mov rcx, [rsp+2B68h+var_2B30]
mov r8, [rsp+2B68h+var_2B30]
add r8, [rsp+2B68h+var_2B40]
mov eax, [rsp+2B68h+var_2C]
and eax, 0FFFFFFF9h
lea rdi, [rsp+2B68h+var_2B28]
lea rdx, [rsp+2B68h+var_2B48]
lea r9, [rsp+2B68h+var_2B50]
mov [rsp+2B68h+var_2B68], eax
call tinfl_decompress
mov [rsp+2B68h+var_2B54], eax
mov rax, [rsp+2B68h+var_2B48]
add rax, [rsp+2B68h+var_2B38]
mov [rsp+2B68h+var_2B38], rax
cmp [rsp+2B68h+var_2B50], 0
jz short loc_FDCC5
mov rax, [rsp+2B68h+var_20]
mov rdi, [rsp+2B68h+var_2B30]
add rdi, [rsp+2B68h+var_2B40]
mov rcx, [rsp+2B68h+var_2B50]
mov esi, ecx
mov rdx, [rsp+2B68h+var_28]
call rax
cmp eax, 0
jnz short loc_FDCC5
jmp short loc_FDCFC
loc_FDCC5:
cmp [rsp+2B68h+var_2B54], 2
jz short loc_FDCE2
cmp [rsp+2B68h+var_2B54], 0
setz al
and al, 1
movzx eax, al
mov [rsp+2B68h+var_30], eax
jmp short loc_FDCFC
loc_FDCE2:
mov rax, [rsp+2B68h+var_2B40]
add rax, [rsp+2B68h+var_2B50]
and rax, 7FFFh
mov [rsp+2B68h+var_2B40], rax
jmp loc_FDC1F
loc_FDCFC:
mov rdi, [rsp+2B68h+var_2B30]
call _free
mov rcx, [rsp+2B68h+var_2B38]
mov rax, [rsp+2B68h+var_18]
mov [rax], rcx
mov eax, [rsp+2B68h+var_30]
mov [rsp+2B68h+var_4], eax
loc_FDD24:
mov eax, [rsp+2B68h+var_4]
add rsp, 2B68h
retn
| long long tinfl_decompress_mem_to_callback(
long long a1,
_QWORD *a2,
unsigned int ( *a3)(unsigned long long, _QWORD, long long),
long long a4,
int a5)
{
int v6; // [rsp+14h] [rbp-2B54h]
long long v7; // [rsp+18h] [rbp-2B50h] BYREF
long long v8; // [rsp+20h] [rbp-2B48h] BYREF
long long v9; // [rsp+28h] [rbp-2B40h]
long long v10; // [rsp+30h] [rbp-2B38h]
unsigned long long v11; // [rsp+38h] [rbp-2B30h]
_DWORD v12[2750]; // [rsp+40h] [rbp-2B28h] BYREF
BOOL v13; // [rsp+2B38h] [rbp-30h]
int v14; // [rsp+2B3Ch] [rbp-2Ch]
long long v15; // [rsp+2B40h] [rbp-28h]
unsigned int ( *v16)(unsigned long long, _QWORD, long long); // [rsp+2B48h] [rbp-20h]
_QWORD *v17; // [rsp+2B50h] [rbp-18h]
long long v18; // [rsp+2B58h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = 0;
v11 = malloc(0x8000LL);
v10 = 0LL;
v9 = 0LL;
if ( v11 )
{
v12[0] = 0;
while ( 1 )
{
v8 = *v17 - v10;
v7 = 0x8000 - v9;
v6 = tinfl_decompress(
(long long)v12,
(unsigned __int8 *)(v10 + v18),
&v8,
v11,
(unsigned __int8 *)(v9 + v11),
&v7,
v14 & 0xF9);
v10 += v8;
if ( v7 )
{
if ( !v16(v9 + v11, (unsigned int)v7, v15) )
break;
}
if ( v6 != 2 )
{
v13 = v6 == 0;
break;
}
v9 = ((_WORD)v7 + (_WORD)v9) & 0x7FFF;
}
free(v11);
*v17 = v10;
return v13;
}
else
{
return (unsigned int)-1;
}
}
| tinfl_decompress_mem_to_callback:
SUB RSP,0x2b68
MOV qword ptr [RSP + 0x2b58],RDI
MOV qword ptr [RSP + 0x2b50],RSI
MOV qword ptr [RSP + 0x2b48],RDX
MOV qword ptr [RSP + 0x2b40],RCX
MOV dword ptr [RSP + 0x2b3c],R8D
MOV dword ptr [RSP + 0x2b38],0x0
MOV EDI,0x8000
CALL 0x0010ba00
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x28],0x0
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x001fdc13
MOV dword ptr [RSP + 0x2b64],0xffffffff
JMP 0x001fdd24
LAB_001fdc13:
JMP 0x001fdc15
LAB_001fdc15:
MOV dword ptr [RSP + 0x40],0x0
JMP 0x001fdc1f
LAB_001fdc1f:
MOV RAX,qword ptr [RSP + 0x2b50]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
MOV EAX,0x8000
SUB RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RSP + 0x2b58]
ADD RSI,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
MOV R8,qword ptr [RSP + 0x38]
ADD R8,qword ptr [RSP + 0x28]
MOV EAX,dword ptr [RSP + 0x2b3c]
AND EAX,0xfffffff9
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0x20]
LEA R9,[RSP + 0x18]
MOV dword ptr [RSP],EAX
CALL 0x001f5ce0
MOV dword ptr [RSP + 0x14],EAX
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x30],RAX
CMP qword ptr [RSP + 0x18],0x0
JZ 0x001fdcc5
MOV RAX,qword ptr [RSP + 0x2b48]
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x18]
MOV ESI,ECX
MOV RDX,qword ptr [RSP + 0x2b40]
CALL RAX
CMP EAX,0x0
JNZ 0x001fdcc5
JMP 0x001fdcfc
LAB_001fdcc5:
CMP dword ptr [RSP + 0x14],0x2
JZ 0x001fdce2
CMP dword ptr [RSP + 0x14],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x2b38],EAX
JMP 0x001fdcfc
LAB_001fdce2:
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,qword ptr [RSP + 0x18]
AND RAX,0x7fff
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001fdc1f
LAB_001fdcfc:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0010b900
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x2b50]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RSP + 0x2b38]
MOV dword ptr [RSP + 0x2b64],EAX
LAB_001fdd24:
MOV EAX,dword ptr [RSP + 0x2b64]
ADD RSP,0x2b68
RET
|
uint tinfl_decompress_mem_to_callback
(long param_1,long *param_2,code *param_3,int8 param_4,uint param_5)
{
int iVar1;
int iVar2;
ulong local_2b50;
long local_2b48;
ulong local_2b40;
long local_2b38;
void *local_2b30;
int4 local_2b28 [2750];
uint local_30;
uint local_2c;
int8 local_28;
code *local_20;
long *local_18;
long local_10;
uint local_4;
local_30 = 0;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_2b30 = malloc(0x8000);
local_2b38 = 0;
local_2b40 = 0;
if (local_2b30 == (void *)0x0) {
local_4 = 0xffffffff;
}
else {
local_2b28[0] = 0;
while( true ) {
local_2b48 = *local_18 - local_2b38;
local_2b50 = 0x8000 - local_2b40;
iVar1 = tinfl_decompress(local_2b28,local_10 + local_2b38,&local_2b48,local_2b30,
(long)local_2b30 + local_2b40,&local_2b50,local_2c & 0xfffffff9);
local_2b38 = local_2b48 + local_2b38;
if ((local_2b50 != 0) &&
(iVar2 = (*local_20)((long)local_2b30 + local_2b40,local_2b50 & 0xffffffff,local_28),
iVar2 == 0)) goto LAB_001fdcfc;
if (iVar1 != 2) break;
local_2b40 = local_2b40 + local_2b50 & 0x7fff;
}
local_30 = (uint)(iVar1 == 0);
LAB_001fdcfc:
free(local_2b30);
*local_18 = local_2b38;
local_4 = local_30;
}
return local_4;
}
| |
52,359 | tinfl_decompress_mem_to_callback | 7CodeWizard[P]stablediffusion/thirdparty/miniz.h | int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size,
tinfl_put_buf_func_ptr pPut_buf_func,
void *pPut_buf_user, int flags) {
int result = 0;
tinfl_decompressor decomp;
mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE);
size_t in_buf_ofs = 0, dict_ofs = 0;
if (!pDict)
return TINFL_STATUS_FAILED;
tinfl_init(&decomp);
for (;;) {
size_t in_buf_size = *pIn_buf_size - in_buf_ofs,
dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
tinfl_status status =
tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs,
&in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
(flags & ~(TINFL_FLAG_HAS_MORE_INPUT |
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)));
in_buf_ofs += in_buf_size;
if ((dst_buf_size) &&
(!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
break;
if (status != TINFL_STATUS_HAS_MORE_OUTPUT) {
result = (status == TINFL_STATUS_DONE);
break;
}
dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
}
MZ_FREE(pDict);
*pIn_buf_size = in_buf_ofs;
return result;
} | O3 | c | tinfl_decompress_mem_to_callback:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b38, %rsp # imm = 0x2B38
movl %r8d, %r15d
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x38(%rsp)
movl $0x8000, %edi # imm = 0x8000
callq 0xa7b0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x82439
leaq 0x40(%rsp), %rax
movl $0x0, (%rax)
andl $-0x7, %r15d
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%rsp), %rax
movq (%rax), %rax
subq %r13, %rax
movq %rax, 0x20(%rsp)
movl $0x8000, %eax # imm = 0x8000
subq %rbp, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
leaq (%rax,%r13), %rsi
movq 0x8(%rsp), %rcx
leaq (%rcx,%rbp), %rbx
movl %r15d, %r14d
movl %r15d, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %r8
leaq 0x18(%rsp), %r9
callq 0x7e76f
movl %eax, %r12d
addq 0x20(%rsp), %r13
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x82413
movq %rbx, %rdi
movl %r15d, %esi
movq 0x30(%rsp), %rdx
callq *0x28(%rsp)
testl %eax, %eax
je 0x82440
cmpl $0x2, %r12d
jne 0x8242e
addl %ebp, %r15d
andl $0x7fff, %r15d # imm = 0x7FFF
movq %r15, %rbp
movl %r14d, %r15d
jmp 0x823a1
xorl %ebp, %ebp
testl %r12d, %r12d
sete %bpl
jmp 0x82442
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
jmp 0x82454
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
callq 0xa6f0
movq 0x10(%rsp), %rax
movq %r13, (%rax)
movl %ebp, %eax
addq $0x2b38, %rsp # imm = 0x2B38
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| tinfl_decompress_mem_to_callback:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2B38h
mov r15d, r8d
mov [rsp+2B68h+var_2B38], rcx
mov [rsp+2B68h+var_2B40], rdx
mov [rsp+2B68h+var_2B58], rsi
mov [rsp+2B68h+var_2B30], rdi
mov edi, 8000h
call _malloc
mov [rsp+2B68h+var_2B60], rax
test rax, rax
jz loc_82439
lea rax, [rsp+2B68h+var_2B28]
mov dword ptr [rax], 0
and r15d, 0FFFFFFF9h
xor r13d, r13d
xor ebp, ebp
loc_823A1:
mov rax, [rsp+2B68h+var_2B58]
mov rax, [rax]
sub rax, r13
mov [rsp+2B68h+var_2B48], rax
mov eax, 8000h
sub rax, rbp
mov [rsp+2B68h+var_2B50], rax
mov rax, [rsp+2B68h+var_2B30]
lea rsi, [rax+r13]
mov rcx, [rsp+2B68h+var_2B60]
lea rbx, [rcx+rbp]
mov r14d, r15d
mov [rsp+2B68h+var_2B68], r15d
lea rdi, [rsp+2B68h+var_2B28]
lea rdx, [rsp+2B68h+var_2B48]
mov r8, rbx
lea r9, [rsp+2B68h+var_2B50]
call tinfl_decompress
mov r12d, eax
add r13, [rsp+2B68h+var_2B48]
mov r15, [rsp+2B68h+var_2B50]
test r15, r15
jz short loc_82413
mov rdi, rbx
mov esi, r15d
mov rdx, [rsp+2B68h+var_2B38]
call [rsp+2B68h+var_2B40]
test eax, eax
jz short loc_82440
loc_82413:
cmp r12d, 2
jnz short loc_8242E
add r15d, ebp
and r15d, 7FFFh
mov rbp, r15
mov r15d, r14d
jmp loc_823A1
loc_8242E:
xor ebp, ebp
test r12d, r12d
setz bpl
jmp short loc_82442
loc_82439:
mov ebp, 0FFFFFFFFh
jmp short loc_82454
loc_82440:
xor ebp, ebp
loc_82442:
mov rdi, [rsp+2B68h+var_2B60]
call _free
mov rax, [rsp+2B68h+var_2B58]
mov [rax], r13
loc_82454:
mov eax, ebp
add rsp, 2B38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long tinfl_decompress_mem_to_callback(
long long a1,
_QWORD *a2,
unsigned int ( *a3)(unsigned long long, _QWORD, long long),
long long a4,
int a5)
{
unsigned int v6; // r15d
long long v7; // r13
long long v8; // rbp
unsigned int v9; // r14d
int v10; // r12d
__int16 v11; // r15
BOOL v12; // ebp
long long v14; // [rsp+0h] [rbp-2B68h]
unsigned long long v15; // [rsp+8h] [rbp-2B60h]
long long v16; // [rsp+18h] [rbp-2B50h] BYREF
long long v17; // [rsp+20h] [rbp-2B48h] BYREF
unsigned int ( *v18)(unsigned long long, _QWORD, long long); // [rsp+28h] [rbp-2B40h]
long long v19; // [rsp+30h] [rbp-2B38h]
long long v20; // [rsp+38h] [rbp-2B30h]
_QWORD v21[1381]; // [rsp+40h] [rbp-2B28h] BYREF
v19 = a4;
v18 = a3;
v20 = a1;
v15 = malloc(0x8000LL);
if ( v15 )
{
LODWORD(v21[0]) = 0;
v6 = a5 & 0xFFFFFFF9;
v7 = 0LL;
v8 = 0LL;
while ( 1 )
{
v17 = *a2 - v7;
v16 = 0x8000 - v8;
v9 = v6;
LODWORD(v14) = v6;
v10 = tinfl_decompress(v21, v20 + v7, &v17, v15, (_BYTE *)(v15 + v8), &v16, v14);
v7 += v17;
v11 = v16;
if ( v16 )
{
if ( !v18(v15 + v8, (unsigned int)v16, v19) )
break;
}
if ( v10 != 2 )
{
v12 = v10 == 0;
goto LABEL_10;
}
v8 = ((_WORD)v8 + v11) & 0x7FFF;
v6 = v9;
}
v12 = 0;
LABEL_10:
free(v15);
*a2 = v7;
}
else
{
return -1;
}
return v12;
}
| |||
52,360 | LefDefParser::defwViaPolygon(char const*, int, double*, double*, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwViaPolygon(const char *layerName,
int num_polys,
double *xl,
double *yl,
int mask)
{
int i;
defwFunc = DEFW_VIA; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_VIA)
return DEFW_BAD_ORDER;
if (defVersionNum < 5.6)
return DEFW_WRONG_VERSION;
if (!mask) {
fprintf(defwFile, "\n + POLYGON %s ", layerName);
} else {
if (defVersionNum < 5.8) {
return DEFW_WRONG_VERSION;
}
fprintf(defwFile, "\n + POLYGON %s + MASK %d ", layerName, mask);
}
printPointsNum = 0;
for (i = 0; i < num_polys; i++) {
if ((i == 0) || ((i % 5) != 0))
printPoints(defwFile, *xl++, *yl++, "", " ");
else {
printPoints(defwFile, *xl++, *yl++, "\n ", " ");
defwLines++;
}
}
defwLines++;
return DEFW_OK;
} | O3 | cpp | LefDefParser::defwViaPolygon(char const*, int, double*, double*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rdx
leaq 0x15197(%rip), %rax # 0x1e178
movl $0x19, (%rax)
leaq 0x1517a(%rip), %r15 # 0x1e168
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9059
movq %rcx, %rbx
leaq 0x15174(%rip), %rcx # 0x1e174
movl $0x2, %eax
cmpl $0x19, (%rcx)
jne 0x90f5
movsd 0x150aa(%rip), %xmm0 # 0x1e0c0
movl $0x5, %eax
movsd 0xb0bd(%rip), %xmm1 # 0x140e0
ucomisd %xmm0, %xmm1
ja 0x90f5
movl %esi, %ebp
testl %r8d, %r8d
je 0x9063
movsd 0xb0cc(%rip), %xmm1 # 0x14108
ucomisd %xmm0, %xmm1
ja 0x90f5
leaq 0xc3b4(%rip), %rsi # 0x15401
movl %r8d, %ecx
xorl %eax, %eax
callq 0x10e0
jmp 0x9071
movl $0x1, %eax
jmp 0x90f5
leaq 0xc382(%rip), %rsi # 0x153ec
xorl %eax, %eax
callq 0x10e0
movl $0x0, 0x15129(%rip) # 0x1e1a4
testl %ebp, %ebp
jle 0x90ea
movl %ebp, %ebp
xorl %r13d, %r13d
leaq 0xcab1(%rip), %r12 # 0x15b3c
movq (%r15), %rdi
movsd (%r14,%r13,8), %xmm0
movsd (%rbx,%r13,8), %xmm1
testl %r13d, %r13d
je 0x90d3
movl %r13d, %eax
movl $0xcccccccd, %ecx # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %eax
movl %r13d, %ecx
subl %eax, %ecx
jne 0x90d3
leaq 0xc360(%rip), %rsi # 0x15420
movq %r12, %rdx
callq 0x9104
leaq 0x150a1(%rip), %rax # 0x1e170
incl (%rax)
jmp 0x90e2
leaq 0xc15d(%rip), %rsi # 0x15237
movq %r12, %rdx
callq 0x9104
incq %r13
cmpl %r13d, %ebp
jne 0x908b
leaq 0x1507f(%rip), %rax # 0x1e170
incl (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN12LefDefParser14defwViaPolygonEPKciPdS2_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov rdx, rdi
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 19h
lea r15, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [r15]
test rdi, rdi
jz short loc_9059
mov rbx, rcx
lea rcx, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov eax, 2
cmp dword ptr [rcx], 19h
jnz loc_90F5
movsd xmm0, cs:_ZN12LefDefParserL13defVersionNumE; LefDefParser::defVersionNum
mov eax, 5
movsd xmm1, cs:dbl_140E0
ucomisd xmm1, xmm0
ja loc_90F5
mov ebp, esi
test r8d, r8d
jz short loc_9063
movsd xmm1, cs:qword_14108
ucomisd xmm1, xmm0
ja loc_90F5
lea rsi, aPolygonSMaskD; "\n + POLYGON %s + MASK %d "
mov ecx, r8d
xor eax, eax
call _fprintf
jmp short loc_9071
loc_9059:
mov eax, 1
jmp loc_90F5
loc_9063:
lea rsi, aPolygonS; "\n + POLYGON %s "
xor eax, eax
call _fprintf
loc_9071:
mov cs:_ZN12LefDefParserL14printPointsNumE, 0; LefDefParser::printPointsNum
test ebp, ebp
jle short loc_90EA
mov ebp, ebp
xor r13d, r13d
lea r12, asc_15B37+5; " "
loc_908B:
mov rdi, [r15]
movsd xmm0, qword ptr [r14+r13*8]
movsd xmm1, qword ptr [rbx+r13*8]
test r13d, r13d
jz short loc_90D3
mov eax, r13d
mov ecx, 0CCCCCCCDh
imul rax, rcx
shr rax, 22h
lea eax, [rax+rax*4]
mov ecx, r13d
sub ecx, eax
jnz short loc_90D3
lea rsi, asc_15420; "\n "
mov rdx, r12
call _ZN12LefDefParserL11printPointsEP8_IO_FILEddPKcS3_; LefDefParser::printPoints(_IO_FILE *,double,double,char const*,char const*)
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
inc dword ptr [rax]
jmp short loc_90E2
loc_90D3:
lea rsi, asc_15234+3; ""
mov rdx, r12
call _ZN12LefDefParserL11printPointsEP8_IO_FILEddPKcS3_; LefDefParser::printPoints(_IO_FILE *,double,double,char const*,char const*)
loc_90E2:
inc r13
cmp ebp, r13d
jnz short loc_908B
loc_90EA:
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
inc dword ptr [rax]
xor eax, eax
loc_90F5:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::defwViaPolygon(LefDefParser *this, const char *a2, long long a3, double *a4, double *a5)
{
long long result; // rax
long long v8; // rcx
long long v9; // r13
double v10; // xmm0_8
double v11; // xmm1_8
LefDefParser::defwFunc = 25;
if ( !LefDefParser::defwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::defwState == 25 )
{
result = 5LL;
if ( *(double *)&LefDefParser::defVersionNum >= 5.6 )
{
if ( (_DWORD)a5 )
{
if ( *(double *)&LefDefParser::defVersionNum < 5.8 )
return result;
fprintf(LefDefParser::defwFile, "\n + POLYGON %s + MASK %d ", (const char *)this, (_DWORD)a5);
}
else
{
fprintf(LefDefParser::defwFile, "\n + POLYGON %s ", (const char *)this);
}
LefDefParser::printPointsNum = 0;
if ( (int)a2 > 0 )
{
v9 = 0LL;
do
{
v10 = *(double *)(a3 + 8 * v9);
v11 = a4[v9];
if ( !(_DWORD)v9 || (v8 = (unsigned int)v9 % 5) != 0 )
{
LefDefParser::printPoints(LefDefParser::defwFile, "", " ", v8, v10, v11);
}
else
{
LefDefParser::printPoints(LefDefParser::defwFile, "\n ", " ", v8, v10, v11);
++LefDefParser::defwLines;
}
++v9;
}
while ( (_DWORD)a2 != (_DWORD)v9 );
}
++LefDefParser::defwLines;
return 0LL;
}
}
return result;
}
| defwViaPolygon:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RDX,RDI
LEA RAX,[0x11e178]
MOV dword ptr [RAX],0x19
LEA R15,[0x11e168]
MOV RDI,qword ptr [R15]
TEST RDI,RDI
JZ 0x00109059
MOV RBX,RCX
LEA RCX,[0x11e174]
MOV EAX,0x2
CMP dword ptr [RCX],0x19
JNZ 0x001090f5
MOVSD XMM0,qword ptr [0x0011e0c0]
MOV EAX,0x5
MOVSD XMM1,qword ptr [0x001140e0]
UCOMISD XMM1,XMM0
JA 0x001090f5
MOV EBP,ESI
TEST R8D,R8D
JZ 0x00109063
MOVSD XMM1,qword ptr [0x00114108]
UCOMISD XMM1,XMM0
JA 0x001090f5
LEA RSI,[0x115401]
MOV ECX,R8D
XOR EAX,EAX
CALL 0x001010e0
JMP 0x00109071
LAB_00109059:
MOV EAX,0x1
JMP 0x001090f5
LAB_00109063:
LEA RSI,[0x1153ec]
XOR EAX,EAX
CALL 0x001010e0
LAB_00109071:
MOV dword ptr [0x0011e1a4],0x0
TEST EBP,EBP
JLE 0x001090ea
MOV EBP,EBP
XOR R13D,R13D
LEA R12,[0x115b3c]
LAB_0010908b:
MOV RDI,qword ptr [R15]
MOVSD XMM0,qword ptr [R14 + R13*0x8]
MOVSD XMM1,qword ptr [RBX + R13*0x8]
TEST R13D,R13D
JZ 0x001090d3
MOV EAX,R13D
MOV ECX,0xcccccccd
IMUL RAX,RCX
SHR RAX,0x22
LEA EAX,[RAX + RAX*0x4]
MOV ECX,R13D
SUB ECX,EAX
JNZ 0x001090d3
LEA RSI,[0x115420]
MOV RDX,R12
CALL 0x00109104
LEA RAX,[0x11e170]
INC dword ptr [RAX]
JMP 0x001090e2
LAB_001090d3:
LEA RSI,[0x115237]
MOV RDX,R12
CALL 0x00109104
LAB_001090e2:
INC R13
CMP EBP,R13D
JNZ 0x0010908b
LAB_001090ea:
LEA RAX,[0x11e170]
INC dword ptr [RAX]
XOR EAX,EAX
LAB_001090f5:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::defwViaPolygon(char const*, int, double*, double*, int) */
int8
LefDefParser::defwViaPolygon(char *param_1,int param_2,double *param_3,double *param_4,int param_5)
{
int8 uVar1;
ulong uVar2;
defwFunc = 0x19;
if (defwFile == (FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if ((defwState == 0x19) && (uVar1 = 5, DAT_001140e0 <= defVersionNum)) {
if (param_5 == 0) {
fprintf(defwFile,"\n + POLYGON %s ",param_1);
}
else {
if (defVersionNum < DAT_00114108) {
defwFunc = 0x19;
return 5;
}
fprintf(defwFile,"\n + POLYGON %s + MASK %d ",param_1,(ulong)(uint)param_5);
}
printPointsNum = 0;
if (0 < param_2) {
uVar2 = 0;
do {
if (((int)uVar2 == 0) || ((int)uVar2 + (int)((uVar2 & 0xffffffff) / 5) * -5 != 0)) {
printPoints(defwFile,param_3[uVar2],param_4[uVar2],""," ");
}
else {
printPoints(defwFile,param_3[uVar2],param_4[uVar2],"\n "," ");
defwLines = defwLines + 1;
}
uVar2 = uVar2 + 1;
} while (param_2 != (int)uVar2);
}
defwLines = defwLines + 1;
uVar1 = 0;
}
}
return uVar1;
}
| |
52,361 | ggml_out_prod | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_out_prod(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_out_prod(a, b));
GGML_ASSERT(!ggml_is_transposed(a));
bool is_node = false;
if (a->grad || b->grad) {
is_node = true;
}
// a is broadcastable to b for ne[2] and ne[3] -> use b->ne[2] and b->ne[3]
const int64_t ne[4] = { a->ne[0], b->ne[0], b->ne[2], b->ne[3] };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
result->op = GGML_OP_OUT_PROD;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O0 | c | ggml_out_prod:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x121ad0
testb $0x1, %al
jne 0x12198a
movq 0xb65db(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0xb664c(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x5e2b4(%rip), %rsi # 0x17fc1a
leaq 0x67d01(%rip), %rdx # 0x18966e
movl $0x1033, %ecx # imm = 0x1033
leaq 0x681c0(%rip), %r8 # 0x189b39
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x12198c
jmp 0x12198e
movq 0x48(%rsp), %rdi
callq 0x11b490
testb $0x1, %al
jne 0x12199e
jmp 0x1219e2
movq 0xb6583(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0xb65f4(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x5e25c(%rip), %rsi # 0x17fc1a
leaq 0x67ca9(%rip), %rdx # 0x18966e
movl $0x1034, %ecx # imm = 0x1034
leaq 0x6806d(%rip), %r8 # 0x189a3e
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x1219e4
movb $0x0, 0x3f(%rsp)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x121a07
movq 0x40(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x121a0c
movb $0x1, 0x3f(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rcx
xorl %esi, %esi
movl $0x4, %edx
callq 0x11c2c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x19, 0x50(%rax)
testb $0x1, 0x3f(%rsp)
je 0x121a87
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11cfc0
movq %rax, (%rsp)
jmp 0x121a8f
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x121a8f
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x48(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x40(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0xa8(%rax)
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| ggml_out_prod:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_18]
call ggml_can_out_prod
test al, 1
jnz short loc_12198A
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 1033h
lea r8, aGgmlCanOutProd; "ggml_can_out_prod(a, b)"
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_12198A:
jmp short $+2
loc_12198C:
jmp short $+2
loc_12198E:
mov rdi, [rsp+58h+var_10]
call ggml_is_transposed
test al, 1
jnz short loc_12199E
jmp short loc_1219E2
loc_12199E:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 1034h
lea r8, aGgmlIsTranspos; "!ggml_is_transposed(a)"
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_1219E2:
jmp short $+2
loc_1219E4:
mov [rsp+58h+var_19], 0
mov rax, [rsp+58h+var_10]
cmp qword ptr [rax+98h], 0
jnz short loc_121A07
mov rax, [rsp+58h+var_18]
cmp qword ptr [rax+98h], 0
jz short loc_121A0C
loc_121A07:
mov [rsp+58h+var_19], 1
loc_121A0C:
mov rax, [rsp+58h+var_10]
mov rax, [rax+10h]
mov [rsp+58h+var_48], rax
mov rax, [rsp+58h+var_18]
mov rax, [rax+10h]
mov [rsp+58h+var_40], rax
mov rax, [rsp+58h+var_18]
mov rax, [rax+20h]
mov [rsp+58h+var_38], rax
mov rax, [rsp+58h+var_18]
mov rax, [rax+28h]
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_8]
lea rcx, [rsp+58h+var_48]
xor esi, esi
mov edx, 4
call ggml_new_tensor
mov [rsp+58h+var_50], rax
mov rax, [rsp+58h+var_50]
mov dword ptr [rax+50h], 19h
test [rsp+58h+var_19], 1
jz short loc_121A87
mov rdi, [rsp+58h+var_8]
mov rsi, [rsp+58h+var_50]
call ggml_dup_tensor
mov [rsp+58h+var_58], rax
jmp short loc_121A8F
loc_121A87:
xor eax, eax
mov [rsp+58h+var_58], rax
jmp short $+2
loc_121A8F:
mov rcx, [rsp+58h+var_58]
mov rax, [rsp+58h+var_50]
mov [rax+98h], rcx
mov rcx, [rsp+58h+var_10]
mov rax, [rsp+58h+var_50]
mov [rax+0A0h], rcx
mov rcx, [rsp+58h+var_18]
mov rax, [rsp+58h+var_50]
mov [rax+0A8h], rcx
mov rax, [rsp+58h+var_50]
add rsp, 58h
retn
| long long ggml_out_prod(long long a1, long long a2, _QWORD *a3)
{
long long v3; // rdi
long long v4; // rdi
long long v6; // [rsp+0h] [rbp-58h]
long long v7; // [rsp+8h] [rbp-50h]
_QWORD v8[5]; // [rsp+10h] [rbp-48h] BYREF
char v9; // [rsp+3Fh] [rbp-19h]
_QWORD *v10; // [rsp+40h] [rbp-18h]
long long v11; // [rsp+48h] [rbp-10h]
long long v12; // [rsp+50h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
if ( (ggml_can_out_prod(a2, a3) & 1) == 0 )
{
fflush(stdout);
v3 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
4147,
"ggml_can_out_prod(a, b)");
ggml_print_backtrace();
abort(v3);
}
if ( ggml_is_transposed(v11) )
{
fflush(stdout);
v4 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
4148,
"!ggml_is_transposed(a)");
ggml_print_backtrace();
abort(v4);
}
v9 = 0;
if ( *(_QWORD *)(v11 + 152) || v10[19] )
v9 = 1;
v8[0] = *(_QWORD *)(v11 + 16);
v8[1] = v10[2];
v8[2] = v10[4];
v8[3] = v10[5];
v7 = ggml_new_tensor(v12, 0, 4u, (long long)v8);
*(_DWORD *)(v7 + 80) = 25;
if ( (v9 & 1) != 0 )
v6 = ggml_dup_tensor(v12, (unsigned int *)v7);
else
v6 = 0LL;
*(_QWORD *)(v7 + 152) = v6;
*(_QWORD *)(v7 + 160) = v11;
*(_QWORD *)(v7 + 168) = v10;
return v7;
}
| |||
52,362 | ggml_out_prod | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_out_prod(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_out_prod(a, b));
GGML_ASSERT(!ggml_is_transposed(a));
bool is_node = false;
if (a->grad || b->grad) {
is_node = true;
}
// a is broadcastable to b for ne[2] and ne[3] -> use b->ne[2] and b->ne[3]
const int64_t ne[4] = { a->ne[0], b->ne[0], b->ne[2], b->ne[3] };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
result->op = GGML_OP_OUT_PROD;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O1 | c | ggml_out_prod:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rax
cmpq 0x18(%rdx), %rax
jne 0x92746
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%rdx), %rax
cqto
idivq 0x20(%rsi)
testq %rdx, %rdx
jne 0x92746
movq 0x28(%rbx), %rax
cqto
idivq 0x28(%r14)
testq %rdx, %rdx
jne 0x92746
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
ja 0x9274b
movq %rdi, %r15
cmpq $0x0, 0x98(%r14)
jne 0x926aa
cmpq $0x0, 0x98(%rbx)
je 0x9273f
movb $0x1, %bpl
vmovups 0x20(%rbx), %xmm0
vmovsd 0x10(%rbx), %xmm1
vmovsd 0x10(%r14), %xmm2
vmovlhps %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
movq %rsp, %rcx
vmovaps %xmm0, 0x10(%rcx)
vmovaps %xmm1, (%rcx)
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movq %rax, %r12
movl $0x19, 0x50(%rax)
testb %bpl, %bpl
je 0x92715
movl (%r12), %esi
movq %r12, %rcx
addq $0x10, %rcx
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e8b7
movq %rax, %r13
movq %r13, 0x98(%r12)
movq %r14, 0xa0(%r12)
movq %rbx, 0xa8(%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x926ad
callq 0xd502
callq 0xd547
| ggml_out_prod:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+18h]
cmp rax, [rdx+18h]
jnz loc_92746
mov rbx, rdx
mov r14, rsi
mov rax, [rdx+20h]
cqo
idiv qword ptr [rsi+20h]
test rdx, rdx
jnz loc_92746
mov rax, [rbx+28h]
cqo
idiv qword ptr [r14+28h]
test rdx, rdx
jnz loc_92746
mov rax, [r14+30h]
cmp rax, [r14+38h]
ja loc_9274B
mov r15, rdi
cmp qword ptr [r14+98h], 0
jnz short loc_926AA
cmp qword ptr [rbx+98h], 0
jz loc_9273F
loc_926AA:
mov bpl, 1
loc_926AD:
vmovups xmm0, xmmword ptr [rbx+20h]
vmovsd xmm1, qword ptr [rbx+10h]
vmovsd xmm2, qword ptr [r14+10h]
vmovlhps xmm1, xmm2, xmm1
mov rcx, rsp
vmovaps xmmword ptr [rcx+10h], xmm0
vmovaps xmmword ptr [rcx], xmm1
xor r13d, r13d
mov rdi, r15
xor esi, esi
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r12, rax
mov dword ptr [rax+50h], 19h
test bpl, bpl
jz short loc_92715
mov esi, [r12]
mov rcx, r12
add rcx, 10h
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r13, rax
loc_92715:
mov [r12+98h], r13
mov [r12+0A0h], r14
mov [r12+0A8h], rbx
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9273F:
xor ebp, ebp
jmp loc_926AD
loc_92746:
call ggml_out_prod_cold_1
loc_9274B:
call ggml_out_prod_cold_2
| _QWORD * ggml_out_prod(long long a1, _QWORD *a2, _QWORD *a3)
{
bool v5; // bp
long long v11; // r13
long long v12; // rax
_QWORD *v13; // r12
_QWORD v15[11]; // [rsp+0h] [rbp-58h] BYREF
if ( a2[3] != a3[3] || (_RBX = a3, _R14 = a2, (long long)a3[4] % a2[4]) || (long long)a3[5] % a2[5] )
ggml_out_prod_cold_1();
if ( a2[6] > a2[7] )
ggml_out_prod_cold_2();
v5 = a2[19] || a3[19];
__asm
{
vmovups xmm0, xmmword ptr [rbx+20h]
vmovsd xmm1, qword ptr [rbx+10h]
vmovsd xmm2, qword ptr [r14+10h]
vmovlhps xmm1, xmm2, xmm1
}
_RCX = v15;
__asm
{
vmovaps xmmword ptr [rcx+10h], xmm0
vmovaps xmmword ptr [rcx], xmm1
}
v11 = 0LL;
v12 = ggml_new_tensor_impl(a1, 0, 4, v15, 0LL, 0LL, _XMM0, _XMM1);
v13 = (_QWORD *)v12;
*(_DWORD *)(v12 + 80) = 25;
if ( v5 )
v11 = ggml_new_tensor_impl(a1, *(_DWORD *)v12, 4, (_QWORD *)(v12 + 16), 0LL, 0LL, _XMM0, _XMM1);
v13[19] = v11;
v13[20] = a2;
v13[21] = _RBX;
return v13;
}
| |||
52,363 | ggml_out_prod | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_out_prod(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_out_prod(a, b));
GGML_ASSERT(!ggml_is_transposed(a));
bool is_node = false;
if (a->grad || b->grad) {
is_node = true;
}
// a is broadcastable to b for ne[2] and ne[3] -> use b->ne[2] and b->ne[3]
const int64_t ne[4] = { a->ne[0], b->ne[0], b->ne[2], b->ne[3] };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
result->op = GGML_OP_OUT_PROD;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_out_prod:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rax
cmpq 0x18(%rdx), %rax
jne 0x6b487
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdx), %rdi
movq %rdi, %rax
cqto
idivq 0x20(%rsi)
testq %rdx, %rdx
jne 0x6b487
movq 0x28(%rbx), %rsi
movq %rsi, %rax
cqto
idivq 0x28(%r14)
testq %rdx, %rdx
jne 0x6b487
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
ja 0x6b4bc
cmpq $0x0, 0x98(%r14)
jne 0x6b40f
cmpq $0x0, 0x98(%rbx)
je 0x6b483
movb $0x1, %bpl
movq 0x10(%r14), %rax
movq %rsp, %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
xorl %r13d, %r13d
pushq $0x4
popq %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x6835b
movq %rax, %r12
movl $0x19, 0x50(%rax)
testb %bpl, %bpl
je 0x6b459
movq %r15, %rdi
movq %r12, %rsi
callq 0x68a65
movq %rax, %r13
movq %r13, 0x98(%r12)
movq %r14, 0xa0(%r12)
movq %rbx, 0xa8(%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x6b412
movq 0x6aaba(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6ab0b(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2ed77(%rip), %rsi # 0x9a21e
leaq 0x363d0(%rip), %rdx # 0xa187e
leaq 0x36831(%rip), %r8 # 0xa1ce6
movl $0x1033, %ecx # imm = 0x1033
jmp 0x6b4ef
movq 0x6aa85(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6aad6(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2ed42(%rip), %rsi # 0x9a21e
leaq 0x3639b(%rip), %rdx # 0xa187e
leaq 0x36701(%rip), %r8 # 0xa1beb
movl $0x1034, %ecx # imm = 0x1034
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_out_prod:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+18h]
cmp rax, [rdx+18h]
jnz loc_6B487
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, [rdx+20h]
mov rax, rdi
cqo
idiv qword ptr [rsi+20h]
test rdx, rdx
jnz loc_6B487
mov rsi, [rbx+28h]
mov rax, rsi
cqo
idiv qword ptr [r14+28h]
test rdx, rdx
jnz loc_6B487
mov rax, [r14+30h]
cmp rax, [r14+38h]
ja loc_6B4BC
cmp qword ptr [r14+98h], 0
jnz short loc_6B40F
cmp qword ptr [rbx+98h], 0
jz short loc_6B483
loc_6B40F:
mov bpl, 1
loc_6B412:
mov rax, [r14+10h]
mov rcx, rsp
mov [rcx], rax
mov rax, [rbx+10h]
mov [rcx+8], rax
mov [rcx+10h], rdi
mov [rcx+18h], rsi
xor r13d, r13d
push 4
pop rdx
mov rdi, r15
xor esi, esi
call ggml_new_tensor
mov r12, rax
mov dword ptr [rax+50h], 19h
test bpl, bpl
jz short loc_6B459
mov rdi, r15
mov rsi, r12
call ggml_dup_tensor
mov r13, rax
loc_6B459:
mov [r12+98h], r13
mov [r12+0A0h], r14
mov [r12+0A8h], rbx
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6B483:
xor ebp, ebp
jmp short loc_6B412
loc_6B487:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlCanOutProd; "ggml_can_out_prod(a, b)"
mov ecx, 1033h
jmp short loc_6B4EF
loc_6B4BC:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlIsTranspos; "!ggml_is_transposed(a)"
mov ecx, 1034h
loc_6B4EF:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| unsigned int * ggml_out_prod(long long a1, _QWORD *a2, _QWORD *a3)
{
long long v6; // rdi
long long v7; // rsi
bool v8; // bp
long long v9; // r13
unsigned int *v10; // rax
unsigned int *v11; // r12
long long v13; // rdi
_QWORD v14[11]; // [rsp+0h] [rbp-58h] BYREF
if ( a2[3] != a3[3] || (v6 = a3[4], v6 % a2[4]) || (v7 = a3[5], v7 % a2[5]) )
{
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
4147LL,
"ggml_can_out_prod(a, b)");
goto LABEL_14;
}
if ( a2[6] > a2[7] )
{
fflush(stdout);
v13 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
4148LL,
"!ggml_is_transposed(a)");
LABEL_14:
ggml_print_backtrace();
abort(v13);
}
v8 = a2[19] || a3[19];
v14[0] = a2[2];
v14[1] = a3[2];
v14[2] = v6;
v14[3] = v7;
v9 = 0LL;
v10 = (unsigned int *)ggml_new_tensor(a1, 0LL, 4LL, (long long)v14);
v11 = v10;
v10[20] = 25;
if ( v8 )
v9 = ggml_dup_tensor(a1, v10);
*((_QWORD *)v11 + 19) = v9;
*((_QWORD *)v11 + 20) = a2;
*((_QWORD *)v11 + 21) = a3;
return v11;
}
| ggml_out_prod:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RSI + 0x18]
CMP RAX,qword ptr [RDX + 0x18]
JNZ 0x0016b487
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDX + 0x20]
MOV RAX,RDI
CQO
IDIV qword ptr [RSI + 0x20]
TEST RDX,RDX
JNZ 0x0016b487
MOV RSI,qword ptr [RBX + 0x28]
MOV RAX,RSI
CQO
IDIV qword ptr [R14 + 0x28]
TEST RDX,RDX
JNZ 0x0016b487
MOV RAX,qword ptr [R14 + 0x30]
CMP RAX,qword ptr [R14 + 0x38]
JA 0x0016b4bc
CMP qword ptr [R14 + 0x98],0x0
JNZ 0x0016b40f
CMP qword ptr [RBX + 0x98],0x0
JZ 0x0016b483
LAB_0016b40f:
MOV BPL,0x1
LAB_0016b412:
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,RSP
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RDI
MOV qword ptr [RCX + 0x18],RSI
XOR R13D,R13D
PUSH 0x4
POP RDX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0016835b
MOV R12,RAX
MOV dword ptr [RAX + 0x50],0x19
TEST BPL,BPL
JZ 0x0016b459
MOV RDI,R15
MOV RSI,R12
CALL 0x00168a65
MOV R13,RAX
LAB_0016b459:
MOV qword ptr [R12 + 0x98],R13
MOV qword ptr [R12 + 0xa0],R14
MOV qword ptr [R12 + 0xa8],RBX
MOV RAX,R12
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016b483:
XOR EBP,EBP
JMP 0x0016b412
LAB_0016b487:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1ce6]
MOV ECX,0x1033
JMP 0x0016b4ef
LAB_0016b4bc:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1beb]
MOV ECX,0x1034
LAB_0016b4ef:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
long ggml_out_prod(int8 param_1,long param_2,long param_3)
{
bool bVar1;
long lVar2;
int8 uVar3;
FILE *__stream;
char *pcVar4;
if (((*(long *)(param_2 + 0x18) == *(long *)(param_3 + 0x18)) &&
(*(long *)(param_3 + 0x20) % *(long *)(param_2 + 0x20) == 0)) &&
(*(long *)(param_3 + 0x28) % *(long *)(param_2 + 0x28) == 0)) {
if (*(ulong *)(param_2 + 0x30) <= *(ulong *)(param_2 + 0x38)) {
if ((*(long *)(param_2 + 0x98) == 0) && (*(long *)(param_3 + 0x98) == 0)) {
bVar1 = false;
}
else {
bVar1 = true;
}
uVar3 = 0;
lVar2 = ggml_new_tensor(param_1,0,4);
*(int4 *)(lVar2 + 0x50) = 0x19;
if (bVar1) {
uVar3 = ggml_dup_tensor(param_1,lVar2);
}
*(int8 *)(lVar2 + 0x98) = uVar3;
*(long *)(lVar2 + 0xa0) = param_2;
*(long *)(lVar2 + 0xa8) = param_3;
return lVar2;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "!ggml_is_transposed(a)";
uVar3 = 0x1034;
}
else {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "ggml_can_out_prod(a, b)";
uVar3 = 0x1033;
}
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar3,pcVar4);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
52,364 | ggml_out_prod | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | struct ggml_tensor * ggml_out_prod(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b) {
GGML_ASSERT(ggml_can_out_prod(a, b));
GGML_ASSERT(!ggml_is_transposed(a));
bool is_node = false;
if (a->grad || b->grad) {
is_node = true;
}
// a is broadcastable to b for ne[2] and ne[3] -> use b->ne[2] and b->ne[3]
const int64_t ne[4] = { a->ne[0], b->ne[0], b->ne[2], b->ne[3] };
struct ggml_tensor * result = ggml_new_tensor(ctx, GGML_TYPE_F32, 4, ne);
result->op = GGML_OP_OUT_PROD;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O3 | c | ggml_out_prod:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rax
cmpq 0x18(%rdx), %rax
jne 0x91594
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdx), %rdi
movq %rdi, %rax
cqto
idivq 0x20(%rsi)
testq %rdx, %rdx
jne 0x91594
movq 0x28(%rbx), %rsi
movq %rsi, %rax
cqto
idivq 0x28(%r14)
testq %rdx, %rdx
jne 0x91594
movq 0x30(%r14), %rax
cmpq 0x38(%r14), %rax
ja 0x91599
cmpq $0x0, 0x98(%r14)
jne 0x914fe
cmpq $0x0, 0x98(%rbx)
je 0x9158d
movb $0x1, %bpl
movq 0x10(%r14), %rax
movq %rsp, %rcx
movq %rax, (%rcx)
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rcx)
movq %rdi, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
xorl %r13d, %r13d
movq %r15, %rdi
xorl %esi, %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8d64f
movq %rax, %r12
movl $0x19, 0x50(%rax)
testb %bpl, %bpl
je 0x91563
movl (%r12), %esi
movq %r12, %rcx
addq $0x10, %rcx
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8d64f
movq %rax, %r13
movq %r13, 0x98(%r12)
movq %r14, 0xa0(%r12)
movq %rbx, 0xa8(%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x91501
callq 0xd423
callq 0xd468
| ggml_out_prod:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+18h]
cmp rax, [rdx+18h]
jnz loc_91594
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, [rdx+20h]
mov rax, rdi
cqo
idiv qword ptr [rsi+20h]
test rdx, rdx
jnz loc_91594
mov rsi, [rbx+28h]
mov rax, rsi
cqo
idiv qword ptr [r14+28h]
test rdx, rdx
jnz loc_91594
mov rax, [r14+30h]
cmp rax, [r14+38h]
ja loc_91599
cmp qword ptr [r14+98h], 0
jnz short loc_914FE
cmp qword ptr [rbx+98h], 0
jz loc_9158D
loc_914FE:
mov bpl, 1
loc_91501:
mov rax, [r14+10h]
mov rcx, rsp
mov [rcx], rax
mov rax, [rbx+10h]
mov [rcx+8], rax
mov [rcx+10h], rdi
mov [rcx+18h], rsi
xor r13d, r13d
mov rdi, r15
xor esi, esi
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r12, rax
mov dword ptr [rax+50h], 19h
test bpl, bpl
jz short loc_91563
mov esi, [r12]
mov rcx, r12
add rcx, 10h
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r13, rax
loc_91563:
mov [r12+98h], r13
mov [r12+0A0h], r14
mov [r12+0A8h], rbx
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9158D:
xor ebp, ebp
jmp loc_91501
loc_91594:
call ggml_out_prod_cold_1
loc_91599:
call ggml_out_prod_cold_2
| _QWORD * ggml_out_prod(long long a1, _QWORD *a2, _QWORD *a3, __m128 a4, __m128 a5)
{
long long v8; // rdi
long long v9; // rsi
bool v10; // bp
long long v11; // r13
long long v12; // rax
_QWORD *v13; // r12
_QWORD v15[11]; // [rsp+0h] [rbp-58h] BYREF
if ( a2[3] != a3[3] || (v8 = a3[4], v8 % a2[4]) || (v9 = a3[5], v9 % a2[5]) )
ggml_out_prod_cold_1();
if ( a2[6] > a2[7] )
ggml_out_prod_cold_2();
v10 = a2[19] || a3[19];
v15[0] = a2[2];
v15[1] = a3[2];
v15[2] = v8;
v15[3] = v9;
v11 = 0LL;
v12 = ggml_new_tensor_impl(a1, 0, 4, v15, 0LL, 0LL, a4, a5);
v13 = (_QWORD *)v12;
*(_DWORD *)(v12 + 80) = 25;
if ( v10 )
v11 = ggml_new_tensor_impl(a1, *(_DWORD *)v12, 4, (_QWORD *)(v12 + 16), 0LL, 0LL, a4, a5);
v13[19] = v11;
v13[20] = a2;
v13[21] = a3;
return v13;
}
| |||
52,365 | 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 0x917c3(%rip), %rax # 0x129de8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0x84328
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x98643
callq 0x6d1fe
leaq 0x90cae(%rip), %rax # 0x1292f8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x98660
popq %rbx
jmp 0x6d1fe
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_98643
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_98643:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_98660
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_98660:
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,[0x229de8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
ADD RDI,0x40
CALL 0x00184328
MOV RDI,qword ptr [RBX + 0x38]
TEST RDI,RDI
JZ 0x00198643
CALL 0x0016d1fe
LAB_00198643:
LEA RAX,[0x2292f8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x00198660
POP RBX
JMP 0x0016d1fe
LAB_00198660:
POP RBX
RET
|
/* minja::MacroTemplateToken::~MacroTemplateToken() */
void __thiscall minja::MacroTemplateToken::~MacroTemplateToken(MacroTemplateToken *this)
{
*(int ***)this = &PTR__MacroTemplateToken_00229df8;
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_00229308;
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;
}
| |
52,366 | my_uni_utf32 | eloqsql/strings/ctype-ucs2.c | static int
my_uni_utf32(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s + 4 > e)
return MY_CS_TOOSMALL4;
if (wc > 0x10FFFF)
return MY_CS_ILUNI;
s[0]= (uchar) (wc >> 24);
s[1]= (uchar) (wc >> 16) & 0xFF;
s[2]= (uchar) (wc >> 8) & 0xFF;
s[3]= (uchar) wc & 0xFF;
return 4;
} | O0 | c | my_uni_utf32:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0x52f4b
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x52fbc
cmpq $0x10ffff, -0x18(%rbp) # imm = 0x10FFFF
jbe 0x52f5e
movl $0x0, -0x4(%rbp)
jmp 0x52fbc
movq -0x18(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
shrq $0x10, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x18(%rbp), %rax
shrq $0x8, %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x18(%rbp), %rax
movzbl %al, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_uni_utf32:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_52F4B
mov [rbp+var_4], 0FFFFFF98h
jmp short loc_52FBC
loc_52F4B:
cmp [rbp+var_18], offset unk_10FFFF
jbe short loc_52F5E
mov [rbp+var_4], 0
jmp short loc_52FBC
loc_52F5E:
mov rax, [rbp+var_18]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rax, [rbp+var_18]
shr rax, 10h
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov rax, [rbp+var_18]
shr rax, 8
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov rax, [rbp+var_18]
movzx eax, al
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+3], cl
mov [rbp+var_4], 4
loc_52FBC:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_uni_utf32(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( (unsigned long long)(a3 + 4) <= a4 )
{
if ( a2 <= (unsigned long long)&unk_10FFFF )
{
*a3 = BYTE3(a2);
a3[1] = BYTE2(a2);
a3[2] = BYTE1(a2);
a3[3] = a2;
return 4;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-104;
}
}
| my_uni_utf32:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00152f4b
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x00152fbc
LAB_00152f4b:
CMP qword ptr [RBP + -0x18],0x10ffff
JBE 0x00152f5e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00152fbc
LAB_00152f5e:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x10
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x8
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,AL
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x3],CL
MOV dword ptr [RBP + -0x4],0x4
LAB_00152fbc:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_utf32(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int4 local_c;
if (param_4 < param_3 + 4) {
local_c = 0xffffff98;
}
else if (param_2 < 0x110000) {
*param_3 = (char)(param_2 >> 0x18);
param_3[1] = (char)(param_2 >> 0x10);
param_3[2] = (char)(param_2 >> 8);
param_3[3] = (char)param_2;
local_c = 4;
}
else {
local_c = 0;
}
return local_c;
}
| |
52,367 | r3d_textures_load | r3d/src/r3d_state.c | void r3d_textures_load(void)
{
r3d_texture_load_white();
r3d_texture_load_black();
r3d_texture_load_normal();
r3d_texture_load_rand_noise();
r3d_texture_load_ibl_brdf_lut();
if (R3D.env.ssaoEnabled) {
r3d_texture_load_ssao_kernel();
}
} | O3 | c | r3d_textures_load:
pushq %rbp
movq %rsp, %rbp
leaq 0x59762(%rip), %rdi # 0x119d74
movl $0x1, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x1c6b8
movl %eax, 0xf0b5e(%rip) # 0x1b1190
leaq 0x5973c(%rip), %rdi # 0x119d75
movl $0x1, %esi
movl $0x1, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x1c6b8
movl %eax, 0xf0b3b(%rip) # 0x1b1194
leaq 0x59718(%rip), %rdi # 0x119d78
movl $0x1, %esi
movl $0x1, %edx
movl $0x9, %ecx
movl $0x1, %r8d
callq 0x1c6b8
movl %eax, 0xf0b18(%rip) # 0x1b1198
callq 0xc0722
callq 0xc08f1
cmpb $0x1, 0xf0aa8(%rip) # 0x1b1139
jne 0xc0699
popq %rbp
jmp 0xc0b6f
popq %rbp
retq
| r3d_textures_load:
push rbp
mov rbp, rsp
lea rdi, r3d_texture_load_white_DATA
mov esi, 1
mov edx, 1
mov ecx, 1
mov r8d, 1
call rlLoadTexture
mov cs:dword_1B1190, eax
lea rdi, r3d_texture_load_black_DATA
mov esi, 1
mov edx, 1
mov ecx, 1
mov r8d, 1
call rlLoadTexture
mov cs:dword_1B1194, eax
lea rdi, r3d_texture_load_normal_DATA
mov esi, 1
mov edx, 1
mov ecx, 9
mov r8d, 1
call rlLoadTexture
mov cs:dword_1B1198, eax
call r3d_texture_load_rand_noise
call r3d_texture_load_ibl_brdf_lut
cmp cs:byte_1B1139, 1
jnz short loc_C0699
pop rbp
jmp r3d_texture_load_ssao_kernel
loc_C0699:
pop rbp
retn
| long long r3d_textures_load()
{
long long result; // rax
dword_1B1190 = rlLoadTexture((long long)&r3d_texture_load_white_DATA, 1u, 1u, 1u, 1u);
dword_1B1194 = rlLoadTexture((long long)&r3d_texture_load_black_DATA, 1u, 1u, 1u, 1u);
dword_1B1198 = rlLoadTexture((long long)&r3d_texture_load_normal_DATA, 1u, 1u, 9u, 1u);
r3d_texture_load_rand_noise();
result = r3d_texture_load_ibl_brdf_lut();
if ( byte_1B1139 == 1 )
return r3d_texture_load_ssao_kernel();
return result;
}
| r3d_textures_load:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x219d74]
MOV ESI,0x1
MOV EDX,0x1
MOV ECX,0x1
MOV R8D,0x1
CALL 0x0011c6b8
MOV dword ptr [0x002b1190],EAX
LEA RDI,[0x219d75]
MOV ESI,0x1
MOV EDX,0x1
MOV ECX,0x1
MOV R8D,0x1
CALL 0x0011c6b8
MOV dword ptr [0x002b1194],EAX
LEA RDI,[0x219d78]
MOV ESI,0x1
MOV EDX,0x1
MOV ECX,0x9
MOV R8D,0x1
CALL 0x0011c6b8
MOV dword ptr [0x002b1198],EAX
CALL 0x001c0722
CALL 0x001c08f1
CMP byte ptr [0x002b1139],0x1
JNZ 0x001c0699
POP RBP
JMP 0x001c0b6f
LAB_001c0699:
POP RBP
RET
|
void r3d_textures_load(void)
{
DAT_002b1190 = rlLoadTexture(&r3d_texture_load_white_DATA,1,1,1,1);
DAT_002b1194 = rlLoadTexture(&r3d_texture_load_black_DATA,1,1,1,1);
DAT_002b1198 = rlLoadTexture(r3d_texture_load_normal_DATA,1,1,9,1);
r3d_texture_load_rand_noise();
r3d_texture_load_ibl_brdf_lut();
if (DAT_002b1139 == '\x01') {
r3d_texture_load_ssao_kernel();
return;
}
return;
}
| |
52,368 | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp | void
PatchTable::EvaluateBasisFaceVarying(
PatchHandle const & handle, REAL s, REAL t,
REAL wP[], REAL wDs[], REAL wDt[],
REAL wDss[], REAL wDst[], REAL wDtt[],
int channel) const {
PatchParam param = getPatchFVarPatchParam(handle.patchIndex, channel);
PatchDescriptor::Type patchType = param.IsRegular()
? GetFVarPatchDescriptorRegular(channel).GetType()
: GetFVarPatchDescriptorIrregular(channel).GetType();
internal::EvaluatePatchBasis(patchType, param, s, t, wP, wDs, wDt, wDss, wDst, wDtt);
} | O0 | cpp | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movl 0x20(%rbp), %edx
callq 0xcccb0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc99f0
testb $0x1, %al
jne 0x141132
jmp 0x141150
movq -0x60(%rbp), %rsi
movl 0x20(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0xced20
leaq -0x50(%rbp), %rdi
callq 0xceef0
movl %eax, -0x64(%rbp)
jmp 0x14116c
movq -0x60(%rbp), %rsi
movl 0x20(%rbp), %edx
leaq -0x54(%rbp), %rdi
callq 0xd00a0
leaq -0x54(%rbp), %rdi
callq 0xceef0
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq 0x10(%rbp), %r10
movq 0x18(%rbp), %rax
leaq -0x48(%rbp), %rsi
xorps %xmm2, %xmm2
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xd6e80
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| _ZNK10OpenSubdiv6v3_6_03Far10PatchTable24EvaluateBasisFaceVaryingIdEEvRKNS2_11PatchHandleET_S7_PS7_S8_S8_S8_S8_S8_i:
push rbp
mov rbp, rsp
sub rsp, 80h
mov eax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_38], r8
mov [rbp+var_40], r9
mov rdi, [rbp+var_8]; this
mov qword ptr [rbp+var_60], rdi
mov rax, [rbp+var_10]
mov esi, [rax+4]; int
mov edx, [rbp+arg_10]; int
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable22getPatchFVarPatchParamEii; OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(int,int)
mov [rbp+var_48], rax
lea rdi, [rbp+var_48]; this
call __ZNK10OpenSubdiv6v3_6_03Far10PatchParam9IsRegularEv; OpenSubdiv::v3_6_0::Far::PatchParam::IsRegular(void)
test al, 1
jnz short loc_141132
jmp short loc_141150
loc_141132:
mov rsi, qword ptr [rbp+var_60]; int
mov edx, [rbp+arg_10]
lea rdi, [rbp+var_50]; this
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable29GetFVarPatchDescriptorRegularEi; OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorRegular(int)
lea rdi, [rbp+var_50]; this
call __ZNK10OpenSubdiv6v3_6_03Far15PatchDescriptor7GetTypeEv; OpenSubdiv::v3_6_0::Far::PatchDescriptor::GetType(void)
mov [rbp+var_64], eax
jmp short loc_14116C
loc_141150:
mov rsi, qword ptr [rbp+var_60]; int
mov edx, [rbp+arg_10]
lea rdi, [rbp+var_54]; this
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable31GetFVarPatchDescriptorIrregularEi; OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorIrregular(int)
lea rdi, [rbp+var_54]; this
call __ZNK10OpenSubdiv6v3_6_03Far15PatchDescriptor7GetTypeEv; OpenSubdiv::v3_6_0::Far::PatchDescriptor::GetType(void)
mov [rbp+var_64], eax
loc_14116C:
mov eax, [rbp+var_64]
mov [rbp+var_4C], eax
mov edi, [rbp+var_4C]
movsd xmm0, [rbp+var_18]
movsd xmm1, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+var_38]
mov r9, [rbp+var_40]
mov r10, [rbp+arg_0]
mov rax, [rbp+arg_8]
lea rsi, [rbp+var_48]
xorps xmm2, xmm2
mov [rsp+80h+var_80], r10
mov [rsp+80h+var_78], rax
call __ZN10OpenSubdiv6v3_6_03Far8internal18EvaluatePatchBasisIdEEiiRKNS1_10PatchParamET_S7_PS7_S8_S8_S8_S8_S8_S7_; OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<double>(int,OpenSubdiv::v3_6_0::Far::PatchParam const&,double,double,double*,double*,double*,double*,double*,double*,double)
add rsp, 80h
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>(
OpenSubdiv::v3_6_0::Far::PatchTable *a1,
long long a2,
double *a3,
_QWORD *a4,
_QWORD *a5,
_QWORD *a6,
double a7,
double a8,
_QWORD *a9,
_QWORD *a10,
int a11)
{
int Type; // [rsp+1Ch] [rbp-64h]
_BYTE v13[4]; // [rsp+2Ch] [rbp-54h] BYREF
_BYTE v14[4]; // [rsp+30h] [rbp-50h] BYREF
int v15; // [rsp+34h] [rbp-4Ch]
long long PatchFVarPatchParam; // [rsp+38h] [rbp-48h] BYREF
_QWORD *v17; // [rsp+40h] [rbp-40h]
_QWORD *v18; // [rsp+48h] [rbp-38h]
_QWORD *v19; // [rsp+50h] [rbp-30h]
double *v20; // [rsp+58h] [rbp-28h]
double v21; // [rsp+60h] [rbp-20h]
double v22; // [rsp+68h] [rbp-18h]
long long v23; // [rsp+70h] [rbp-10h]
OpenSubdiv::v3_6_0::Far::PatchTable *v24; // [rsp+78h] [rbp-8h]
v24 = a1;
v23 = a2;
v22 = a7;
v21 = a8;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
PatchFVarPatchParam = OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(a1, *(_DWORD *)(a2 + 4), a11);
if ( (OpenSubdiv::v3_6_0::Far::PatchParam::IsRegular((OpenSubdiv::v3_6_0::Far::PatchParam *)&PatchFVarPatchParam) & 1) != 0 )
{
OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorRegular(
(OpenSubdiv::v3_6_0::Far::PatchTable *)v14,
(int)a1);
Type = OpenSubdiv::v3_6_0::Far::PatchDescriptor::GetType((OpenSubdiv::v3_6_0::Far::PatchDescriptor *)v14);
}
else
{
OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorIrregular(
(OpenSubdiv::v3_6_0::Far::PatchTable *)v13,
(int)a1);
Type = OpenSubdiv::v3_6_0::Far::PatchDescriptor::GetType((OpenSubdiv::v3_6_0::Far::PatchDescriptor *)v13);
}
v15 = Type;
return OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<double>(
Type,
(OpenSubdiv::v3_6_0::Far::PatchParam *)&PatchFVarPatchParam,
v20,
v19,
v18,
v17,
v22,
v21,
0.0,
a9,
a10);
}
| |||
52,369 | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp | void
PatchTable::EvaluateBasisFaceVarying(
PatchHandle const & handle, REAL s, REAL t,
REAL wP[], REAL wDs[], REAL wDt[],
REAL wDss[], REAL wDst[], REAL wDtt[],
int channel) const {
PatchParam param = getPatchFVarPatchParam(handle.patchIndex, channel);
PatchDescriptor::Type patchType = param.IsRegular()
? GetFVarPatchDescriptorRegular(channel).GetType()
: GetFVarPatchDescriptorIrregular(channel).GetType();
internal::EvaluatePatchBasis(patchType, param, s, t, wP, wDs, wDt, wDss, wDst, wDtt);
} | O1 | cpp | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r13
movl 0x70(%rsp), %ebp
movl 0x4(%rsi), %esi
movl %ebp, %edx
callq 0x3a150
movq %rax, 0x20(%rsp)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
btq $0x25, %rax
jb 0x6a9fd
callq 0x3ab00
jmp 0x6aa02
callq 0x3a730
movl (%rbx), %edi
leaq 0x20(%rsp), %rsi
xorps %xmm2, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x18(%rsp), %r9
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x3c1a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZNK10OpenSubdiv6v3_6_03Far10PatchTable24EvaluateBasisFaceVaryingIdEEvRKNS2_11PatchHandleET_S7_PS7_S8_S8_S8_S8_S8_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], r9
mov r14, r8
mov r15, rcx
mov r12, rdx
movsd [rsp+58h+var_48], xmm1
movsd [rsp+58h+var_50], xmm0
mov r13, rdi
mov ebp, [rsp+58h+arg_10]
mov esi, [rsi+4]; int
mov edx, ebp; int
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable22getPatchFVarPatchParamEii; OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(int,int)
mov [rsp+58h+var_38], rax
lea rbx, [rsp+58h+var_54]
mov rdi, rbx; this
mov rsi, r13; int
mov edx, ebp
bt rax, 25h ; '%'
jb short loc_6A9FD
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable31GetFVarPatchDescriptorIrregularEi; OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorIrregular(int)
jmp short loc_6AA02
loc_6A9FD:
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable29GetFVarPatchDescriptorRegularEi; OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorRegular(int)
loc_6AA02:
mov edi, [rbx]
lea rsi, [rsp+58h+var_38]
xorps xmm2, xmm2
movsd xmm0, [rsp+58h+var_50]
movsd xmm1, [rsp+58h+var_48]
mov rdx, r12
mov rcx, r15
mov r8, r14
mov r9, [rsp+58h+var_40]
push [rsp+58h+arg_8]
push [rsp+60h+arg_0]
call __ZN10OpenSubdiv6v3_6_03Far8internal18EvaluatePatchBasisIdEEiiRKNS1_10PatchParamET_S7_PS7_S8_S8_S8_S8_S8_S7_; OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<double>(int,OpenSubdiv::v3_6_0::Far::PatchParam const&,double,double,double*,double*,double*,double*,double*,double*,double)
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>(
OpenSubdiv::v3_6_0::Far::PatchTable *a1,
long long a2,
double *a3,
double *a4,
__m128d *a5,
double *a6,
double a7,
double a8,
double *a9,
double *a10,
int a11)
{
unsigned int v15; // [rsp+4h] [rbp-54h] BYREF
double v16; // [rsp+8h] [rbp-50h]
double v17; // [rsp+10h] [rbp-48h]
double *v18; // [rsp+18h] [rbp-40h]
unsigned long long v19[7]; // [rsp+20h] [rbp-38h] BYREF
v18 = a6;
v17 = a8;
v16 = a7;
v19[0] = OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(a1, *(_DWORD *)(a2 + 4), a11);
if ( (v19[0] & 0x2000000000LL) != 0 )
OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorRegular(
(OpenSubdiv::v3_6_0::Far::PatchTable *)&v15,
(int)a1);
else
OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorIrregular(
(OpenSubdiv::v3_6_0::Far::PatchTable *)&v15,
(int)a1);
return OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<double>(
v15,
v19,
a3,
a4,
a5,
v18,
v16,
v17,
0.0,
a9,
a10);
}
| EvaluateBasisFaceVarying<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],R9
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOVSD qword ptr [RSP + 0x10],XMM1
MOVSD qword ptr [RSP + 0x8],XMM0
MOV R13,RDI
MOV EBP,dword ptr [RSP + 0x70]
MOV ESI,dword ptr [RSI + 0x4]
MOV EDX,EBP
CALL 0x0013a150
MOV qword ptr [RSP + 0x20],RAX
LEA RBX,[RSP + 0x4]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,EBP
BT RAX,0x25
JC 0x0016a9fd
CALL 0x0013ab00
JMP 0x0016aa02
LAB_0016a9fd:
CALL 0x0013a730
LAB_0016aa02:
MOV EDI,dword ptr [RBX]
LEA RSI,[RSP + 0x20]
XORPS XMM2,XMM2
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP + 0x10]
MOV RDX,R12
MOV RCX,R15
MOV R8,R14
MOV R9,qword ptr [RSP + 0x18]
PUSH qword ptr [RSP + 0x68]
PUSH qword ptr [RSP + 0x68]
CALL 0x0013c1a0
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* void
OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle
const&, double, double, double*, double*, double*, double*, double*, double*, int) const */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>
(PatchTable *this,PatchHandle *param_1,double param_2,double param_3,double *param_4,
double *param_5,double *param_6,double *param_7,double *param_8,double *param_9,
int param_10)
{
int local_54;
double local_50;
double local_48;
double *local_40;
ulong local_38;
local_50 = param_2;
local_48 = param_3;
local_40 = param_7;
local_38 = getPatchFVarPatchParam(this,*(int *)(param_1 + 4),param_10);
if ((local_38 & 0x2000000000) == 0) {
GetFVarPatchDescriptorIrregular((int)&local_54);
}
else {
GetFVarPatchDescriptorRegular((int)&local_54);
}
internal::EvaluatePatchBasis<double>
(local_54,(PatchParam *)&local_38,local_50,local_48,param_4,param_5,param_6,local_40,
param_8,param_9,0.0);
return;
}
| |
52,370 | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp | void
PatchTable::EvaluateBasisFaceVarying(
PatchHandle const & handle, REAL s, REAL t,
REAL wP[], REAL wDs[], REAL wDt[],
REAL wDss[], REAL wDst[], REAL wDtt[],
int channel) const {
PatchParam param = getPatchFVarPatchParam(handle.patchIndex, channel);
PatchDescriptor::Type patchType = param.IsRegular()
? GetFVarPatchDescriptorRegular(channel).GetType()
: GetFVarPatchDescriptorIrregular(channel).GetType();
internal::EvaluatePatchBasis(patchType, param, s, t, wP, wDs, wDt, wDss, wDst, wDtt);
} | O2 | cpp | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movss %xmm1, 0x1c(%rsp)
movss %xmm0, 0x18(%rsp)
movq %rdi, %r13
movl 0x80(%rsp), %ebp
movl 0x4(%rsi), %esi
movl %ebp, %edx
callq 0x525f0
leaq 0x30(%rsp), %rbx
movq %rax, (%rbx)
xorl %r14d, %r14d
btq $0x25, %rax
setae %r14b
movq %r13, %rdi
movl %ebp, %esi
callq 0x515c0
movl 0x4(%rax,%r14,4), %edi
movaps 0x70(%rsp), %xmm0
movups %xmm0, (%rsp)
xorps %xmm2, %xmm2
movq %rbx, %rsi
movss 0x18(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
movq %r12, %rdx
movq %r15, %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
callq 0x533f0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZNK10OpenSubdiv6v3_6_03Far10PatchTable24EvaluateBasisFaceVaryingIfEEvRKNS2_11PatchHandleET_S7_PS7_S8_S8_S8_S8_S8_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rsp+68h+var_40], r9
mov [rsp+68h+var_48], r8
mov r15, rcx
mov r12, rdx
movss [rsp+68h+var_4C], xmm1
movss [rsp+68h+var_50], xmm0
mov r13, rdi
mov ebp, [rsp+68h+arg_10]
mov esi, [rsi+4]; int
mov edx, ebp; int
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable22getPatchFVarPatchParamEii; OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(int,int)
lea rbx, [rsp+68h+var_38]
mov [rbx], rax
xor r14d, r14d
bt rax, 25h ; '%'
setnb r14b
mov rdi, r13; this
mov esi, ebp; int
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable19getFVarPatchChannelEi; OpenSubdiv::v3_6_0::Far::PatchTable::getFVarPatchChannel(int)
mov edi, [rax+r14*4+4]
movaps xmm0, [rsp+68h+arg_0]
movups [rsp+68h+var_68], xmm0
xorps xmm2, xmm2
mov rsi, rbx
movss xmm0, [rsp+68h+var_50]
movss xmm1, [rsp+68h+var_4C]
mov rdx, r12
mov rcx, r15
mov r8, [rsp+68h+var_48]
mov r9, [rsp+68h+var_40]
call __ZN10OpenSubdiv6v3_6_03Far8internal18EvaluatePatchBasisIfEEiiRKNS1_10PatchParamET_S7_PS7_S8_S8_S8_S8_S8_S7_; OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<float>(int,OpenSubdiv::v3_6_0::Far::PatchParam const&,float,float,float*,float*,float*,float*,float*,float*,float)
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(
OpenSubdiv::v3_6_0::Far::PatchTable *this,
long long a2,
__m128 *a3,
long long a4,
long long a5,
long long a6,
float a7,
float a8,
__int128 a9,
int a10)
{
long long FVarPatchChannel; // rax
_QWORD v16[7]; // [rsp+30h] [rbp-38h] BYREF
v16[0] = OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(this, *(_DWORD *)(a2 + 4), a10);
FVarPatchChannel = OpenSubdiv::v3_6_0::Far::PatchTable::getFVarPatchChannel(this, a10);
return OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<float>(
*(_DWORD *)(FVarPatchChannel + 4LL * ((v16[0] & 0x2000000000LL) == 0) + 4),
(OpenSubdiv::v3_6_0::Far::PatchParam *)v16,
a3,
a4,
a5,
a6,
a7,
a8,
0.0,
(float *)a9,
*((long long *)&a9 + 1));
}
| EvaluateBasisFaceVarying<float>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV R15,RCX
MOV R12,RDX
MOVSS dword ptr [RSP + 0x1c],XMM1
MOVSS dword ptr [RSP + 0x18],XMM0
MOV R13,RDI
MOV EBP,dword ptr [RSP + 0x80]
MOV ESI,dword ptr [RSI + 0x4]
MOV EDX,EBP
CALL 0x001525f0
LEA RBX,[RSP + 0x30]
MOV qword ptr [RBX],RAX
XOR R14D,R14D
BT RAX,0x25
SETNC R14B
MOV RDI,R13
MOV ESI,EBP
CALL 0x001515c0
MOV EDI,dword ptr [RAX + R14*0x4 + 0x4]
MOVAPS XMM0,xmmword ptr [RSP + 0x70]
MOVUPS xmmword ptr [RSP],XMM0
XORPS XMM2,XMM2
MOV RSI,RBX
MOVSS XMM0,dword ptr [RSP + 0x18]
MOVSS XMM1,dword ptr [RSP + 0x1c]
MOV RDX,R12
MOV RCX,R15
MOV R8,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
CALL 0x001533f0
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* void
OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle
const&, float, float, float*, float*, float*, float*, float*, float*, int) const */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>
(PatchTable *this,PatchHandle *param_1,float param_2,float param_3,float *param_4,
float *param_5,float *param_6,float *param_7,float *param_8,float *param_9,int param_10)
{
long lVar1;
ulong uVar2;
ulong local_38;
local_38 = getPatchFVarPatchParam(this,*(int *)(param_1 + 4),param_10);
uVar2 = local_38 & 0x2000000000;
lVar1 = getFVarPatchChannel(this,param_10);
internal::EvaluatePatchBasis<float>
(*(int *)(lVar1 + 4 + (ulong)(uVar2 == 0) * 4),(PatchParam *)&local_38,param_2,param_3,
param_4,param_5,param_6,param_7,param_8,param_9,0.0);
return;
}
| |
52,371 | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/patchTable.cpp | void
PatchTable::EvaluateBasisFaceVarying(
PatchHandle const & handle, REAL s, REAL t,
REAL wP[], REAL wDs[], REAL wDt[],
REAL wDss[], REAL wDst[], REAL wDtt[],
int channel) const {
PatchParam param = getPatchFVarPatchParam(handle.patchIndex, channel);
PatchDescriptor::Type patchType = param.IsRegular()
? GetFVarPatchDescriptorRegular(channel).GetType()
: GetFVarPatchDescriptorIrregular(channel).GetType();
internal::EvaluatePatchBasis(patchType, param, s, t, wP, wDs, wDt, wDss, wDst, wDtt);
} | O3 | cpp | void OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<float>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle const&, float, float, float*, float*, float*, float*, float*, float*, int) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r13
movl 0x70(%rsp), %ebp
movl 0x4(%rsi), %esi
movl %ebp, %edx
callq 0x3a130
movq %rax, 0x20(%rsp)
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %edx
btq $0x25, %rax
jb 0x6bec5
callq 0x3aae0
jmp 0x6beca
callq 0x3a710
movl (%rbx), %edi
leaq 0x20(%rsp), %rsi
xorps %xmm2, %xmm2
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x18(%rsp), %r9
pushq 0x68(%rsp)
pushq 0x68(%rsp)
callq 0x3c150
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZNK10OpenSubdiv6v3_6_03Far10PatchTable24EvaluateBasisFaceVaryingIdEEvRKNS2_11PatchHandleET_S7_PS7_S8_S8_S8_S8_S8_i:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], r9
mov r14, r8
mov r15, rcx
mov r12, rdx
movsd [rsp+58h+var_48], xmm1
movsd [rsp+58h+var_50], xmm0
mov r13, rdi
mov ebp, [rsp+58h+arg_10]
mov esi, [rsi+4]; int
mov edx, ebp; int
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable22getPatchFVarPatchParamEii; OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(int,int)
mov [rsp+58h+var_38], rax
lea rbx, [rsp+58h+var_54]
mov rdi, rbx; this
mov rsi, r13; int
mov edx, ebp
bt rax, 25h ; '%'
jb short loc_6BEC5
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable31GetFVarPatchDescriptorIrregularEi; OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorIrregular(int)
jmp short loc_6BECA
loc_6BEC5:
call __ZNK10OpenSubdiv6v3_6_03Far10PatchTable29GetFVarPatchDescriptorRegularEi; OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorRegular(int)
loc_6BECA:
mov edi, [rbx]
lea rsi, [rsp+58h+var_38]
xorps xmm2, xmm2
movsd xmm0, [rsp+58h+var_50]
movsd xmm1, [rsp+58h+var_48]
mov rdx, r12
mov rcx, r15
mov r8, r14
mov r9, [rsp+58h+var_40]
push [rsp+58h+arg_8]
push [rsp+60h+arg_0]
call __ZN10OpenSubdiv6v3_6_03Far8internal18EvaluatePatchBasisIdEEiiRKNS1_10PatchParamET_S7_PS7_S8_S8_S8_S8_S8_S7_; OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<double>(int,OpenSubdiv::v3_6_0::Far::PatchParam const&,double,double,double*,double*,double*,double*,double*,double*,double)
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>(
OpenSubdiv::v3_6_0::Far::PatchTable *a1,
long long a2,
__m128d *a3,
__m128d *a4,
__m128d *a5,
__m128d *a6,
double a7,
double a8,
__m128d *a9,
__m128d *a10,
int a11)
{
unsigned int v15; // [rsp+4h] [rbp-54h] BYREF
double v16; // [rsp+8h] [rbp-50h]
double v17; // [rsp+10h] [rbp-48h]
__m128d *v18; // [rsp+18h] [rbp-40h]
unsigned long long v19[7]; // [rsp+20h] [rbp-38h] BYREF
v18 = a6;
v17 = a8;
v16 = a7;
v19[0] = OpenSubdiv::v3_6_0::Far::PatchTable::getPatchFVarPatchParam(a1, *(_DWORD *)(a2 + 4), a11);
if ( (v19[0] & 0x2000000000LL) != 0 )
OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorRegular(
(OpenSubdiv::v3_6_0::Far::PatchTable *)&v15,
(int)a1);
else
OpenSubdiv::v3_6_0::Far::PatchTable::GetFVarPatchDescriptorIrregular(
(OpenSubdiv::v3_6_0::Far::PatchTable *)&v15,
(int)a1);
return OpenSubdiv::v3_6_0::Far::internal::EvaluatePatchBasis<double>(
v15,
v19,
a3,
a4,
a5,
v18,
v16,
v17,
0.0,
a9,
a10);
}
| EvaluateBasisFaceVarying<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],R9
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOVSD qword ptr [RSP + 0x10],XMM1
MOVSD qword ptr [RSP + 0x8],XMM0
MOV R13,RDI
MOV EBP,dword ptr [RSP + 0x70]
MOV ESI,dword ptr [RSI + 0x4]
MOV EDX,EBP
CALL 0x0013a130
MOV qword ptr [RSP + 0x20],RAX
LEA RBX,[RSP + 0x4]
MOV RDI,RBX
MOV RSI,R13
MOV EDX,EBP
BT RAX,0x25
JC 0x0016bec5
CALL 0x0013aae0
JMP 0x0016beca
LAB_0016bec5:
CALL 0x0013a710
LAB_0016beca:
MOV EDI,dword ptr [RBX]
LEA RSI,[RSP + 0x20]
XORPS XMM2,XMM2
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM1,qword ptr [RSP + 0x10]
MOV RDX,R12
MOV RCX,R15
MOV R8,R14
MOV R9,qword ptr [RSP + 0x18]
PUSH qword ptr [RSP + 0x68]
PUSH qword ptr [RSP + 0x68]
CALL 0x0013c150
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* void
OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>(OpenSubdiv::v3_6_0::Far::PatchTable::PatchHandle
const&, double, double, double*, double*, double*, double*, double*, double*, int) const */
void __thiscall
OpenSubdiv::v3_6_0::Far::PatchTable::EvaluateBasisFaceVarying<double>
(PatchTable *this,PatchHandle *param_1,double param_2,double param_3,double *param_4,
double *param_5,double *param_6,double *param_7,double *param_8,double *param_9,
int param_10)
{
int local_54;
double local_50;
double local_48;
double *local_40;
ulong local_38;
local_50 = param_2;
local_48 = param_3;
local_40 = param_7;
local_38 = getPatchFVarPatchParam(this,*(int *)(param_1 + 4),param_10);
if ((local_38 & 0x2000000000) == 0) {
GetFVarPatchDescriptorIrregular((int)&local_54);
}
else {
GetFVarPatchDescriptorRegular((int)&local_54);
}
internal::EvaluatePatchBasis<double>
(local_54,(PatchParam *)&local_38,local_50,local_48,param_4,param_5,param_6,local_40,
param_8,param_9,0.0);
return;
}
| |
52,372 | my_strnxfrm_unicode_full_bin | eloqsql/strings/ctype-utf8.c | size_t
my_strnxfrm_unicode_full_bin(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *dst0= dst;
uchar *de= dst + dstlen;
dst+= my_strnxfrm_unicode_full_bin_internal(cs, dst, de, &nweights,
src, src + srclen);
DBUG_ASSERT(dst <= de); /* Safety */
if (flags & MY_STRXFRM_PAD_WITH_SPACE)
{
for ( ; dst < de && nweights; nweights--)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
my_strxfrm_desc_and_reverse(dst0, dst, flags, 0);
if (flags & MY_STRXFRM_PAD_TO_MAXLEN)
{
while (dst < de)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
return dst - dst0;
} | O3 | c | my_strnxfrm_unicode_full_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movl 0x10(%rbp), %r15d
leaq -0x24(%rbp), %rax
movl %ecx, (%rax)
leaq (%rsi,%rdx), %r14
addq %r8, %r9
movq %r14, %rdx
movq %rax, %rcx
callq 0x53203
leaq (%rbx,%rax), %rcx
testb $0x40, %r15b
jne 0x5334c
movq %rcx, %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x3e1aa
testb %r15b, %r15b
setns %al
cmpq %r14, %r12
setae %cl
orb %al, %cl
jne 0x53398
leaq 0x1(%r12), %rax
movb $0x0, (%r12)
cmpq %r14, %rax
jae 0x53342
leaq 0x2(%r12), %rax
movb $0x0, 0x1(%r12)
cmpq %r14, %rax
jae 0x53342
movb $0x20, 0x2(%r12)
addq $0x3, %r12
movq %r12, %rax
movq %rax, %r12
cmpq %r14, %rax
jb 0x53316
jmp 0x5339b
cmpq %r12, %rax
jge 0x532ef
cmpl $0x0, -0x24(%rbp)
je 0x532ef
leaq 0x1(%rcx), %r12
movb $0x0, (%rcx)
cmpq %r14, %r12
jae 0x5337b
leaq 0x2(%rcx), %r12
movb $0x0, 0x1(%rcx)
cmpq %r14, %r12
jae 0x5337b
movb $0x20, 0x2(%rcx)
addq $0x3, %rcx
movq %rcx, %r12
movl -0x24(%rbp), %eax
decl %eax
movl %eax, -0x24(%rbp)
cmpq %r14, %r12
jae 0x532f2
movq %r12, %rcx
testl %eax, %eax
jne 0x53357
jmp 0x532f2
movq %r12, %rax
subq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_strnxfrm_unicode_full_bin:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov rbx, rsi
mov r15d, [rbp+arg_0]
lea rax, [rbp+var_24]
mov [rax], ecx
lea r14, [rsi+rdx]
add r9, r8
mov rdx, r14
mov rcx, rax
call my_strnxfrm_unicode_full_bin_internal
lea rcx, [rbx+rax]
test r15b, 40h
jnz short loc_5334C
loc_532EF:
mov r12, rcx
loc_532F2:
mov rdi, rbx
mov rsi, r12
mov edx, r15d
xor ecx, ecx
call my_strxfrm_desc_and_reverse
test r15b, r15b
setns al
cmp r12, r14
setnb cl
or cl, al
jnz loc_53398
loc_53316:
lea rax, [r12+1]
mov byte ptr [r12], 0
cmp rax, r14
jnb short loc_53342
lea rax, [r12+2]
mov byte ptr [r12+1], 0
cmp rax, r14
jnb short loc_53342
mov byte ptr [r12+2], 20h ; ' '
add r12, 3
mov rax, r12
loc_53342:
mov r12, rax
cmp rax, r14
jb short loc_53316
jmp short loc_5339B
loc_5334C:
cmp rax, r12
jge short loc_532EF
cmp [rbp+var_24], 0
jz short loc_532EF
loc_53357:
lea r12, [rcx+1]
mov byte ptr [rcx], 0
cmp r12, r14
jnb short loc_5337B
lea r12, [rcx+2]
mov byte ptr [rcx+1], 0
cmp r12, r14
jnb short loc_5337B
mov byte ptr [rcx+2], 20h ; ' '
add rcx, 3
mov r12, rcx
loc_5337B:
mov eax, [rbp+var_24]
dec eax
mov [rbp+var_24], eax
cmp r12, r14
jnb loc_532F2
mov rcx, r12
test eax, eax
jnz short loc_53357
jmp loc_532F2
loc_53398:
mov rax, r12
loc_5339B:
sub rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_strnxfrm_unicode_full_bin(
long long a1,
_BYTE *a2,
long long a3,
int a4,
long long a5,
long long a6,
unsigned int a7)
{
unsigned long long v8; // r14
long long v9; // rax
_BYTE *v10; // rcx
_BYTE *v11; // r12
_BYTE *v12; // rax
int v13; // eax
int v15[9]; // [rsp+Ch] [rbp-24h] BYREF
v15[0] = a4;
v8 = (unsigned long long)&a2[a3];
v9 = my_strnxfrm_unicode_full_bin_internal(a1, a2, (unsigned long long)&a2[a3], v15, a5, a5 + a6);
v10 = &a2[v9];
if ( (a7 & 0x40) != 0 && v9 < a3 && v15[0] )
{
do
{
v11 = v10 + 1;
*v10 = 0;
if ( (unsigned long long)(v10 + 1) < v8 )
{
v11 = v10 + 2;
v10[1] = 0;
if ( (unsigned long long)(v10 + 2) < v8 )
{
v10[2] = 32;
v11 = v10 + 3;
}
}
v13 = --v15[0];
if ( (unsigned long long)v11 >= v8 )
break;
v10 = v11;
}
while ( v13 );
}
else
{
v11 = &a2[v9];
}
my_strxfrm_desc_and_reverse(a2, v11, a7, 0);
if ( (a7 & 0x80u) == 0 || (unsigned long long)v11 >= v8 )
{
v12 = v11;
}
else
{
do
{
v12 = v11 + 1;
*v11 = 0;
if ( (unsigned long long)(v11 + 1) < v8 )
{
v12 = v11 + 2;
v11[1] = 0;
if ( (unsigned long long)(v11 + 2) < v8 )
{
v11[2] = 32;
v12 = v11 + 3;
}
}
v11 = v12;
}
while ( (unsigned long long)v12 < v8 );
}
return v12 - a2;
}
| my_strnxfrm_unicode_full_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV RBX,RSI
MOV R15D,dword ptr [RBP + 0x10]
LEA RAX,[RBP + -0x24]
MOV dword ptr [RAX],ECX
LEA R14,[RSI + RDX*0x1]
ADD R9,R8
MOV RDX,R14
MOV RCX,RAX
CALL 0x00153203
LEA RCX,[RBX + RAX*0x1]
TEST R15B,0x40
JNZ 0x0015334c
LAB_001532ef:
MOV R12,RCX
LAB_001532f2:
MOV RDI,RBX
MOV RSI,R12
MOV EDX,R15D
XOR ECX,ECX
CALL 0x0013e1aa
TEST R15B,R15B
SETNS AL
CMP R12,R14
SETNC CL
OR CL,AL
JNZ 0x00153398
LAB_00153316:
LEA RAX,[R12 + 0x1]
MOV byte ptr [R12],0x0
CMP RAX,R14
JNC 0x00153342
LEA RAX,[R12 + 0x2]
MOV byte ptr [R12 + 0x1],0x0
CMP RAX,R14
JNC 0x00153342
MOV byte ptr [R12 + 0x2],0x20
ADD R12,0x3
MOV RAX,R12
LAB_00153342:
MOV R12,RAX
CMP RAX,R14
JC 0x00153316
JMP 0x0015339b
LAB_0015334c:
CMP RAX,R12
JGE 0x001532ef
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001532ef
LAB_00153357:
LEA R12,[RCX + 0x1]
MOV byte ptr [RCX],0x0
CMP R12,R14
JNC 0x0015337b
LEA R12,[RCX + 0x2]
MOV byte ptr [RCX + 0x1],0x0
CMP R12,R14
JNC 0x0015337b
MOV byte ptr [RCX + 0x2],0x20
ADD RCX,0x3
MOV R12,RCX
LAB_0015337b:
MOV EAX,dword ptr [RBP + -0x24]
DEC EAX
MOV dword ptr [RBP + -0x24],EAX
CMP R12,R14
JNC 0x001532f2
MOV RCX,R12
TEST EAX,EAX
JNZ 0x00153357
JMP 0x001532f2
LAB_00153398:
MOV RAX,R12
LAB_0015339b:
SUB RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin
(int8 param_1,long param_2,long param_3,int param_4,long param_5,long param_6,
uint param_7)
{
int1 *puVar1;
long lVar2;
int1 *puVar3;
int1 *puVar4;
int local_2c;
puVar1 = (int1 *)(param_2 + param_3);
local_2c = param_4;
lVar2 = my_strnxfrm_unicode_full_bin_internal
(param_1,param_2,puVar1,&local_2c,param_5,param_6 + param_5);
puVar4 = (int1 *)(param_2 + lVar2);
if (((param_7 & 0x40) != 0) && (lVar2 < param_3)) {
do {
if (local_2c == 0) break;
puVar3 = puVar4 + 1;
*puVar4 = 0;
if (puVar3 < puVar1) {
puVar3 = puVar4 + 2;
puVar4[1] = 0;
if (puVar3 < puVar1) {
puVar4[2] = 0x20;
puVar3 = puVar4 + 3;
}
}
local_2c = local_2c + -1;
puVar4 = puVar3;
} while (puVar3 < puVar1);
}
my_strxfrm_desc_and_reverse(param_2,puVar4,param_7,0);
puVar3 = puVar4;
if (puVar4 < puVar1 && (char)param_7 < '\0') {
do {
puVar4 = puVar3 + 1;
*puVar3 = 0;
if (puVar4 < puVar1) {
puVar4 = puVar3 + 2;
puVar3[1] = 0;
if (puVar4 < puVar1) {
puVar3[2] = 0x20;
puVar4 = puVar3 + 3;
}
}
puVar3 = puVar4;
} while (puVar4 < puVar1);
}
return (long)puVar4 - param_2;
}
| |
52,373 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const | monkey531[P]llama/common/./json.hpp | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | 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>::operator[](unsigned long) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x5b64b
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20390
movq %rax, %rbx
movq %r14, %rdi
callq 0x3b8b2
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x436f2(%rip), %rsi # 0x9ed5f
leaq 0x10(%rsp), %rdi
callq 0x5b6ce
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x3b766
xorl %ebp, %ebp
leaq 0x84c20(%rip), %rsi # 0xe02b8
leaq -0x146bd(%rip), %rdx # 0x46fe2
movq %rbx, %rdi
callq 0x20b30
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20d78
testb %bpl, %bpl
jne 0x5b6be
jmp 0x5b6c6
movq %rax, %r14
movq %rbx, %rdi
callq 0x20520
movq %r14, %rdi
callq 0x20b90
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_5B64B
mov rax, [r14+8]
shl rsi, 4
add rsi, [rax]
mov rax, rsi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_5B64B:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_5B6BE
jmp short loc_5B6C6
mov r14, rax
loc_5B6BE:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5B6C6:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v4[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(
v4,
"cannot use operator[] with a numeric argument with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
0x131u,
(long long)v4,
a1);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return **(_QWORD **)(a1 + 8) + 16 * a2;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x0015b64b
MOV RAX,qword ptr [R14 + 0x8]
SHL RSI,0x4
ADD RSI,qword ptr [RAX]
MOV RAX,RSI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0015b64b:
PUSH 0x20
POP RDI
CALL 0x00120390
MOV RBX,RAX
MOV RDI,R14
CALL 0x0013b8b2
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0015b666:
LEA RSI,[0x19ed5f]
LEA RDI,[RSP + 0x10]
CALL 0x0015b6ce
MOV BPL,0x1
LAB_0015b67a:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x0013b766
XOR EBP,EBP
LEA RSI,[0x1e02b8]
LEA RDX,[0x146fe2]
MOV RDI,RBX
CALL 0x00120b30
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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[](unsigned long) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*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>
)0x2) {
return param_1 * 0x10 + **(long **)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0015b666 to 0015b676 has its CatchHandler @ 0015b6bb */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 0015b67a to 0015b6a6 has its CatchHandler @ 0015b6a7 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
52,374 | mi_status | eloqsql/storage/myisam/mi_info.c | int mi_status(MI_INFO *info, register MI_ISAMINFO *x, uint flag)
{
MY_STAT state;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("mi_status");
x->recpos = info->lastpos;
if (flag == HA_STATUS_POS)
DBUG_RETURN(0); /* Compatible with ISAM */
if (!(flag & HA_STATUS_NO_LOCK))
{
mysql_mutex_lock(&share->intern_lock);
(void) _mi_readinfo(info,F_RDLCK,0);
fast_mi_writeinfo(info);
mysql_mutex_unlock(&share->intern_lock);
}
if (flag & HA_STATUS_VARIABLE)
{
x->records = info->state->records;
x->deleted = info->state->del;
x->delete_length = info->state->empty;
x->data_file_length =info->state->data_file_length;
x->index_file_length=info->state->key_file_length;
x->keys = share->state.header.keys;
x->check_time = share->state.check_time;
x->mean_reclength= x->records ?
(ulong) ((x->data_file_length - x->delete_length) / x->records) :
(ulong) share->min_pack_length;
}
if (flag & HA_STATUS_ERRKEY)
{
x->errkey = info->errkey;
x->dupp_key_pos= info->dupp_key_pos;
}
if (flag & HA_STATUS_CONST)
{
x->reclength = share->base.reclength;
x->max_data_file_length=share->base.max_data_file_length;
x->max_index_file_length=info->s->base.max_key_file_length;
x->filenr = info->dfile;
x->options = share->options;
x->create_time=share->state.create_time;
x->reflength= mi_get_pointer_length(share->base.max_data_file_length,
myisam_data_pointer_size);
x->record_offset= ((share->options &
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
0L : share->base.pack_reclength);
x->sortkey= -1; /* No clustering */
x->rec_per_key = share->state.rec_per_key_part;
x->key_map = share->state.key_map;
x->data_file_name = share->data_file_name;
x->index_file_name = share->index_file_name;
}
if ((flag & HA_STATUS_TIME) && !mysql_file_fstat(info->dfile, &state, MYF(0)))
{
MSAN_STAT_WORKAROUND(&state);
x->update_time=state.st_mtime;
}
else
x->update_time=0;
if (flag & HA_STATUS_AUTO)
{
x->auto_increment= share->state.auto_increment+1;
if (!x->auto_increment) /* This shouldn't happen */
x->auto_increment= ~(ulonglong) 0;
}
DBUG_RETURN(0);
} | O3 | c | mi_status:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq (%rdi), %r13
movq 0x170(%rdi), %rax
movq %rax, 0x10(%rsi)
cmpl $0x1, %edx
je 0x811b4
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
testb $0x2, %r14b
jne 0x80fee
leaq 0x480(%r13), %r12
cmpq $0x0, 0x4c0(%r13)
jne 0x811ce
movq %r12, %rdi
callq 0x291d0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x82af3
movq (%r15), %rax
cmpl $0x0, 0x368(%rax)
jne 0x80fd6
movq %r15, %rdi
xorl %esi, %esi
callq 0x82be6
movq 0x4c0(%r13), %rdi
testq %rdi, %rdi
jne 0x811e7
movq %r12, %rdi
callq 0x291a0
testb $0x10, %r14b
je 0x81061
movq 0x8(%r15), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdx
movq %rdx, 0x48(%rbx)
movq 0x8(%r15), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rbx)
movq 0x8(%r15), %rsi
movq 0x20(%rsi), %rsi
movq %rsi, 0x38(%rbx)
movzbl 0x12(%r13), %esi
movl %esi, 0x80(%rbx)
movq 0xe0(%r13), %rsi
movq %rsi, 0xa0(%rbx)
testq %rcx, %rcx
je 0x81056
subq %rdx, %rax
xorl %edx, %edx
divq %rcx
jmp 0x8105d
movq 0x320(%r13), %rax
movq %rax, 0x58(%rbx)
testb $0x20, %r14b
je 0x8107f
movl 0x1f0(%r15), %eax
movl %eax, 0x88(%rbx)
movq 0x1a0(%r15), %rax
movq %rax, 0x20(%rbx)
testb $0x8, %r14b
je 0x81145
movq 0x140(%r13), %rax
movq %rax, 0x50(%rbx)
movq 0x110(%r13), %rax
movq %rax, 0x30(%rbx)
movq (%r15), %rax
movq 0x118(%rax), %rax
movq %rax, 0x40(%rbx)
movl 0x1c0(%r15), %eax
movl %eax, 0x90(%rbx)
movl 0x318(%r13), %eax
movl %eax, 0x84(%rbx)
movq 0xd0(%r13), %rax
movq %rax, 0x98(%rbx)
movq 0x110(%r13), %rdi
leaq 0x30b2ad(%rip), %rax # 0x38c390
movl (%rax), %esi
callq 0x970ef
movl %eax, 0xb0(%rbx)
testb $0x5, 0x318(%r13)
je 0x810fe
xorl %eax, %eax
jmp 0x81105
movq 0x148(%r13), %rax
movq %rax, 0xb8(%rbx)
movl $0xffffffff, 0x8c(%rbx) # imm = 0xFFFFFFFF
movq 0x88(%r13), %rax
movq %rax, 0xc0(%rbx)
movq 0xc0(%r13), %rax
movq %rax, 0x68(%rbx)
movq 0x260(%r13), %rax
movq %rax, 0x70(%rbx)
movq 0x268(%r13), %rax
movq %rax, 0x78(%rbx)
testb $0x4, %r14b
je 0x8118f
movl 0x1c0(%r15), %r15d
leaq 0x30bf17(%rip), %rax # 0x38d070
movq (%rax), %rax
leaq -0x108(%rbp), %rdi
movl %r15d, %esi
movl $0xc, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x811fc
leaq -0xc0(%rbp), %rsi
movl %r15d, %edi
xorl %edx, %edx
callq 0xa5b77
testl %eax, %eax
je 0x811c8
xorl %eax, %eax
movq %rax, 0xa8(%rbx)
testb $0x40, %r14b
je 0x811b4
movq 0x60(%r13), %rax
incq %rax
movq $-0x1, %rcx
cmovneq %rax, %rcx
movq %rcx, 0x60(%rbx)
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x68(%rbp), %rax
jmp 0x81191
leaq 0x609f3(%rip), %rsi # 0xe1bc8
movq %r12, %rdi
movl $0x2e, %edx
callq 0x2eee9
jmp 0x80fb4
leaq 0x30be82(%rip), %rax # 0x38d070
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x80fe6
leaq -0xc0(%rbp), %rdx
leaq -0x2c(%rbp), %r12
movq %rax, %rdi
movl %r15d, %esi
movq %r12, %rcx
callq 0x2dba7
movl (%r12), %eax
jmp 0x8118b
| mi_status:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov r13, [rdi]
mov rax, [rdi+170h]
mov [rsi+10h], rax
cmp edx, 1
jz loc_811B4
mov r14d, edx
mov rbx, rsi
mov r15, rdi
test r14b, 2
jnz short loc_80FEE
lea r12, [r13+480h]
cmp qword ptr [r13+4C0h], 0
jnz loc_811CE
mov rdi, r12
call _pthread_mutex_lock
loc_80FB4:
mov rdi, r15
xor esi, esi
xor edx, edx
call _mi_readinfo
mov rax, [r15]
cmp dword ptr [rax+368h], 0
jnz short loc_80FD6
mov rdi, r15
xor esi, esi
call _mi_writeinfo
loc_80FD6:
mov rdi, [r13+4C0h]
test rdi, rdi
jnz loc_811E7
loc_80FE6:
mov rdi, r12
call _pthread_mutex_unlock
loc_80FEE:
test r14b, 10h
jz short loc_81061
mov rax, [r15+8]
mov rcx, [rax]
mov [rbx], rcx
mov rax, [r15+8]
mov rax, [rax+8]
mov [rbx+8], rax
mov rax, [r15+8]
mov rdx, [rax+10h]
mov [rbx+48h], rdx
mov rax, [r15+8]
mov rax, [rax+28h]
mov [rbx+28h], rax
mov rsi, [r15+8]
mov rsi, [rsi+20h]
mov [rbx+38h], rsi
movzx esi, byte ptr [r13+12h]
mov [rbx+80h], esi
mov rsi, [r13+0E0h]
mov [rbx+0A0h], rsi
test rcx, rcx
jz short loc_81056
sub rax, rdx
xor edx, edx
div rcx
jmp short loc_8105D
loc_81056:
mov rax, [r13+320h]
loc_8105D:
mov [rbx+58h], rax
loc_81061:
test r14b, 20h
jz short loc_8107F
mov eax, [r15+1F0h]
mov [rbx+88h], eax
mov rax, [r15+1A0h]
mov [rbx+20h], rax
loc_8107F:
test r14b, 8
jz loc_81145
mov rax, [r13+140h]
mov [rbx+50h], rax
mov rax, [r13+110h]
mov [rbx+30h], rax
mov rax, [r15]
mov rax, [rax+118h]
mov [rbx+40h], rax
mov eax, [r15+1C0h]
mov [rbx+90h], eax
mov eax, [r13+318h]
mov [rbx+84h], eax
mov rax, [r13+0D0h]
mov [rbx+98h], rax
mov rdi, [r13+110h]
lea rax, myisam_data_pointer_size
mov esi, [rax]
call mi_get_pointer_length
mov [rbx+0B0h], eax
test byte ptr [r13+318h], 5
jz short loc_810FE
xor eax, eax
jmp short loc_81105
loc_810FE:
mov rax, [r13+148h]
loc_81105:
mov [rbx+0B8h], rax
mov dword ptr [rbx+8Ch], 0FFFFFFFFh
mov rax, [r13+88h]
mov [rbx+0C0h], rax
mov rax, [r13+0C0h]
mov [rbx+68h], rax
mov rax, [r13+260h]
mov [rbx+70h], rax
mov rax, [r13+268h]
mov [rbx+78h], rax
loc_81145:
test r14b, 4
jz short loc_8118F
mov r15d, [r15+1C0h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_108]
mov esi, r15d
mov edx, 0Ch
call qword ptr [rax+158h]
test rax, rax
jnz loc_811FC
lea rsi, [rbp+var_C0]
mov edi, r15d
xor edx, edx
call my_fstat
loc_8118B:
test eax, eax
jz short loc_811C8
loc_8118F:
xor eax, eax
loc_81191:
mov [rbx+0A8h], rax
test r14b, 40h
jz short loc_811B4
mov rax, [r13+60h]
inc rax
mov rcx, 0FFFFFFFFFFFFFFFFh
cmovnz rcx, rax
mov [rbx+60h], rcx
loc_811B4:
xor eax, eax
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_811C8:
mov rax, [rbp+var_68]
jmp short loc_81191
loc_811CE:
lea rsi, aWorkspaceLlm4b_16; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r12
mov edx, 2Eh ; '.'
call psi_mutex_lock
jmp loc_80FB4
loc_811E7:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_80FE6
loc_811FC:
lea rdx, [rbp+var_C0]
lea r12, [rbp+var_2C]
mov rdi, rax
mov esi, r15d
mov rcx, r12
call mi_status_cold_1
mov eax, [r12]
jmp loc_8118B
| long long mi_status(_DWORD *a1, long long a2, int a3)
{
long long v3; // r13
char v4; // r14
unsigned long long v5; // rcx
long long v6; // rdx
long long v7; // rax
unsigned long long v8; // rax
long long v9; // rax
unsigned int v10; // r15d
long long v11; // rax
int v12; // eax
long long v13; // rax
long long v14; // rcx
_BYTE v16[72]; // [rsp+8h] [rbp-108h] BYREF
_BYTE v17[88]; // [rsp+50h] [rbp-C0h] BYREF
long long v18; // [rsp+A8h] [rbp-68h]
_DWORD v19[11]; // [rsp+E4h] [rbp-2Ch] BYREF
v3 = *(_QWORD *)a1;
*(_QWORD *)(a2 + 16) = *((_QWORD *)a1 + 46);
if ( a3 != 1 )
{
v4 = a3;
if ( (a3 & 2) == 0 )
{
if ( *(_QWORD *)(v3 + 1216) )
psi_mutex_lock(v3 + 1152, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_info.c", 0x2Eu);
else
pthread_mutex_lock(v3 + 1152);
mi_readinfo(a1, 0LL, 0LL);
if ( !*(_DWORD *)(*(_QWORD *)a1 + 872LL) )
mi_writeinfo(a1, 0LL);
if ( *(_QWORD *)(v3 + 1216) )
PSI_server[44]();
pthread_mutex_unlock(v3 + 1152);
}
if ( (v4 & 0x10) != 0 )
{
v5 = **((_QWORD **)a1 + 1);
*(_QWORD *)a2 = v5;
*(_QWORD *)(a2 + 8) = *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
v6 = *(_QWORD *)(*((_QWORD *)a1 + 1) + 16LL);
*(_QWORD *)(a2 + 72) = v6;
v7 = *(_QWORD *)(*((_QWORD *)a1 + 1) + 40LL);
*(_QWORD *)(a2 + 40) = v7;
*(_QWORD *)(a2 + 56) = *(_QWORD *)(*((_QWORD *)a1 + 1) + 32LL);
*(_DWORD *)(a2 + 128) = *(unsigned __int8 *)(v3 + 18);
*(_QWORD *)(a2 + 160) = *(_QWORD *)(v3 + 224);
if ( v5 )
v8 = (v7 - v6) / v5;
else
v8 = *(_QWORD *)(v3 + 800);
*(_QWORD *)(a2 + 88) = v8;
}
if ( (v4 & 0x20) != 0 )
{
*(_DWORD *)(a2 + 136) = a1[124];
*(_QWORD *)(a2 + 32) = *((_QWORD *)a1 + 52);
}
if ( (v4 & 8) != 0 )
{
*(_QWORD *)(a2 + 80) = *(_QWORD *)(v3 + 320);
*(_QWORD *)(a2 + 48) = *(_QWORD *)(v3 + 272);
*(_QWORD *)(a2 + 64) = *(_QWORD *)(*(_QWORD *)a1 + 280LL);
*(_DWORD *)(a2 + 144) = a1[112];
*(_DWORD *)(a2 + 132) = *(_DWORD *)(v3 + 792);
*(_QWORD *)(a2 + 152) = *(_QWORD *)(v3 + 208);
*(_DWORD *)(a2 + 176) = mi_get_pointer_length(*(_QWORD *)(v3 + 272), myisam_data_pointer_size);
if ( (*(_BYTE *)(v3 + 792) & 5) != 0 )
v9 = 0LL;
else
v9 = *(_QWORD *)(v3 + 328);
*(_QWORD *)(a2 + 184) = v9;
*(_DWORD *)(a2 + 140) = -1;
*(_QWORD *)(a2 + 192) = *(_QWORD *)(v3 + 136);
*(_QWORD *)(a2 + 104) = *(_QWORD *)(v3 + 192);
*(_QWORD *)(a2 + 112) = *(_QWORD *)(v3 + 608);
*(_QWORD *)(a2 + 120) = *(_QWORD *)(v3 + 616);
}
if ( (v4 & 4) != 0
&& ((v10 = a1[112], (v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v16, v10, 12LL)) != 0)
? (mi_status_cold_1(v11, v10, (long long)v17, v19), v12 = v19[0])
: (v12 = my_fstat(v10, v17, 0LL)),
!v12) )
{
v13 = v18;
}
else
{
v13 = 0LL;
}
*(_QWORD *)(a2 + 168) = v13;
if ( (v4 & 0x40) != 0 )
{
v14 = -1LL;
if ( *(_QWORD *)(v3 + 96) != -1LL )
v14 = *(_QWORD *)(v3 + 96) + 1LL;
*(_QWORD *)(a2 + 96) = v14;
}
}
return 0LL;
}
| mi_status:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R13,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x170]
MOV qword ptr [RSI + 0x10],RAX
CMP EDX,0x1
JZ 0x001811b4
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
TEST R14B,0x2
JNZ 0x00180fee
LEA R12,[R13 + 0x480]
CMP qword ptr [R13 + 0x4c0],0x0
JNZ 0x001811ce
MOV RDI,R12
CALL 0x001291d0
LAB_00180fb4:
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00182af3
MOV RAX,qword ptr [R15]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x00180fd6
MOV RDI,R15
XOR ESI,ESI
CALL 0x00182be6
LAB_00180fd6:
MOV RDI,qword ptr [R13 + 0x4c0]
TEST RDI,RDI
JNZ 0x001811e7
LAB_00180fe6:
MOV RDI,R12
CALL 0x001291a0
LAB_00180fee:
TEST R14B,0x10
JZ 0x00181061
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RAX,qword ptr [R15 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,qword ptr [R15 + 0x8]
MOV RDX,qword ptr [RAX + 0x10]
MOV qword ptr [RBX + 0x48],RDX
MOV RAX,qword ptr [R15 + 0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBX + 0x28],RAX
MOV RSI,qword ptr [R15 + 0x8]
MOV RSI,qword ptr [RSI + 0x20]
MOV qword ptr [RBX + 0x38],RSI
MOVZX ESI,byte ptr [R13 + 0x12]
MOV dword ptr [RBX + 0x80],ESI
MOV RSI,qword ptr [R13 + 0xe0]
MOV qword ptr [RBX + 0xa0],RSI
TEST RCX,RCX
JZ 0x00181056
SUB RAX,RDX
XOR EDX,EDX
DIV RCX
JMP 0x0018105d
LAB_00181056:
MOV RAX,qword ptr [R13 + 0x320]
LAB_0018105d:
MOV qword ptr [RBX + 0x58],RAX
LAB_00181061:
TEST R14B,0x20
JZ 0x0018107f
MOV EAX,dword ptr [R15 + 0x1f0]
MOV dword ptr [RBX + 0x88],EAX
MOV RAX,qword ptr [R15 + 0x1a0]
MOV qword ptr [RBX + 0x20],RAX
LAB_0018107f:
TEST R14B,0x8
JZ 0x00181145
MOV RAX,qword ptr [R13 + 0x140]
MOV qword ptr [RBX + 0x50],RAX
MOV RAX,qword ptr [R13 + 0x110]
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + 0x118]
MOV qword ptr [RBX + 0x40],RAX
MOV EAX,dword ptr [R15 + 0x1c0]
MOV dword ptr [RBX + 0x90],EAX
MOV EAX,dword ptr [R13 + 0x318]
MOV dword ptr [RBX + 0x84],EAX
MOV RAX,qword ptr [R13 + 0xd0]
MOV qword ptr [RBX + 0x98],RAX
MOV RDI,qword ptr [R13 + 0x110]
LEA RAX,[0x48c390]
MOV ESI,dword ptr [RAX]
CALL 0x001970ef
MOV dword ptr [RBX + 0xb0],EAX
TEST byte ptr [R13 + 0x318],0x5
JZ 0x001810fe
XOR EAX,EAX
JMP 0x00181105
LAB_001810fe:
MOV RAX,qword ptr [R13 + 0x148]
LAB_00181105:
MOV qword ptr [RBX + 0xb8],RAX
MOV dword ptr [RBX + 0x8c],0xffffffff
MOV RAX,qword ptr [R13 + 0x88]
MOV qword ptr [RBX + 0xc0],RAX
MOV RAX,qword ptr [R13 + 0xc0]
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R13 + 0x260]
MOV qword ptr [RBX + 0x70],RAX
MOV RAX,qword ptr [R13 + 0x268]
MOV qword ptr [RBX + 0x78],RAX
LAB_00181145:
TEST R14B,0x4
JZ 0x0018118f
MOV R15D,dword ptr [R15 + 0x1c0]
LEA RAX,[0x48d070]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x108]
MOV ESI,R15D
MOV EDX,0xc
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001811fc
LEA RSI,[RBP + -0xc0]
MOV EDI,R15D
XOR EDX,EDX
CALL 0x001a5b77
LAB_0018118b:
TEST EAX,EAX
JZ 0x001811c8
LAB_0018118f:
XOR EAX,EAX
LAB_00181191:
MOV qword ptr [RBX + 0xa8],RAX
TEST R14B,0x40
JZ 0x001811b4
MOV RAX,qword ptr [R13 + 0x60]
INC RAX
MOV RCX,-0x1
CMOVNZ RCX,RAX
MOV qword ptr [RBX + 0x60],RCX
LAB_001811b4:
XOR EAX,EAX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001811c8:
MOV RAX,qword ptr [RBP + -0x68]
JMP 0x00181191
LAB_001811ce:
LEA RSI,[0x1e1bc8]
MOV RDI,R12
MOV EDX,0x2e
CALL 0x0012eee9
JMP 0x00180fb4
LAB_001811e7:
LEA RAX,[0x48d070]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00180fe6
LAB_001811fc:
LEA RDX,[RBP + -0xc0]
LEA R12,[RBP + -0x2c]
MOV RDI,RAX
MOV ESI,R15D
MOV RCX,R12
CALL 0x0012dba7
MOV EAX,dword ptr [R12]
JMP 0x0018118b
|
int8 mi_status(long *param_1,ulong *param_2,uint param_3)
{
pthread_mutex_t *__mutex;
long lVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
int1 local_110 [72];
int1 local_c8 [88];
ulong local_70;
int local_34;
lVar1 = *param_1;
param_2[2] = param_1[0x2e];
if (param_3 == 1) {
return 0;
}
if ((param_3 & 2) == 0) {
__mutex = (pthread_mutex_t *)(lVar1 + 0x480);
if (*(long *)(lVar1 + 0x4c0) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_info.c",
0x2e);
}
_mi_readinfo(param_1,0,0);
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
if (*(long *)(lVar1 + 0x4c0) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
}
if ((param_3 & 0x10) != 0) {
uVar3 = *(ulong *)param_1[1];
*param_2 = uVar3;
param_2[1] = *(ulong *)(param_1[1] + 8);
uVar4 = *(ulong *)(param_1[1] + 0x10);
param_2[9] = uVar4;
uVar6 = *(ulong *)(param_1[1] + 0x28);
param_2[5] = uVar6;
param_2[7] = *(ulong *)(param_1[1] + 0x20);
*(uint *)(param_2 + 0x10) = (uint)*(byte *)(lVar1 + 0x12);
param_2[0x14] = *(ulong *)(lVar1 + 0xe0);
if (uVar3 == 0) {
uVar3 = *(ulong *)(lVar1 + 800);
}
else {
uVar3 = (uVar6 - uVar4) / uVar3;
}
param_2[0xb] = uVar3;
}
if ((param_3 & 0x20) != 0) {
*(int *)(param_2 + 0x11) = (int)param_1[0x3e];
param_2[4] = param_1[0x34];
}
if ((param_3 & 8) != 0) {
param_2[10] = *(ulong *)(lVar1 + 0x140);
param_2[6] = *(ulong *)(lVar1 + 0x110);
param_2[8] = *(ulong *)(*param_1 + 0x118);
*(int *)(param_2 + 0x12) = (int)param_1[0x38];
*(int4 *)((long)param_2 + 0x84) = *(int4 *)(lVar1 + 0x318);
param_2[0x13] = *(ulong *)(lVar1 + 0xd0);
uVar2 = mi_get_pointer_length
(*(int8 *)(lVar1 + 0x110),(int4)myisam_data_pointer_size);
*(int4 *)(param_2 + 0x16) = uVar2;
if ((*(byte *)(lVar1 + 0x318) & 5) == 0) {
uVar4 = *(ulong *)(lVar1 + 0x148);
}
else {
uVar4 = 0;
}
param_2[0x17] = uVar4;
*(int4 *)((long)param_2 + 0x8c) = 0xffffffff;
param_2[0x18] = *(ulong *)(lVar1 + 0x88);
param_2[0xd] = *(ulong *)(lVar1 + 0xc0);
param_2[0xe] = *(ulong *)(lVar1 + 0x260);
param_2[0xf] = *(ulong *)(lVar1 + 0x268);
}
if ((param_3 & 4) != 0) {
uVar2 = (int4)param_1[0x38];
lVar5 = (**(code **)(PSI_server + 0x158))(local_110,uVar2,0xc);
if (lVar5 == 0) {
local_34 = my_fstat(uVar2,local_c8,0);
}
else {
mi_status_cold_1(lVar5,uVar2,local_c8,&local_34);
}
if (local_34 == 0) goto LAB_00181191;
}
local_70 = 0;
LAB_00181191:
param_2[0x15] = local_70;
if ((param_3 & 0x40) != 0) {
uVar6 = *(long *)(lVar1 + 0x60) + 1;
uVar4 = 0xffffffffffffffff;
if (uVar6 != 0) {
uVar4 = uVar6;
}
param_2[0xc] = uVar4;
}
return 0;
}
| |
52,375 | columnPosForMultiLine(char const*, unsigned long, unsigned long, unsigned long, unsigned long) | ericcurtin[P]linenoise/linenoise.cpp | static size_t columnPosForMultiLine(const char * buf, size_t buf_len, size_t pos, size_t cols, size_t ini_pos) {
size_t ret = 0;
size_t colwid = ini_pos;
size_t off = 0;
while (off < buf_len) {
size_t col_len;
size_t len = nextCharLen(buf, buf_len, off, &col_len);
int dif = (int) (colwid + col_len) - (int) cols;
if (dif > 0) {
ret += dif;
colwid = col_len;
} else if (dif == 0) {
colwid = 0;
} else {
colwid += col_len;
}
if (off >= pos) {
break;
}
off += len;
ret += col_len;
}
return ret;
} | O0 | cpp | columnPosForMultiLine(char const*, unsigned long, unsigned long, unsigned long, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5773
movq 0xab77(%rip), %rax # 0x10260
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
addq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jle 0x572c
movslq -0x54(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x574a
cmpl $0x0, -0x54(%rbp)
jne 0x573c
movq $0x0, -0x38(%rbp)
jmp 0x5748
movq -0x48(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x574a
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x5756
jmp 0x5773
movq -0x50(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x56d4
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| _ZL21columnPosForMultiLinePKcmmmm:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], 0
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
mov [rbp+var_40], 0
loc_56D4:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_10]
jnb loc_5773
mov rax, cs:_ZL11nextCharLen; nextCharLen
mov rdi, [rbp+var_8]; char *
mov rsi, [rbp+var_10]; unsigned __int64
mov rdx, [rbp+var_40]; unsigned __int64
lea rcx, [rbp+var_48]; unsigned __int64 *
call rax ; defaultNextCharLen(char const*,ulong,ulong,ulong *); defaultNextCharLen(char const*,ulong,ulong,ulong *)
mov [rbp+var_50], rax
mov rax, [rbp+var_38]
add rax, [rbp+var_48]
mov rcx, [rbp+var_20]
sub eax, ecx
mov [rbp+var_54], eax
cmp [rbp+var_54], 0
jle short loc_572C
movsxd rax, [rbp+var_54]
add rax, [rbp+var_30]
mov [rbp+var_30], rax
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
jmp short loc_574A
loc_572C:
cmp [rbp+var_54], 0
jnz short loc_573C
mov [rbp+var_38], 0
jmp short loc_5748
loc_573C:
mov rax, [rbp+var_48]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
loc_5748:
jmp short $+2
loc_574A:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_18]
jb short loc_5756
jmp short loc_5773
loc_5756:
mov rax, [rbp+var_50]
add rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rax, [rbp+var_48]
add rax, [rbp+var_30]
mov [rbp+var_30], rax
jmp loc_56D4
loc_5773:
mov rax, [rbp+var_30]
add rsp, 60h
pop rbp
retn
| long long columnPosForMultiLine(
char *a1,
unsigned long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5)
{
int v6; // [rsp+Ch] [rbp-54h]
long long v7; // [rsp+10h] [rbp-50h]
unsigned long long v8; // [rsp+18h] [rbp-48h] BYREF
unsigned long long v9; // [rsp+20h] [rbp-40h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
long long v11; // [rsp+30h] [rbp-30h]
unsigned long long v12; // [rsp+38h] [rbp-28h]
long long v13; // [rsp+40h] [rbp-20h]
unsigned long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
char *v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v11 = 0LL;
v10 = a5;
v9 = 0LL;
while ( v9 < v15 )
{
v7 = nextCharLen(v16, v15, v9, &v8);
v6 = v8 + v10 - v13;
if ( v6 <= 0 )
{
if ( v6 )
v10 += v8;
else
v10 = 0LL;
}
else
{
v11 += v6;
v10 = v8;
}
if ( v9 >= v14 )
break;
v9 += v7;
v11 += v8;
}
return v11;
}
| columnPosForMultiLine:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV qword ptr [RBP + -0x40],0x0
LAB_001056d4:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x00105773
MOV RAX,qword ptr [0x00110260]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x40]
LEA RCX,[RBP + -0x48]
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x20]
SUB EAX,ECX
MOV dword ptr [RBP + -0x54],EAX
CMP dword ptr [RBP + -0x54],0x0
JLE 0x0010572c
MOVSXD RAX,dword ptr [RBP + -0x54]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0010574a
LAB_0010572c:
CMP dword ptr [RBP + -0x54],0x0
JNZ 0x0010573c
MOV qword ptr [RBP + -0x38],0x0
JMP 0x00105748
LAB_0010573c:
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
LAB_00105748:
JMP 0x0010574a
LAB_0010574a:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x00105756
JMP 0x00105773
LAB_00105756:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001056d4
LAB_00105773:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x60
POP RBP
RET
|
/* columnPosForMultiLine(char const*, unsigned long, unsigned long, unsigned long, unsigned long) */
long columnPosForMultiLine(char *param_1,ulong param_2,ulong param_3,ulong param_4,ulong param_5)
{
int iVar1;
long lVar2;
ulong local_50;
ulong local_48;
ulong local_40;
long local_38;
ulong local_30;
ulong local_28;
ulong local_20;
ulong local_18;
char *local_10;
local_38 = 0;
local_48 = 0;
local_40 = param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
if (local_18 <= local_48) {
return local_38;
}
lVar2 = (*(code *)nextCharLen)(local_10,local_18,local_48,&local_50);
iVar1 = ((int)local_40 + (int)local_50) - (int)local_28;
if (iVar1 < 1) {
if (iVar1 == 0) {
local_40 = 0;
}
else {
local_40 = local_50 + local_40;
}
}
else {
local_38 = iVar1 + local_38;
local_40 = local_50;
}
if (local_20 <= local_48) break;
local_48 = lVar2 + local_48;
local_38 = local_50 + local_38;
}
return local_38;
}
| |
52,376 | columnPosForMultiLine(char const*, unsigned long, unsigned long, unsigned long, unsigned long) | ericcurtin[P]linenoise/linenoise.cpp | static size_t columnPosForMultiLine(const char * buf, size_t buf_len, size_t pos, size_t cols, size_t ini_pos) {
size_t ret = 0;
size_t colwid = ini_pos;
size_t off = 0;
while (off < buf_len) {
size_t col_len;
size_t len = nextCharLen(buf, buf_len, off, &col_len);
int dif = (int) (colwid + col_len) - (int) cols;
if (dif > 0) {
ret += dif;
colwid = col_len;
} else if (dif == 0) {
colwid = 0;
} else {
colwid += col_len;
}
if (off >= pos) {
break;
}
off += len;
ret += col_len;
}
return ret;
} | O1 | cpp | columnPosForMultiLine(char const*, unsigned long, unsigned long, unsigned long, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, (%rsp)
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq %r12, %rbp
jae 0x4495
movq (%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
leaq 0x10(%rsp), %rcx
callq *0x7d78(%rip) # 0xc1d0
movq 0x10(%rsp), %rcx
addq %rcx, %rbx
movl %ebx, %edx
subl 0x8(%rsp), %edx
cmoveq %r14, %rbx
testl %edx, %edx
cmovgq %rcx, %rbx
cmovlel %r14d, %edx
cmpq %r15, %rbp
cmovaeq %r14, %rax
cmovaeq %r14, %rcx
addq %rbp, %rax
addq %r13, %rcx
addq %rdx, %rcx
movq %rcx, %r13
cmpq %r15, %rbp
movq %rax, %rbp
jb 0x443e
jmp 0x4498
movq %r13, %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZL21columnPosForMultiLinePKcmmmm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, r8
mov [rsp+48h+var_40], rcx
mov r15, rdx
mov r12, rsi
mov [rsp+48h+var_48], rdi
xor r14d, r14d
xor ebp, ebp
xor r13d, r13d
loc_443E:
cmp rbp, r12
jnb short loc_4495
mov rdi, [rsp+48h+var_48]; char *
mov rsi, r12; unsigned __int64
mov rdx, rbp; unsigned __int64
lea rcx, [rsp+48h+var_38]; unsigned __int64 *
call cs:_ZL11nextCharLen; defaultNextCharLen(char const*,ulong,ulong,ulong *)
mov rcx, [rsp+48h+var_38]
add rbx, rcx
mov edx, ebx
sub edx, dword ptr [rsp+48h+var_40]
cmovz rbx, r14
test edx, edx
cmovg rbx, rcx
cmovle edx, r14d
cmp rbp, r15
cmovnb rax, r14
cmovnb rcx, r14
add rax, rbp
add rcx, r13
add rcx, rdx
mov r13, rcx
cmp rbp, r15
mov rbp, rax
jb short loc_443E
jmp short loc_4498
loc_4495:
mov rcx, r13
loc_4498:
mov rax, rcx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long columnPosForMultiLine(
const char *a1,
unsigned long long a2,
unsigned long long a3,
int a4,
unsigned long long a5)
{
unsigned long long v7; // rbp
long long v8; // r13
long long CharLen; // rax
unsigned long long v10; // rcx
long long v11; // rdx
long long v12; // rcx
bool v13; // cf
unsigned long long v16[7]; // [rsp+10h] [rbp-38h] BYREF
v7 = 0LL;
v8 = 0LL;
while ( v7 < a2 )
{
CharLen = nextCharLen(a1, a2, v7, v16);
v10 = v16[0];
a5 += v16[0];
v11 = (unsigned int)(a5 - a4);
if ( (_DWORD)a5 == a4 )
a5 = 0LL;
if ( (int)v11 <= 0 )
v11 = 0LL;
else
a5 = v16[0];
if ( v7 >= a3 )
{
CharLen = 0LL;
v10 = 0LL;
}
v12 = v11 + v8 + v10;
v8 = v12;
v13 = v7 < a3;
v7 += CharLen;
if ( !v13 )
return v12;
}
return v8;
}
| columnPosForMultiLine:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,R8
MOV qword ptr [RSP + 0x8],RCX
MOV R15,RDX
MOV R12,RSI
MOV qword ptr [RSP],RDI
XOR R14D,R14D
XOR EBP,EBP
XOR R13D,R13D
LAB_0010443e:
CMP RBP,R12
JNC 0x00104495
MOV RDI,qword ptr [RSP]
MOV RSI,R12
MOV RDX,RBP
LEA RCX,[RSP + 0x10]
CALL qword ptr [0x0010c1d0]
MOV RCX,qword ptr [RSP + 0x10]
ADD RBX,RCX
MOV EDX,EBX
SUB EDX,dword ptr [RSP + 0x8]
CMOVZ RBX,R14
TEST EDX,EDX
CMOVG RBX,RCX
CMOVLE EDX,R14D
CMP RBP,R15
CMOVNC RAX,R14
CMOVNC RCX,R14
ADD RAX,RBP
ADD RCX,R13
ADD RCX,RDX
MOV R13,RCX
CMP RBP,R15
MOV RBP,RAX
JC 0x0010443e
JMP 0x00104498
LAB_00104495:
MOV RCX,R13
LAB_00104498:
MOV RAX,RCX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* columnPosForMultiLine(char const*, unsigned long, unsigned long, unsigned long, unsigned long) */
long columnPosForMultiLine(char *param_1,ulong param_2,ulong param_3,ulong param_4,ulong param_5)
{
ulong uVar1;
ulong uVar2;
long lVar3;
uint uVar4;
ulong uVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
int local_40;
ulong local_38;
uVar7 = 0;
lVar3 = 0;
uVar6 = 0;
do {
if (param_2 <= uVar6) {
return lVar3;
}
uVar1 = (*(code *)nextCharLen)(param_1,param_2,uVar6,&local_38);
local_40 = (int)param_4;
uVar4 = (int)(param_5 + local_38) - local_40;
param_5 = param_5 + local_38;
if (uVar4 == 0) {
param_5 = uVar7;
}
if (0 < (int)uVar4) {
param_5 = local_38;
}
uVar5 = (ulong)uVar4;
if ((int)uVar4 < 1) {
uVar5 = uVar7;
}
uVar2 = local_38;
if (param_3 <= uVar6) {
uVar2 = uVar7;
uVar1 = uVar7;
}
lVar3 = uVar2 + lVar3 + uVar5;
bVar8 = uVar6 < param_3;
uVar6 = uVar1 + uVar6;
} while (bVar8);
return lVar3;
}
| |
52,377 | net_field_length | eloqsql/libmariadb/libmariadb/mariadb_lib.c | ulong
net_field_length(uchar **packet)
{
reg1 uchar *pos= *packet;
if (*pos < 251)
{
(*packet)++;
return (ulong) *pos;
}
if (*pos == 251)
{
(*packet)++;
return NULL_LENGTH;
}
if (*pos == 252)
{
(*packet)+=3;
return (ulong) uint2korr(pos+1);
}
if (*pos == 253)
{
(*packet)+=4;
return (ulong) uint3korr(pos+1);
}
(*packet)+=9; /* Must be 254 when here */
return (ulong) uint4korr(pos+1);
} | O3 | c | net_field_length:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movzbl (%rax), %ecx
cmpl $0xfa, %ecx
ja 0x17df3
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movzbl (%rax), %eax
popq %rbp
retq
cmpl $0xfd, %ecx
je 0x17e27
cmpl $0xfc, %ecx
je 0x17e1a
cmpl $0xfb, %ecx
jne 0x17e3e
incq %rax
movq %rax, (%rdi)
movq $-0x1, %rax
jmp 0x17df1
leaq 0x3(%rax), %rcx
movq %rcx, (%rdi)
movzwl 0x1(%rax), %eax
jmp 0x17df1
leaq 0x4(%rax), %rcx
movq %rcx, (%rdi)
movzwl 0x1(%rax), %ecx
movzbl 0x3(%rax), %eax
shll $0x10, %eax
orq %rcx, %rax
jmp 0x17df1
leaq 0x9(%rax), %rcx
movq %rcx, (%rdi)
movl 0x1(%rax), %eax
jmp 0x17df1
| net_field_length:
push rbp
mov rbp, rsp
mov rax, [rdi]
movzx ecx, byte ptr [rax]
cmp ecx, 0FAh
ja short loc_17DF3
lea rcx, [rax+1]
mov [rdi], rcx
movzx eax, byte ptr [rax]
loc_17DF1:
pop rbp
retn
loc_17DF3:
cmp ecx, 0FDh
jz short loc_17E27
cmp ecx, 0FCh
jz short loc_17E1A
cmp ecx, 0FBh
jnz short loc_17E3E
inc rax
mov [rdi], rax
mov rax, 0FFFFFFFFFFFFFFFFh
jmp short loc_17DF1
loc_17E1A:
lea rcx, [rax+3]
mov [rdi], rcx
movzx eax, word ptr [rax+1]
jmp short loc_17DF1
loc_17E27:
lea rcx, [rax+4]
mov [rdi], rcx
movzx ecx, word ptr [rax+1]
movzx eax, byte ptr [rax+3]
shl eax, 10h
or rax, rcx
jmp short loc_17DF1
loc_17E3E:
lea rcx, [rax+9]
mov [rdi], rcx
mov eax, [rax+1]
jmp short loc_17DF1
| unsigned long long net_field_length(unsigned __int8 **a1)
{
unsigned __int8 *v1; // rax
unsigned int v2; // ecx
v1 = *a1;
v2 = **a1;
if ( v2 > 0xFA )
{
switch ( v2 )
{
case 0xFDu:
*a1 = v1 + 4;
return *(unsigned __int16 *)(v1 + 1) | (unsigned long long)(v1[3] << 16);
case 0xFCu:
*a1 = v1 + 3;
return *(unsigned __int16 *)(v1 + 1);
case 0xFBu:
*a1 = v1 + 1;
return -1LL;
default:
*a1 = v1 + 9;
return *(unsigned int *)(v1 + 1);
}
}
else
{
*a1 = v1 + 1;
return *v1;
}
}
| net_field_length:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOVZX ECX,byte ptr [RAX]
CMP ECX,0xfa
JA 0x00117df3
LEA RCX,[RAX + 0x1]
MOV qword ptr [RDI],RCX
MOVZX EAX,byte ptr [RAX]
LAB_00117df1:
POP RBP
RET
LAB_00117df3:
CMP ECX,0xfd
JZ 0x00117e27
CMP ECX,0xfc
JZ 0x00117e1a
CMP ECX,0xfb
JNZ 0x00117e3e
INC RAX
MOV qword ptr [RDI],RAX
MOV RAX,-0x1
JMP 0x00117df1
LAB_00117e1a:
LEA RCX,[RAX + 0x3]
MOV qword ptr [RDI],RCX
MOVZX EAX,word ptr [RAX + 0x1]
JMP 0x00117df1
LAB_00117e27:
LEA RCX,[RAX + 0x4]
MOV qword ptr [RDI],RCX
MOVZX ECX,word ptr [RAX + 0x1]
MOVZX EAX,byte ptr [RAX + 0x3]
SHL EAX,0x10
OR RAX,RCX
JMP 0x00117df1
LAB_00117e3e:
LEA RCX,[RAX + 0x9]
MOV qword ptr [RDI],RCX
MOV EAX,dword ptr [RAX + 0x1]
JMP 0x00117df1
|
ulong net_field_length(long *param_1)
{
byte bVar1;
byte *pbVar2;
ulong uVar3;
pbVar2 = (byte *)*param_1;
bVar1 = *pbVar2;
if (bVar1 < 0xfb) {
*param_1 = (long)(pbVar2 + 1);
uVar3 = (ulong)*pbVar2;
}
else if (bVar1 == 0xfd) {
*param_1 = (long)(pbVar2 + 4);
uVar3 = (ulong)*(uint3 *)(pbVar2 + 1);
}
else if (bVar1 == 0xfc) {
*param_1 = (long)(pbVar2 + 3);
uVar3 = (ulong)*(ushort *)(pbVar2 + 1);
}
else if (bVar1 == 0xfb) {
*param_1 = (long)(pbVar2 + 1);
uVar3 = 0xffffffffffffffff;
}
else {
*param_1 = (long)(pbVar2 + 9);
uVar3 = (ulong)*(uint *)(pbVar2 + 1);
}
return uVar3;
}
| |
52,378 | my_caseup_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map= cs->to_upper;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O0 | c | my_caseup_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xe7252
jmp 0xe7254
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0xe728b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe7254
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_caseup_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+50h]
mov [rbp+var_38], rax
jmp short $+2
loc_E7252:
jmp short $+2
loc_E7254:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jz short loc_E728B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_E7254
loc_E728B:
mov rax, [rbp+var_18]
pop rbp
retn
| long long my_caseup_8bit(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4)
{
_BYTE *v4; // rax
long long v6; // [rsp+0h] [rbp-38h]
unsigned __int8 *v8; // [rsp+28h] [rbp-10h]
v8 = a2;
v6 = *(_QWORD *)(a1 + 80);
while ( v8 != &a2[a3] )
{
v4 = a4++;
*v4 = *(_BYTE *)(v6 + *v8++);
}
return a3;
}
| my_caseup_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001e7252
LAB_001e7252:
JMP 0x001e7254
LAB_001e7254:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001e728b
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001e7254
LAB_001e728b:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long my_caseup_8bit(long param_1,byte *param_2,long param_3,int1 *param_4)
{
long lVar1;
int1 *local_28;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x50);
local_28 = param_4;
for (local_18 = param_2; local_18 != param_2 + param_3; local_18 = local_18 + 1) {
*local_28 = *(int1 *)(lVar1 + (ulong)*local_18);
local_28 = local_28 + 1;
}
return param_3;
}
| |
52,379 | minja::Parser::parseParameters[abi:cxx11]() | monkey531[P]llama/common/minja.hpp | Expression::Parameters parseParameters() {
consumeSpaces();
if (consumeToken("(").empty()) throw std::runtime_error("Expected opening parenthesis in param list");
Expression::Parameters result;
while (it != end) {
if (!consumeToken(")").empty()) {
return result;
}
auto expr = parseExpression();
if (!expr) throw std::runtime_error("Expected expression in call args");
if (auto ident = dynamic_cast<VariableExpr*>(expr.get())) {
if (!consumeToken("=").empty()) {
auto value = parseExpression();
if (!value) throw std::runtime_error("Expected expression in for named arg");
result.emplace_back(ident->get_name(), std::move(value));
} else {
result.emplace_back(ident->get_name(), nullptr);
}
} else {
result.emplace_back(std::string(), std::move(expr));
}
if (consumeToken(",").empty()) {
if (consumeToken(")").empty()) {
throw std::runtime_error("Expected closing parenthesis in call args");
}
return result;
}
}
throw std::runtime_error("Expected closing parenthesis in call args");
} | O2 | cpp | minja::Parser::parseParameters[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r12
movq %rdi, 0x8(%rsp)
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x64c86
leaq 0x57820(%rip), %rsi # 0xbbe3a
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x291dc
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r12, %rsi
callq 0x64388
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rbx
callq 0x254d8
leaq 0x40(%rsp), %rdi
callq 0x254d8
testq %rbx, %rbx
je 0x64970
movq 0x8(%rsp), %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x60(%rsp)
leaq 0x40(%rsp), %rbp
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r14
pushq $0x1
popq %rbx
movq 0x20(%r12), %rax
cmpq 0x18(%r12), %rax
je 0x648c2
movq %rbp, %rdi
leaq 0x5744f(%rip), %rsi # 0xbbaf3
movq %r15, %rdx
callq 0x291dc
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x64388
movq 0x28(%rsp), %r13
movq %r14, %rdi
callq 0x254d8
movq %rbp, %rdi
callq 0x254d8
testq %r13, %r13
jne 0x648ae
movq %r15, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x63b96
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x648f4
leaq 0x9bc84(%rip), %rsi # 0x100380
leaq 0x9c0a5(%rip), %rdx # 0x1007a8
xorl %ecx, %ecx
callq 0x24be0
testq %rax, %rax
je 0x647a5
movq %rax, %r13
movq %rbp, %rdi
leaq 0x52aab(%rip), %rsi # 0xb71cb
leaq 0x7(%rsp), %rdx
callq 0x291dc
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x64388
movq 0x28(%rsp), %r15
movq %r14, %rdi
callq 0x254d8
movq %rbp, %rdi
callq 0x254d8
testq %r15, %r15
je 0x647cc
movq %rbp, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x63b96
cmpq $0x0, 0x40(%rsp)
leaq 0x10(%rsp), %r15
je 0x64910
addq $0x20, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x24e40
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x6eac0
movq %r14, %rdi
callq 0x254d8
leaq 0x48(%rsp), %rdi
callq 0x52fe0
jmp 0x647fe
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x6eac0
jmp 0x647f6
addq $0x20, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x24e40
andq $0x0, 0x40(%rsp)
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x75282
leaq 0x10(%rsp), %r15
movq %r14, %rdi
callq 0x254d8
movq %rbp, %rdi
leaq 0x48d9a(%rip), %rsi # 0xad5a2
leaq 0x7(%rsp), %rdx
callq 0x291dc
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x64388
movq 0x28(%rsp), %r13
movq %r14, %rdi
callq 0x254d8
movq %rbp, %rdi
callq 0x254d8
testq %r13, %r13
jne 0x6488a
movq %rbp, %rdi
leaq 0x572ad(%rip), %rsi # 0xbbaf3
leaq 0x7(%rsp), %rdx
callq 0x291dc
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x64388
movq 0x28(%rsp), %r15
movq %r14, %rdi
callq 0x254d8
movq %rbp, %rdi
callq 0x254d8
movb $0x1, %al
movq %rax, 0x60(%rsp)
testq %r15, %r15
leaq 0x10(%rsp), %r15
je 0x64940
leaq 0x18(%rsp), %rdi
callq 0x52fe0
testq %r13, %r13
jne 0x6468a
testb $0x1, 0x60(%rsp)
jne 0x648ae
movq 0x8(%rsp), %rdi
callq 0x64acc
movq 0x8(%rsp), %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %r14
leaq 0x53057(%rip), %rsi # 0xb792b
movq %rax, %rdi
callq 0x24370
movq 0x9d705(%rip), %rsi # 0x101fe8
movq 0x9d65e(%rip), %rdx # 0x101f48
movq %r14, %rdi
callq 0x251c0
jmp 0x64940
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %r14
leaq 0x52fdf(%rip), %rsi # 0xb78e5
movq %rax, %rdi
callq 0x24370
jmp 0x6495a
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %r14
leaq 0x52fe4(%rip), %rsi # 0xb7906
movq %rax, %rdi
callq 0x24370
movq 0x9d6b7(%rip), %rsi # 0x101fe8
movq 0x9d610(%rip), %rdx # 0x101f48
movq %r14, %rdi
callq 0x251c0
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %r14
leaq 0x52fd9(%rip), %rsi # 0xb792b
movq %rax, %rdi
callq 0x24370
movq 0x9d687(%rip), %rsi # 0x101fe8
movq 0x9d5e0(%rip), %rdx # 0x101f48
movq %r14, %rdi
callq 0x251c0
pushq $0x10
popq %rdi
callq 0x244f0
movq %rax, %r14
leaq 0x53483(%rip), %rsi # 0xb7e05
movq %rax, %rdi
callq 0x24370
movq 0x9d657(%rip), %rsi # 0x101fe8
movq 0x9d5b0(%rip), %rdx # 0x101f48
movq %r14, %rdi
callq 0x251c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x24780
jmp 0x64a6b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x254d8
jmp 0x64a6b
movq %rax, %rbx
jmp 0x64a6b
jmp 0x64a0d
jmp 0x649fe
movq %rax, %rbx
movq %r14, %rdi
callq 0x24780
jmp 0x64a01
jmp 0x649e1
jmp 0x64a40
jmp 0x64a40
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x64a39
jmp 0x64a31
jmp 0x64a40
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x254d8
jmp 0x64a01
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x52fe0
jmp 0x64a43
movq %rax, %rbx
movq %r14, %rdi
callq 0x24780
jmp 0x64a43
jmp 0x64a4f
movq %rax, %rbx
movq %r14, %rdi
callq 0x24780
jmp 0x64a61
jmp 0x64a40
jmp 0x64a31
jmp 0x64a40
jmp 0x64a4f
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x254d8
jmp 0x64a43
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x52fe0
jmp 0x64a61
movq %rax, %rbx
jmp 0x64a61
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x254d8
movq 0x8(%rsp), %rdi
callq 0x64acc
movq %rbx, %rdi
callq 0x25250
| _ZN5minja6Parser15parseParametersB5cxx11Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12, rsi
mov [rsp+98h+var_90], rdi
push 1
pop rsi
mov rdi, r12
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
lea rsi, asc_BBE35+5; "("
lea rdi, [rsp+98h+var_58]
lea rdx, [rsp+98h+lpsrc]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+98h+var_78]
lea rdx, [rsp+98h+var_58]
push 1
pop rcx
mov rsi, r12
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
lea rdi, [rsp+98h+var_78]; void *
mov rbx, [rdi+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+98h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test rbx, rbx
jz loc_64970
mov rax, [rsp+98h+var_90]
and qword ptr [rax+10h], 0
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov [rsp+98h+var_38], 0
lea rbp, [rsp+98h+var_58]
lea r15, [rsp+98h+lpsrc]
lea r14, [rsp+98h+var_78]
push 1
pop rbx
loc_6468A:
mov rax, [r12+20h]
cmp rax, [r12+18h]
jz loc_648C2
mov rdi, rbp
lea rsi, a09401910201912+51h; ")"
mov rdx, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r14
mov rsi, r12
mov rdx, rbp
mov ecx, ebx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov r13, [rsp+98h+var_70]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r13, r13
jnz loc_648AE
mov rdi, r15; this
mov rsi, r12; bool
mov edx, ebx
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
mov rdi, [rsp+98h+lpsrc]; lpsrc
test rdi, rdi
jz loc_648F4
lea rsi, _ZTIN5minja10ExpressionE; lpstype
lea rdx, _ZTIN5minja12VariableExprE; lpdtype
xor ecx, ecx; s2d
call ___dynamic_cast
test rax, rax
jz loc_647A5
mov r13, rax
mov rdi, rbp
lea rsi, asc_B71CA+1; "="
lea rdx, [rsp+98h+var_91]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r14
mov rsi, r12
mov rdx, rbp
mov ecx, ebx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov r15, [rsp+98h+var_70]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r15, r15
jz short loc_647CC
mov rdi, rbp; this
mov rsi, r12; bool
mov edx, ebx
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
cmp [rsp+98h+var_58], 0
lea r15, [rsp+98h+lpsrc]
jz loc_64910
add r13, 20h ; ' '
mov rdi, r14
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov rdi, [rsp+98h+var_90]
mov rsi, r14
mov rdx, rbp
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EE12emplace_backIJS6_SA_EEERSB_DpOT_; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::emplace_back<std::string,std::shared_ptr<minja::Expression>>(std::string,std::shared_ptr<minja::Expression> &&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+98h+var_50]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_647FE
loc_647A5:
lea rax, [rsp+98h+var_68]
mov [rsp+98h+var_78], rax
and [rsp+98h+var_70], 0
mov [rsp+98h+var_68], 0
mov rdi, [rsp+98h+var_90]
mov rsi, r14
mov rdx, r15
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EE12emplace_backIJS6_SA_EEERSB_DpOT_; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::emplace_back<std::string,std::shared_ptr<minja::Expression>>(std::string,std::shared_ptr<minja::Expression> &&)
jmp short loc_647F6
loc_647CC:
add r13, 20h ; ' '
mov rdi, r14
mov rsi, r13
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
and [rsp+98h+var_58], 0
mov rdi, [rsp+98h+var_90]
mov rsi, r14
mov rdx, rbp
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EE12emplace_backIJS6_DnEEERSB_DpOT_; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::emplace_back<std::string,decltype(nullptr)>(std::string,decltype(nullptr) &&)
lea r15, [rsp+98h+lpsrc]
loc_647F6:
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_647FE:
mov rdi, rbp
lea rsi, asc_AD59F+3; ","
lea rdx, [rsp+98h+var_91]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r14
mov rsi, r12
mov rdx, rbp
mov ecx, ebx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov r13, [rsp+98h+var_70]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test r13, r13
jnz short loc_6488A
mov rdi, rbp
lea rsi, a09401910201912+51h; ")"
lea rdx, [rsp+98h+var_91]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r14
mov rsi, r12
mov rdx, rbp
mov ecx, ebx
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov r15, [rsp+98h+var_70]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov al, 1
mov [rsp+98h+var_38], rax
test r15, r15
lea r15, [rsp+98h+lpsrc]
jz loc_64940
loc_6488A:
lea rdi, [rsp+98h+var_80]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
test r13, r13
jnz loc_6468A
test byte ptr [rsp+98h+var_38], 1
jnz short loc_648AE
mov rdi, [rsp+98h+var_90]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EED2Ev; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::~vector()
loc_648AE:
mov rax, [rsp+98h+var_90]
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_648C2:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedClosin_1; "Expected closing parenthesis in call ar"...
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, r14; void *
call ___cxa_throw
jmp short loc_64940
loc_648F4:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedExpres_0; "Expected expression in call args"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_6495A
loc_64910:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedExpres_1; "Expected expression in for named arg"
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, r14; void *
call ___cxa_throw
loc_64940:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedClosin_1; "Expected closing parenthesis in call ar"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_6495A:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_64970:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedOpenin; "Expected opening parenthesis in param l"...
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, r14; void *
call ___cxa_throw
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp loc_64A6B
mov rbx, rax
lea rdi, [rsp+98h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp loc_64A6B
mov rbx, rax
jmp loc_64A6B
jmp short loc_64A0D
jmp short loc_649FE
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_64A01
jmp short loc_649E1
jmp short loc_64A40
jmp short loc_64A40
loc_649E1:
mov rbx, rax
lea rdi, [rsp+98h+var_78]
jmp short loc_64A39
jmp short loc_64A31
jmp short loc_64A40
mov rbx, rax
lea rdi, [rsp+98h+var_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_64A01
loc_649FE:
mov rbx, rax
loc_64A01:
lea rdi, [rsp+98h+var_50]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_64A43
loc_64A0D:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_64A43
jmp short loc_64A4F
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_64A61
jmp short loc_64A40
jmp short loc_64A31
jmp short loc_64A40
jmp short loc_64A4F
loc_64A31:
mov rbx, rax
lea rdi, [rsp+98h+var_58]; void *
loc_64A39:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_64A43
loc_64A40:
mov rbx, rax
loc_64A43:
lea rdi, [rsp+98h+var_80]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
jmp short loc_64A61
loc_64A4F:
mov rbx, rax
jmp short loc_64A61
mov rbx, rax
lea rdi, [rsp+98h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_64A61:
mov rdi, [rsp+98h+var_90]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN5minja10ExpressionEEESaISB_EED2Ev; std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::~vector()
loc_64A6B:
mov rdi, rbx
call __Unwind_Resume
| long long minja::Parser::parseParameters[abi:cxx11](long long a1, _QWORD *a2)
{
long long v2; // rbx
long long v3; // r13
char *v4; // rax
char *v5; // r13
long long v6; // r15
long long v7; // r13
long long v8; // r15
long long v9; // rax
std::runtime_error *v11; // r14
std::runtime_error *v12; // r14
std::runtime_error *v13; // r14
std::runtime_error *exception; // r14
void *lpsrc; // [rsp+10h] [rbp-88h] BYREF
long long v16; // [rsp+18h] [rbp-80h] BYREF
char *v17; // [rsp+20h] [rbp-78h] BYREF
long long v18; // [rsp+28h] [rbp-70h]
char v19; // [rsp+30h] [rbp-68h] BYREF
long long v20; // [rsp+40h] [rbp-58h] BYREF
long long v21[3]; // [rsp+48h] [rbp-50h] BYREF
long long v22; // [rsp+60h] [rbp-38h]
minja::Parser::consumeSpaces(a2, 1LL);
std::string::basic_string<std::allocator<char>>(&v20, (long long)"(");
minja::Parser::consumeToken(&v17, (long long)a2, &v20, 1u);
v2 = v18;
std::string::~string(&v17);
std::string::~string(&v20);
if ( !v2 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected opening parenthesis in param list");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v22 = 0LL;
do
{
if ( a2[4] == a2[3] )
{
v11 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v11, "Expected closing parenthesis in call args");
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
std::string::basic_string<std::allocator<char>>(&v20, (long long)")");
minja::Parser::consumeToken(&v17, (long long)a2, &v20, 1u);
v3 = v18;
std::string::~string(&v17);
std::string::~string(&v20);
if ( v3 )
return a1;
minja::Parser::parseExpression((minja::Parser *)&lpsrc, a2, 1);
if ( !lpsrc )
{
v12 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v12, "Expected expression in call args");
goto LABEL_23;
}
v4 = (char *)__dynamic_cast(
lpsrc,
(const struct __class_type_info *)&`typeinfo for'minja::Expression,
(const struct __class_type_info *)&`typeinfo for'minja::VariableExpr,
0LL);
if ( !v4 )
{
v17 = &v19;
v18 = 0LL;
v19 = 0;
std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::emplace_back<std::string,std::shared_ptr<minja::Expression>>(
a1,
&v17,
&lpsrc);
LABEL_12:
std::string::~string(&v17);
goto LABEL_13;
}
v5 = v4;
std::string::basic_string<std::allocator<char>>(&v20, (long long)"=");
minja::Parser::consumeToken(&v17, (long long)a2, &v20, 1u);
v6 = v18;
std::string::~string(&v17);
std::string::~string(&v20);
if ( !v6 )
{
std::string::basic_string(&v17, v5 + 32);
v20 = 0LL;
std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::emplace_back<std::string,decltype(nullptr)>(
a1,
&v17,
&v20);
goto LABEL_12;
}
minja::Parser::parseExpression((minja::Parser *)&v20, a2, 1);
if ( !v20 )
{
v13 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v13, "Expected expression in for named arg");
__cxa_throw(
v13,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
std::string::basic_string(&v17, v5 + 32);
std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::emplace_back<std::string,std::shared_ptr<minja::Expression>>(
a1,
&v17,
&v20);
std::string::~string(&v17);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v21);
LABEL_13:
std::string::basic_string<std::allocator<char>>(&v20, (long long)",");
minja::Parser::consumeToken(&v17, (long long)a2, &v20, 1u);
v7 = v18;
std::string::~string(&v17);
std::string::~string(&v20);
if ( !v7 )
{
std::string::basic_string<std::allocator<char>>(&v20, (long long)")");
minja::Parser::consumeToken(&v17, (long long)a2, &v20, 1u);
v8 = v18;
std::string::~string(&v17);
std::string::~string(&v20);
LOBYTE(v9) = 1;
v22 = v9;
if ( !v8 )
{
v12 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v12, "Expected closing parenthesis in call args");
LABEL_23:
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v16);
}
while ( v7 );
if ( (v22 & 1) == 0 )
std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>>::~vector(a1);
return a1;
}
| parseParameters[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12,RSI
MOV qword ptr [RSP + 0x8],RDI
PUSH 0x1
POP RSI
MOV RDI,R12
CALL 0x00164c86
LAB_00164613:
LEA RSI,[0x1bbe3a]
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0x10]
CALL 0x001291dc
LAB_00164629:
LEA RDI,[RSP + 0x20]
LEA RDX,[RSP + 0x40]
PUSH 0x1
POP RCX
MOV RSI,R12
CALL 0x00164388
LEA RDI,[RSP + 0x20]
MOV RBX,qword ptr [RDI + 0x8]
CALL 0x001254d8
LEA RDI,[RSP + 0x40]
CALL 0x001254d8
TEST RBX,RBX
JZ 0x00164970
MOV RAX,qword ptr [RSP + 0x8]
AND qword ptr [RAX + 0x10],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RSP + 0x60],0x0
LEA RBP,[RSP + 0x40]
LEA R15,[RSP + 0x10]
LEA R14,[RSP + 0x20]
PUSH 0x1
POP RBX
LAB_0016468a:
MOV RAX,qword ptr [R12 + 0x20]
CMP RAX,qword ptr [R12 + 0x18]
JZ 0x001648c2
LAB_0016469a:
MOV RDI,RBP
LEA RSI,[0x1bbaf3]
MOV RDX,R15
CALL 0x001291dc
LAB_001646ac:
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBP
MOV ECX,EBX
CALL 0x00164388
MOV R13,qword ptr [RSP + 0x28]
MOV RDI,R14
CALL 0x001254d8
MOV RDI,RBP
CALL 0x001254d8
TEST R13,R13
JNZ 0x001648ae
LAB_001646da:
MOV RDI,R15
MOV RSI,R12
MOV EDX,EBX
CALL 0x00163b96
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x001648f4
LEA RSI,[0x200380]
LEA RDX,[0x2007a8]
XOR ECX,ECX
CALL 0x00124be0
TEST RAX,RAX
JZ 0x001647a5
LAB_00164713:
MOV R13,RAX
MOV RDI,RBP
LEA RSI,[0x1b71cb]
LEA RDX,[RSP + 0x7]
CALL 0x001291dc
LAB_0016472a:
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBP
MOV ECX,EBX
CALL 0x00164388
MOV R15,qword ptr [RSP + 0x28]
MOV RDI,R14
CALL 0x001254d8
MOV RDI,RBP
CALL 0x001254d8
TEST R15,R15
JZ 0x001647cc
LAB_00164754:
MOV RDI,RBP
MOV RSI,R12
MOV EDX,EBX
CALL 0x00163b96
CMP qword ptr [RSP + 0x40],0x0
LEA R15,[RSP + 0x10]
JZ 0x00164910
ADD R13,0x20
LAB_00164776:
MOV RDI,R14
MOV RSI,R13
CALL 0x00124e40
LAB_00164781:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
CALL 0x0016eac0
MOV RDI,R14
CALL 0x001254d8
LEA RDI,[RSP + 0x48]
CALL 0x00152fe0
JMP 0x001647fe
LAB_001647a5:
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
AND qword ptr [RSP + 0x28],0x0
MOV byte ptr [RSP + 0x30],0x0
LAB_001647ba:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
MOV RDX,R15
CALL 0x0016eac0
JMP 0x001647f6
LAB_001647cc:
ADD R13,0x20
LAB_001647d0:
MOV RDI,R14
MOV RSI,R13
CALL 0x00124e40
AND qword ptr [RSP + 0x40],0x0
LAB_001647e1:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
CALL 0x00175282
LEA R15,[RSP + 0x10]
LAB_001647f6:
MOV RDI,R14
CALL 0x001254d8
LAB_001647fe:
MOV RDI,RBP
LEA RSI,[0x1ad5a2]
LEA RDX,[RSP + 0x7]
CALL 0x001291dc
LAB_00164812:
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBP
MOV ECX,EBX
CALL 0x00164388
MOV R13,qword ptr [RSP + 0x28]
MOV RDI,R14
CALL 0x001254d8
MOV RDI,RBP
CALL 0x001254d8
TEST R13,R13
JNZ 0x0016488a
LAB_0016483c:
MOV RDI,RBP
LEA RSI,[0x1bbaf3]
LEA RDX,[RSP + 0x7]
CALL 0x001291dc
LAB_00164850:
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBP
MOV ECX,EBX
CALL 0x00164388
LAB_00164860:
MOV R15,qword ptr [RSP + 0x28]
MOV RDI,R14
CALL 0x001254d8
MOV RDI,RBP
CALL 0x001254d8
MOV AL,0x1
MOV qword ptr [RSP + 0x60],RAX
TEST R15,R15
LEA R15,[RSP + 0x10]
JZ 0x00164940
LAB_0016488a:
LEA RDI,[RSP + 0x18]
CALL 0x00152fe0
TEST R13,R13
JNZ 0x0016468a
TEST byte ptr [RSP + 0x60],0x1
JNZ 0x001648ae
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00164acc
LAB_001648ae:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001648c2:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV R14,RAX
LAB_001648cd:
LEA RSI,[0x1b792b]
MOV RDI,RAX
CALL 0x00124370
LAB_001648dc:
MOV RSI,qword ptr [0x00201fe8]
MOV RDX,qword ptr [0x00201f48]
MOV RDI,R14
CALL 0x001251c0
LAB_001648f4:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV R14,RAX
LAB_001648ff:
LEA RSI,[0x1b78e5]
MOV RDI,RAX
CALL 0x00124370
LAB_0016490e:
JMP 0x0016495a
LAB_00164910:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV R14,RAX
LAB_0016491b:
LEA RSI,[0x1b7906]
MOV RDI,RAX
CALL 0x00124370
LAB_0016492a:
MOV RSI,qword ptr [0x00201fe8]
MOV RDX,qword ptr [0x00201f48]
MOV RDI,R14
CALL 0x001251c0
LAB_00164940:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV R14,RAX
LAB_0016494b:
LEA RSI,[0x1b792b]
MOV RDI,RAX
CALL 0x00124370
LAB_0016495a:
MOV RSI,qword ptr [0x00201fe8]
MOV RDX,qword ptr [0x00201f48]
MOV RDI,R14
CALL 0x001251c0
LAB_00164970:
PUSH 0x10
POP RDI
CALL 0x001244f0
MOV R14,RAX
LAB_0016497b:
LEA RSI,[0x1b7e05]
MOV RDI,RAX
CALL 0x00124370
LAB_0016498a:
MOV RSI,qword ptr [0x00201fe8]
MOV RDX,qword ptr [0x00201f48]
MOV RDI,R14
CALL 0x001251c0
|
/* minja::Parser::parseParameters[abi:cxx11]() */
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
* minja::Parser::parseParameters_abi_cxx11_(void)
{
long lVar1;
long lVar2;
int8 uVar3;
runtime_error *prVar4;
long in_RSI;
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
*in_RDI;
allocator local_91;
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
*local_90;
long local_88;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_80 [8];
int1 *local_78;
long local_70;
int1 local_68 [16];
long local_58;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_50 [24];
ulong local_38;
local_90 = in_RDI;
consumeSpaces();
/* try { // try from 00164613 to 00164628 has its CatchHandler @ 001649c2 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_58,"(",(allocator *)&local_88)
;
/* try { // try from 00164629 to 0016463d has its CatchHandler @ 001649b0 */
consumeToken(&local_78);
lVar2 = local_70;
std::__cxx11::string::~string((string *)&local_78);
std::__cxx11::string::~string((string *)&local_58);
if (lVar2 == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016497b to 00164989 has its CatchHandler @ 001649a0 */
std::runtime_error::runtime_error(prVar4,"Expected opening parenthesis in param list");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00201fe8,PTR__runtime_error_00201f48);
}
*(int8 *)(local_90 + 0x10) = 0;
*(int8 *)local_90 = 0;
*(int8 *)(local_90 + 8) = 0;
local_38 = 0;
do {
if (*(long *)(in_RSI + 0x20) == *(long *)(in_RSI + 0x18)) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001648cd to 001648db has its CatchHandler @ 00164a1c */
std::runtime_error::runtime_error(prVar4,"Expected closing parenthesis in call args");
/* try { // try from 001648dc to 001648f1 has its CatchHandler @ 00164a1a */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00201fe8,PTR__runtime_error_00201f48);
}
/* try { // try from 0016469a to 001646ab has its CatchHandler @ 00164a4f */
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_58,")",(allocator *)&local_88);
/* try { // try from 001646ac to 001646bb has its CatchHandler @ 00164a54 */
consumeToken((string *)&local_78);
lVar2 = local_70;
std::__cxx11::string::~string((string *)&local_78);
std::__cxx11::string::~string((string *)&local_58);
if (lVar2 != 0) {
return local_90;
}
/* try { // try from 001646da to 001646e6 has its CatchHandler @ 00164a2f */
parseExpression(SUB81((allocator *)&local_88,0));
if (local_88 == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001648ff to 0016490d has its CatchHandler @ 00164a0d */
std::runtime_error::runtime_error(prVar4,"Expected expression in call args");
goto LAB_0016495a;
}
lVar2 = __dynamic_cast(local_88,&Expression::typeinfo,&VariableExpr::typeinfo,0);
if (lVar2 == 0) {
local_78 = local_68;
local_70 = 0;
local_68[0] = 0;
/* try { // try from 001647ba to 001647c9 has its CatchHandler @ 001649e1 */
std::
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
::emplace_back<std::__cxx11::string,std::shared_ptr<minja::Expression>>
(local_90,(string *)&local_78,(allocator *)&local_88);
LAB_001647f6:
std::__cxx11::string::~string((string *)&local_78);
}
else {
/* try { // try from 00164713 to 00164729 has its CatchHandler @ 00164a29 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_58,"=",&local_91);
/* try { // try from 0016472a to 00164739 has its CatchHandler @ 00164a2b */
consumeToken((string *)&local_78);
lVar1 = local_70;
std::__cxx11::string::~string((string *)&local_78);
std::__cxx11::string::~string((string *)&local_58);
if (lVar1 == 0) {
/* try { // try from 001647d0 to 001647da has its CatchHandler @ 001649dd */
std::__cxx11::string::string((string *)&local_78,(string *)(lVar2 + 0x20));
local_58 = 0;
/* try { // try from 001647e1 to 001647f0 has its CatchHandler @ 001649db */
std::
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
::emplace_back<std::__cxx11::string,decltype(nullptr)>
(local_90,(string *)&local_78,(_func_decltype_nullptr **)&local_58);
goto LAB_001647f6;
}
/* try { // try from 00164754 to 00164760 has its CatchHandler @ 001649ed */
parseExpression(SUB81((string *)&local_58,0));
if (local_58 == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016491b to 00164929 has its CatchHandler @ 001649ce */
std::runtime_error::runtime_error(prVar4,"Expected expression in for named arg");
/* try { // try from 0016492a to 0016493f has its CatchHandler @ 001649cc */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00201fe8,PTR__runtime_error_00201f48);
}
/* try { // try from 00164776 to 00164780 has its CatchHandler @ 001649fe */
std::__cxx11::string::string((string *)&local_78,(string *)(lVar2 + 0x20));
/* try { // try from 00164781 to 00164790 has its CatchHandler @ 001649ef */
std::
vector<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::__cxx11::string,std::shared_ptr<minja::Expression>>>>
::emplace_back<std::__cxx11::string,std::shared_ptr<minja::Expression>>
(local_90,(string *)&local_78,(string *)&local_58);
std::__cxx11::string::~string((string *)&local_78);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_50);
}
/* try { // try from 001647fe to 00164811 has its CatchHandler @ 00164a40 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_58,",",&local_91);
/* try { // try from 00164812 to 00164821 has its CatchHandler @ 00164a31 */
consumeToken((string *)&local_78);
lVar2 = local_70;
std::__cxx11::string::~string((string *)&local_78);
std::__cxx11::string::~string((string *)&local_58);
if (lVar2 == 0) {
/* try { // try from 0016483c to 0016484f has its CatchHandler @ 001649df */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_58,")",&local_91);
/* try { // try from 00164850 to 0016485f has its CatchHandler @ 001649eb */
consumeToken((string *)&local_78);
lVar1 = local_70;
std::__cxx11::string::~string((string *)&local_78);
uVar3 = std::__cxx11::string::~string((string *)&local_58);
local_38 = CONCAT71((int7)((ulong)uVar3 >> 8),1);
if (lVar1 == 0) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016494b to 00164959 has its CatchHandler @ 001649ca */
std::runtime_error::runtime_error(prVar4,"Expected closing parenthesis in call args");
LAB_0016495a:
/* try { // try from 0016495a to 0016496f has its CatchHandler @ 00164a2d */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00201fe8,PTR__runtime_error_00201f48);
}
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_80);
if (lVar2 == 0) {
if ((local_38 & 1) == 0) {
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(local_90);
}
return local_90;
}
} while( true );
}
| |
52,380 | uf_prespace | eloqsql/storage/myisam/mi_packrec.c | static void uf_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
} | O3 | c | uf_prespace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %ecx
movl 0x1c(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x370e8
subl %ecx, %r13d
leaq 0x6413e(%rip), %rax # 0x9b1f0
movq %rbx, -0x30(%rbp)
movl (%rax,%rcx,4), %ebx
andl (%r14), %ebx
movl %r13d, %ecx
shll %cl, %ebx
movq %r14, %rdi
callq 0x35d09
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %ebx, %eax
movq -0x30(%rbp), %rbx
jmp 0x37102
movl (%r14), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r14)
shrl %cl, %eax
movl 0x1c(%r15), %ecx
leaq 0x640f1(%rip), %rdx # 0x9b1f0
andl (%rdx,%rcx,4), %eax
movl %eax, %edx
leaq (%r12,%rdx), %r13
cmpq %rbx, %r13
jbe 0x37117
movl $0x1, 0x28(%r14)
jmp 0x37148
movq %r12, %rdi
movl $0x20, %esi
callq 0x281d0
cmpq %rbx, %r13
je 0x37148
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x365fa
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| uf_prespace:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
mov ecx, [rsi+4]
mov r13d, [rdi+1Ch]
cmp ecx, r13d
jnb short loc_370E8
sub r13d, ecx
lea rax, mask
mov [rbp+var_30], rbx
mov ebx, [rax+rcx*4]
and ebx, [r14]
mov ecx, r13d
shl ebx, cl
mov rdi, r14
call fill_buffer
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, ebx
mov rbx, [rbp+var_30]
jmp short loc_37102
loc_370E8:
mov eax, [r14]
sub ecx, r13d
mov [r14+4], ecx
shr eax, cl
mov ecx, [r15+1Ch]
lea rdx, mask
and eax, [rdx+rcx*4]
loc_37102:
mov edx, eax
lea r13, [r12+rdx]
cmp r13, rbx
jbe short loc_37117
mov dword ptr [r14+28h], 1
jmp short loc_37148
loc_37117:
mov rdi, r12
mov esi, 20h ; ' '
call _memset
cmp r13, rbx
jz short loc_37148
mov rdi, r15
mov rsi, r14
mov rdx, r13
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes
loc_37148:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long uf_prespace(long long a1, unsigned int *a2, long long a3, _BYTE *a4)
{
long long v6; // rcx
unsigned int v7; // r13d
int v8; // r13d
int v9; // ebx
long long result; // rax
unsigned int v11; // eax
unsigned int v12; // ecx
_BYTE *v13; // r13
_BYTE *v14; // [rsp+0h] [rbp-30h]
v6 = a2[1];
v7 = *(_DWORD *)(a1 + 28);
if ( (unsigned int)v6 >= v7 )
{
v11 = *a2;
v12 = v6 - v7;
a2[1] = v12;
result = mask[*(unsigned int *)(a1 + 28)] & (v11 >> v12);
}
else
{
v8 = v7 - v6;
v14 = a4;
v9 = (*a2 & mask[v6]) << v8;
fill_buffer((long long)a2);
a2[1] = 32 - v8;
result = v9 + (*a2 >> -(char)v8);
a4 = v14;
}
v13 = (_BYTE *)(a3 + (unsigned int)result);
if ( v13 <= a4 )
{
result = memset(a3, 32LL, (unsigned int)result);
if ( v13 != a4 )
return (long long)decode_bytes(a1, (long long)a2, v13, a4);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_prespace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x1c]
CMP ECX,R13D
JNC 0x001370e8
SUB R13D,ECX
LEA RAX,[0x19b1f0]
MOV qword ptr [RBP + -0x30],RBX
MOV EBX,dword ptr [RAX + RCX*0x4]
AND EBX,dword ptr [R14]
MOV ECX,R13D
SHL EBX,CL
MOV RDI,R14
CALL 0x00135d09
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,EBX
MOV RBX,qword ptr [RBP + -0x30]
JMP 0x00137102
LAB_001370e8:
MOV EAX,dword ptr [R14]
SUB ECX,R13D
MOV dword ptr [R14 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [R15 + 0x1c]
LEA RDX,[0x19b1f0]
AND EAX,dword ptr [RDX + RCX*0x4]
LAB_00137102:
MOV EDX,EAX
LEA R13,[R12 + RDX*0x1]
CMP R13,RBX
JBE 0x00137117
MOV dword ptr [R14 + 0x28],0x1
JMP 0x00137148
LAB_00137117:
MOV RDI,R12
MOV ESI,0x20
CALL 0x001281d0
CMP R13,RBX
JZ 0x00137148
MOV RDI,R15
MOV RSI,R14
MOV RDX,R13
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001365fa
LAB_00137148:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_prespace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
ulong uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
byte bVar6;
uVar5 = param_2[1];
uVar2 = *(uint *)(param_1 + 0x1c);
if (uVar5 < uVar2) {
uVar3 = (&mask)[uVar5];
uVar4 = *param_2;
bVar6 = (byte)(uVar2 - uVar5);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar2 - uVar5);
uVar5 = (*param_2 >> (-bVar6 & 0x1f)) + ((uVar3 & uVar4) << (bVar6 & 0x1f));
}
else {
param_2[1] = uVar5 - uVar2;
uVar5 = *param_2 >> ((byte)(uVar5 - uVar2) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
uVar1 = (long)param_3 + (ulong)uVar5;
if (param_4 < uVar1) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar5);
if (uVar1 != param_4) {
decode_bytes(param_1,param_2,uVar1,param_4);
return;
}
}
return;
}
| |
52,381 | ma_log_new | eloqsql/storage/maria/ma_write.c | my_bool _ma_log_new(MARIA_PAGE *ma_page, my_bool root_page)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2 + KEY_NR_STORE_SIZE
+1];
uint page_length;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
MARIA_HA *info= ma_page->info;
MARIA_SHARE *share= info->s;
my_off_t page= ma_page->pos / share->block_size;
DBUG_ENTER("_ma_log_new");
DBUG_PRINT("enter", ("page: %lu", (ulong) page));
DBUG_ASSERT(share->now_transactional);
/* Store address of new root page */
page_store(log_data + FILEID_STORE_SIZE, page);
/* Store link to next unused page */
if (info->key_del_used == 2)
page= 0; /* key_del not changed */
else
page= ((share->key_del_current == HA_OFFSET_ERROR) ? IMPOSSIBLE_PAGE_NO :
share->key_del_current / share->block_size);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
key_nr_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE*2,
ma_page->keyinfo->key_nr);
log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE*2 + KEY_NR_STORE_SIZE]=
(uchar) root_page;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
page_length= ma_page->size - LSN_STORE_SIZE;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= ma_page->buff + LSN_STORE_SIZE;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= page_length;
/* Remember new page length for future log entires for same page */
ma_page->org_size= ma_page->size;
if (translog_write_record(&lsn, LOGREC_REDO_INDEX_NEW_PAGE,
info->trn, info,
(translog_size_t)
(sizeof(log_data) + page_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
} | O3 | c | ma_log_new:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq (%rcx), %r10
movl 0x7bc(%r10), %r9d
xorl %r8d, %r8d
xorl %edx, %edx
divq %r9
movl %eax, -0x14(%rbp)
shrq $0x20, %rax
movb %al, -0x10(%rbp)
cmpb $0x2, 0x67e(%rcx)
je 0x565b6
movq 0x700(%r10), %rax
cmpq $-0x1, %rax
je 0x565ac
xorl %edx, %edx
divq %r9
movq %rax, %r8
jmp 0x565b6
movabsq $0xffffffffff, %r8 # imm = 0xFFFFFFFFFF
leaq -0x16(%rbp), %rax
movl %r8d, 0x7(%rax)
shrq $0x20, %r8
movb %r8b, 0xb(%rax)
movq 0x8(%rdi), %rdx
movb 0xa5(%rdx), %dl
movb %dl, 0xc(%rax)
movb %sil, 0xd(%rax)
leaq -0x60(%rbp), %r10
movq %rax, 0x20(%r10)
movq $0xe, 0x28(%r10)
movl 0x20(%rdi), %r8d
leal -0x7(%r8), %edx
movq 0x10(%rdi), %rsi
addq $0x7, %rsi
movq %rsi, 0x30(%r10)
movq %rdx, 0x38(%r10)
movl %r8d, 0x24(%rdi)
movq 0x8(%rcx), %rdx
addl $0x7, %r8d
subq $0x8, %rsp
leaq -0x20(%rbp), %rdi
movl $0xd, %esi
movl $0x4, %r9d
pushq $0x0
pushq %rax
pushq %r10
callq 0x29c44
addq $0x20, %rsp
testb %al, %al
setne %al
movq %fs:0x28, %rcx
cmpq -0x8(%rbp), %rcx
jne 0x56646
addq $0x60, %rsp
popq %rbp
retq
callq 0x29250
| _ma_log_new:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
mov rcx, [rdi]
mov rax, [rdi+18h]
mov r10, [rcx]
mov r9d, [r10+7BCh]
xor r8d, r8d
xor edx, edx
div r9
mov [rbp+var_14], eax
shr rax, 20h
mov [rbp+var_10], al
cmp byte ptr [rcx+67Eh], 2
jz short loc_565B6
mov rax, [r10+700h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_565AC
xor edx, edx
div r9
mov r8, rax
jmp short loc_565B6
loc_565AC:
mov r8, 0FFFFFFFFFFh
loc_565B6:
lea rax, [rbp+var_16]
mov [rax+7], r8d
shr r8, 20h
mov [rax+0Bh], r8b
mov rdx, [rdi+8]
mov dl, [rdx+0A5h]
mov [rax+0Ch], dl
mov [rax+0Dh], sil
lea r10, [rbp+var_60]
mov [r10+20h], rax
mov qword ptr [r10+28h], 0Eh
mov r8d, [rdi+20h]
lea edx, [r8-7]
mov rsi, [rdi+10h]
add rsi, 7
mov [r10+30h], rsi
mov [r10+38h], rdx
mov [rdi+24h], r8d
mov rdx, [rcx+8]
add r8d, 7
sub rsp, 8
lea rdi, [rbp+var_20]
mov esi, 0Dh
mov r9d, 4
push 0
push rax
push r10
call translog_write_record
add rsp, 20h
test al, al
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_8]
jnz short loc_56646
add rsp, 60h
pop rbp
retn
loc_56646:
call ___stack_chk_fail
| bool ma_log_new(long long **a1, char a2)
{
long long *v2; // rcx
long long v3; // r10
unsigned long long v4; // r9
long long v5; // r8
unsigned long long v6; // rax
int v7; // r8d
__int128 v9; // [rsp+0h] [rbp-60h] BYREF
__int16 *v10; // [rsp+20h] [rbp-40h]
long long v11; // [rsp+28h] [rbp-38h]
long long v12; // [rsp+30h] [rbp-30h]
long long v13; // [rsp+38h] [rbp-28h]
_BYTE v14[10]; // [rsp+40h] [rbp-20h] BYREF
__int16 v15; // [rsp+4Ah] [rbp-16h] BYREF
int v16; // [rsp+4Ch] [rbp-14h]
char v17; // [rsp+50h] [rbp-10h]
int v18; // [rsp+51h] [rbp-Fh]
char v19; // [rsp+55h] [rbp-Bh]
char v20; // [rsp+56h] [rbp-Ah]
char v21; // [rsp+57h] [rbp-9h]
unsigned long long v22; // [rsp+58h] [rbp-8h]
v22 = __readfsqword(0x28u);
v2 = *a1;
v3 = **a1;
v4 = *(unsigned int *)(v3 + 1980);
v5 = 0LL;
v6 = (unsigned long long)a1[3] / v4;
v16 = v6;
v17 = BYTE4(v6);
if ( *((_BYTE *)v2 + 1662) != 2 )
{
if ( *(_QWORD *)(v3 + 1792) == -1LL )
v5 = 0xFFFFFFFFFFLL;
else
v5 = *(_QWORD *)(v3 + 1792) / v4;
}
v18 = v5;
v19 = BYTE4(v5);
v20 = *((_BYTE *)a1[1] + 165);
v21 = a2;
v10 = &v15;
v11 = 14LL;
v7 = *((_DWORD *)a1 + 8);
v12 = (long long)a1[2] + 7;
v13 = (unsigned int)(v7 - 7);
*((_DWORD *)a1 + 9) = v7;
return (unsigned __int8)translog_write_record((unsigned long long)v14, &byte_9[4], v2[1], v2, v7 + 7, 4, &v9, &v15, 0LL) != 0;
}
| _ma_log_new:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x18]
MOV R10,qword ptr [RCX]
MOV R9D,dword ptr [R10 + 0x7bc]
XOR R8D,R8D
XOR EDX,EDX
DIV R9
MOV dword ptr [RBP + -0x14],EAX
SHR RAX,0x20
MOV byte ptr [RBP + -0x10],AL
CMP byte ptr [RCX + 0x67e],0x2
JZ 0x001565b6
MOV RAX,qword ptr [R10 + 0x700]
CMP RAX,-0x1
JZ 0x001565ac
XOR EDX,EDX
DIV R9
MOV R8,RAX
JMP 0x001565b6
LAB_001565ac:
MOV R8,0xffffffffff
LAB_001565b6:
LEA RAX,[RBP + -0x16]
MOV dword ptr [RAX + 0x7],R8D
SHR R8,0x20
MOV byte ptr [RAX + 0xb],R8B
MOV RDX,qword ptr [RDI + 0x8]
MOV DL,byte ptr [RDX + 0xa5]
MOV byte ptr [RAX + 0xc],DL
MOV byte ptr [RAX + 0xd],SIL
LEA R10,[RBP + -0x60]
MOV qword ptr [R10 + 0x20],RAX
MOV qword ptr [R10 + 0x28],0xe
MOV R8D,dword ptr [RDI + 0x20]
LEA EDX,[R8 + -0x7]
MOV RSI,qword ptr [RDI + 0x10]
ADD RSI,0x7
MOV qword ptr [R10 + 0x30],RSI
MOV qword ptr [R10 + 0x38],RDX
MOV dword ptr [RDI + 0x24],R8D
MOV RDX,qword ptr [RCX + 0x8]
ADD R8D,0x7
SUB RSP,0x8
LEA RDI,[RBP + -0x20]
MOV ESI,0xd
MOV R9D,0x4
PUSH 0x0
PUSH RAX
PUSH R10
CALL 0x00129c44
ADD RSP,0x20
TEST AL,AL
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x8]
JNZ 0x00156646
ADD RSP,0x60
POP RBP
RET
LAB_00156646:
CALL 0x00129250
|
bool _ma_log_new(long *param_1,int1 param_2)
{
int iVar1;
long *plVar2;
int1 auVar3 [16];
int1 auVar4 [16];
char cVar5;
ulong uVar6;
ulong uVar7;
long in_FS_OFFSET;
int1 local_68 [32];
int1 *local_48;
int8 local_40;
long local_38;
ulong local_30;
int1 local_28 [10];
int1 local_1e [2];
int4 local_1c;
int1 local_18;
int4 local_17;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
plVar2 = (long *)*param_1;
uVar7 = CONCAT44(0,*(uint *)(*plVar2 + 0x7bc));
uVar6 = 0;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar7;
auVar4._8_8_ = 0;
auVar4._0_8_ = param_1[3];
local_1c = SUB164(auVar4 / auVar3,0);
local_18 = SUB161(auVar4 / auVar3,4);
if (*(char *)((long)plVar2 + 0x67e) != '\x02') {
uVar6 = *(ulong *)(*plVar2 + 0x700);
if (uVar6 == 0xffffffffffffffff) {
uVar6 = 0xffffffffff;
}
else {
uVar6 = uVar6 / uVar7;
}
}
local_48 = local_1e;
local_17 = (int4)uVar6;
local_13 = (int1)(uVar6 >> 0x20);
local_12 = *(int1 *)(param_1[1] + 0xa5);
local_40 = 0xe;
iVar1 = (int)param_1[4];
local_30 = (ulong)(iVar1 - 7);
local_38 = param_1[2] + 7;
*(int *)((long)param_1 + 0x24) = iVar1;
local_11 = param_2;
cVar5 = translog_write_record(local_28,0xd,plVar2[1],plVar2,iVar1 + 7,4,local_68,local_48,0);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return cVar5 != '\0';
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
52,382 | my_fread | eloqsql/mysys/my_fstream.c | size_t my_fread(FILE *stream, uchar *Buffer, size_t Count, myf MyFlags)
{
size_t readbytes;
DBUG_ENTER("my_fread");
DBUG_PRINT("my",("stream: %p Buffer %p Count: %u MyFlags: %lu",
stream, Buffer, (uint) Count, MyFlags));
if ((readbytes= fread(Buffer, sizeof(char), Count, stream)) != Count)
{
DBUG_PRINT("error",("Read only %d bytes", (int) readbytes));
if (MyFlags & (MY_WME | MY_FAE | MY_FNABP))
{
if (ferror(stream))
my_error(EE_READ, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno);
else
if (MyFlags & (MY_NABP | MY_FNABP))
my_error(EE_EOFERR, MYF(ME_BELL),
my_filename(my_fileno(stream)),errno);
}
my_errno=errno ? errno : -1;
if (ferror(stream) || MyFlags & (MY_NABP | MY_FNABP))
DBUG_RETURN((size_t) -1); /* Return with error */
}
if (MyFlags & (MY_NABP | MY_FNABP))
DBUG_RETURN(0); /* Read ok */
DBUG_RETURN(readbytes);
} | O0 | c | my_fread:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x9060a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x285c0
movq %rax, -0x30(%rbp)
cmpq -0x20(%rbp), %rax
je 0x90720
jmp 0x90630
jmp 0x90632
movq -0x28(%rbp), %rax
andq $0x1a, %rax
cmpq $0x0, %rax
je 0x906c6
movq -0x10(%rbp), %rdi
callq 0x28730
cmpl $0x0, %eax
je 0x90684
movq -0x10(%rbp), %rdi
callq 0x90750
movl %eax, %edi
callq 0x8ffa0
movq %rax, -0x38(%rbp)
callq 0x28040
movq -0x38(%rbp), %rdx
movl (%rax), %ecx
movl $0x2, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x7a620
jmp 0x906c4
movq -0x28(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0x906c2
movq -0x10(%rbp), %rdi
callq 0x90750
movl %eax, %edi
callq 0x8ffa0
movq %rax, -0x40(%rbp)
callq 0x28040
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
movl $0x9, %edi
movl $0x4, %esi
movb $0x0, %al
callq 0x7a620
jmp 0x906c4
jmp 0x906c6
callq 0x28040
cmpl $0x0, (%rax)
je 0x906dc
callq 0x28040
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x906e6
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %eax, -0x44(%rbp)
jmp 0x906e6
movl -0x44(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0x841b0
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x28730
cmpl $0x0, %eax
jne 0x90712
movq -0x28(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0x9071e
jmp 0x90714
movq $-0x1, -0x8(%rbp)
jmp 0x90744
jmp 0x90720
movq -0x28(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0x9073a
jmp 0x90730
movq $0x0, -0x8(%rbp)
jmp 0x90744
jmp 0x9073c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
| my_fread:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
jmp short $+2
loc_9060A:
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_10]
mov esi, 1
call _fread
mov [rbp+var_30], rax
cmp rax, [rbp+var_20]
jz loc_90720
jmp short $+2
loc_90630:
jmp short $+2
loc_90632:
mov rax, [rbp+var_28]
and rax, 1Ah
cmp rax, 0
jz loc_906C6
mov rdi, [rbp+var_10]
call _ferror
cmp eax, 0
jz short loc_90684
mov rdi, [rbp+var_10]
call my_fileno
mov edi, eax
call my_filename
mov [rbp+var_38], rax
call ___errno_location
mov rdx, [rbp+var_38]
mov ecx, [rax]
mov edi, 2
mov esi, 4
mov al, 0
call my_error
jmp short loc_906C4
loc_90684:
mov rax, [rbp+var_28]
and rax, 6
cmp rax, 0
jz short loc_906C2
mov rdi, [rbp+var_10]
call my_fileno
mov edi, eax
call my_filename
mov [rbp+var_40], rax
call ___errno_location
mov rdx, [rbp+var_40]
mov ecx, [rax]
mov edi, 9
mov esi, 4
mov al, 0
call my_error
loc_906C2:
jmp short $+2
loc_906C4:
jmp short $+2
loc_906C6:
call ___errno_location
cmp dword ptr [rax], 0
jz short loc_906DC
call ___errno_location
mov eax, [rax]
mov [rbp+var_44], eax
jmp short loc_906E6
loc_906DC:
mov eax, 0FFFFFFFFh
mov [rbp+var_44], eax
jmp short $+2
loc_906E6:
mov eax, [rbp+var_44]
mov [rbp+var_48], eax
call _my_thread_var
mov ecx, [rbp+var_48]
mov [rax], ecx
mov rdi, [rbp+var_10]
call _ferror
cmp eax, 0
jnz short loc_90712
mov rax, [rbp+var_28]
and rax, 6
cmp rax, 0
jz short loc_9071E
loc_90712:
jmp short $+2
loc_90714:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_90744
loc_9071E:
jmp short $+2
loc_90720:
mov rax, [rbp+var_28]
and rax, 6
cmp rax, 0
jz short loc_9073A
jmp short $+2
loc_90730:
mov [rbp+var_8], 0
jmp short loc_90744
loc_9073A:
jmp short $+2
loc_9073C:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_90744:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long my_fread(long long a1, long long a2, long long a3, char a4)
{
int v4; // eax
unsigned int *v5; // rax
int v6; // eax
unsigned int *v7; // rax
int v9; // [rsp+Ch] [rbp-44h]
const char *v10; // [rsp+10h] [rbp-40h]
const char *v11; // [rsp+18h] [rbp-38h]
long long v12; // [rsp+20h] [rbp-30h]
v12 = fread(a2, 1LL, a3, a1);
if ( v12 == a3 )
goto LABEL_13;
if ( (a4 & 0x1A) != 0 )
{
if ( (unsigned int)ferror(a1) )
{
v4 = my_fileno(a1);
v11 = my_filename(v4);
v5 = (unsigned int *)__errno_location();
my_error(2u, 4LL, v11, *v5);
}
else if ( (a4 & 6) != 0 )
{
v6 = my_fileno(a1);
v10 = my_filename(v6);
v7 = (unsigned int *)__errno_location();
my_error(9u, 4LL, v10, *v7);
}
}
v9 = *(_DWORD *)__errno_location() ? *(_DWORD *)__errno_location() : -1;
*(_DWORD *)my_thread_var() = v9;
if ( (unsigned int)ferror(a1) || (a4 & 6) != 0 )
return -1LL;
LABEL_13:
if ( (a4 & 6) != 0 )
return 0LL;
return v12;
}
| my_fread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
JMP 0x0019060a
LAB_0019060a:
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x001285c0
MOV qword ptr [RBP + -0x30],RAX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x00190720
JMP 0x00190630
LAB_00190630:
JMP 0x00190632
LAB_00190632:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x1a
CMP RAX,0x0
JZ 0x001906c6
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00128730
CMP EAX,0x0
JZ 0x00190684
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00190750
MOV EDI,EAX
CALL 0x0018ffa0
MOV qword ptr [RBP + -0x38],RAX
CALL 0x00128040
MOV RDX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX]
MOV EDI,0x2
MOV ESI,0x4
MOV AL,0x0
CALL 0x0017a620
JMP 0x001906c4
LAB_00190684:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001906c2
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00190750
MOV EDI,EAX
CALL 0x0018ffa0
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00128040
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX]
MOV EDI,0x9
MOV ESI,0x4
MOV AL,0x0
CALL 0x0017a620
LAB_001906c2:
JMP 0x001906c4
LAB_001906c4:
JMP 0x001906c6
LAB_001906c6:
CALL 0x00128040
CMP dword ptr [RAX],0x0
JZ 0x001906dc
CALL 0x00128040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001906e6
LAB_001906dc:
MOV EAX,0xffffffff
MOV dword ptr [RBP + -0x44],EAX
JMP 0x001906e6
LAB_001906e6:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x48],EAX
CALL 0x001841b0
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00128730
CMP EAX,0x0
JNZ 0x00190712
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x6
CMP RAX,0x0
JZ 0x0019071e
LAB_00190712:
JMP 0x00190714
LAB_00190714:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00190744
LAB_0019071e:
JMP 0x00190720
LAB_00190720:
MOV RAX,qword ptr [RBP + -0x28]
AND RAX,0x6
CMP RAX,0x0
JZ 0x0019073a
JMP 0x00190730
LAB_00190730:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00190744
LAB_0019073a:
JMP 0x0019073c
LAB_0019073c:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_00190744:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
size_t my_fread(FILE *param_1,void *param_2,size_t param_3,ulong param_4)
{
int iVar1;
int4 uVar2;
int8 uVar3;
int *piVar4;
int local_4c;
size_t local_10;
local_10 = fread(param_2,1,param_3,param_1);
if (local_10 != param_3) {
if ((param_4 & 0x1a) != 0) {
iVar1 = ferror(param_1);
if (iVar1 == 0) {
if ((param_4 & 6) != 0) {
uVar2 = my_fileno(param_1);
uVar3 = my_filename(uVar2);
piVar4 = __errno_location();
my_error(9,4,uVar3,*piVar4);
}
}
else {
uVar2 = my_fileno(param_1);
uVar3 = my_filename(uVar2);
piVar4 = __errno_location();
my_error(2,4,uVar3,*piVar4);
}
}
piVar4 = __errno_location();
if (*piVar4 == 0) {
local_4c = -1;
}
else {
piVar4 = __errno_location();
local_4c = *piVar4;
}
piVar4 = (int *)_my_thread_var();
*piVar4 = local_4c;
iVar1 = ferror(param_1);
if ((iVar1 != 0) || ((param_4 & 6) != 0)) {
return 0xffffffffffffffff;
}
}
if ((param_4 & 6) != 0) {
local_10 = 0;
}
return local_10;
}
| |
52,383 | mi_ft_del | eloqsql/storage/myisam/ft_update.c | int _mi_ft_del(MI_INFO *info, uint keynr, uchar *keybuf, const uchar *record,
my_off_t pos)
{
int error= -1;
FT_WORD *wlist;
DBUG_ENTER("_mi_ft_del");
DBUG_PRINT("enter",("keynr: %d",keynr));
if ((wlist=_mi_ft_parserecord(info, keynr, record, &info->ft_memroot)))
error=_mi_ft_erase(info,keynr,keybuf,wlist,pos);
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_PRINT("exit",("Return: %d",error));
DBUG_RETURN(error);
} | O3 | c | mi_ft_del:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r13
leaq 0x90(%rdi), %rbx
movq %rcx, %rdx
movq %rbx, %rcx
callq 0x754f7
testq %rax, %rax
je 0x75a96
movq %r13, %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
callq 0x758e4
movl %eax, %r14d
jmp 0x75a9c
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
movl $0x2, %esi
movq %rbx, %rdi
callq 0x9e1a3
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _mi_ft_del:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15, rdx
mov r12d, esi
mov r13, rdi
lea rbx, [rdi+90h]
mov rdx, rcx
mov rcx, rbx
call _mi_ft_parserecord
test rax, rax
jz short loc_75A96
mov rdi, r13
mov esi, r12d
mov rdx, r15
mov rcx, rax
mov r8, r14
call _mi_ft_erase
mov r14d, eax
jmp short loc_75A9C
loc_75A96:
mov r14d, 0FFFFFFFFh
loc_75A9C:
mov esi, 2
mov rdi, rbx
call free_root
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mi_ft_del(_QWORD *a1, unsigned int a2, long long a3, long long a4, long long a5, __m128i a6)
{
_QWORD *v8; // rax
unsigned int v9; // r14d
v8 = mi_ft_parserecord(a1, a2, a4, (long long)(a1 + 18));
if ( v8 )
v9 = mi_ft_erase((long long)a1, a2, a3, v8, a5, a6);
else
v9 = -1;
free_root(a1 + 18, 2LL);
return v9;
}
| _mi_ft_del:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15,RDX
MOV R12D,ESI
MOV R13,RDI
LEA RBX,[RDI + 0x90]
MOV RDX,RCX
MOV RCX,RBX
CALL 0x001754f7
TEST RAX,RAX
JZ 0x00175a96
MOV RDI,R13
MOV ESI,R12D
MOV RDX,R15
MOV RCX,RAX
MOV R8,R14
CALL 0x001758e4
MOV R14D,EAX
JMP 0x00175a9c
LAB_00175a96:
MOV R14D,0xffffffff
LAB_00175a9c:
MOV ESI,0x2
MOV RDI,RBX
CALL 0x0019e1a3
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
_mi_ft_del(long param_1,ulong param_2,int8 param_3,int8 param_4,int8 param_5)
{
int4 uVar1;
long lVar2;
lVar2 = _mi_ft_parserecord(param_1,param_2,param_4,param_1 + 0x90);
if (lVar2 == 0) {
uVar1 = 0xffffffff;
}
else {
uVar1 = _mi_ft_erase(param_1,param_2 & 0xffffffff,param_3,lVar2,param_5);
}
free_root(param_1 + 0x90,2);
return uVar1;
}
| |
52,384 | inline_mysql_file_write | eloqsql/include/mysql/psi/mysql_file.h | static inline size_t
inline_mysql_file_write(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_write(file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_write(file, buffer, count, flags);
return result;
} | O0 | c | inline_mysql_file_write:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x2251c0(%rip), %rax # 0x2c8038
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x7, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%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 0xa2f87
leaq 0x225176(%rip), %rax # 0x2c8038
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xfe9d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xa2f32
cmpq $0x0, -0x38(%rbp)
jne 0xa2f17
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xa2f22
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xa2f22
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xa2f5f
cmpq $-0x1, -0x38(%rbp)
je 0xa2f46
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xa2f51
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xa2f51
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x2250d2(%rip), %rax # 0x2c8038
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa2fa7
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xfe9d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_write_0:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 7
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 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 loc_A2F87
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call my_write
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_A2F32
cmp [rbp+var_38], 0
jnz short loc_A2F17
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_A2F22
loc_A2F17:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_A2F22:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_A2F5F
loc_A2F32:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_A2F46
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_A2F51
loc_A2F46:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_A2F51:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_A2F5F:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_A2FA7
loc_A2F87:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call my_write
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_A2FA7:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
| long long inline_mysql_file_write_0(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
long long v7; // [rsp+0h] [rbp-A0h]
long long v8; // [rsp+8h] [rbp-98h]
_BYTE v9[72]; // [rsp+18h] [rbp-88h] BYREF
long long v10; // [rsp+60h] [rbp-40h]
long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+70h] [rbp-30h]
long long v13; // [rsp+78h] [rbp-28h]
long long v14; // [rsp+80h] [rbp-20h]
unsigned int v15; // [rsp+88h] [rbp-18h]
unsigned int v16; // [rsp+8Ch] [rbp-14h]
long long v17; // [rsp+90h] [rbp-10h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = a5;
v12 = a6;
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, a3, 7LL);
if ( v10 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v10, v13, v17, v16);
v11 = my_write(v15, v14, v13, v12);
if ( (v12 & 6) != 0 )
{
if ( v11 )
v8 = 0LL;
else
v8 = v13;
((void ( *)(long long, long long))PSI_server[67])(v10, v8);
}
else
{
if ( v11 == -1 )
v7 = 0LL;
else
v7 = v11;
((void ( *)(long long, long long))PSI_server[67])(v10, v7);
}
return v11;
}
else
{
return my_write(v15, v14, v13, v12);
}
}
| inline_mysql_file_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x3c8038]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],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 0x001a2f87
LEA RAX,[0x3c8038]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fe9d0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001a2f32
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001a2f17
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001a2f22
LAB_001a2f17:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001a2f22
LAB_001a2f22:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001a2f5f
LAB_001a2f32:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001a2f46
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001a2f51
LAB_001a2f46:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001a2f51
LAB_001a2f51:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001a2f5f:
LEA RAX,[0x3c8038]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001a2fa7
LAB_001a2f87:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fe9d0
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001a2fa7:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_write
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,ulong param_6)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
ulong local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,7);
if (local_48 == 0) {
local_10 = my_write(local_20,local_28,local_30,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_write(local_20,local_28,local_30,local_38);
if ((local_38 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
| |
52,385 | ma_memmap_file | eloqsql/storage/maria/ma_packrec.c | my_bool _ma_memmap_file(MARIA_HA *info)
{
MARIA_SHARE *share= info->s;
DBUG_ENTER("maria_memmap_file");
if (!info->s->file_map)
{
if (mysql_file_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0)) <
share->state.state.data_file_length+MEMMAP_EXTRA_MARGIN)
{
DBUG_PRINT("warning",("File isn't extended for memmap"));
DBUG_RETURN(0);
}
if (_ma_dynmap_file(info, share->state.state.data_file_length))
DBUG_RETURN(0);
}
info->opt_flag|= MEMMAP_USED;
info->read_record= share->read_record= _ma_read_mempack_record;
share->scan= _ma_read_rnd_mempack_record;
DBUG_RETURN(1);
} | O3 | c | ma_memmap_file:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
cmpq $0x0, 0x5f0(%r12)
je 0x653ab
orb $0x20, 0x61c(%rbx)
leaq 0x9f(%rip), %rax # 0x65428
movq %rax, 0x648(%r12)
movq %rax, 0x3d8(%rbx)
leaq 0x136(%rip), %rax # 0x654d5
movq %rax, 0x658(%r12)
movb $0x1, %al
jmp 0x65404
movl 0x480(%rbx), %r14d
leaq 0x34965f(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
movl %r14d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x65411
movl %r14d, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xc056c
movq 0x40(%r12), %rsi
leaq 0x7(%rsi), %rcx
cmpq %rcx, %rax
jb 0x65402
movq %rbx, %rdi
callq 0x66fcc
testb %al, %al
je 0x6537b
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x28(%rbp), %r15
movq %rax, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x2e4bc
movq (%r15), %rax
jmp 0x653e4
| _ma_memmap_file:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 50h
mov rbx, rdi
mov r12, [rdi]
cmp qword ptr [r12+5F0h], 0
jz short loc_653AB
loc_6537B:
or byte ptr [rbx+61Ch], 20h
lea rax, _ma_read_mempack_record
mov [r12+648h], rax
mov [rbx+3D8h], rax
lea rax, _ma_read_rnd_mempack_record
mov [r12+658h], rax
mov al, 1
jmp short loc_65404
loc_653AB:
mov r14d, [rbx+480h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_70]
mov esi, r14d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz short loc_65411
mov edi, r14d
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
loc_653E4:
mov rsi, [r12+40h]
lea rcx, [rsi+7]
cmp rax, rcx
jb short loc_65402
mov rdi, rbx
call _ma_dynmap_file
test al, al
jz loc_6537B
loc_65402:
xor eax, eax
loc_65404:
add rsp, 50h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_65411:
lea r15, [rbp+var_28]
mov rdi, rax
mov esi, r14d
mov rdx, r15
call _ma_memmap_file_cold_1
mov rax, [r15]
jmp short loc_653E4
| char ma_memmap_file(long long a1)
{
_QWORD *v1; // r12
unsigned int v3; // r14d
long long v4; // rax
unsigned long long v5; // rax
long long v6; // rsi
_BYTE v7[72]; // [rsp+0h] [rbp-70h] BYREF
unsigned long long v8[5]; // [rsp+48h] [rbp-28h] BYREF
v1 = *(_QWORD **)a1;
if ( !*(_QWORD *)(*(_QWORD *)a1 + 1520LL) )
{
v3 = *(_DWORD *)(a1 + 1152);
v4 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v7, v3, 8LL);
if ( v4 )
{
ma_memmap_file_cold_1(v4, v3, v8);
v5 = v8[0];
}
else
{
v5 = my_seek(v3, 0LL, 2LL, 0LL);
}
v6 = v1[8];
if ( v5 < v6 + 7 || (unsigned __int8)ma_dynmap_file(a1, v6) )
return 0;
}
*(_BYTE *)(a1 + 1564) |= 0x20u;
v1[201] = ma_read_mempack_record;
*(_QWORD *)(a1 + 984) = ma_read_mempack_record;
v1[203] = ma_read_rnd_mempack_record;
return 1;
}
| _ma_memmap_file:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV R12,qword ptr [RDI]
CMP qword ptr [R12 + 0x5f0],0x0
JZ 0x001653ab
LAB_0016537b:
OR byte ptr [RBX + 0x61c],0x20
LEA RAX,[0x165428]
MOV qword ptr [R12 + 0x648],RAX
MOV qword ptr [RBX + 0x3d8],RAX
LEA RAX,[0x1654d5]
MOV qword ptr [R12 + 0x658],RAX
MOV AL,0x1
JMP 0x00165404
LAB_001653ab:
MOV R14D,dword ptr [RBX + 0x480]
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x70]
MOV ESI,R14D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00165411
MOV EDI,R14D
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x001c056c
LAB_001653e4:
MOV RSI,qword ptr [R12 + 0x40]
LEA RCX,[RSI + 0x7]
CMP RAX,RCX
JC 0x00165402
MOV RDI,RBX
CALL 0x00166fcc
TEST AL,AL
JZ 0x0016537b
LAB_00165402:
XOR EAX,EAX
LAB_00165404:
ADD RSP,0x50
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00165411:
LEA R15,[RBP + -0x28]
MOV RDI,RAX
MOV ESI,R14D
MOV RDX,R15
CALL 0x0012e4bc
MOV RAX,qword ptr [R15]
JMP 0x001653e4
|
int8 _ma_memmap_file(long *param_1)
{
int4 uVar1;
long lVar2;
char cVar3;
int8 uVar4;
long lVar5;
int1 local_78 [72];
ulong local_30;
lVar2 = *param_1;
if (*(long *)(lVar2 + 0x5f0) == 0) {
uVar1 = (int4)param_1[0x90];
lVar5 = (**(code **)(PSI_server + 0x158))(local_78,uVar1,8);
if (lVar5 == 0) {
local_30 = my_seek(uVar1,0,2,0);
}
else {
_ma_memmap_file_cold_1(lVar5,uVar1,&local_30);
}
if (*(long *)(lVar2 + 0x40) + 7U <= local_30) {
cVar3 = _ma_dynmap_file(param_1);
if (cVar3 == '\0') goto LAB_0016537b;
}
uVar4 = 0;
}
else {
LAB_0016537b:
*(byte *)((long)param_1 + 0x61c) = *(byte *)((long)param_1 + 0x61c) | 0x20;
*(code **)(lVar2 + 0x648) = _ma_read_mempack_record;
param_1[0x7b] = (long)_ma_read_mempack_record;
*(code **)(lVar2 + 0x658) = _ma_read_rnd_mempack_record;
uVar4 = 0x165401;
}
return uVar4;
}
| |
52,386 | write_hook_for_undo_key_insert | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_undo_key_insert(enum translog_record_type type,
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
struct st_msg_to_write_hook_for_undo_key *msg=
(struct st_msg_to_write_hook_for_undo_key *) hook_arg;
MARIA_SHARE *share= tbl_info->s;
if (msg->auto_increment > 0)
{
/*
Only reason to set it here is to have a mutex protect from checkpoint
reading at the same time (would see a corrupted value).
The purpose of the following code is to set auto_increment if the row
has a with auto_increment value higher than the current one. We also
want to be able to restore the old value, in case of rollback,
if no one else has tried to set the value.
The logic used is that we only restore the auto_increment value if
tbl_info->last_auto_increment == share->last_auto_increment
when it's time to do the rollback.
*/
DBUG_PRINT("info",("auto_inc: %lu new auto_inc: %lu",
(ulong)share->state.auto_increment,
(ulong)msg->auto_increment));
if (share->state.auto_increment < msg->auto_increment)
{
/* Remember the original value, in case of rollback */
tbl_info->last_auto_increment= share->last_auto_increment=
share->state.auto_increment;
share->state.auto_increment= msg->auto_increment;
}
else
{
/*
If the current value would have affected the original auto_increment
value, set it to an impossible value so that it's not restored on
rollback
*/
if (msg->auto_increment > share->last_auto_increment)
share->last_auto_increment= ~(ulonglong) 0;
}
}
return write_hook_for_undo_key(type, trn, tbl_info, lsn, hook_arg);
} | O0 | c | write_hook_for_undo_key_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x70660
jmp 0x705eb
jmp 0x705ed
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x70638
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x610(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x3e8(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xd8(%rax)
jmp 0x7065e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x610(%rcx), %rax
jbe 0x7065c
movq -0x38(%rbp), %rax
movq $-0x1, 0x610(%rax)
jmp 0x7065e
jmp 0x70660
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x70520
addq $0x40, %rsp
popq %rbp
retq
nop
| write_hook_for_undo_key_insert:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
cmp qword ptr [rax+18h], 0
jbe short loc_70660
jmp short $+2
loc_705EB:
jmp short $+2
loc_705ED:
mov rax, [rbp+var_38]
mov rax, [rax+0D8h]
mov rcx, [rbp+var_30]
cmp rax, [rcx+18h]
jnb short loc_70638
mov rax, [rbp+var_38]
mov rcx, [rax+0D8h]
mov rax, [rbp+var_38]
mov [rax+610h], rcx
mov rax, [rbp+var_18]
mov [rax+3E8h], rcx
mov rax, [rbp+var_30]
mov rcx, [rax+18h]
mov rax, [rbp+var_38]
mov [rax+0D8h], rcx
jmp short loc_7065E
loc_70638:
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_38]
cmp rax, [rcx+610h]
jbe short loc_7065C
mov rax, [rbp+var_38]
mov qword ptr [rax+610h], 0FFFFFFFFFFFFFFFFh
loc_7065C:
jmp short $+2
loc_7065E:
jmp short $+2
loc_70660:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call write_hook_for_undo_key
add rsp, 40h
pop rbp
retn
| long long write_hook_for_undo_key_insert(unsigned int a1, long long a2, long long *a3, long long a4, long long a5)
{
long long v5; // rcx
long long v7; // [rsp+8h] [rbp-38h]
v7 = *a3;
if ( *(_QWORD *)(a5 + 24) )
{
if ( *(_QWORD *)(v7 + 216) >= *(_QWORD *)(a5 + 24) )
{
if ( *(_QWORD *)(a5 + 24) > *(_QWORD *)(v7 + 1552) )
*(_QWORD *)(v7 + 1552) = -1LL;
}
else
{
v5 = *(_QWORD *)(v7 + 216);
*(_QWORD *)(v7 + 1552) = v5;
a3[125] = v5;
*(_QWORD *)(v7 + 216) = *(_QWORD *)(a5 + 24);
}
}
return write_hook_for_undo_key(a1, a2, (long long)a3, a4, a5);
}
| write_hook_for_undo_key_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x18],0x0
JBE 0x00170660
JMP 0x001705eb
LAB_001705eb:
JMP 0x001705ed
LAB_001705ed:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x00170638
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0xd8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x3e8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0xd8],RCX
JMP 0x0017065e
LAB_00170638:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RCX + 0x610]
JBE 0x0017065c
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],-0x1
LAB_0017065c:
JMP 0x0017065e
LAB_0017065e:
JMP 0x00170660
LAB_00170660:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x00170520
ADD RSP,0x40
POP RBP
RET
|
void write_hook_for_undo_key_insert
(int4 param_1,int8 param_2,long *param_3,int8 param_4,long param_5)
{
long lVar1;
lVar1 = *param_3;
if (*(long *)(param_5 + 0x18) != 0) {
if (*(ulong *)(lVar1 + 0xd8) < *(ulong *)(param_5 + 0x18)) {
*(long *)(lVar1 + 0x610) = *(long *)(lVar1 + 0xd8);
param_3[0x7d] = *(long *)(lVar1 + 0xd8);
*(int8 *)(lVar1 + 0xd8) = *(int8 *)(param_5 + 0x18);
}
else if (*(ulong *)(lVar1 + 0x610) < *(ulong *)(param_5 + 0x18)) {
*(int8 *)(lVar1 + 0x610) = 0xffffffffffffffff;
}
}
write_hook_for_undo_key(param_1,param_2,param_3,param_4,param_5);
return;
}
| |
52,387 | alaya::LinearPool<float, int>::find_bsearch(float) | AlayaLite/include/utils/query_utils.hpp | auto find_bsearch(DistanceType dist) -> int {
int l = 0;
int r = size_;
while (l < r) {
int mid = (l + r) / 2;
if (data_[mid].distance_ > dist) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
} | O0 | cpp | alaya::LinearPool<float, int>::find_bsearch(float):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movss %xmm0, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rax), %rax
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x1eadd
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
addl 0x14(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x10(%rsp)
addq $0x20, %rdi
movslq 0x10(%rsp), %rsi
callq 0x1ea40
movss 0x4(%rax), %xmm0
ucomiss 0x1c(%rsp), %xmm0
jbe 0x1ead0
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1eadb
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x1ea89
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN5alaya10LinearPoolIfiE12find_bsearchEf:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
movss [rsp+28h+var_C], xmm0
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov [rsp+28h+var_10], 0
mov rax, [rax+8]
mov [rsp+28h+var_14], eax
loc_1EA89:
mov eax, [rsp+28h+var_10]
cmp eax, [rsp+28h+var_14]
jge short loc_1EADD
mov rdi, [rsp+28h+var_20]
mov eax, [rsp+28h+var_10]
add eax, [rsp+28h+var_14]
mov ecx, 2
cdq
idiv ecx
mov [rsp+28h+var_18], eax
add rdi, 20h ; ' '
movsxd rsi, [rsp+28h+var_18]
call _ZNSt6vectorIN5alaya8NeighborIifEENS0_10AlignAllocIS2_EEEixEm; std::vector<alaya::Neighbor<int,float>,alaya::AlignAlloc<alaya::Neighbor<int,float>>>::operator[](ulong)
movss xmm0, dword ptr [rax+4]
ucomiss xmm0, [rsp+28h+var_C]
jbe short loc_1EAD0
mov eax, [rsp+28h+var_18]
mov [rsp+28h+var_14], eax
jmp short loc_1EADB
loc_1EAD0:
mov eax, [rsp+28h+var_18]
add eax, 1
mov [rsp+28h+var_10], eax
loc_1EADB:
jmp short loc_1EA89
loc_1EADD:
mov eax, [rsp+28h+var_10]
add rsp, 28h
retn
| long long alaya::LinearPool<float,int>::find_bsearch(long long a1, float a2)
{
int v3; // [rsp+10h] [rbp-18h]
int v4; // [rsp+14h] [rbp-14h]
int v5; // [rsp+18h] [rbp-10h]
v5 = 0;
v4 = *(_QWORD *)(a1 + 8);
while ( v5 < v4 )
{
v3 = (v4 + v5) / 2;
if ( *(float *)(std::vector<alaya::Neighbor<int,float>,alaya::AlignAlloc<alaya::Neighbor<int,float>>>::operator[](
a1 + 32,
v3)
+ 4) <= a2 )
v5 = v3 + 1;
else
v4 = (v4 + v5) / 2;
}
return (unsigned int)v5;
}
| find_bsearch:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOVSS dword ptr [RSP + 0x1c],XMM0
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x18],0x0
MOV RAX,qword ptr [RAX + 0x8]
MOV dword ptr [RSP + 0x14],EAX
LAB_0011ea89:
MOV EAX,dword ptr [RSP + 0x18]
CMP EAX,dword ptr [RSP + 0x14]
JGE 0x0011eadd
MOV RDI,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0x18]
ADD EAX,dword ptr [RSP + 0x14]
MOV ECX,0x2
CDQ
IDIV ECX
MOV dword ptr [RSP + 0x10],EAX
ADD RDI,0x20
MOVSXD RSI,dword ptr [RSP + 0x10]
CALL 0x0011ea40
MOVSS XMM0,dword ptr [RAX + 0x4]
UCOMISS XMM0,dword ptr [RSP + 0x1c]
JBE 0x0011ead0
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0011eadb
LAB_0011ead0:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x18],EAX
LAB_0011eadb:
JMP 0x0011ea89
LAB_0011eadd:
MOV EAX,dword ptr [RSP + 0x18]
ADD RSP,0x28
RET
|
/* alaya::LinearPool<float, int>::find_bsearch(float) */
int __thiscall alaya::LinearPool<float,int>::find_bsearch(LinearPool<float,int> *this,float param_1)
{
int iVar1;
long lVar2;
int local_14;
int local_10;
local_10 = 0;
iVar1 = (int)*(int8 *)(this + 8);
while (local_14 = iVar1, local_10 < local_14) {
iVar1 = (local_10 + local_14) / 2;
lVar2 = std::vector<alaya::Neighbor<int,float>,alaya::AlignAlloc<alaya::Neighbor<int,float>>>::
operator[]((vector<alaya::Neighbor<int,float>,alaya::AlignAlloc<alaya::Neighbor<int,float>>>
*)(this + 0x20),(long)iVar1);
if (*(float *)(lVar2 + 4) <= param_1) {
local_10 = iVar1 + 1;
iVar1 = local_14;
}
}
return local_10;
}
| |
52,388 | lf_pinbox_real_free | eloqsql/mysys/lf_alloc-pin.c | static void lf_pinbox_real_free(LF_PINS *pins)
{
int npins;
void *list;
void **addr= NULL;
void *first= NULL, *last= NULL;
struct st_my_thread_var *var= my_thread_var;
void *stack_ends_here= var ? var->stack_ends_here : NULL;
LF_PINBOX *pinbox= pins->pinbox;
npins= pinbox->pins_in_array+1;
#ifdef HAVE_ALLOCA
if (stack_ends_here != NULL)
{
int alloca_size= sizeof(void *)*LF_PINBOX_PINS*npins;
/* create a sorted list of pinned addresses, to speed up searches */
if (available_stack_size(&pinbox, stack_ends_here) >
alloca_size + ALLOCA_SAFETY_MARGIN)
{
struct st_harvester hv;
addr= (void **) alloca(alloca_size);
hv.granary= addr;
hv.npins= npins;
/* scan the dynarray and accumulate all pinned addresses */
lf_dynarray_iterate(&pinbox->pinarray,
(lf_dynarray_func)harvest_pins, &hv);
npins= (int)(hv.granary-addr);
/* and sort them */
if (npins)
qsort(addr, npins, sizeof(void *), (qsort_cmp)ptr_cmp);
}
}
#endif
list= pins->purgatory;
pins->purgatory= 0;
pins->purgatory_count= 0;
while (list)
{
void *cur= list;
list= *(void **)((char *)cur+pinbox->free_ptr_offset);
if (npins)
{
if (addr) /* use binary search */
{
void **a, **b, **c;
for (a= addr, b= addr+npins-1, c= a+(b-a)/2; (b-a) > 1; c= a+(b-a)/2)
if (cur == *c)
a= b= c;
else if (cur > *c)
a= c;
else
b= c;
if (cur == *a || cur == *b)
goto found;
}
else /* no alloca - no cookie. linear search here */
{
if (lf_dynarray_iterate(&pinbox->pinarray,
(lf_dynarray_func)match_pins, cur))
goto found;
}
}
/* not pinned - freeing */
if (last)
last= next_node(pinbox, last)= (uchar *)cur;
else
first= last= (uchar *)cur;
continue;
found:
/* pinned - keeping */
add_to_purgatory(pins, cur);
}
if (last)
pinbox->free_func(first, last, pinbox->free_func_arg);
} | O3 | c | lf_pinbox_real_free:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
callq 0xa16ee
testq %rax, %rax
je 0xa5206
movq 0xb8(%rax), %rax
movq 0x20(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movl 0x40(%rdi), %r8d
incl %r8d
testq %rax, %rax
je 0xa5215
movl %r8d, %ecx
shll $0x5, %ecx
leaq -0x38(%rbp), %rdx
subq %rdx, %rax
leal 0x2000(%rcx), %edx
movslq %edx, %rdx
cmpq %rdx, %rax
jle 0xa5215
movslq %ecx, %rax
movq %rsp, %r14
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
leaq -0x70(%rbp), %r12
movq %r14, (%r12)
movl %r8d, 0x8(%r12)
leaq 0x38d(%rip), %rsi # 0xa555c
movq %r12, %rdx
callq 0xa5725
movq (%r12), %r8
subq %r14, %r8
shrq $0x3, %r8
testl %r8d, %r8d
je 0xa5218
movslq %r8d, %rsi
leaq 0x3c3(%rip), %rcx # 0xa55b4
movl $0x8, %edx
movq %r14, %rdi
movq %r8, %r15
callq 0x295d0
movq %r15, %r8
jmp 0xa5218
movq 0x20(%rbx), %rax
movq %rax, -0x38(%rbp)
movl 0x40(%rax), %r8d
incl %r8d
xorl %r14d, %r14d
movq 0x28(%rbx), %r15
movq $0x0, 0x28(%rbx)
movl $0x0, 0x30(%rbx)
testq %r15, %r15
je 0xa5360
movslq %r8d, %rax
leaq (%r14,%rax,8), %r13
addq $-0x8, %r13
leaq -0x8(,%rax,8), %rcx
movq %rcx, %rax
sarq $0x3, %rax
movq %rcx, -0x60(%rbp)
shrq $0x3f, %rcx
addq %rax, %rcx
andq $-0x2, %rcx
leaq (%r14,%rcx,4), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
xorl %r10d, %r10d
movq %rbx, -0x58(%rbp)
movq %r14, -0x50(%rbp)
movq %r15, %r12
movq -0x38(%rbp), %rdi
movl 0x38(%rdi), %eax
movq (%r15,%rax), %r15
testl %r8d, %r8d
je 0xa52e5
testq %r14, %r14
je 0xa52fa
movq %r14, %rcx
movq %r13, %rax
cmpq $0x9, -0x60(%rbp)
jl 0xa52db
movq -0x48(%rbp), %rdx
movq %r13, %rax
movq %r14, %rcx
cmpq (%rdx), %r12
cmovbeq %rdx, %rax
cmovaeq %rdx, %rcx
cmoveq %rdx, %rax
movq %rax, %rsi
subq %rcx, %rsi
movq %rsi, %rdx
sarq $0x3, %rdx
movq %rsi, %rdi
shrq $0x3f, %rdi
addq %rdx, %rdi
andq $-0x2, %rdi
leaq (%rcx,%rdi,4), %rdx
cmpq $0x8, %rsi
jg 0xa52a7
cmpq (%rcx), %r12
je 0xa5321
cmpq (%rax), %r12
je 0xa5321
testq %r10, %r10
je 0xa5339
movq -0x38(%rbp), %rax
movl 0x38(%rax), %eax
movq %r12, (%r10,%rax)
movq %r12, %r10
jmp 0xa5340
leaq 0x2cc(%rip), %rsi # 0xa55cd
movq %r12, %rdx
movq %r8, %r14
movq %r10, %rbx
callq 0xa5725
movq %rbx, %r10
movq %r14, %r8
movq -0x50(%rbp), %r14
movq -0x58(%rbp), %rbx
testl %eax, %eax
je 0xa52e5
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movl 0x38(%rax), %eax
movq %rcx, (%r12,%rax)
movq %r12, 0x28(%rbx)
incl 0x30(%rbx)
jmp 0xa5340
movq %r12, %r10
movq %r12, -0x40(%rbp)
testq %r15, %r15
jne 0xa5278
testq %r10, %r10
je 0xa5360
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x40(%rbp), %rdi
movq %r10, %rsi
callq *0x28(%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xa537e
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| lf_pinbox_real_free:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
call _my_thread_var
test rax, rax
jz loc_A5206
mov rax, [rax+0B8h]
mov rdi, [rbx+20h]
mov [rbp+var_38], rdi
mov r8d, [rdi+40h]
inc r8d
test rax, rax
jz loc_A5215
mov ecx, r8d
shl ecx, 5
lea rdx, [rbp+var_38]
sub rax, rdx
lea edx, [rcx+2000h]
movsxd rdx, edx
cmp rax, rdx
jle short loc_A5215
movsxd rax, ecx
mov r14, rsp
add rax, 0Fh
and rax, 0FFFFFFFFFFFFFFF0h
sub r14, rax
mov rsp, r14
lea r12, [rbp+var_70]
mov [r12], r14
mov [r12+8], r8d
lea rsi, harvest_pins
mov rdx, r12
call lf_dynarray_iterate
mov r8, [r12]
sub r8, r14
shr r8, 3
test r8d, r8d
jz short loc_A5218
movsxd rsi, r8d
lea rcx, ptr_cmp
mov edx, 8
mov rdi, r14
mov r15, r8
call _qsort
mov r8, r15
jmp short loc_A5218
loc_A5206:
mov rax, [rbx+20h]
mov [rbp+var_38], rax
mov r8d, [rax+40h]
inc r8d
loc_A5215:
xor r14d, r14d
loc_A5218:
mov r15, [rbx+28h]
mov qword ptr [rbx+28h], 0
mov dword ptr [rbx+30h], 0
test r15, r15
jz loc_A5360
movsxd rax, r8d
lea r13, [r14+rax*8]
add r13, 0FFFFFFFFFFFFFFF8h
lea rcx, ds:0FFFFFFFFFFFFFFF8h[rax*8]
mov rax, rcx
sar rax, 3
mov [rbp+var_60], rcx
shr rcx, 3Fh
add rcx, rax
and rcx, 0FFFFFFFFFFFFFFFEh
lea rax, [r14+rcx*4]
mov [rbp+var_48], rax
mov [rbp+var_40], 0
xor r10d, r10d
mov [rbp+var_58], rbx
mov [rbp+var_50], r14
loc_A5278:
mov r12, r15
mov rdi, [rbp+var_38]
mov eax, [rdi+38h]
mov r15, [r15+rax]
test r8d, r8d
jz short loc_A52E5
test r14, r14
jz short loc_A52FA
mov rcx, r14
mov rax, r13
cmp [rbp+var_60], 9
jl short loc_A52DB
mov rdx, [rbp+var_48]
mov rax, r13
mov rcx, r14
loc_A52A7:
cmp r12, [rdx]
cmovbe rax, rdx
cmovnb rcx, rdx
cmovz rax, rdx
mov rsi, rax
sub rsi, rcx
mov rdx, rsi
sar rdx, 3
mov rdi, rsi
shr rdi, 3Fh
add rdi, rdx
and rdi, 0FFFFFFFFFFFFFFFEh
lea rdx, [rcx+rdi*4]
cmp rsi, 8
jg short loc_A52A7
loc_A52DB:
cmp r12, [rcx]
jz short loc_A5321
cmp r12, [rax]
jz short loc_A5321
loc_A52E5:
test r10, r10
jz short loc_A5339
mov rax, [rbp+var_38]
mov eax, [rax+38h]
mov [r10+rax], r12
mov r10, r12
jmp short loc_A5340
loc_A52FA:
lea rsi, match_pins
mov rdx, r12
mov r14, r8
mov rbx, r10
call lf_dynarray_iterate
mov r10, rbx
mov r8, r14
mov r14, [rbp+var_50]
mov rbx, [rbp+var_58]
test eax, eax
jz short loc_A52E5
loc_A5321:
mov rax, [rbx+20h]
mov rcx, [rbx+28h]
mov eax, [rax+38h]
mov [r12+rax], rcx
mov [rbx+28h], r12
inc dword ptr [rbx+30h]
jmp short loc_A5340
loc_A5339:
mov r10, r12
mov [rbp+var_40], r12
loc_A5340:
test r15, r15
jnz loc_A5278
test r10, r10
jz short loc_A5360
mov rax, [rbp+var_38]
mov rdx, [rax+30h]
mov rdi, [rbp+var_40]
mov rsi, r10
call qword ptr [rax+28h]
loc_A5360:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_A537E
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A537E:
call ___stack_chk_fail
| unsigned long long lf_pinbox_real_free(long long a1, const char *a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rax
long long v5; // rdi
unsigned long long v6; // r8
char *v7; // r14
unsigned long long v8; // r15
unsigned long long v9; // r15
long long v10; // r13
unsigned long long v11; // rcx
unsigned long long v12; // r10
unsigned long long v13; // r12
_QWORD *v14; // rax
char *v15; // rdx
unsigned long long v16; // r14
unsigned long long v17; // rbx
int v18; // eax
char *v20; // [rsp+0h] [rbp-70h] BYREF
int v21; // [rsp+8h] [rbp-68h]
long long v22; // [rsp+10h] [rbp-60h]
long long v23; // [rsp+18h] [rbp-58h]
char *v24; // [rsp+20h] [rbp-50h]
char *v25; // [rsp+28h] [rbp-48h]
unsigned long long v26; // [rsp+30h] [rbp-40h]
_QWORD v27[7]; // [rsp+38h] [rbp-38h] BYREF
v2 = a1;
v27[1] = __readfsqword(0x28u);
v3 = my_thread_var(a1, a2);
if ( v3 )
{
v4 = *(_QWORD *)(v3 + 184);
v5 = *(_QWORD *)(a1 + 32);
v27[0] = v5;
v6 = (unsigned int)(*(_DWORD *)(v5 + 64) + 1);
if ( v4 && v4 - (long long)v27 > 32 * (int)v6 + 0x2000 )
{
v7 = (char *)&v20 - ((32 * (int)v6 + 15LL) & 0xFFFFFFFFFFFFFFF0LL);
v20 = v7;
v21 = v6;
lf_dynarray_iterate(v5, harvest_pins, &v20);
v6 = (unsigned long long)(v20 - v7) >> 3;
if ( (_DWORD)v6 )
{
v8 = (unsigned long long)(v20 - v7) >> 3;
qsort(v7, (int)v6, 8LL, ptr_cmp);
v6 = v8;
}
goto LABEL_8;
}
}
else
{
v27[0] = *(_QWORD *)(a1 + 32);
v6 = (unsigned int)(*(_DWORD *)(v27[0] + 64LL) + 1);
}
v7 = 0LL;
LABEL_8:
v9 = *(_QWORD *)(v2 + 40);
*(_QWORD *)(v2 + 40) = 0LL;
*(_DWORD *)(v2 + 48) = 0;
if ( !v9 )
return __readfsqword(0x28u);
v10 = (long long)&v7[8 * (int)v6 - 8];
v22 = 8LL * (int)v6 - 8;
v11 = ((v22 >> 3) + ((unsigned long long)v22 >> 63)) & 0xFFFFFFFFFFFFFFFELL;
v25 = &v7[4 * v11];
v26 = 0LL;
v12 = 0LL;
v23 = v2;
v24 = v7;
do
{
v13 = v9;
v9 = *(_QWORD *)(v9 + *(unsigned int *)(v27[0] + 56LL));
if ( (_DWORD)v6 )
{
if ( v7 )
{
v11 = (unsigned long long)v7;
v14 = (_QWORD *)v10;
if ( v22 >= 9 )
{
v15 = v25;
v14 = (_QWORD *)v10;
v11 = (unsigned long long)v7;
do
{
if ( v13 <= *(_QWORD *)v15 )
v14 = v15;
if ( v13 >= *(_QWORD *)v15 )
v11 = (unsigned long long)v15;
if ( v13 == *(_QWORD *)v15 )
v14 = v15;
v15 = (char *)(v11
+ 4
* ((((long long)((long long)v14 - v11) >> 3) + (((unsigned long long)v14 - v11) >> 63)) & 0xFFFFFFFFFFFFFFFELL));
}
while ( (long long)((long long)v14 - v11) > 8 );
}
if ( v13 == *(_QWORD *)v11 || v13 == *v14 )
{
LABEL_26:
v11 = *(_QWORD *)(v2 + 40);
*(_QWORD *)(v13 + *(unsigned int *)(*(_QWORD *)(v2 + 32) + 56LL)) = v11;
*(_QWORD *)(v2 + 40) = v13;
++*(_DWORD *)(v2 + 48);
continue;
}
}
else
{
v16 = v6;
v17 = v12;
v18 = lf_dynarray_iterate(v27[0], match_pins, v13);
v12 = v17;
v6 = v16;
v7 = v24;
v2 = v23;
if ( v18 )
goto LABEL_26;
}
}
if ( v12 )
{
*(_QWORD *)(v12 + *(unsigned int *)(v27[0] + 56LL)) = v13;
v12 = v13;
}
else
{
v12 = v13;
v26 = v13;
}
}
while ( v9 );
if ( v12 )
(*(void ( **)(unsigned long long, unsigned long long, _QWORD, unsigned long long, unsigned long long))(v27[0] + 40LL))(
v26,
v12,
*(_QWORD *)(v27[0] + 48LL),
v11,
v6);
return __readfsqword(0x28u);
}
| lf_pinbox_real_free:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x001a16ee
TEST RAX,RAX
JZ 0x001a5206
MOV RAX,qword ptr [RAX + 0xb8]
MOV RDI,qword ptr [RBX + 0x20]
MOV qword ptr [RBP + -0x38],RDI
MOV R8D,dword ptr [RDI + 0x40]
INC R8D
TEST RAX,RAX
JZ 0x001a5215
MOV ECX,R8D
SHL ECX,0x5
LEA RDX,[RBP + -0x38]
SUB RAX,RDX
LEA EDX,[RCX + 0x2000]
MOVSXD RDX,EDX
CMP RAX,RDX
JLE 0x001a5215
MOVSXD RAX,ECX
MOV R14,RSP
ADD RAX,0xf
AND RAX,-0x10
SUB R14,RAX
MOV RSP,R14
LEA R12,[RBP + -0x70]
MOV qword ptr [R12],R14
MOV dword ptr [R12 + 0x8],R8D
LEA RSI,[0x1a555c]
MOV RDX,R12
CALL 0x001a5725
MOV R8,qword ptr [R12]
SUB R8,R14
SHR R8,0x3
TEST R8D,R8D
JZ 0x001a5218
MOVSXD RSI,R8D
LEA RCX,[0x1a55b4]
MOV EDX,0x8
MOV RDI,R14
MOV R15,R8
CALL 0x001295d0
MOV R8,R15
JMP 0x001a5218
LAB_001a5206:
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV R8D,dword ptr [RAX + 0x40]
INC R8D
LAB_001a5215:
XOR R14D,R14D
LAB_001a5218:
MOV R15,qword ptr [RBX + 0x28]
MOV qword ptr [RBX + 0x28],0x0
MOV dword ptr [RBX + 0x30],0x0
TEST R15,R15
JZ 0x001a5360
MOVSXD RAX,R8D
LEA R13,[R14 + RAX*0x8]
ADD R13,-0x8
LEA RCX,[-0x8 + RAX*0x8]
MOV RAX,RCX
SAR RAX,0x3
MOV qword ptr [RBP + -0x60],RCX
SHR RCX,0x3f
ADD RCX,RAX
AND RCX,-0x2
LEA RAX,[R14 + RCX*0x4]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x40],0x0
XOR R10D,R10D
MOV qword ptr [RBP + -0x58],RBX
MOV qword ptr [RBP + -0x50],R14
LAB_001a5278:
MOV R12,R15
MOV RDI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RDI + 0x38]
MOV R15,qword ptr [R15 + RAX*0x1]
TEST R8D,R8D
JZ 0x001a52e5
TEST R14,R14
JZ 0x001a52fa
MOV RCX,R14
MOV RAX,R13
CMP qword ptr [RBP + -0x60],0x9
JL 0x001a52db
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,R13
MOV RCX,R14
LAB_001a52a7:
CMP R12,qword ptr [RDX]
CMOVBE RAX,RDX
CMOVNC RCX,RDX
CMOVZ RAX,RDX
MOV RSI,RAX
SUB RSI,RCX
MOV RDX,RSI
SAR RDX,0x3
MOV RDI,RSI
SHR RDI,0x3f
ADD RDI,RDX
AND RDI,-0x2
LEA RDX,[RCX + RDI*0x4]
CMP RSI,0x8
JG 0x001a52a7
LAB_001a52db:
CMP R12,qword ptr [RCX]
JZ 0x001a5321
CMP R12,qword ptr [RAX]
JZ 0x001a5321
LAB_001a52e5:
TEST R10,R10
JZ 0x001a5339
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x38]
MOV qword ptr [R10 + RAX*0x1],R12
MOV R10,R12
JMP 0x001a5340
LAB_001a52fa:
LEA RSI,[0x1a55cd]
MOV RDX,R12
MOV R14,R8
MOV RBX,R10
CALL 0x001a5725
MOV R10,RBX
MOV R8,R14
MOV R14,qword ptr [RBP + -0x50]
MOV RBX,qword ptr [RBP + -0x58]
TEST EAX,EAX
JZ 0x001a52e5
LAB_001a5321:
MOV RAX,qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x28]
MOV EAX,dword ptr [RAX + 0x38]
MOV qword ptr [R12 + RAX*0x1],RCX
MOV qword ptr [RBX + 0x28],R12
INC dword ptr [RBX + 0x30]
JMP 0x001a5340
LAB_001a5339:
MOV R10,R12
MOV qword ptr [RBP + -0x40],R12
LAB_001a5340:
TEST R15,R15
JNZ 0x001a5278
TEST R10,R10
JZ 0x001a5360
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,R10
CALL qword ptr [RAX + 0x28]
LAB_001a5360:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001a537e
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a537e:
CALL 0x00129270
|
/* WARNING: Type propagation algorithm not settling */
void lf_pinbox_real_free(long param_1)
{
ulong uVar1;
ulong uVar2;
int8 uVar3;
code *pcVar4;
ulong *puVar5;
int iVar6;
long lVar7;
ulong *puVar8;
ulong *puVar9;
ulong **__base;
long lVar10;
int iVar11;
ulong uVar12;
ulong *puVar13;
ulong *puVar14;
ulong uVar15;
long in_FS_OFFSET;
ulong *apuStack_80 [2];
int local_70;
long local_68;
long local_60;
ulong *local_58;
ulong *local_50;
ulong local_48;
long local_40;
long local_38;
__base = apuStack_80 + 1;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
apuStack_80[0] = (ulong *)0x1a5164;
lVar7 = _my_thread_var();
if (lVar7 == 0) {
local_40 = *(long *)(param_1 + 0x20);
iVar11 = *(int *)(*(long *)(param_1 + 0x20) + 0x40) + 1;
}
else {
lVar10 = *(long *)(param_1 + 0x20);
local_40 = lVar10;
iVar11 = *(int *)(lVar10 + 0x40) + 1;
if ((*(long *)(lVar7 + 0xb8) != 0) &&
((long)(iVar11 * 0x20 + 0x2000) < *(long *)(lVar7 + 0xb8) - (long)&local_40)) {
lVar7 = -(long)(iVar11 * 0x20);
__base = (ulong **)((long)apuStack_80 + lVar7 + 8U);
apuStack_80[1] = (ulong *)__base;
local_70 = iVar11;
*(int8 *)((long)apuStack_80 + lVar7) = 0x1a51d7;
lf_dynarray_iterate(lVar10,harvest_pins,apuStack_80 + 1);
iVar11 = (int)((ulong)((long)apuStack_80[1] - (long)__base) >> 3);
puVar14 = (ulong *)__base;
if (iVar11 != 0) {
*(int8 *)((long)apuStack_80 + lVar7) = 0x1a5201;
qsort(__base,(long)iVar11,8,ptr_cmp);
}
goto LAB_001a5218;
}
}
puVar14 = (ulong *)0x0;
LAB_001a5218:
uVar15 = *(ulong *)(param_1 + 0x28);
*(int8 *)(param_1 + 0x28) = 0;
*(int4 *)(param_1 + 0x30) = 0;
if (uVar15 != 0) {
puVar13 = puVar14 + (long)iVar11 + -1;
local_68 = (long)iVar11 * 8 + -8;
local_50 = (ulong *)((long)puVar14 +
((local_68 >> 3) - (local_68 >> 0x3f) & 0xfffffffffffffffeU) * 4);
local_48 = 0;
uVar12 = 0;
local_60 = param_1;
local_58 = puVar14;
do {
lVar7 = local_40;
uVar1 = *(ulong *)(uVar15 + *(uint *)(local_40 + 0x38));
if (iVar11 == 0) {
LAB_001a52e5:
if (uVar12 == 0) {
local_48 = uVar15;
uVar12 = uVar15;
}
else {
*(ulong *)(uVar12 + *(uint *)(local_40 + 0x38)) = uVar15;
uVar12 = uVar15;
}
}
else {
puVar8 = puVar13;
puVar9 = puVar14;
puVar5 = local_50;
lVar10 = local_68;
if (puVar14 == (ulong *)0x0) {
__base[-1] = (ulong *)0x1a530f;
iVar6 = lf_dynarray_iterate(lVar7,match_pins,uVar15);
param_1 = local_60;
puVar14 = local_58;
if (iVar6 == 0) goto LAB_001a52e5;
}
else {
while (8 < lVar10) {
uVar2 = *puVar5;
if (uVar2 > uVar15 || uVar15 == uVar2) {
puVar8 = puVar5;
}
if (uVar2 <= uVar15) {
puVar9 = puVar5;
}
if (uVar15 == uVar2) {
puVar8 = puVar5;
}
lVar10 = (long)puVar8 - (long)puVar9;
puVar5 = (ulong *)((long)puVar9 +
((lVar10 >> 3) - (lVar10 >> 0x3f) & 0xfffffffffffffffeU) * 4);
}
if ((uVar15 != *puVar9) && (uVar15 != *puVar8)) goto LAB_001a52e5;
}
*(int8 *)(uVar15 + *(uint *)(*(long *)(param_1 + 0x20) + 0x38)) =
*(int8 *)(param_1 + 0x28);
*(ulong *)(param_1 + 0x28) = uVar15;
*(int *)(param_1 + 0x30) = *(int *)(param_1 + 0x30) + 1;
}
uVar2 = local_48;
uVar15 = uVar1;
} while (uVar1 != 0);
if (uVar12 != 0) {
uVar3 = *(int8 *)(local_40 + 0x30);
pcVar4 = *(code **)(local_40 + 0x28);
__base[-1] = (ulong *)0x1a5360;
(*pcVar4)(uVar2,uVar12,uVar3);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__base[-1] = (ulong *)lf_pinbox_free;
__stack_chk_fail();
}
return;
}
| |
52,389 | void Catch::AssertionHandler::handleExpr<bool>(Catch::ExprLhs<bool> const&) | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.hpp | auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
return UnaryExpr<LhsT>{ m_lhs };
} | O3 | cpp | void Catch::AssertionHandler::handleExpr<bool>(Catch::ExprLhs<bool> const&):
pushq %rbx
subq $0x10, %rsp
movb (%rsi), %al
movq %rsp, %rsi
movb $0x0, 0x8(%rsi)
movb %al, 0x9(%rsi)
leaq 0x109600(%rip), %rcx # 0x12c7d0
addq $0x10, %rcx
movq %rcx, (%rsi)
movb %al, 0xa(%rsi)
callq 0x58fe8
movq %rsp, %rdi
callq 0x66232
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x66232
movq %rbx, %rdi
callq 0x17740
| _ZN5Catch16AssertionHandler10handleExprIbEEvRKNS_7ExprLhsIT_EE:
push rbx
sub rsp, 10h
mov al, [rsi]
mov rsi, rsp
mov byte ptr [rsi+8], 0
mov [rsi+9], al
lea rcx, _ZTVN5Catch9UnaryExprIbEE; `vtable for'Catch::UnaryExpr<bool>
add rcx, 10h
mov [rsi], rcx
mov [rsi+0Ah], al
call _ZN5Catch16AssertionHandler10handleExprERKNS_20ITransientExpressionE; Catch::AssertionHandler::handleExpr(Catch::ITransientExpression const&)
mov rdi, rsp; this
call _ZN5Catch20ITransientExpressionD2Ev; Catch::ITransientExpression::~ITransientExpression()
add rsp, 10h
pop rbx
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN5Catch20ITransientExpressionD2Ev; Catch::ITransientExpression::~ITransientExpression()
mov rdi, rbx
call __Unwind_Resume
| void Catch::AssertionHandler::handleExpr<bool>(Catch::AssertionHandler *a1, char *a2)
{
char v2; // al
long long *v3; // [rsp+0h] [rbp-18h] BYREF
char v4; // [rsp+8h] [rbp-10h]
char v5; // [rsp+9h] [rbp-Fh]
char v6; // [rsp+Ah] [rbp-Eh]
v2 = *a2;
v4 = 0;
v5 = v2;
v3 = &`vtable for'Catch::UnaryExpr<bool> + 2;
v6 = v2;
Catch::AssertionHandler::handleExpr(a1, (const Catch::ITransientExpression *)&v3);
Catch::ITransientExpression::~ITransientExpression((Catch::ITransientExpression *)&v3);
}
| handleExpr<bool>:
PUSH RBX
SUB RSP,0x10
MOV AL,byte ptr [RSI]
MOV RSI,RSP
MOV byte ptr [RSI + 0x8],0x0
MOV byte ptr [RSI + 0x9],AL
LEA RCX,[0x22c7d0]
ADD RCX,0x10
MOV qword ptr [RSI],RCX
MOV byte ptr [RSI + 0xa],AL
LAB_001231da:
CALL 0x00158fe8
LAB_001231df:
MOV RDI,RSP
CALL 0x00166232
ADD RSP,0x10
POP RBX
RET
|
/* void Catch::AssertionHandler::handleExpr<bool>(Catch::ExprLhs<bool> const&) */
void __thiscall Catch::AssertionHandler::handleExpr<bool>(AssertionHandler *this,ExprLhs *param_1)
{
int **local_18;
int1 local_10;
ExprLhs local_f;
ExprLhs local_e;
local_f = *param_1;
local_10 = 0;
local_18 = &PTR_streamReconstructedExpression_0022c7e0;
local_e = local_f;
/* try { // try from 001231da to 001231de has its CatchHandler @ 001231ed */
handleExpr(this,(ITransientExpression *)&local_18);
ITransientExpression::~ITransientExpression((ITransientExpression *)&local_18);
return;
}
| |
52,390 | init_alloc_root | eloqsql/mysys/my_alloc.c | void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)),
myf my_flags)
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, pre_alloc_size));
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32;
mem_root->block_size= (block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1;
if (my_flags & MY_THREAD_SPECIFIC)
mem_root->block_size|= 1;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;
mem_root->m_psi_key= key;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(key, size, MYF(my_flags))))
{
mem_root->free->size= size;
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
TRASH_MEM(mem_root->free);
}
}
#endif
DBUG_VOID_RETURN;
} | O3 | c | init_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq $0x20, 0x18(%rsi)
andq $-0x2, %rdx
movl %r8d, %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addq %rdx, %rcx
addq $-0x28, %rcx
movq %rcx, 0x20(%rsi)
movq %rax, 0x30(%rsi)
movq $0x4, 0x28(%rsi)
movl %edi, 0x38(%rsi)
testq %rbx, %rbx
je 0x52f00
movq %rsi, %r14
leaq 0x18(%rbx), %r15
movq %r15, %rsi
movq %r8, %rdx
callq 0x4b61d
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x52f00
movq %r15, 0x10(%rax)
movq (%r14), %rax
movq %rbx, 0x8(%rax)
movq (%r14), %rax
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| init_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
xor eax, eax
mov [rsi+10h], rax
mov qword ptr [rsi+18h], 20h ; ' '
and rdx, 0FFFFFFFFFFFFFFFEh
mov ecx, r8d
shr ecx, 10h
and ecx, 1
add rcx, rdx
add rcx, 0FFFFFFFFFFFFFFD8h
mov [rsi+20h], rcx
mov [rsi+30h], rax
mov qword ptr [rsi+28h], 4
mov [rsi+38h], edi
test rbx, rbx
jz short loc_52F00
mov r14, rsi
lea r15, [rbx+18h]
mov rsi, r15
mov rdx, r8
call my_malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_52F00
mov [rax+10h], r15
mov rax, [r14]
mov [rax+8], rbx
mov rax, [r14]
mov qword ptr [rax], 0
loc_52F00:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long init_alloc_root(unsigned int a1, long long *a2, long long a3, long long a4, unsigned int a5)
{
long long result; // rax
*(_OWORD *)a2 = 0LL;
result = 0LL;
a2[2] = 0LL;
a2[3] = 32LL;
a2[4] = (a3 & 0xFFFFFFFFFFFFFFFELL) + (HIWORD(a5) & 1) - 40;
a2[6] = 0LL;
a2[5] = 4LL;
*((_DWORD *)a2 + 14) = a1;
if ( a4 )
{
result = my_malloc(a1, a4 + 24, a5);
a2[2] = result;
*a2 = result;
if ( result )
{
*(_QWORD *)(result + 16) = a4 + 24;
*(_QWORD *)(*a2 + 8) = a4;
result = *a2;
*(_QWORD *)*a2 = 0LL;
}
}
return result;
}
| init_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],0x20
AND RDX,-0x2
MOV ECX,R8D
SHR ECX,0x10
AND ECX,0x1
ADD RCX,RDX
ADD RCX,-0x28
MOV qword ptr [RSI + 0x20],RCX
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x28],0x4
MOV dword ptr [RSI + 0x38],EDI
TEST RBX,RBX
JZ 0x00152f00
MOV R14,RSI
LEA R15,[RBX + 0x18]
MOV RSI,R15
MOV RDX,R8
CALL 0x0014b61d
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x00152f00
MOV qword ptr [RAX + 0x10],R15
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX],0x0
LAB_00152f00:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void init_alloc_root(int4 param_1,long *param_2,ulong param_3,long param_4,int8 param_5)
{
long lVar1;
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0x20;
param_2[4] = (ulong)((uint)param_5 >> 0x10 & 1) + (param_3 & 0xfffffffffffffffe) + -0x28;
param_2[6] = 0;
param_2[5] = 4;
*(int4 *)(param_2 + 7) = param_1;
if (param_4 != 0) {
lVar1 = my_malloc(param_1,param_4 + 0x18,param_5);
param_2[2] = lVar1;
*param_2 = lVar1;
if (lVar1 != 0) {
*(long *)(lVar1 + 0x10) = param_4 + 0x18;
*(long *)(*param_2 + 8) = param_4;
*(int8 *)*param_2 = 0;
}
}
return;
}
| |
52,391 | js_clone_shape | bluesky950520[P]quickjs/quickjs.c | static JSShape *js_clone_shape(JSContext *ctx, JSShape *sh1)
{
JSShape *sh;
void *sh_alloc, *sh_alloc1;
size_t size;
JSShapeProperty *pr;
uint32_t i, hash_size;
hash_size = sh1->prop_hash_mask + 1;
size = get_shape_size(hash_size, sh1->prop_size);
sh_alloc = js_malloc(ctx, size);
if (!sh_alloc)
return NULL;
sh_alloc1 = get_alloc_from_shape(sh1);
memcpy(sh_alloc, sh_alloc1, size);
sh = get_shape_from_alloc(sh_alloc, hash_size);
sh->header.ref_count = 1;
add_gc_object(ctx->rt, &sh->header, JS_GC_OBJ_TYPE_SHAPE);
sh->is_hashed = FALSE;
if (sh->proto) {
js_dup(JS_MKPTR(JS_TAG_OBJECT, sh->proto));
}
for(i = 0, pr = get_shape_prop(sh); i < sh->prop_count; i++, pr++) {
JS_DupAtom(ctx, pr->atom);
}
return sh;
} | O0 | c | js_clone_shape:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %edi
movq 0x50(%rsp), %rax
movslq 0x24(%rax), %rsi
callq 0x32330
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x27fa0
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x64460
movq $0x0, 0x60(%rsp)
jmp 0x6455b
movq 0x50(%rsp), %rdi
callq 0x63b50
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0xe610
movq 0x40(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x63f20
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movl $0x1, (%rax)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x48(%rsp), %rsi
movl $0x2, %edx
callq 0x2a3c0
movq 0x48(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x644ff
movq 0x48(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq $-0x1, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x279c0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x48(%rsp), %rdi
callq 0x32570
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x64551
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %esi
callq 0x2e290
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
jmp 0x64516
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| js_clone_shape:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov [rsp+68h+var_18], rsi
mov rax, [rsp+68h+var_18]
mov eax, [rax+20h]
add eax, 1
mov [rsp+68h+var_48], eax
mov eax, [rsp+68h+var_48]
mov edi, eax
mov rax, [rsp+68h+var_18]
movsxd rsi, dword ptr [rax+24h]
call get_shape_size
mov [rsp+68h+var_38], rax
mov rdi, [rsp+68h+var_10]
mov rsi, [rsp+68h+var_38]
call js_malloc
mov [rsp+68h+var_28], rax
cmp [rsp+68h+var_28], 0
jnz short loc_64460
mov [rsp+68h+var_8], 0
jmp loc_6455B
loc_64460:
mov rdi, [rsp+68h+var_18]
call get_alloc_from_shape
mov [rsp+68h+var_30], rax
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_38]
call _memcpy
mov rdi, [rsp+68h+var_28]
mov eax, [rsp+68h+var_48]
mov esi, eax
call get_shape_from_alloc
mov [rsp+68h+var_20], rax
mov rax, [rsp+68h+var_20]
mov dword ptr [rax], 1
mov rax, [rsp+68h+var_10]
mov rdi, [rax+18h]
mov rsi, [rsp+68h+var_20]
mov edx, 2
call add_gc_object
mov rax, [rsp+68h+var_20]
mov byte ptr [rax+18h], 0
mov rax, [rsp+68h+var_20]
cmp qword ptr [rax+38h], 0
jz short loc_644FF
mov rax, [rsp+68h+var_20]
mov rax, [rax+38h]
mov [rsp+68h+var_58], rax
mov [rsp+68h+var_50], 0FFFFFFFFFFFFFFFFh
mov rdi, [rsp+68h+var_58]
mov rsi, [rsp+68h+var_50]
call js_dup
mov [rsp+68h+var_68], rax
mov [rsp+68h+var_60], rdx
loc_644FF:
mov [rsp+68h+var_44], 0
mov rdi, [rsp+68h+var_20]
call get_shape_prop
mov [rsp+68h+var_40], rax
loc_64516:
mov eax, [rsp+68h+var_44]
mov rcx, [rsp+68h+var_20]
cmp eax, [rcx+28h]
jnb short loc_64551
mov rdi, [rsp+68h+var_10]
mov rax, [rsp+68h+var_40]
mov esi, [rax+4]
call JS_DupAtom
mov eax, [rsp+68h+var_44]
add eax, 1
mov [rsp+68h+var_44], eax
mov rax, [rsp+68h+var_40]
add rax, 8
mov [rsp+68h+var_40], rax
jmp short loc_64516
loc_64551:
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_8], rax
loc_6455B:
mov rax, [rsp+68h+var_8]
add rsp, 68h
retn
| long long js_clone_shape(long long a1, long long a2)
{
unsigned int v3; // [rsp+20h] [rbp-48h]
unsigned int v4; // [rsp+24h] [rbp-44h]
long long shape_prop; // [rsp+28h] [rbp-40h]
long long shape_size; // [rsp+30h] [rbp-38h]
long long alloc_from_shape; // [rsp+38h] [rbp-30h]
long long v8; // [rsp+40h] [rbp-28h]
long long shape_from_alloc; // [rsp+48h] [rbp-20h]
v3 = *(_DWORD *)(a2 + 32) + 1;
shape_size = get_shape_size(v3, *(int *)(a2 + 36));
v8 = js_malloc(a1, shape_size);
if ( !v8 )
return 0LL;
alloc_from_shape = get_alloc_from_shape(a2);
memcpy(v8, alloc_from_shape, shape_size);
shape_from_alloc = get_shape_from_alloc(v8, v3);
*(_DWORD *)shape_from_alloc = 1;
add_gc_object(*(_QWORD *)(a1 + 24), shape_from_alloc, 2);
*(_BYTE *)(shape_from_alloc + 24) = 0;
if ( *(_QWORD *)(shape_from_alloc + 56) )
js_dup(*(_DWORD **)(shape_from_alloc + 56), 0xFFFFFFFF);
v4 = 0;
shape_prop = get_shape_prop(shape_from_alloc);
while ( v4 < *(_DWORD *)(shape_from_alloc + 40) )
{
JS_DupAtom(a1, *(_DWORD *)(shape_prop + 4));
++v4;
shape_prop += 8LL;
}
return shape_from_alloc;
}
| js_clone_shape:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV RAX,qword ptr [RSP + 0x50]
MOV EAX,dword ptr [RAX + 0x20]
ADD EAX,0x1
MOV dword ptr [RSP + 0x20],EAX
MOV EAX,dword ptr [RSP + 0x20]
MOV EDI,EAX
MOV RAX,qword ptr [RSP + 0x50]
MOVSXD RSI,dword ptr [RAX + 0x24]
CALL 0x00132330
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x00127fa0
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],0x0
JNZ 0x00164460
MOV qword ptr [RSP + 0x60],0x0
JMP 0x0016455b
LAB_00164460:
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00163b50
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0010e610
MOV RDI,qword ptr [RSP + 0x40]
MOV EAX,dword ptr [RSP + 0x20]
MOV ESI,EAX
CALL 0x00163f20
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x48]
MOV EDX,0x2
CALL 0x0012a3c0
MOV RAX,qword ptr [RSP + 0x48]
MOV byte ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RSP + 0x48]
CMP qword ptr [RAX + 0x38],0x0
JZ 0x001644ff
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],-0x1
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001279c0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
LAB_001644ff:
MOV dword ptr [RSP + 0x24],0x0
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00132570
MOV qword ptr [RSP + 0x28],RAX
LAB_00164516:
MOV EAX,dword ptr [RSP + 0x24]
MOV RCX,qword ptr [RSP + 0x48]
CMP EAX,dword ptr [RCX + 0x28]
JNC 0x00164551
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RAX + 0x4]
CALL 0x0012e290
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x8
MOV qword ptr [RSP + 0x28],RAX
JMP 0x00164516
LAB_00164551:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x60],RAX
LAB_0016455b:
MOV RAX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
int4 * js_clone_shape(long param_1,long param_2)
{
int iVar1;
size_t __n;
void *__dest;
void *__src;
uint local_44;
long local_40;
int4 *local_8;
iVar1 = *(int *)(param_2 + 0x20) + 1;
__n = get_shape_size(iVar1,(long)*(int *)(param_2 + 0x24));
__dest = (void *)js_malloc(param_1,__n);
if (__dest == (void *)0x0) {
local_8 = (int4 *)0x0;
}
else {
__src = (void *)get_alloc_from_shape(param_2);
memcpy(__dest,__src,__n);
local_8 = (int4 *)get_shape_from_alloc(__dest,iVar1);
*local_8 = 1;
add_gc_object(*(int8 *)(param_1 + 0x18),local_8,2);
*(int1 *)(local_8 + 6) = 0;
if (*(long *)(local_8 + 0xe) != 0) {
js_dup(*(int8 *)(local_8 + 0xe),0xffffffffffffffff);
}
local_44 = 0;
local_40 = get_shape_prop(local_8);
for (; local_44 < (uint)local_8[10]; local_44 = local_44 + 1) {
JS_DupAtom(param_1,*(int4 *)(local_40 + 4));
local_40 = local_40 + 8;
}
}
return local_8;
}
| |
52,392 | multi_alloc_root | eloqsql/mysys/my_alloc.c | void *multi_alloc_root(MEM_ROOT *root, ...)
{
va_list args;
char **ptr, *start, *res;
size_t tot_length, length;
DBUG_ENTER("multi_alloc_root");
/*
We don't need to do DBUG_PRINT here as it will be done when alloc_root
is called
*/
va_start(args, root);
tot_length= 0;
while ((ptr= va_arg(args, char **)))
{
length= va_arg(args, uint);
tot_length+= ALIGN_SIZE(length);
}
va_end(args);
if (!(start= (char*) alloc_root(root, tot_length)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args, root);
res= start;
while ((ptr= va_arg(args, char **)))
{
*ptr= res;
length= va_arg(args, uint);
res+= ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
} | O0 | c | multi_alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0xed751
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rsi, -0x108(%rbp)
movq %rdi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0xed7df
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0xed7fc
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xed896
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0xed84f
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0xed86c
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xed7a4
leaq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xed460
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xed8c0
jmp 0xed8b3
movq $0x0, -0x8(%rbp)
jmp 0xed9f5
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0xed927
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0xed944
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xed9e9
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0xed9a2
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0xed9bf
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xed8ec
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
| multi_alloc_root:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_ED751
movaps [rbp+var_E0], xmm0
movaps [rbp+var_D0], xmm1
movaps [rbp+var_C0], xmm2
movaps [rbp+var_B0], xmm3
movaps [rbp+var_A0], xmm4
movaps [rbp+var_90], xmm5
movaps [rbp+var_80], xmm6
movaps [rbp+var_70], xmm7
loc_ED751:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_108], rsi
mov [rbp+var_10], rdi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov [rbp+var_50], 0
loc_ED7A4:
lea rax, [rbp+var_30]
mov [rbp+var_120], rax
mov eax, [rbp+var_30]
mov [rbp+var_114], eax
cmp eax, 28h ; '('
ja short loc_ED7DF
mov rcx, [rbp+var_120]
mov edx, [rbp+var_114]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_128], rax
jmp short loc_ED7FC
loc_ED7DF:
mov rcx, [rbp+var_120]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_128], rax
loc_ED7FC:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_ED896
lea rax, [rbp+var_30]
mov [rbp+var_138], rax
mov eax, [rbp+var_30]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_ED84F
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_ED86C
loc_ED84F:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_ED86C:
mov rax, [rbp+var_140]
mov eax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp loc_ED7A4
loc_ED896:
lea rax, [rbp+var_30]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_50]
call alloc_root
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_ED8C0
jmp short $+2
loc_ED8B3:
mov [rbp+var_8], 0
jmp loc_ED9F5
loc_ED8C0:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_ED8EC:
lea rax, [rbp+var_30]
mov [rbp+var_150], rax
mov eax, [rbp+var_30]
mov [rbp+var_144], eax
cmp eax, 28h ; '('
ja short loc_ED927
mov rcx, [rbp+var_150]
mov edx, [rbp+var_144]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_158], rax
jmp short loc_ED944
loc_ED927:
mov rcx, [rbp+var_150]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_158], rax
loc_ED944:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_ED9E9
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax], rcx
lea rax, [rbp+var_30]
mov [rbp+var_168], rax
mov eax, [rbp+var_30]
mov [rbp+var_15C], eax
cmp eax, 28h ; '('
ja short loc_ED9A2
mov rcx, [rbp+var_168]
mov edx, [rbp+var_15C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_170], rax
jmp short loc_ED9BF
loc_ED9A2:
mov rcx, [rbp+var_168]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_170], rax
loc_ED9BF:
mov rax, [rbp+var_170]
mov eax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp loc_ED8EC
loc_ED9E9:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_ED9F5:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
| char * multi_alloc_root(
_QWORD **a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char *v15; // rax
char *v16; // rax
char *v17; // rax
char *v18; // rax
char v20; // [rsp+60h] [rbp-110h] BYREF
long long v21; // [rsp+68h] [rbp-108h]
long long v22; // [rsp+70h] [rbp-100h]
long long v23; // [rsp+78h] [rbp-F8h]
long long v24; // [rsp+80h] [rbp-F0h]
long long v25; // [rsp+88h] [rbp-E8h]
__m128 v26; // [rsp+90h] [rbp-E0h]
__m128 v27; // [rsp+A0h] [rbp-D0h]
__m128 v28; // [rsp+B0h] [rbp-C0h]
__m128 v29; // [rsp+C0h] [rbp-B0h]
__m128 v30; // [rsp+D0h] [rbp-A0h]
__m128 v31; // [rsp+E0h] [rbp-90h]
__m128 v32; // [rsp+F0h] [rbp-80h]
__m128 v33; // [rsp+100h] [rbp-70h]
long long v34; // [rsp+118h] [rbp-58h]
long long i; // [rsp+120h] [rbp-50h]
char *j; // [rsp+128h] [rbp-48h]
char *v37; // [rsp+130h] [rbp-40h]
char **v38; // [rsp+138h] [rbp-38h]
int v39; // [rsp+140h] [rbp-30h]
int v40; // [rsp+144h] [rbp-2Ch]
char *v41; // [rsp+148h] [rbp-28h]
char *v42; // [rsp+150h] [rbp-20h]
_QWORD **v43; // [rsp+160h] [rbp-10h]
v26 = a7;
v27 = a8;
v28 = a9;
v29 = a10;
v30 = a11;
v31 = a12;
v32 = a13;
v33 = a14;
v25 = a6;
v24 = a5;
v23 = a4;
v22 = a3;
v21 = a2;
v43 = a1;
v42 = &v20;
v41 = &a15;
v40 = 48;
v39 = 8;
for ( i = 0LL; ; i += (v34 + 7) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( (unsigned int)v39 > 0x28 )
{
v15 = v41;
v41 += 8;
}
else
{
v15 = &v42[v39];
v39 += 8;
}
v38 = *(char ***)v15;
if ( !v38 )
break;
if ( (unsigned int)v39 > 0x28 )
{
v16 = v41;
v41 += 8;
}
else
{
v16 = &v42[v39];
v39 += 8;
}
v34 = *(unsigned int *)v16;
}
v37 = alloc_root(v43, i);
if ( !v37 )
return 0LL;
v42 = &v20;
v41 = &a15;
v40 = 48;
v39 = 8;
for ( j = v37; ; j += (v34 + 7) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( (unsigned int)v39 > 0x28 )
{
v17 = v41;
v41 += 8;
}
else
{
v17 = &v42[v39];
v39 += 8;
}
v38 = *(char ***)v17;
if ( !v38 )
break;
*v38 = j;
if ( (unsigned int)v39 > 0x28 )
{
v18 = v41;
v41 += 8;
}
else
{
v18 = &v42[v39];
v39 += 8;
}
v34 = *(unsigned int *)v18;
}
return v37;
}
| multi_alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x001ed751
MOVAPS xmmword ptr [RBP + -0xe0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM2
MOVAPS xmmword ptr [RBP + -0xb0],XMM3
MOVAPS xmmword ptr [RBP + -0xa0],XMM4
MOVAPS xmmword ptr [RBP + -0x90],XMM5
MOVAPS xmmword ptr [RBP + -0x80],XMM6
MOVAPS xmmword ptr [RBP + -0x70],XMM7
LAB_001ed751:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV qword ptr [RBP + -0x108],RSI
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
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],0x8
MOV qword ptr [RBP + -0x50],0x0
LAB_001ed7a4:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x114],EAX
CMP EAX,0x28
JA 0x001ed7df
MOV RCX,qword ptr [RBP + -0x120]
MOV EDX,dword ptr [RBP + -0x114]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x001ed7fc
LAB_001ed7df:
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x128],RAX
LAB_001ed7fc:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ed896
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x001ed84f
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x001ed86c
LAB_001ed84f:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_001ed86c:
MOV RAX,qword ptr [RBP + -0x140]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001ed7a4
LAB_001ed896:
LEA RAX,[RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x001ed460
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001ed8c0
JMP 0x001ed8b3
LAB_001ed8b3:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001ed9f5
LAB_001ed8c0:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
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],0x8
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ed8ec:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x150],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x144],EAX
CMP EAX,0x28
JA 0x001ed927
MOV RCX,qword ptr [RBP + -0x150]
MOV EDX,dword ptr [RBP + -0x144]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x158],RAX
JMP 0x001ed944
LAB_001ed927:
MOV RCX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x158],RAX
LAB_001ed944:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ed9e9
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x168],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x15c],EAX
CMP EAX,0x28
JA 0x001ed9a2
MOV RCX,qword ptr [RBP + -0x168]
MOV EDX,dword ptr [RBP + -0x15c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x170],RAX
JMP 0x001ed9bf
LAB_001ed9a2:
MOV RCX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x170],RAX
LAB_001ed9bf:
MOV RAX,qword ptr [RBP + -0x170]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001ed8ec
LAB_001ed9e9:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001ed9f5:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long multi_alloc_root(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
uint *local_178;
uint *local_160;
uint *local_148;
uint *local_130;
uint local_118 [2];
int8 local_110;
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
ulong local_60;
long local_58;
long local_50;
long local_40;
uint local_38;
int4 local_34;
uint *local_30;
uint *local_28;
int8 local_18;
long local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (uint *)&stack0x00000008;
local_34 = 0x30;
local_38 = 8;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (uint *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 2;
}
local_40 = *(long *)local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (uint *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 2;
}
local_60 = (ulong)*local_148;
local_58 = (local_60 + 7 & 0xfffffffffffffff8) + local_58;
}
local_110 = param_10;
local_108 = param_11;
local_100 = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_18 = param_9;
local_10 = alloc_root(param_9,local_58);
if (local_10 == 0) {
local_10 = 0;
}
else {
local_30 = (uint *)&stack0x00000008;
local_38 = 8;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (uint *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 2;
}
if (*(long **)local_160 == (long *)0x0) break;
**(long **)local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (uint *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 2;
}
local_50 = ((ulong)*local_178 + 7 & 0xfffffffffffffff8) + local_50;
}
}
return local_10;
}
| |
52,393 | nglog::DumpStackTrace(int, void (*)(char const*, void*), void*) | ng-log[P]ng-log/src/utilities.cc | static void DumpStackTrace(int skip_count, DebugWriter* writerfn, void* arg) {
// Print stack trace
void* stack[32];
int depth = GetStackTrace(stack, ARRAYSIZE(stack), skip_count + 1);
for (int i = 0; i < depth; i++) {
# if defined(HAVE_SYMBOLIZE)
if (FLAGS_symbolize_stacktrace) {
DumpPCAndSymbol(writerfn, arg, stack[i], " ");
} else {
DumpPC(writerfn, arg, stack[i], " ");
}
# else
DumpPC(writerfn, arg, stack[i], " ");
# endif
}
} | O1 | cpp | nglog::DumpStackTrace(int, void (*)(char const*, void*), void*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x918, %rsp # imm = 0x918
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
movl $0x2, %edx
callq 0x202e0
testl %eax, %eax
jle 0x214ec
movl %eax, %r13d
leaq 0x110(%rsp), %r15
xorl %ebp, %ebp
movq 0x10(%rsp,%rbp,8), %r12
leaq 0xe68f(%rip), %rax # 0x2fac9
cmpb $0x1, (%rax)
jne 0x214b1
leaq -0x1(%r12), %rdi
movl $0x400, %edx # imm = 0x400
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x20586
testb %al, %al
leaq 0x1174(%rip), %rax # 0x225d0
cmovneq %r15, %rax
movq %rax, (%rsp)
movl $0x400, %esi # imm = 0x400
movq %r13, %r15
movq %r14, %r13
movq %rbx, %r14
leaq 0x510(%rsp), %rbx
movq %rbx, %rdi
leaq 0x2b27(%rip), %rdx # 0x23fab
leaq 0x2881(%rip), %rcx # 0x23d0c
movl $0x12, %r8d
movq %r12, %r9
xorl %eax, %eax
callq 0x78b0
movq %rbx, %rdi
movq %r14, %rbx
movq %r13, %r14
movq %r15, %r13
leaq 0x110(%rsp), %r15
jmp 0x214da
movl $0x64, %esi
movq %r15, %rdi
leaq 0x2af8(%rip), %rdx # 0x23fb8
leaq 0x2845(%rip), %rcx # 0x23d0c
movl $0x12, %r8d
movq %r12, %r9
xorl %eax, %eax
callq 0x78b0
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
incq %rbp
cmpq %rbp, %r13
jne 0x2142e
addq $0x918, %rsp # imm = 0x918
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5nglogL14DumpStackTraceEiPFvPKcPvES2_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 918h
mov rbx, rsi
mov r14, rdi
lea rdi, [rsp+948h+var_938]; this
mov esi, offset qword_20; void **
mov edx, 2; int
call _ZN5nglog5tools13GetStackTraceEPPvii; nglog::tools::GetStackTrace(void **,int,int)
test eax, eax
jle loc_214EC
mov r13d, eax
lea r15, [rsp+948h+var_838]
xor ebp, ebp
loc_2142E:
mov r12, [rsp+rbp*8+948h+var_938]
lea rax, _ZN3fLB26FLAGS_symbolize_stacktraceE; fLB::FLAGS_symbolize_stacktrace
cmp byte ptr [rax], 1
jnz short loc_214B1
lea rdi, [r12-1]
mov edx, 400h
mov rsi, r15
xor ecx, ecx
call _ZN5nglog5tools9SymbolizeEPvPcmNS0_16SymbolizeOptionsE; nglog::tools::Symbolize(void *,char *,ulong,nglog::tools::SymbolizeOptions)
test al, al
lea rax, aUnknown; "(unknown)"
cmovnz rax, r15
mov [rsp+948h+var_948], rax
mov esi, 400h
mov r15, r13
mov r13, r14
mov r14, rbx
lea rbx, [rsp+948h+var_438]
mov rdi, rbx
lea rdx, aSPS; "%s@ %*p %s\n"
lea rcx, asc_23D0C; " "
mov r8d, 12h
mov r9, r12
xor eax, eax
call _snprintf
mov rdi, rbx
mov rbx, r14
mov r14, r13
mov r13, r15
lea r15, [rsp+948h+var_838]
jmp short loc_214DA
loc_214B1:
mov esi, 64h ; 'd'
mov rdi, r15
lea rdx, aSP; "%s@ %*p\n"
lea rcx, asc_23D0C; " "
mov r8d, 12h
mov r9, r12
xor eax, eax
call _snprintf
mov rdi, r15
loc_214DA:
mov rsi, rbx
call r14
inc rbp
cmp r13, rbp
jnz loc_2142E
loc_214EC:
add rsp, 918h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nglog::DumpStackTrace(nglog *this, long long a2, void (*a3)(const char *, void *), void *a4)
{
long long result; // rax
long long v5; // r13
long long i; // rbp
const void *v7; // r12
bool v8; // zf
const char *v9; // rax
_QWORD v10[32]; // [rsp+10h] [rbp-938h] BYREF
_BYTE v11[1024]; // [rsp+110h] [rbp-838h] BYREF
_BYTE v12[1080]; // [rsp+510h] [rbp-438h] BYREF
result = nglog::tools::GetStackTrace((nglog::tools *)v10, (void **)&qword_20, 2);
if ( (int)result > 0 )
{
v5 = (unsigned int)result;
for ( i = 0LL; i != v5; ++i )
{
v7 = (const void *)v10[i];
if ( fLB::FLAGS_symbolize_stacktrace == 1 )
{
v8 = (unsigned __int8)nglog::tools::Symbolize(
(unsigned long long)v7 - 1,
(nglog::tools::_anonymous_namespace_ *)v11,
(char *)&stru_400) == 0;
v9 = "(unknown)";
if ( !v8 )
v9 = v11;
snprintf(v12, 1024LL, "%s@ %*p %s\n", " ", 18, v7, v9);
result = ((long long ( *)(_BYTE *, long long))this)(v12, a2);
}
else
{
snprintf(v11, 100LL, "%s@ %*p\n", " ", 18, (const void *)v10[i]);
result = ((long long ( *)(_BYTE *, long long))this)(v11, a2);
}
}
}
return result;
}
| DumpStackTrace:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x918
MOV RBX,RSI
MOV R14,RDI
LEA RDI,[RSP + 0x10]
MOV ESI,0x20
MOV EDX,0x2
CALL 0x001202e0
TEST EAX,EAX
JLE 0x001214ec
MOV R13D,EAX
LEA R15,[RSP + 0x110]
XOR EBP,EBP
LAB_0012142e:
MOV R12,qword ptr [RSP + RBP*0x8 + 0x10]
LEA RAX,[0x12fac9]
CMP byte ptr [RAX],0x1
JNZ 0x001214b1
LEA RDI,[R12 + -0x1]
MOV EDX,0x400
MOV RSI,R15
XOR ECX,ECX
CALL 0x00120586
TEST AL,AL
LEA RAX,[0x1225d0]
CMOVNZ RAX,R15
MOV qword ptr [RSP],RAX
MOV ESI,0x400
MOV R15,R13
MOV R13,R14
MOV R14,RBX
LEA RBX,[RSP + 0x510]
MOV RDI,RBX
LEA RDX,[0x123fab]
LEA RCX,[0x123d0c]
MOV R8D,0x12
MOV R9,R12
XOR EAX,EAX
CALL 0x001078b0
MOV RDI,RBX
MOV RBX,R14
MOV R14,R13
MOV R13,R15
LEA R15,[RSP + 0x110]
JMP 0x001214da
LAB_001214b1:
MOV ESI,0x64
MOV RDI,R15
LEA RDX,[0x123fb8]
LEA RCX,[0x123d0c]
MOV R8D,0x12
MOV R9,R12
XOR EAX,EAX
CALL 0x001078b0
MOV RDI,R15
LAB_001214da:
MOV RSI,RBX
CALL R14
INC RBP
CMP R13,RBP
JNZ 0x0012142e
LAB_001214ec:
ADD RSP,0x918
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::DumpStackTrace(int, void (*)(char const*, void*), void*) */
void nglog::DumpStackTrace(int param_1,_func_void_char_ptr_void_ptr *param_2,void *param_3)
{
void *pvVar1;
char cVar2;
uint uVar3;
char *pcVar4;
ulong uVar5;
int4 in_register_0000003c;
char *__s;
void *local_938 [32];
char local_838 [1024];
char local_438 [1032];
uVar3 = tools::GetStackTrace(local_938,0x20,2);
if (0 < (int)uVar3) {
uVar5 = 0;
do {
__s = local_838;
pvVar1 = local_938[uVar5];
if (fLB::FLAGS_symbolize_stacktrace == '\x01') {
cVar2 = tools::Symbolize((long)pvVar1 + -1,__s,0x400,0);
pcVar4 = "(unknown)";
if (cVar2 != '\0') {
pcVar4 = __s;
}
__s = local_438;
snprintf(__s,0x400,"%s@ %*p %s\n",&DAT_00123d0c,0x12,pvVar1,pcVar4);
}
else {
snprintf(__s,100,"%s@ %*p\n",&DAT_00123d0c,0x12,pvVar1);
}
(*(code *)CONCAT44(in_register_0000003c,param_1))(__s,param_2);
uVar5 = uVar5 + 1;
} while (uVar3 != uVar5);
}
return;
}
| |
52,394 | inline_mysql_cond_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
} | O0 | c | inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x25b35e(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| inline_mysql_cond_init_2:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_cond_init_2(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = ((long long ( *)(_QWORD, long long))PSI_server[12])(a1, a2);
return pthread_cond_init(a2, a3);
}
| inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a370
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
| |
52,395 | 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());
} | 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> 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 $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7f378
testb %al, %al
je 0x9e99b
addq $0x40, %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0x69646
jmp 0x9eb5f
movq %r14, %rdi
callq 0x7f972
testb %al, %al
je 0x9e9b6
movq %r13, %rdi
xorl %esi, %esi
callq 0x64c84
jmp 0x9eb5f
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x9ea21
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
movq (%rax), %r15
movq 0x8(%rax), %rbx
leaq 0x38(%rsp), %r12
cmpq %rbx, %r15
je 0x9ea05
movq %r12, %rdi
movq %r15, %rsi
callq 0x9e964
movq %r14, %rdi
movq %r12, %rsi
callq 0x69268
movq %r12, %rdi
callq 0x64c70
addq $0x50, %r15
jmp 0x9e9dc
leaq 0x10(%rsp), %rsi
movq %r13, %rdi
callq 0x9f36a
leaq 0x10(%rsp), %rdi
callq 0x6a31c
jmp 0x9eb5f
cmpq $0x0, 0x20(%r14)
je 0x9ebd7
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9f3a2
movq 0x20(%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x78(%rsp), %rbp
leaq 0xa8(%rsp), %r13
leaq 0x88(%rsp), %r12
cmpq 0x30(%rsp), %r15
je 0x9eb1a
leaq 0x10(%r15), %rsi
movzbl (%r15), %eax
testl %eax, %eax
je 0x9eac7
cmpl $0x4, %eax
je 0x9eac7
cmpl $0x3, %eax
jne 0x9eabd
leaq 0x68(%rsp), %rdi
callq 0x9e964
movq %r12, %rdi
movq %r15, %rsi
callq 0x80052
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x9a56a
movq %r12, %rbx
movq %rax, %rdi
leaq 0x68(%rsp), %r12
movq %r12, %rsi
callq 0x67582
movq %rbx, %rdi
jmp 0x9eb04
addb $-0x5, %al
cmpb $0x3, %al
ja 0x9eb74
movq %rbp, %rdi
callq 0x9e964
movq %r13, %rdi
movq %r15, %rsi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7956c
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x9a56a
movq %rax, %rdi
movq %rbp, %rsi
callq 0x67582
movq %r13, %rdi
movq %rbp, %r12
callq 0x27998
movq %r12, %rdi
callq 0x64c70
addq $0x60, %r15
jmp 0x9ea5a
cmpq $0x0, 0x30(%r14)
movq 0x8(%rsp), %r13
je 0x9eb5f
leaq 0x10(%rsp), %rsi
movb $0x1, (%rsi)
leaq 0x58(%rsp), %rdi
callq 0x9f3b6
leaq 0x33bab(%rip), %rsi # 0xd26ea
movq %r13, %rdi
callq 0x968b2
leaq 0x58(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x67582
movq %r14, %rdi
callq 0x64c70
movq %r13, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %r12
leaq 0x38(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x20
popq %rcx
movq %r15, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x7956c
leaq 0x33b21(%rip), %rsi # 0xd26c0
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x74aaa
movb $0x1, %bl
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x27450
xorl %ebx, %ebx
movq 0x8242a(%rip), %rsi # 0x120ff0
movq 0x8238b(%rip), %rdx # 0x120f58
movq %r12, %rdi
callq 0x275b0
jmp 0x9ec32
pushq $0x10
popq %rdi
callq 0x265e0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x7f388
leaq 0x33afc(%rip), %rsi # 0xd26f7
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x74aaa
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x27450
xorl %ebp, %ebp
movq 0x823cd(%rip), %rsi # 0x120ff0
movq 0x8232e(%rip), %rdx # 0x120f58
movq %rbx, %rdi
callq 0x275b0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x27998
jmp 0x9ec47
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rdi
callq 0x27998
testb %bpl, %bpl
jne 0x9ec5e
jmp 0x9ed10
movq %rax, %r14
movq %rbx, %rdi
callq 0x268f0
jmp 0x9ed10
movq %rax, %r14
leaq 0x58(%rsp), %rdi
jmp 0x9ecde
jmp 0x9ecf4
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x27998
jmp 0x9ec8b
movq %rax, %r14
movb $0x1, %bl
leaq 0x38(%rsp), %rdi
callq 0x27998
testb %bl, %bl
jne 0x9ec9e
jmp 0x9ece8
movq %rax, %r14
movq %r12, %rdi
callq 0x268f0
jmp 0x9ece8
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x27998
jmp 0x9ecbd
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x9ecde
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x27998
jmp 0x9ecd9
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x64c70
jmp 0x9ece8
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x64c70
jmp 0x9ed10
movq %rax, %r14
jmp 0x9ed06
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x64c70
leaq 0x10(%rsp), %rdi
callq 0x6a31c
movq %r14, %rdi
callq 0x27660
| _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, 0C8h
mov r14, rsi
mov r13, rdi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_9E99B
add r14, 40h ; '@'
mov rdi, r13
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_9EB5F
loc_9E99B:
mov rdi, r14; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_9E9B6
mov rdi, r13
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))
jmp loc_9EB5F
loc_9E9B6:
mov rax, [r14+10h]
test rax, rax
jz short loc_9EA21
xorps xmm0, xmm0
lea r14, [rsp+0F8h+var_E8]
and qword ptr [r14+10h], 0
movaps xmmword ptr [r14], xmm0
mov r15, [rax]
mov rbx, [rax+8]
lea r12, [rsp+0F8h+var_C0]
loc_9E9DC:
cmp r15, rbx
jz short loc_9EA05
mov rdi, r12
mov rsi, r15
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, r14
mov rsi, r12
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, r12
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()
add r15, 50h ; 'P'
jmp short loc_9E9DC
loc_9EA05:
lea rsi, [rsp+0F8h+var_E8]
mov rdi, r13
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_
lea rdi, [rsp+0F8h+var_E8]
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_9EB5F
loc_9EA21:
cmp qword ptr [r14+20h], 0
jz loc_9EBD7
mov [rsp+0F8h+var_F0], r13
mov rdi, r13
xor esi, esi
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6objectESt16initializer_listINS0_6detail8json_refISD_EEE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::object(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>>>)
mov rax, [r14+20h]
mov r15, [rax]
mov rax, [rax+8]
mov [rsp+0F8h+var_C8], rax
lea rbp, [rsp+0F8h+var_80]
lea r13, [rsp+0F8h+var_50]
loc_9EA5A:
lea r12, [rsp+0F8h+var_70]
cmp r15, [rsp+0F8h+var_C8]
jz loc_9EB1A
lea rsi, [r15+10h]
movzx eax, byte ptr [r15]
test eax, eax
jz short loc_9EAC7
cmp eax, 4
jz short loc_9EAC7
cmp eax, 3
jnz short loc_9EABD
lea rdi, [rsp+0F8h+var_90]
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 _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, [rsp+0F8h+var_F0]
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 rbx, r12
mov rdi, rax
lea r12, [rsp+0F8h+var_90]
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, rbx
jmp short loc_9EB04
loc_9EABD:
add al, 0FBh
cmp al, 3
ja loc_9EB74
loc_9EAC7:
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, r13
mov rsi, r15
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
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, [rsp+0F8h+var_F0]
mov rsi, r13
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, r13; void *
mov r12, rbp
loc_9EB04:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r12
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()
add r15, 60h ; '`'
jmp loc_9EA5A
loc_9EB1A:
cmp qword ptr [r14+30h], 0
mov r13, [rsp+0F8h+var_F0]
jz short loc_9EB5F
lea rsi, [rsp+0F8h+var_E8]
mov byte ptr [rsi], 1
lea rdi, [rsp+0F8h+var_A0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
lea rsi, aCallable; "__callable__"
mov rdi, r13
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+0F8h+var_A0]
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
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_9EB5F:
mov rax, r13
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9EB74:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r12, rax
lea rdi, [rsp+0F8h+var_C0]
push 0FFFFFFFFFFFFFFFFh
pop rdx
push 20h ; ' '
pop rcx
mov rsi, r15
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"...
lea rdi, [rsp+0F8h+var_E8]
lea rdx, [rsp+0F8h+var_C0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bl, 1
lea rsi, [rsp+0F8h+var_E8]
mov rdi, r12
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebx, ebx
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r12; void *
call ___cxa_throw
jmp short loc_9EC32
loc_9EBD7:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+0F8h+var_C0]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetJsonNotDefi; "get<json> not defined for this value ty"...
lea rdi, [rsp+0F8h+var_E8]
lea rdx, [rsp+0F8h+var_C0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+0F8h+var_E8]
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_9EC32:
mov r14, rax
lea rdi, [rsp+0F8h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_9EC47
mov r14, rax
mov bpl, 1
loc_9EC47:
lea rdi, [rsp+0F8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_9EC5E
jmp loc_9ED10
mov r14, rax
loc_9EC5E:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp loc_9ED10
mov r14, rax
lea rdi, [rsp+0F8h+var_A0]
jmp short loc_9ECDE
jmp short loc_9ECF4
mov r14, rax
lea rdi, [rsp+0F8h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_9EC8B
mov r14, rax
mov bl, 1
loc_9EC8B:
lea rdi, [rsp+0F8h+var_C0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bl, bl
jnz short loc_9EC9E
jmp short loc_9ECE8
mov r14, rax
loc_9EC9E:
mov rdi, r12; void *
call ___cxa_free_exception
jmp short loc_9ECE8
mov r14, rax
lea rdi, [rsp+0F8h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_9ECBD
mov r14, rax
loc_9ECBD:
lea rdi, [rsp+0F8h+var_90]
jmp short loc_9ECDE
mov r14, rax
lea rdi, [rsp+0F8h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_9ECD9
mov r14, rax
loc_9ECD9:
lea rdi, [rsp+0F8h+var_80]
loc_9ECDE:
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_9ECE8
mov r14, rax
loc_9ECE8:
mov rdi, [rsp+0F8h+var_F0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_9ED10
loc_9ECF4:
mov r14, rax
jmp short loc_9ED06
mov r14, rax
lea rdi, [rsp+0F8h+var_C0]
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_9ED06:
lea rdi, [rsp+0F8h+var_E8]
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_9ED10:
mov rdi, r14
call __Unwind_Resume
| unsigned __int8 * 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>>(
unsigned __int8 *a1,
long long a2)
{
long long *v4; // rax
long long v5; // r15
long long v6; // rbx
long long v7; // rax
_BYTE *v8; // r15
_BYTE *v9; // rsi
int v10; // eax
long long v11; // rax
_BYTE *v12; // r12
_QWORD *v13; // rdi
long long v14; // rax
long long v15; // rax
void *v17; // r12
void *exception; // rbx
__int128 v20; // [rsp+10h] [rbp-E8h] BYREF
long long v21; // [rsp+20h] [rbp-D8h]
_BYTE *v22; // [rsp+30h] [rbp-C8h]
_BYTE v23[32]; // [rsp+38h] [rbp-C0h] BYREF
_BYTE v24[16]; // [rsp+58h] [rbp-A0h] BYREF
_BYTE v25[16]; // [rsp+68h] [rbp-90h] BYREF
_BYTE v26[16]; // [rsp+78h] [rbp-80h] BYREF
_QWORD v27[4]; // [rsp+88h] [rbp-70h] BYREF
_QWORD v28[10]; // [rsp+A8h] [rbp-50h] BYREF
if ( minja::Value::is_primitive((minja::Value *)a2) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
a1,
(unsigned __int8 *)(a2 + 64));
return a1;
}
if ( minja::Value::is_null((minja::Value *)a2) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json((long long)a1);
return a1;
}
v4 = *(long long **)(a2 + 16);
if ( v4 )
{
v21 = 0LL;
v20 = 0LL;
v5 = *v4;
v6 = v4[1];
while ( v5 != v6 )
{
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>>(
v23,
v5);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::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)&v20,
(long long)v23);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v23);
v5 += 80LL;
}
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,
&v20);
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 *)&v20);
return a1;
}
if ( !*(_QWORD *)(a2 + 32) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v23, a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)&v20, (long long)"get<json> not defined for this value type: ", (long long)v23);
std::runtime_error::runtime_error(exception, &v20);
__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>::object(
a1,
0LL,
0LL);
v7 = *(_QWORD *)(a2 + 32);
v8 = *(_BYTE **)v7;
v22 = *(_BYTE **)(v7 + 8);
while ( v8 != v22 )
{
v9 = v8 + 16;
v10 = (unsigned __int8)*v8;
if ( *v8 && v10 != 4 )
{
if ( v10 == 3 )
{
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,
v9);
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)v27,
(long long)v8);
v11 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
(long long)a1,
v27);
v12 = 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>::operator=(
v11,
(long long)v25);
v13 = v27;
goto LABEL_19;
}
if ( (unsigned __int8)(v10 - 5) > 3u )
{
v17 = __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)v23,
(long long)v8,
-1,
32,
0,
0);
std::operator+<char>((long long)&v20, (long long)"Invalid key type for conversion to JSON: ", (long long)v23);
std::runtime_error::runtime_error(v17, &v20);
__cxa_throw(
v17,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
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,
v9);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::dump(
(long long)v28,
(long long)v8,
-1,
32,
0,
0);
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[](
(long long)a1,
v28);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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);
v13 = v28;
v12 = v26;
LABEL_19:
std::string::~string(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v12);
v8 += 96;
}
if ( *(_QWORD *)(a2 + 48) )
{
LOBYTE(v20) = 1;
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(
v24,
&v20);
v15 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
(long long)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=(
v15,
(long long)v24);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v24);
}
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,0xc8
MOV R14,RSI
MOV R13,RDI
MOV RDI,RSI
CALL 0x0017f378
TEST AL,AL
JZ 0x0019e99b
ADD R14,0x40
MOV RDI,R13
MOV RSI,R14
CALL 0x00169646
JMP 0x0019eb5f
LAB_0019e99b:
MOV RDI,R14
CALL 0x0017f972
TEST AL,AL
JZ 0x0019e9b6
MOV RDI,R13
XOR ESI,ESI
CALL 0x00164c84
JMP 0x0019eb5f
LAB_0019e9b6:
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
JZ 0x0019ea21
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
AND qword ptr [R14 + 0x10],0x0
MOVAPS xmmword ptr [R14],XMM0
MOV R15,qword ptr [RAX]
MOV RBX,qword ptr [RAX + 0x8]
LEA R12,[RSP + 0x38]
LAB_0019e9dc:
CMP R15,RBX
JZ 0x0019ea05
LAB_0019e9e1:
MOV RDI,R12
MOV RSI,R15
CALL 0x0019e964
LAB_0019e9ec:
MOV RDI,R14
MOV RSI,R12
CALL 0x00169268
MOV RDI,R12
CALL 0x00164c70
ADD R15,0x50
JMP 0x0019e9dc
LAB_0019ea05:
LEA RSI,[RSP + 0x10]
MOV RDI,R13
CALL 0x0019f36a
LAB_0019ea12:
LEA RDI,[RSP + 0x10]
CALL 0x0016a31c
JMP 0x0019eb5f
LAB_0019ea21:
CMP qword ptr [R14 + 0x20],0x0
JZ 0x0019ebd7
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0019f3a2
MOV RAX,qword ptr [R14 + 0x20]
MOV R15,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RAX
LEA RBP,[RSP + 0x78]
LEA R13,[RSP + 0xa8]
LAB_0019ea5a:
LEA R12,[RSP + 0x88]
CMP R15,qword ptr [RSP + 0x30]
JZ 0x0019eb1a
LEA RSI,[R15 + 0x10]
MOVZX EAX,byte ptr [R15]
TEST EAX,EAX
JZ 0x0019eac7
CMP EAX,0x4
JZ 0x0019eac7
CMP EAX,0x3
JNZ 0x0019eabd
LAB_0019ea83:
LEA RDI,[RSP + 0x68]
CALL 0x0019e964
LAB_0019ea8d:
MOV RDI,R12
MOV RSI,R15
CALL 0x00180052
LAB_0019ea98:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x0019a56a
MOV RBX,R12
MOV RDI,RAX
LEA R12,[RSP + 0x68]
MOV RSI,R12
CALL 0x00167582
MOV RDI,RBX
JMP 0x0019eb04
LAB_0019eabd:
ADD AL,0xfb
CMP AL,0x3
JA 0x0019eb74
LAB_0019eac7:
MOV RDI,RBP
CALL 0x0019e964
LAB_0019eacf:
MOV RDI,R13
MOV RSI,R15
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0017956c
LAB_0019eae6:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R13
CALL 0x0019a56a
MOV RDI,RAX
MOV RSI,RBP
CALL 0x00167582
MOV RDI,R13
MOV R12,RBP
LAB_0019eb04:
CALL 0x00127998
MOV RDI,R12
CALL 0x00164c70
ADD R15,0x60
JMP 0x0019ea5a
LAB_0019eb1a:
CMP qword ptr [R14 + 0x30],0x0
MOV R13,qword ptr [RSP + 0x8]
JZ 0x0019eb5f
LEA RSI,[RSP + 0x10]
MOV byte ptr [RSI],0x1
LEA RDI,[RSP + 0x58]
CALL 0x0019f3b6
LAB_0019eb38:
LEA RSI,[0x1d26ea]
MOV RDI,R13
CALL 0x001968b2
LAB_0019eb47:
LEA R14,[RSP + 0x58]
MOV RDI,RAX
MOV RSI,R14
CALL 0x00167582
MOV RDI,R14
CALL 0x00164c70
LAB_0019eb5f:
MOV RAX,R13
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019eb74:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV R12,RAX
LAB_0019eb7f:
LEA RDI,[RSP + 0x38]
PUSH -0x1
POP RDX
PUSH 0x20
POP RCX
MOV RSI,R15
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0017956c
LAB_0019eb98:
LEA RSI,[0x1d26c0]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x38]
CALL 0x00174aaa
MOV BL,0x1
LAB_0019ebb0:
LEA RSI,[RSP + 0x10]
MOV RDI,R12
CALL 0x00127450
XOR EBX,EBX
MOV RSI,qword ptr [0x00220ff0]
MOV RDX,qword ptr [0x00220f58]
MOV RDI,R12
CALL 0x001275b0
LAB_0019ebd7:
PUSH 0x10
POP RDI
CALL 0x001265e0
MOV RBX,RAX
LAB_0019ebe2:
LEA RDI,[RSP + 0x38]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0017f388
LAB_0019ebf4:
LEA RSI,[0x1d26f7]
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0x38]
CALL 0x00174aaa
MOV BPL,0x1
LAB_0019ec0d:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00127450
XOR EBP,EBP
MOV RSI,qword ptr [0x00220ff0]
MOV RDX,qword ptr [0x00220f58]
MOV RDI,RBX
CALL 0x001275b0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>>
(void)
{
long *plVar1;
long lVar2;
char cVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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;
runtime_error *prVar5;
Value *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;
string *this;
long lVar6;
char *pcVar7;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
char *local_c8;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_c0 [32];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_a0 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_90 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_80 [16];
string local_70 [32];
string local_50 [32];
cVar3 = is_primitive(in_RSI);
if (cVar3 == '\0') {
cVar3 = is_null(in_RSI);
if (cVar3 == '\0') {
plVar1 = *(long **)(in_RSI + 0x10);
if (plVar1 == (long *)0x0) {
if (*(long *)(in_RSI + 0x20) == 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019ebe2 to 0019ebf3 has its CatchHandler @ 0019ec5b */
dump_abi_cxx11_((int)local_c0,SUB81(in_RSI,0));
/* try { // try from 0019ebf4 to 0019ec09 has its CatchHandler @ 0019ec41 */
std::operator+((char *)&local_e8,(string *)"get<json> not defined for this value type: ");
/* try { // try from 0019ec0d to 0019ec31 has its CatchHandler @ 0019ec32 */
std::runtime_error::runtime_error(prVar5,(string *)&local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00220ff0,PTR__runtime_error_00220f58);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::object();
local_c8 = (char *)(*(int8 **)(in_RSI + 0x20))[1];
for (pcVar7 = (char *)**(int8 **)(in_RSI + 0x20); pcVar7 != local_c8;
pcVar7 = pcVar7 + 0x60) {
cVar3 = *pcVar7;
if ((cVar3 == '\0') || (cVar3 == '\x04')) {
LAB_0019eac7:
/* try { // try from 0019eac7 to 0019eace has its CatchHandler @ 0019ece5 */
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 0019eacf to 0019eae5 has its CatchHandler @ 0019ecd6 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_50,pcVar7,0xffffffffffffffff,0x20,0,0);
/* try { // try from 0019eae6 to 0019eaf2 has its CatchHandler @ 0019ecc4 */
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[](in_RDI,local_50);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_80);
this = local_50;
pbVar4 = local_80;
}
else {
if (cVar3 != '\x03') {
if (3 < (byte)(cVar3 - 5U)) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10,pcVar7 + 0x10);
/* try { // try from 0019eb7f to 0019eb97 has its CatchHandler @ 0019ec9b */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_c0,pcVar7,0xffffffffffffffff,0x20,0,0);
/* try { // try from 0019eb98 to 0019ebad has its CatchHandler @ 0019ec86 */
std::operator+((char *)&local_e8,
(string *)"Invalid key type for conversion to JSON: ");
/* try { // try from 0019ebb0 to 0019ebd4 has its CatchHandler @ 0019ec77 */
std::runtime_error::runtime_error(prVar5,(string *)&local_e8);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00220ff0,PTR__runtime_error_00220f58);
}
goto LAB_0019eac7;
}
/* try { // try from 0019ea83 to 0019ea8c has its CatchHandler @ 0019ece5 */
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 0019ea8d to 0019ea97 has its CatchHandler @ 0019ecba */
_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_70,pcVar7);
/* try { // try from 0019ea98 to 0019eaa4 has its CatchHandler @ 0019eca8 */
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[](in_RDI,local_70);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_90);
this = local_70;
pbVar4 = local_90;
}
std::__cxx11::string::~string(this);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(pbVar4);
}
if (*(long *)(in_RSI + 0x30) != 0) {
local_e8 = CONCAT71(local_e8._1_7_,1);
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IbbTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_a0);
/* try { // try from 0019eb38 to 0019eb46 has its CatchHandler @ 0019ec6b */
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[]<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=(pbVar4,local_a0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_a0);
}
}
else {
local_d8 = 0;
local_e8 = 0;
uStack_e0 = 0;
lVar2 = plVar1[1];
for (lVar6 = *plVar1; lVar6 != lVar2; lVar6 = lVar6 + 0x50) {
/* try { // try from 0019e9e1 to 0019e9eb has its CatchHandler @ 0019ecf4 */
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 0019e9ec to 0019e9f6 has its CatchHandler @ 0019ecf9 */
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,local_c0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_c0);
}
/* try { // try from 0019ea05 to 0019ea11 has its CatchHandler @ 0019ec75 */
_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);
}
}
else {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)in_RDI);
}
}
else {
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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,in_RSI + 0x40);
}
return in_RDI;
}
| |
52,396 | my_xml_enter | eloqsql/strings/xml.c | static int my_xml_enter(MY_XML_PARSER *st, const char *str, size_t len)
{
if (my_xml_attr_ensure_space(st, len + 1 /* the separator char */))
return MY_XML_ERROR;
if (st->attr.end > st->attr.start)
{
st->attr.end[0]= '/';
st->attr.end++;
}
memcpy(st->attr.end, str, len);
st->attr.end+= len;
st->attr.end[0]= '\0';
if (st->flags & MY_XML_FLAG_RELATIVE_NAMES)
return st->enter ? st->enter(st, str, len) : MY_XML_OK;
else
return st->enter ?
st->enter(st, st->attr.start, st->attr.end - st->attr.start) : MY_XML_OK;
} | O0 | c | my_xml_enter:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x786f0
cmpl $0x0, %eax
je 0x78226
movl $0x1, -0x4(%rbp)
jmp 0x7833c
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x118(%rcx), %rax
jbe 0x78262
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movb $0x2f, (%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x24230
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x120(%rax), %rcx
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x782e7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x782d8
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
jmp 0x782df
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x782df
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7833c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x148(%rax)
je 0x7832f
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x120(%rcx), %rdx
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rdx
callq *%rax
movl %eax, -0x28(%rbp)
jmp 0x78336
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x78336
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_xml_enter:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
add rsi, 1
call my_xml_attr_ensure_space
cmp eax, 0
jz short loc_78226
mov [rbp+var_4], 1
jmp loc_7833C
loc_78226:
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+118h]
jbe short loc_78262
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_10]
mov rcx, [rax+120h]
add rcx, 1
mov [rax+120h], rcx
loc_78262:
mov rax, [rbp+var_10]
mov rdi, [rax+120h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+120h]
mov [rax+120h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 1
cmp eax, 0
jz short loc_782E7
mov rax, [rbp+var_10]
cmp qword ptr [rax+148h], 0
jz short loc_782D8
mov rax, [rbp+var_10]
mov rax, [rax+148h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_24], eax
jmp short loc_782DF
loc_782D8:
xor eax, eax
mov [rbp+var_24], eax
jmp short $+2
loc_782DF:
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_7833C
loc_782E7:
mov rax, [rbp+var_10]
cmp qword ptr [rax+148h], 0
jz short loc_7832F
mov rax, [rbp+var_10]
mov rax, [rax+148h]
mov rdi, [rbp+var_10]
mov rcx, [rbp+var_10]
mov rsi, [rcx+118h]
mov rcx, [rbp+var_10]
mov rdx, [rcx+120h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+118h]
sub rdx, rcx
call rax
mov [rbp+var_28], eax
jmp short loc_78336
loc_7832F:
xor eax, eax
mov [rbp+var_28], eax
jmp short $+2
loc_78336:
mov eax, [rbp+var_28]
mov [rbp+var_4], eax
loc_7833C:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_xml_enter(long long a1, long long a2, long long a3)
{
if ( (unsigned int)my_xml_attr_ensure_space(a1, a3 + 1) )
{
return 1;
}
else
{
if ( *(_QWORD *)(a1 + 288) > *(_QWORD *)(a1 + 280) )
*(_BYTE *)(*(_QWORD *)(a1 + 288))++ = 47;
memcpy(*(_QWORD *)(a1 + 288), a2, a3);
*(_QWORD *)(a1 + 288) += a3;
**(_BYTE **)(a1 + 288) = 0;
if ( (*(_DWORD *)a1 & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 328) )
return (unsigned int)(*(long long ( **)(long long, long long, long long))(a1 + 328))(a1, a2, a3);
else
return 0;
}
else if ( *(_QWORD *)(a1 + 328) )
{
return (unsigned int)(*(long long ( **)(long long, _QWORD, _QWORD))(a1 + 328))(
a1,
*(_QWORD *)(a1 + 280),
*(_QWORD *)(a1 + 288) - *(_QWORD *)(a1 + 280));
}
else
{
return 0;
}
}
}
| my_xml_enter:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x1
CALL 0x001786f0
CMP EAX,0x0
JZ 0x00178226
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0017833c
LAB_00178226:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x118]
JBE 0x00178262
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x120]
ADD RCX,0x1
MOV qword ptr [RAX + 0x120],RCX
LAB_00178262:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x120]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00124230
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x120]
MOV qword ptr [RAX + 0x120],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001782e7
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x148],0x0
JZ 0x001782d8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x148]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001782df
LAB_001782d8:
XOR EAX,EAX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001782df
LAB_001782df:
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017833c
LAB_001782e7:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x148],0x0
JZ 0x0017832f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x148]
MOV RDI,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x118]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x118]
SUB RDX,RCX
CALL RAX
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00178336
LAB_0017832f:
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00178336
LAB_00178336:
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017833c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_xml_enter(uint *param_1,void *param_2,size_t param_3)
{
int iVar1;
int4 local_30;
int4 local_2c;
int4 local_c;
iVar1 = my_xml_attr_ensure_space(param_1,param_3 + 1);
if (iVar1 == 0) {
if (*(ulong *)(param_1 + 0x46) < *(ulong *)(param_1 + 0x48)) {
**(int1 **)(param_1 + 0x48) = 0x2f;
*(long *)(param_1 + 0x48) = *(long *)(param_1 + 0x48) + 1;
}
memcpy(*(void **)(param_1 + 0x48),param_2,param_3);
*(size_t *)(param_1 + 0x48) = param_3 + *(long *)(param_1 + 0x48);
**(int1 **)(param_1 + 0x48) = 0;
if ((*param_1 & 1) == 0) {
if (*(long *)(param_1 + 0x52) == 0) {
local_30 = 0;
}
else {
local_30 = (**(code **)(param_1 + 0x52))
(param_1,*(int8 *)(param_1 + 0x46),
*(long *)(param_1 + 0x48) - *(long *)(param_1 + 0x46));
}
local_c = local_30;
}
else {
if (*(long *)(param_1 + 0x52) == 0) {
local_2c = 0;
}
else {
local_2c = (**(code **)(param_1 + 0x52))(param_1,param_2,param_3);
}
local_c = local_2c;
}
}
else {
local_c = 1;
}
return local_c;
}
| |
52,397 | get_default_configuration_dirs | eloqsql/libmariadb/libmariadb/ma_default.c | char **get_default_configuration_dirs()
{
#ifdef _WIN32
char dirname[FN_REFLEN];
#endif
char *env;
configuration_dirs= (char **)calloc(1, (MAX_CONFIG_DIRS + 1) * sizeof(char *));
if (!configuration_dirs)
goto end;
#ifdef _WIN32
/* On Windows operating systems configuration files are stored in
1. System Windows directory
2. System directory
3. Windows directory
4. C:\
*/
if (!GetSystemWindowsDirectory(dirname, FN_REFLEN) ||
add_cfg_dir(configuration_dirs, dirname))
goto error;
if (!GetWindowsDirectory(dirname, FN_REFLEN) ||
add_cfg_dir(configuration_dirs, dirname))
goto error;
if (add_cfg_dir(configuration_dirs, "C:"))
goto error;
if (GetModuleFileName(NULL, dirname, FN_REFLEN))
{
PathRemoveFileSpec(dirname);
if (add_cfg_dir(configuration_dirs, dirname))
goto error;
}
#else
/* on *nix platforms configuration files are stored in
1. SYSCONFDIR (if build happens inside server package, or
-DDEFAULT_SYSCONFDIR was specified
2. /etc
3. /etc/mysql
*/
#ifdef DEFAULT_SYSCONFDIR
if (add_cfg_dir(configuration_dirs, DEFAULT_SYSCONFDIR))
goto error;
#else
if (add_cfg_dir(configuration_dirs, "/etc"))
goto error;
if (add_cfg_dir(configuration_dirs, "/etc/mysql"))
goto error;
#endif
#endif
/* CONC-537: Read configuration files from MYSQL_HOME directory only if
MARIADB_HOME was not set */
if (!(env= getenv("MARIADB_HOME")))
env= getenv("MYSQL_HOME");
if (env && add_cfg_dir(configuration_dirs, env))
goto error;
end:
return configuration_dirs;
error:
return NULL;
} | O0 | c | get_default_configuration_dirs:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x38, %esi
callq 0x173a0
movq %rax, %rcx
leaq 0x4488f(%rip), %rax # 0x640f0
movq %rcx, (%rax)
leaq 0x44885(%rip), %rax # 0x640f0
cmpq $0x0, (%rax)
jne 0x1f876
jmp 0x1f8f9
leaq 0x44873(%rip), %rax # 0x640f0
movq (%rax), %rdi
leaq 0x329db(%rip), %rsi # 0x52262
callq 0x1f920
cmpl $0x0, %eax
je 0x1f893
jmp 0x1f909
leaq 0x44856(%rip), %rax # 0x640f0
movq (%rax), %rdi
leaq 0x329c3(%rip), %rsi # 0x52267
callq 0x1f920
cmpl $0x0, %eax
je 0x1f8b0
jmp 0x1f909
leaq 0x329bb(%rip), %rdi # 0x52272
callq 0x17720
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x1f8d6
leaq 0x329b2(%rip), %rdi # 0x5227f
callq 0x17720
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1f8f7
leaq 0x4480c(%rip), %rax # 0x640f0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f920
cmpl $0x0, %eax
je 0x1f8f7
jmp 0x1f909
jmp 0x1f8f9
leaq 0x447f0(%rip), %rax # 0x640f0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f911
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_default_configuration_dirs:
push rbp
mov rbp, rsp
sub rsp, 10h
mov edi, 1
mov esi, 38h ; '8'
call _calloc
mov rcx, rax
lea rax, configuration_dirs
mov [rax], rcx
lea rax, configuration_dirs
cmp qword ptr [rax], 0
jnz short loc_1F876
jmp loc_1F8F9
loc_1F876:
lea rax, configuration_dirs
mov rdi, [rax]
lea rsi, aEtc; "/etc"
call add_cfg_dir
cmp eax, 0
jz short loc_1F893
jmp short loc_1F909
loc_1F893:
lea rax, configuration_dirs
mov rdi, [rax]
lea rsi, aEtcMysql; "/etc/mysql"
call add_cfg_dir
cmp eax, 0
jz short loc_1F8B0
jmp short loc_1F909
loc_1F8B0:
lea rdi, aMariadbHome; "MARIADB_HOME"
call _getenv
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_1F8D6
lea rdi, aMysqlHome; "MYSQL_HOME"
call _getenv
mov [rbp+var_10], rax
loc_1F8D6:
cmp [rbp+var_10], 0
jz short loc_1F8F7
lea rax, configuration_dirs
mov rdi, [rax]
mov rsi, [rbp+var_10]
call add_cfg_dir
cmp eax, 0
jz short loc_1F8F7
jmp short loc_1F909
loc_1F8F7:
jmp short $+2
loc_1F8F9:
lea rax, configuration_dirs
mov rax, [rax]
mov [rbp+var_8], rax
jmp short loc_1F911
loc_1F909:
mov [rbp+var_8], 0
loc_1F911:
mov rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long get_default_configuration_dirs()
{
long long v1; // [rsp+0h] [rbp-10h]
configuration_dirs[0] = calloc(1LL, 56LL);
if ( !configuration_dirs[0] )
return configuration_dirs[0];
if ( (unsigned int)add_cfg_dir(configuration_dirs[0], "/etc")
|| (unsigned int)add_cfg_dir(configuration_dirs[0], "/etc/mysql") )
{
return 0LL;
}
v1 = getenv("MARIADB_HOME");
if ( !v1 )
v1 = getenv("MYSQL_HOME");
if ( v1 && (unsigned int)add_cfg_dir(configuration_dirs[0], v1) )
return 0LL;
else
return configuration_dirs[0];
}
| get_default_configuration_dirs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDI,0x1
MOV ESI,0x38
CALL 0x001173a0
MOV RCX,RAX
LEA RAX,[0x1640f0]
MOV qword ptr [RAX],RCX
LEA RAX,[0x1640f0]
CMP qword ptr [RAX],0x0
JNZ 0x0011f876
JMP 0x0011f8f9
LAB_0011f876:
LEA RAX,[0x1640f0]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x152262]
CALL 0x0011f920
CMP EAX,0x0
JZ 0x0011f893
JMP 0x0011f909
LAB_0011f893:
LEA RAX,[0x1640f0]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x152267]
CALL 0x0011f920
CMP EAX,0x0
JZ 0x0011f8b0
JMP 0x0011f909
LAB_0011f8b0:
LEA RDI,[0x152272]
CALL 0x00117720
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x0011f8d6
LEA RDI,[0x15227f]
CALL 0x00117720
MOV qword ptr [RBP + -0x10],RAX
LAB_0011f8d6:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0011f8f7
LEA RAX,[0x1640f0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0011f920
CMP EAX,0x0
JZ 0x0011f8f7
JMP 0x0011f909
LAB_0011f8f7:
JMP 0x0011f8f9
LAB_0011f8f9:
LEA RAX,[0x1640f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0011f911
LAB_0011f909:
MOV qword ptr [RBP + -0x8],0x0
LAB_0011f911:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
void * get_default_configuration_dirs(void)
{
int iVar1;
char *local_18;
void *local_10;
configuration_dirs = calloc(1,0x38);
if (configuration_dirs == (void *)0x0) {
LAB_0011f8f9:
local_10 = configuration_dirs;
}
else {
iVar1 = add_cfg_dir(configuration_dirs,&DAT_00152262);
if ((iVar1 == 0) && (iVar1 = add_cfg_dir(configuration_dirs,"/etc/mysql"), iVar1 == 0)) {
local_18 = getenv("MARIADB_HOME");
if (local_18 == (char *)0x0) {
local_18 = getenv("MYSQL_HOME");
}
if ((local_18 == (char *)0x0) ||
(iVar1 = add_cfg_dir(configuration_dirs,local_18), iVar1 == 0)) goto LAB_0011f8f9;
}
local_10 = (void *)0x0;
}
return local_10;
}
| |
52,398 | get_present_hash_link | eloqsql/storage/maria/ma_pagecache.c | static PAGECACHE_HASH_LINK *get_present_hash_link(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
PAGECACHE_HASH_LINK ***start)
{
reg1 PAGECACHE_HASH_LINK *hash_link;
#if defined(PAGECACHE_DEBUG)
int cnt;
#endif
DBUG_ENTER("get_present_hash_link");
DBUG_PRINT("enter", ("fd: %u pos: %lu", (uint) file->file, (ulong) pageno));
/*
Find the bucket in the hash table for the pair (file, pageno);
start contains the head of the bucket list,
hash_link points to the first member of the list
*/
hash_link= *(*start= &pagecache->hash_root[PAGECACHE_HASH(pagecache,
*file, pageno)]);
#if defined(PAGECACHE_DEBUG)
cnt= 0;
#endif
/* Look for an element for the pair (file, pageno) in the bucket chain */
while (hash_link &&
(hash_link->pageno != pageno ||
hash_link->file.file != file->file))
{
hash_link= hash_link->next;
#if defined(PAGECACHE_DEBUG)
cnt++;
if (! (cnt <= pagecache->hash_links_used))
{
int i;
for (i=0, hash_link= **start ;
i < cnt ; i++, hash_link= hash_link->next)
{
KEYCACHE_DBUG_PRINT("get_present_hash_link", ("fd: %u pos: %lu",
(uint) hash_link->file.file, (ulong) hash_link->pageno));
}
}
KEYCACHE_DBUG_ASSERT(cnt <= pagecache->hash_links_used);
#endif
}
if (hash_link)
{
DBUG_PRINT("exit", ("hash_link: %p", hash_link));
/* Register the request for the page */
hash_link->requests++;
}
/*
As soon as the caller will release the page cache's lock, "hash_link"
will be potentially obsolete (unusable) information.
*/
DBUG_RETURN(hash_link);
} | O0 | c | get_present_hash_link:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x5bc06
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
movslq 0x10(%rdx), %rdx
addq %rdx, %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq $0x1, %rdx
andq %rdx, %rcx
movq %rcx, %rdx
shlq $0x3, %rdx
movq %rax, %rsi
addq %rdx, %rsi
movq -0x20(%rbp), %rdx
movq %rsi, (%rdx)
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x5bc84
movq -0x28(%rbp), %rax
movq 0x60(%rax), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x2a(%rbp)
jne 0x5bc7e
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5bc8d
jmp 0x5bc9a
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5bc4b
cmpq $0x0, -0x28(%rbp)
je 0x5bcb2
jmp 0x5bca3
jmp 0x5bca5
movq -0x28(%rbp), %rax
movl 0x68(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x68(%rax)
jmp 0x5bcb4
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_present_hash_link:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
jmp short $+2
loc_5BC06:
mov rax, [rbp+var_8]
mov rax, [rax+88h]
mov rcx, [rbp+var_18]
mov rdx, [rbp+var_10]
movsxd rdx, dword ptr [rdx+10h]
add rcx, rdx
mov rdx, [rbp+var_8]
mov rdx, [rdx+20h]
sub rdx, 1
and rcx, rdx
mov rdx, rcx
shl rdx, 3
mov rsi, rax
add rsi, rdx
mov rdx, [rbp+var_20]
mov [rdx], rsi
mov rax, [rax+rcx*8]
mov [rbp+var_28], rax
loc_5BC4B:
xor eax, eax
cmp [rbp+var_28], 0
mov [rbp+var_29], al
jz short loc_5BC84
mov rax, [rbp+var_28]
mov rcx, [rax+60h]
mov al, 1
cmp rcx, [rbp+var_18]
mov [rbp+var_2A], al
jnz short loc_5BC7E
mov rax, [rbp+var_28]
mov eax, [rax+28h]
mov rcx, [rbp+var_10]
cmp eax, [rcx+10h]
setnz al
mov [rbp+var_2A], al
loc_5BC7E:
mov al, [rbp+var_2A]
mov [rbp+var_29], al
loc_5BC84:
mov al, [rbp+var_29]
test al, 1
jnz short loc_5BC8D
jmp short loc_5BC9A
loc_5BC8D:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short loc_5BC4B
loc_5BC9A:
cmp [rbp+var_28], 0
jz short loc_5BCB2
jmp short $+2
loc_5BCA3:
jmp short $+2
loc_5BCA5:
mov rax, [rbp+var_28]
mov ecx, [rax+68h]
add ecx, 1
mov [rax+68h], ecx
loc_5BCB2:
jmp short $+2
loc_5BCB4:
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
pop rbp
retn
| long long * get_present_hash_link(long long a1, long long a2, long long a3, _QWORD *a4)
{
long long v4; // rax
long long v5; // rcx
bool v7; // [rsp+Eh] [rbp-2Ah]
bool v8; // [rsp+Fh] [rbp-29h]
long long *i; // [rsp+10h] [rbp-28h]
v4 = *(_QWORD *)(a1 + 136);
v5 = (*(_QWORD *)(a1 + 32) - 1LL) & (*(int *)(a2 + 16) + a3);
*a4 = 8 * v5 + v4;
for ( i = *(long long **)(v4 + 8 * v5); ; i = (long long *)*i )
{
v8 = 0;
if ( i )
{
v7 = 1;
if ( i[12] == a3 )
v7 = *((_DWORD *)i + 10) != *(_DWORD *)(a2 + 16);
v8 = v7;
}
if ( !v8 )
break;
}
if ( i )
++*((_DWORD *)i + 26);
return i;
}
| get_present_hash_link:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
JMP 0x0015bc06
LAB_0015bc06:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RDX + 0x10]
ADD RCX,RDX
MOV RDX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RDX + 0x20]
SUB RDX,0x1
AND RCX,RDX
MOV RDX,RCX
SHL RDX,0x3
MOV RSI,RAX
ADD RSI,RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV qword ptr [RDX],RSI
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_0015bc4b:
XOR EAX,EAX
CMP qword ptr [RBP + -0x28],0x0
MOV byte ptr [RBP + -0x29],AL
JZ 0x0015bc84
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x60]
MOV AL,0x1
CMP RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x2a],AL
JNZ 0x0015bc7e
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x10]
SETNZ AL
MOV byte ptr [RBP + -0x2a],AL
LAB_0015bc7e:
MOV AL,byte ptr [RBP + -0x2a]
MOV byte ptr [RBP + -0x29],AL
LAB_0015bc84:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x0015bc8d
JMP 0x0015bc9a
LAB_0015bc8d:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015bc4b
LAB_0015bc9a:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0015bcb2
JMP 0x0015bca3
LAB_0015bca3:
JMP 0x0015bca5
LAB_0015bca5:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x68]
ADD ECX,0x1
MOV dword ptr [RAX + 0x68],ECX
LAB_0015bcb2:
JMP 0x0015bcb4
LAB_0015bcb4:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
POP RBP
RET
|
int8 * get_present_hash_link(long param_1,long param_2,long param_3,long *param_4)
{
long lVar1;
ulong uVar2;
bool bVar3;
int8 *local_30;
lVar1 = *(long *)(param_1 + 0x88);
uVar2 = param_3 + *(int *)(param_2 + 0x10) & *(long *)(param_1 + 0x20) - 1U;
*param_4 = lVar1 + uVar2 * 8;
local_30 = *(int8 **)(lVar1 + uVar2 * 8);
while( true ) {
bVar3 = false;
if ((local_30 != (int8 *)0x0) && (bVar3 = true, local_30[0xc] == param_3)) {
bVar3 = *(int *)(local_30 + 5) != *(int *)(param_2 + 0x10);
}
if (!bVar3) break;
local_30 = (int8 *)*local_30;
}
if (local_30 != (int8 *)0x0) {
*(int *)(local_30 + 0xd) = *(int *)(local_30 + 0xd) + 1;
}
return local_30;
}
| |
52,399 | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_strip(const std::string & str) {
size_t start = 0;
size_t end = str.size();
while (start < end && std::isspace(str[start])) {
start++;
}
while (end > start && std::isspace(str[end - 1])) {
end--;
}
return str.substr(start, end - start);
} | O1 | cpp | string_strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x22bf2
movq (%r14), %r12
xorl %r15d, %r15d
movsbl (%r12,%r15), %edi
callq 0x190b0
testl %eax, %eax
je 0x22bf5
incq %r15
cmpq %r15, %r13
jne 0x22bd7
movq %r13, %r15
jmp 0x22bf5
xorl %r15d, %r15d
movq (%r14), %rbp
cmpq %r13, %r15
movq %r13, %r12
cmovbq %r15, %r12
cmpq %r15, %r13
jbe 0x22c1f
movsbl -0x1(%rbp,%r13), %edi
decq %r13
callq 0x190b0
testl %eax, %eax
jne 0x22c02
incq %r13
movq %r13, %r12
subq %r15, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x19730
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z12string_stripRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov r13, [rsi+8]
test r13, r13
jz short loc_22BF2
mov r12, [r14]
xor r15d, r15d
loc_22BD7:
movsx edi, byte ptr [r12+r15]
call _isspace
test eax, eax
jz short loc_22BF5
inc r15
cmp r13, r15
jnz short loc_22BD7
mov r15, r13
jmp short loc_22BF5
loc_22BF2:
xor r15d, r15d
loc_22BF5:
mov rbp, [r14]
cmp r15, r13
mov r12, r13
cmovb r12, r15
loc_22C02:
cmp r13, r15
jbe short loc_22C1F
movsx edi, byte ptr [rbp+r13-1]
dec r13
call _isspace
test eax, eax
jnz short loc_22C02
inc r13
mov r12, r13
loc_22C1F:
sub r12, r15
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, r12
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long string_strip(long long a1, long long *a2)
{
unsigned long long v3; // r13
long long v4; // r12
unsigned long long v5; // r15
long long v6; // rbp
unsigned long long v7; // r12
long long v8; // rdi
v3 = a2[1];
if ( v3 )
{
v4 = *a2;
v5 = 0LL;
while ( (unsigned int)isspace((unsigned int)*(char *)(v4 + v5)) )
{
if ( v3 == ++v5 )
{
v5 = v3;
break;
}
}
}
else
{
v5 = 0LL;
}
v6 = *a2;
v7 = v3;
if ( v5 < v3 )
v7 = v5;
while ( v3 > v5 )
{
v8 = (unsigned int)*(char *)(v6 + v3-- - 1);
if ( !(unsigned int)isspace(v8) )
{
v7 = v3 + 1;
break;
}
}
std::string::substr(a1, a2, v5, v7 - v5);
return a1;
}
| string_strip:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV R13,qword ptr [RSI + 0x8]
TEST R13,R13
JZ 0x00122bf2
MOV R12,qword ptr [R14]
XOR R15D,R15D
LAB_00122bd7:
MOVSX EDI,byte ptr [R12 + R15*0x1]
CALL 0x001190b0
TEST EAX,EAX
JZ 0x00122bf5
INC R15
CMP R13,R15
JNZ 0x00122bd7
MOV R15,R13
JMP 0x00122bf5
LAB_00122bf2:
XOR R15D,R15D
LAB_00122bf5:
MOV RBP,qword ptr [R14]
CMP R15,R13
MOV R12,R13
CMOVC R12,R15
LAB_00122c02:
CMP R13,R15
JBE 0x00122c1f
MOVSX EDI,byte ptr [RBP + R13*0x1 + -0x1]
DEC R13
CALL 0x001190b0
TEST EAX,EAX
JNZ 0x00122c02
INC R13
MOV R12,R13
LAB_00122c1f:
SUB R12,R15
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x00119730
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_strip(std::__cxx11::string const&) */
string * string_strip(string *param_1)
{
char *pcVar1;
long lVar2;
int iVar3;
long *in_RSI;
ulong uVar4;
ulong uVar5;
ulong uVar6;
uVar4 = in_RSI[1];
if (uVar4 == 0) {
uVar6 = 0;
}
else {
lVar2 = *in_RSI;
uVar5 = 0;
do {
iVar3 = isspace((int)*(char *)(lVar2 + uVar5));
uVar6 = uVar5;
if (iVar3 == 0) break;
uVar5 = uVar5 + 1;
uVar6 = uVar4;
} while (uVar4 != uVar5);
}
lVar2 = *in_RSI;
do {
if (uVar4 <= uVar6) break;
pcVar1 = (char *)(lVar2 + -1 + uVar4);
uVar4 = uVar4 - 1;
iVar3 = isspace((int)*pcVar1);
} while (iVar3 != 0);
std::__cxx11::string::substr((ulong)param_1,(ulong)in_RSI);
return param_1;
}
|
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.