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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
1,900 | JS_ResolveModule | bluesky950520[P]quickjs/quickjs.c | int JS_ResolveModule(JSContext *ctx, JSValue obj)
{
if (JS_VALUE_GET_TAG(obj) == JS_TAG_MODULE) {
JSModuleDef *m = JS_VALUE_GET_PTR(obj);
if (js_resolve_module(ctx, m) < 0) {
js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
return -1;
}
}
return 0;
} | O2 | c | JS_ResolveModule:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $-0x3, %edx
jne 0x2d604
movq %rdi, %r14
callq 0x2d60e
testl %eax, %eax
jns 0x2d604
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1dcdf
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| JS_ResolveModule:
push r14
push rbx
push rax
xor ebx, ebx
cmp edx, 0FFFFFFFDh
jnz short loc_2D604
mov r14, rdi
call js_resolve_module
test eax, eax
jns short loc_2D604
push 1
pop rsi
mov rdi, r14
call js_free_modules
push 0FFFFFFFFFFFFFFFFh
pop rbx
loc_2D604:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
retn
| long long JS_ResolveModule(long long a1, long long a2, int a3)
{
unsigned int v3; // ebx
v3 = 0;
if ( a3 == -3 && (int)js_resolve_module(a1, a2) < 0 )
{
js_free_modules(a1, 1);
return (unsigned int)-1;
}
return v3;
}
| JS_ResolveModule:
PUSH R14
PUSH RBX
PUSH RAX
XOR EBX,EBX
CMP EDX,-0x3
JNZ 0x0012d604
MOV R14,RDI
CALL 0x0012d60e
TEST EAX,EAX
JNS 0x0012d604
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0011dcdf
PUSH -0x1
POP RBX
LAB_0012d604:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int4 JS_ResolveModule(int8 param_1,int8 param_2,int param_3)
{
int iVar1;
int4 uVar2;
uVar2 = 0;
if (param_3 == -3) {
iVar1 = js_resolve_module();
if (iVar1 < 0) {
js_free_modules(param_1,1);
uVar2 = 0xffffffff;
}
}
return uVar2;
}
|
|
1,901 | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) | monkey531[P]llama/common/minja.hpp | Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
} | O0 | cpp | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
callq 0x222d90
movq 0x10(%rsp), %rdi
leaq 0x1945a7(%rip), %rax # 0x3b71c8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
movq 0x88(%rsp), %rsi
callq 0x222290
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
movq %rdi, 0x18(%rsp)
movq 0x80(%rsp), %rsi
callq 0x222da0
movq 0x20(%rsp), %rdi
callq 0x222dd0
movb %al, 0x2e(%rsp)
jmp 0x222c69
movb 0x2e(%rsp), %al
testb $0x1, %al
jne 0x222d59
jmp 0x222c77
movb $0x1, 0x2f(%rsp)
movl $0x10, %edi
callq 0x64880
movq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x30(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x222df0
jmp 0x222ca7
leaq 0xcf8e7(%rip), %rsi # 0x2f2595
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x98c80
jmp 0x222cbf
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x64640
jmp 0x222cd0
movq 0x8(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
movq 0x1962c7(%rip), %rsi # 0x3b8fa8
movq 0x196288(%rip), %rdx # 0x3b8f70
callq 0x64d60
jmp 0x222d8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x222d61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x222d44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x222d3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x65a60
leaq 0x30(%rsp), %rdi
callq 0x65a60
testb $0x1, 0x2f(%rsp)
jne 0x222d4d
jmp 0x222d57
movq 0x8(%rsp), %rdi
callq 0x652b0
jmp 0x222d61
addq $0x98, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x21f690
movq 0x20(%rsp), %rdi
callq 0x21f6a0
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x222ec0
movq 0x78(%rsp), %rdi
callq 0x64e40
nopl (%rax)
| _ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
sub rsp, 98h
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov rdi, [rsp+98h+var_8]
mov [rsp+98h+var_88], rdi
add rdi, 8
call _ZNSt23enable_shared_from_thisIN5minja7ContextEEC2Ev; std::enable_shared_from_this<minja::Context>::enable_shared_from_this(void)
mov rdi, [rsp+98h+var_88]
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
add rdi, 18h
mov [rsp+98h+var_78], rdi
mov rsi, [rsp+98h+var_10]
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
mov rdi, [rsp+98h+var_88]
add rdi, 68h ; 'h'
mov [rsp+98h+var_80], rdi
mov rsi, [rsp+98h+var_18]
call _ZNSt10shared_ptrIN5minja7ContextEEC2ERKS2_; std::shared_ptr<minja::Context>::shared_ptr(std::shared_ptr<minja::Context> const&)
mov rdi, [rsp+98h+var_78]; this
call _ZNK5minja5Value9is_objectEv; minja::Value::is_object(void)
mov [rsp+98h+var_6A], al
jmp short $+2
loc_222C69:
mov al, [rsp+98h+var_6A]
test al, 1
jnz loc_222D59
jmp short $+2
loc_222C77:
mov [rsp+98h+var_69], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+98h+var_88]
mov [rsp+98h+var_90], rax
add rsi, 18h
lea rdi, [rsp+98h+var_68]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_222CA7:
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+98h+var_48]
lea rdx, [rsp+98h+var_68]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_222CBF:
mov rdi, [rsp+98h+var_90]
lea rsi, [rsp+98h+var_48]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_222CD0:
mov rdi, [rsp+98h+var_90]; void *
mov [rsp+98h+var_69], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_222D8D
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_222D61
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_222D44
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
jmp short loc_222D3A
mov rcx, rax
mov eax, edx
mov [rsp+arg_70], rcx
mov [rsp+arg_6C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_222D3A:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_222D44:
test [rsp+arg_27], 1
jnz short loc_222D4D
jmp short loc_222D57
loc_222D4D:
mov rdi, [rsp+arg_0]; void *
call ___cxa_free_exception
loc_222D57:
jmp short loc_222D61
loc_222D59:
add rsp, 98h
retn
loc_222D61:
mov rdi, [rsp+arg_10]
call _ZNSt10shared_ptrIN5minja7ContextEED2Ev; std::shared_ptr<minja::Context>::~shared_ptr()
mov rdi, [rsp+arg_18]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, [rsp+arg_8]
add rdi, 8
call _ZNSt23enable_shared_from_thisIN5minja7ContextEED2Ev; std::enable_shared_from_this<minja::Context>::~enable_shared_from_this()
mov rdi, [rsp+arg_70]
call __Unwind_Resume
loc_222D8D:
nop dword ptr [rax]
| char minja::Context::Context(_QWORD *a1, long long a2, long long a3)
{
char result; // al
int v4; // r8d
int v5; // r9d
void *exception; // [rsp+8h] [rbp-90h]
_BYTE v7[32]; // [rsp+30h] [rbp-68h] BYREF
_BYTE v8[48]; // [rsp+50h] [rbp-48h] BYREF
long long v9; // [rsp+80h] [rbp-18h]
long long v10; // [rsp+88h] [rbp-10h]
_QWORD *v11; // [rsp+90h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
std::enable_shared_from_this<minja::Context>::enable_shared_from_this(a1 + 1);
*a1 = &`vtable for'minja::Context + 2;
minja::Value::Value((long long)(a1 + 3), v10);
std::shared_ptr<minja::Context>::shared_ptr(a1 + 13, v9);
result = minja::Value::is_object((minja::Value *)(a1 + 3));
if ( (result & 1) == 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((unsigned int)v7, (_DWORD)a1 + 24, -1, 0, v4, v5);
std::operator+<char>((long long)v8, (long long)"Context values must be an object: ", (long long)v7);
std::runtime_error::runtime_error(exception, v8);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| |||
1,902 | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) | monkey531[P]llama/common/minja.hpp | Context(Value && values, const std::shared_ptr<Context> & parent = nullptr) : values_(std::move(values)), parent_(parent) {
if (!values_.is_object()) throw std::runtime_error("Context values must be an object: " + values_.dump());
} | O2 | cpp | minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0xafde6(%rip), %rax # 0x165320
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0xb530e
leaq 0x68(%rbx), %rdi
movq %r15, %rsi
callq 0xb5878
cmpq $0x0, 0x38(%rbx)
je 0xb556d
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x28580
movq %rax, %r15
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xb5618
leaq 0x4c30e(%rip), %rsi # 0x10189d
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x3bd5f
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x291e0
xorl %ebp, %ebp
movq 0xb1a3b(%rip), %rsi # 0x166ff0
movq 0xb199c(%rip), %rdx # 0x166f58
movq %r15, %rdi
callq 0x29320
movq %rax, %r12
leaq 0x20(%rsp), %rdi
callq 0x29678
jmp 0xb55d9
movq %rax, %r12
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x29678
testb %bpl, %bpl
jne 0xb55eb
jmp 0xb55f3
movq %rax, %r12
movq %r15, %rdi
callq 0x28830
leaq 0x70(%rbx), %rdi
callq 0x4b2f2
movq %r14, %rdi
callq 0xb445e
addq $0x10, %rbx
movq %rbx, %rdi
callq 0xb6154
movq %r12, %rdi
callq 0x293c0
| _ZN5minja7ContextC2EONS_5ValueERKSt10shared_ptrIS0_E:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r15, rdx
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
lea r14, [rdi+18h]
mov rdi, r14
call _ZN5minja5ValueC2EOS0_; minja::Value::Value(minja::Value&&)
lea rdi, [rbx+68h]
mov rsi, r15
call _ZNSt12__shared_ptrIN5minja7ContextELN9__gnu_cxx12_Lock_policyE2EEC2ERKS4_; std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2> const&)
cmp qword ptr [rbx+38h], 0
jz short loc_B556D
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B556D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aContextValuesM; "Context values must be an object: "
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_48]
mov rdi, r15
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r12, rax
lea rdi, [rsp+68h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_B55D9
mov r12, rax
mov bpl, 1
loc_B55D9:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_B55EB
jmp short loc_B55F3
mov r12, rax
loc_B55EB:
mov rdi, r15; void *
call ___cxa_free_exception
loc_B55F3:
lea rdi, [rbx+70h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, r14; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rbx, 10h
mov rdi, rbx
call _ZNSt12__weak_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__weak_count<(__gnu_cxx::_Lock_policy)2>::~__weak_count()
mov rdi, r12
call __Unwind_Resume
| long long minja::Context::Context(long long a1, long long a2, long long a3)
{
long long result; // rax
void *exception; // r15
int v6; // r8d
int v7; // r9d
char v8[32]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v9[72]; // [rsp+20h] [rbp-48h] BYREF
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &`vtable for'minja::Context + 2;
minja::Value::Value(a1 + 24, a2);
result = std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(a1 + 104, a3);
if ( !*(_QWORD *)(a1 + 56) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((unsigned int)v8, a1 + 24, -1, 0, v6, v7, v8[0]);
std::operator+<char>((long long)v9, (long long)"Context values must be an object: ", (long long)v8);
std::runtime_error::runtime_error(exception, v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| Context:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R15,RDX
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA RAX,[0x265320]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x18]
MOV RDI,R14
CALL 0x001b530e
LEA RDI,[RBX + 0x68]
MOV RSI,R15
CALL 0x001b5878
CMP qword ptr [RBX + 0x38],0x0
JZ 0x001b556d
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b556d:
PUSH 0x10
POP RDI
CALL 0x00128580
MOV R15,RAX
LAB_001b5578:
MOV RDI,RSP
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x001b5618
LAB_001b5588:
LEA RSI,[0x20189d]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0013bd5f
MOV BPL,0x1
LAB_001b559f:
LEA RSI,[RSP + 0x20]
MOV RDI,R15
CALL 0x001291e0
XOR EBP,EBP
MOV RSI,qword ptr [0x00266ff0]
MOV RDX,qword ptr [0x00266f58]
MOV RDI,R15
CALL 0x00129320
|
/* minja::Context::Context(minja::Value&&, std::shared_ptr<minja::Context> const&) */
void __thiscall minja::Context::Context(Context *this,Value *param_1,shared_ptr *param_2)
{
runtime_error *this_00;
int1 auStack_68 [32];
string local_48 [32];
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__Context_00265330;
Value::Value((Value *)(this + 0x18),param_1);
std::__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2>::__shared_ptr
((__shared_ptr<minja::Context,(__gnu_cxx::_Lock_policy)2> *)(this + 0x68),
(__shared_ptr *)param_2);
if (*(long *)(this + 0x38) != 0) {
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001b5578 to 001b5587 has its CatchHandler @ 001b55e8 */
Value::dump_abi_cxx11_((int)auStack_68,SUB81((Value *)(this + 0x18),0));
/* try { // try from 001b5588 to 001b559b has its CatchHandler @ 001b55d3 */
std::operator+((char *)local_48,(string *)"Context values must be an object: ");
/* try { // try from 001b559f to 001b55c3 has its CatchHandler @ 001b55c4 */
std::runtime_error::runtime_error(this_00,local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00266ff0,PTR__runtime_error_00266f58);
}
|
|
1,903 | die | eloqsql/client/mysqldump.c | static void die(int error_num, const char* fmt_reason, ...)
{
char buffer[1000];
va_list args;
va_start(args,fmt_reason);
my_vsnprintf(buffer, sizeof(buffer), fmt_reason, args);
va_end(args);
fprintf(stderr, "%s: %s\n", my_progname_short, buffer);
fflush(stderr);
ignore_errors= 0; /* force the exit */
maybe_exit(error_num);
} | O0 | c | die:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp # imm = 0x4E0
testb %al, %al
je 0x38de7
movaps %xmm0, -0x4a0(%rbp)
movaps %xmm1, -0x490(%rbp)
movaps %xmm2, -0x480(%rbp)
movaps %xmm3, -0x470(%rbp)
movaps %xmm4, -0x460(%rbp)
movaps %xmm5, -0x450(%rbp)
movaps %xmm6, -0x440(%rbp)
movaps %xmm7, -0x430(%rbp)
movq %r9, -0x4a8(%rbp)
movq %r8, -0x4b0(%rbp)
movq %rcx, -0x4b8(%rbp)
movq %rdx, -0x4c0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x3f4(%rbp)
movq %rsi, -0x400(%rbp)
leaq -0x4d0(%rbp), %rax
movq %rax, -0x410(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x418(%rbp)
movl $0x30, -0x41c(%rbp)
movl $0x10, -0x420(%rbp)
movq -0x400(%rbp), %rdx
leaq -0x3f0(%rbp), %rdi
movq %rdi, -0x4e0(%rbp)
movl $0x3e8, %esi # imm = 0x3E8
leaq -0x420(%rbp), %rcx
callq 0xd4c90
movq -0x4e0(%rbp), %rcx
movq 0x20c162(%rip), %rax # 0x244fe0
movq %rax, -0x4d8(%rbp)
movq (%rax), %rdi
leaq 0x3d3d49(%rip), %rax # 0x40cbd8
movq (%rax), %rdx
leaq 0xaabbd(%rip), %rsi # 0xe3a56
xorl %eax, %eax
callq 0x381d0
movq -0x4d8(%rbp), %rax
movq (%rax), %rdi
callq 0x384c0
movb $0x0, 0x3c87be(%rip) # 0x401674
movl -0x3f4(%rbp), %edi
callq 0x3cb90
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x38edc
addq $0x4e0, %rsp # imm = 0x4E0
popq %rbp
retq
callq 0x382c0
nopw %cs:(%rax,%rax)
| die:
push rbp
mov rbp, rsp
sub rsp, 4E0h
test al, al
jz short loc_38DE7
movaps [rbp+var_4A0], xmm0
movaps [rbp+var_490], xmm1
movaps [rbp+var_480], xmm2
movaps [rbp+var_470], xmm3
movaps [rbp+var_460], xmm4
movaps [rbp+var_450], xmm5
movaps [rbp+var_440], xmm6
movaps [rbp+var_430], xmm7
loc_38DE7:
mov [rbp+var_4A8], r9
mov [rbp+var_4B0], r8
mov [rbp+var_4B8], rcx
mov [rbp+var_4C0], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_3F4], edi
mov [rbp+var_400], rsi
lea rax, [rbp+var_4D0]
mov [rbp+var_410], rax
lea rax, [rbp+arg_0]
mov [rbp+var_418], rax
mov [rbp+var_41C], 30h ; '0'
mov [rbp+var_420], 10h
mov rdx, [rbp+var_400]
lea rdi, [rbp+var_3F0]
mov [rbp+var_4E0], rdi
mov esi, 3E8h
lea rcx, [rbp+var_420]
call my_vsnprintf
mov rcx, [rbp+var_4E0]
mov rax, cs:stderr_ptr
mov [rbp+var_4D8], rax
mov rdi, [rax]
lea rax, my_progname_short
mov rdx, [rax]
lea rsi, aUnknownOptionT+12h; "%s: %s\n"
xor eax, eax
call _fprintf
mov rax, [rbp+var_4D8]
mov rdi, [rax]
call _fflush
mov cs:ignore_errors, 0
mov edi, [rbp+var_3F4]
call maybe_exit
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_38EDC
add rsp, 4E0h
pop rbp
retn
loc_38EDC:
call ___stack_chk_fail
| unsigned long long die(unsigned int a1, long long a2, ...)
{
va_list va; // [rsp+C0h] [rbp-420h] BYREF
long long v4; // [rsp+E0h] [rbp-400h]
unsigned int v5; // [rsp+ECh] [rbp-3F4h]
char v6[1000]; // [rsp+F0h] [rbp-3F0h] BYREF
unsigned long long v7; // [rsp+4D8h] [rbp-8h]
va_start(va, a2);
v7 = __readfsqword(0x28u);
v5 = a1;
v4 = a2;
my_vsnprintf(v6, 1000LL, a2, va);
fprintf(stderr, "%s: %s\n", my_progname_short, v6);
fflush(stderr);
ignore_errors = 0;
maybe_exit(v5);
return __readfsqword(0x28u);
}
| die:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x4e0
TEST AL,AL
JZ 0x00138de7
MOVAPS xmmword ptr [RBP + -0x4a0],XMM0
MOVAPS xmmword ptr [RBP + -0x490],XMM1
MOVAPS xmmword ptr [RBP + -0x480],XMM2
MOVAPS xmmword ptr [RBP + -0x470],XMM3
MOVAPS xmmword ptr [RBP + -0x460],XMM4
MOVAPS xmmword ptr [RBP + -0x450],XMM5
MOVAPS xmmword ptr [RBP + -0x440],XMM6
MOVAPS xmmword ptr [RBP + -0x430],XMM7
LAB_00138de7:
MOV qword ptr [RBP + -0x4a8],R9
MOV qword ptr [RBP + -0x4b0],R8
MOV qword ptr [RBP + -0x4b8],RCX
MOV qword ptr [RBP + -0x4c0],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x3f4],EDI
MOV qword ptr [RBP + -0x400],RSI
LEA RAX,[RBP + -0x4d0]
MOV qword ptr [RBP + -0x410],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x418],RAX
MOV dword ptr [RBP + -0x41c],0x30
MOV dword ptr [RBP + -0x420],0x10
MOV RDX,qword ptr [RBP + -0x400]
LEA RDI,[RBP + -0x3f0]
MOV qword ptr [RBP + -0x4e0],RDI
MOV ESI,0x3e8
LEA RCX,[RBP + -0x420]
CALL 0x001d4c90
MOV RCX,qword ptr [RBP + -0x4e0]
MOV RAX,qword ptr [0x00344fe0]
MOV qword ptr [RBP + -0x4d8],RAX
MOV RDI,qword ptr [RAX]
LEA RAX,[0x50cbd8]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x1e3a56]
XOR EAX,EAX
CALL 0x001381d0
MOV RAX,qword ptr [RBP + -0x4d8]
MOV RDI,qword ptr [RAX]
CALL 0x001384c0
MOV byte ptr [0x00501674],0x0
MOV EDI,dword ptr [RBP + -0x3f4]
CALL 0x0013cb90
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00138edc
ADD RSP,0x4e0
POP RBP
RET
LAB_00138edc:
CALL 0x001382c0
|
void die(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int *puVar1;
char in_AL;
long in_FS_OFFSET;
int1 local_4d8 [16];
int8 local_4c8;
int8 local_4c0;
int8 local_4b8;
int8 local_4b0;
int8 local_4a8;
int8 local_498;
int8 local_488;
int8 local_478;
int8 local_468;
int8 local_458;
int8 local_448;
int8 local_438;
int4 local_428;
int4 local_424;
int1 *local_420;
int1 *local_418;
int8 local_408;
int4 local_3fc;
int1 local_3f8 [1000];
long local_10;
if (in_AL != '\0') {
local_4a8 = param_1;
local_498 = param_2;
local_488 = param_3;
local_478 = param_4;
local_468 = param_5;
local_458 = param_6;
local_448 = param_7;
local_438 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_418 = local_4d8;
local_420 = &stack0x00000008;
local_424 = 0x30;
local_428 = 0x10;
local_4c8 = param_11;
local_4c0 = param_12;
local_4b8 = param_13;
local_4b0 = param_14;
local_408 = param_10;
local_3fc = param_9;
my_vsnprintf(local_3f8,1000,param_10,&local_428);
puVar1 = PTR_stderr_00344fe0;
fprintf(*(FILE **)PTR_stderr_00344fe0,"%s: %s\n",my_progname_short,local_3f8);
fflush(*(FILE **)puVar1);
ignore_errors = 0;
maybe_exit(local_3fc);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,904 | minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&) | monkey531[P]llama/common/minja.hpp | static Value simple_function(const std::string & fn_name, const std::vector<std::string> & params, const std::function<Value(const std::shared_ptr<Context> &, Value & args)> & fn) {
std::map<std::string, size_t> named_positions;
for (size_t i = 0, n = params.size(); i < n; i++) named_positions[params[i]] = i;
return Value::callable([=](const std::shared_ptr<Context> & context, ArgumentsValue & args) -> Value {
auto args_obj = Value::object();
std::vector<bool> provided_args(params.size());
for (size_t i = 0, n = args.args.size(); i < n; i++) {
auto & arg = args.args[i];
if (i < params.size()) {
args_obj.set(params[i], arg);
provided_args[i] = true;
} else {
throw std::runtime_error("Too many positional params for " + fn_name);
}
}
for (auto & [name, value] : args.kwargs) {
auto named_pos_it = named_positions.find(name);
if (named_pos_it == named_positions.end()) {
throw std::runtime_error("Unknown argument " + name + " for function " + fn_name);
}
provided_args[named_pos_it->second] = true;
args_obj.set(name, value);
}
return fn(context, args_obj);
});
} | O3 | cpp | minja::simple_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::Value&)> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0xc0(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x8(%rdx), %rbp
subq (%rdx), %rbp
je 0x78346
sarq $0x5, %rbp
cmpq $0x1, %rbp
adcq $0x0, %rbp
xorl %ebx, %ebx
leaq 0xb8(%rsp), %r13
xorl %r12d, %r12d
movq (%r15), %rsi
addq %rbx, %rsi
movq %r13, %rdi
callq 0xac244
movq %r12, (%rax)
incq %r12
addq $0x20, %rbx
cmpq %r12, %rbp
jne 0x78329
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x54c34
leaq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x21da0
leaq 0x68(%rsp), %r14
leaq 0xb8(%rsp), %rsi
movq %r14, %rdi
callq 0xac69e
leaq 0x98(%rsp), %r15
movq %r15, %rdi
movq 0x28(%rsp), %rsi
callq 0xac2c0
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x88, %edi
callq 0x1a8d0
movq %rax, %r12
leaq 0x30(%rsp), %rsi
movq %rax, %rdi
callq 0x54c34
leaq 0x18(%r12), %rdi
leaq 0x28(%r12), %rbp
movq %rbp, 0x18(%r12)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
addq %rsi, %rdx
callq 0x21da0
leaq 0x40(%r12), %rax
movq 0x78(%rsp), %rdx
testq %rdx, %rdx
je 0x7842d
leaq 0x70(%rsp), %rdi
movl (%rdi), %ecx
movq %rdx, 0x48(%r12)
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rsi
movq %rax, 0x8(%rdx)
leaq 0x90(%rsp), %rdx
movq (%rdx), %rax
movq %rax, 0x60(%r12)
movq $0x0, -0x18(%rdx)
movq %rdi, -0x10(%rdx)
movq %rdi, -0x8(%rdx)
movq %r8, %rax
jmp 0x78440
movq $0x0, 0x48(%r12)
leaq 0x60(%r12), %rdx
xorl %ecx, %ecx
movq %rax, %rsi
movq %rax, 0x50(%r12)
movq %rsi, 0x58(%r12)
movq $0x0, (%rdx)
movl %ecx, 0x40(%r12)
leaq 0x68(%r12), %rdi
movq %r15, %rsi
callq 0xac2c0
movq %rsp, %rsi
movq %r12, (%rsi)
leaq 0x1c8(%rip), %rax # 0x78638
movq %rax, 0x18(%rsi)
leaq 0x83b(%rip), %rax # 0x78cb6
movq %rax, 0x10(%rsi)
movq 0x20(%rsp), %rdi
callq 0x95e5e
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x784a0
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0xa8(%rsp), %rax
testq %rax, %rax
je 0x784ba
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xac900
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x784d9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a8f0
leaq 0x30(%rsp), %rdi
callq 0x20c24
leaq 0xb8(%rsp), %rdi
callq 0xac900
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x78581
jmp 0x78581
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7858c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x7858c
jmp 0x78581
movq %rax, %rbx
movq %r12, %rdi
addq $0x38, %rdi
callq 0xac900
movq 0x18(%r12), %rdi
cmpq %rbp, %rdi
je 0x7854e
movq (%rbp), %rsi
incq %rsi
callq 0x1a8f0
jmp 0x7854e
movq %rax, %rbx
movq %r12, %rdi
callq 0x20c24
jmp 0x7855b
movq %rax, %rbx
movl $0x88, %esi
movq %r12, %rdi
callq 0x1a8f0
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7858c
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x7858c
movq %rax, %rdi
callq 0x21a05
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x785ea
jmp 0x785d5
movq %rax, %rbx
movq %r14, %rdi
callq 0xac900
jmp 0x785a8
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x785c4
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1a8f0
jmp 0x785c4
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20c24
jmp 0x785d5
jmp 0x785d2
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0xac900
movq %rbx, %rdi
callq 0x1afb0
| _ZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_F0], rcx
mov r15, rdx
mov r14, rsi
mov [rsp+118h+var_F8], rdi
lea rax, [rsp+118h+var_58]
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 rbp, [rdx+8]
sub rbp, [rdx]
jz short loc_78346
sar rbp, 5
cmp rbp, 1
adc rbp, 0
xor ebx, ebx
lea r13, [rsp+118h+var_60]
xor r12d, r12d
loc_78329:
mov rsi, [r15]
add rsi, rbx
mov rdi, r13
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmSt4lessIS5_ESaISt4pairIKS5_mEEEixERS9_; std::map<std::string,ulong>::operator[](std::string const&)
mov [rax], r12
inc r12
add rbx, 20h ; ' '
cmp rbp, r12
jnz short loc_78329
loc_78346:
lea rdi, [rsp+118h+var_E8]
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rdi, [rsp+118h+var_D0]
lea r13, [rsp+118h+var_C0]
mov [r13-10h], r13
mov rsi, [r14]
mov rdx, [r14+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea r14, [rsp+118h+var_B0]
lea rsi, [rsp+118h+var_60]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EEC2ERKSE_; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::_Rb_tree(std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>> const&)
lea r15, [rsp+118h+var_80]
mov rdi, r15
mov rsi, [rsp+118h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
xorps xmm0, xmm0
movaps [rsp+118h+var_108], xmm0
movaps [rsp+118h+var_118], xmm0
mov edi, 88h; unsigned __int64
call __Znwm; operator new(ulong)
mov r12, rax
lea rsi, [rsp+118h+var_E8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
lea rdi, [r12+18h]
lea rbp, [r12+28h]
mov [r12+18h], rbp
mov rsi, [rsp+118h+var_D0]
mov rdx, [rsp+118h+var_C8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, [r12+40h]
mov rdx, [rsp+118h+var_A0]
test rdx, rdx
jz short loc_7842D
lea rdi, [rsp+118h+var_A8]
mov ecx, [rdi]
mov [r12+48h], rdx
mov r8, [rdi+10h]
mov rsi, [rdi+18h]
mov [rdx+8], rax
lea rdx, [rsp+118h+var_88]
mov rax, [rdx]
mov [r12+60h], rax
mov qword ptr [rdx-18h], 0
mov [rdx-10h], rdi
mov [rdx-8], rdi
mov rax, r8
jmp short loc_78440
loc_7842D:
mov qword ptr [r12+48h], 0
lea rdx, [r12+60h]
xor ecx, ecx
mov rsi, rax
loc_78440:
mov [r12+50h], rax
mov [r12+58h], rsi
mov qword ptr [rdx], 0
mov [r12+40h], ecx
lea rdi, [r12+68h]
mov rsi, r15
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERS1_EEC2ERKS9_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)
mov rsi, rsp
mov [rsi], r12
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E9_M_invokeERKSt9_Any_dataS6_S8_; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke(std::_Any_data const&,std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEZNS0_L15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISF_SaISF_EERKSt8functionIFS1_S6_RS1_EEE3$_0E10_M_managerERSt9_Any_dataRKSV_St18_Manager_operation; std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
mov rdi, [rsp+118h+var_F8]
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_784A0
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_784A0:
mov rax, [rsp+118h+var_70]
test rax, rax
jz short loc_784BA
mov rdi, r15
mov rsi, r15
mov edx, 3
call rax
loc_784BA:
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, [rsp+118h+var_D0]; void *
cmp rdi, r13
jz short loc_784D9
mov rsi, [rsp+118h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_784D9:
lea rdi, [rsp+118h+var_E8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rsp+118h+var_60]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_78581
jmp short loc_78581
mov rbx, rax
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_7858C
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_7858C
jmp short loc_78581
mov rbx, rax
mov rdi, r12
add rdi, 38h ; '8'
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, [r12+18h]; void *
cmp rdi, rbp
jz short loc_7854E
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7854E
mov rbx, rax
loc_7854E:
mov rdi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_7855B
mov rbx, rax
loc_7855B:
mov esi, 88h; unsigned __int64
mov rdi, r12; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, qword ptr [rsp+118h+var_108]
test rax, rax
jz short loc_7858C
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_7858C
loc_78581:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_7858C:
lea rdi, [rsp+118h+var_E8]
call _ZZN5minjaL15simple_functionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorIS5_SaIS5_EERKSt8functionIFNS_5ValueERKSt10shared_ptrINS_7ContextEERSE_EEEN3$_0D2Ev; minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0::~$_0()
jmp short loc_785D5
mov rbx, rax
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
jmp short loc_785A8
mov rbx, rax
loc_785A8:
mov rdi, [rsp+118h+var_D0]; void *
cmp rdi, r13
jz short loc_785C4
mov rsi, [rsp+118h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_785C4
mov rbx, rax
loc_785C4:
lea rdi, [rsp+118h+var_E8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_785D5
jmp short $+2
loc_785D2:
mov rbx, rax
loc_785D5:
lea rdi, [rsp+118h+var_60]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESt10_Select1stIS8_ESt4lessIS5_ESaIS8_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,ulong>,std::_Select1st<std::pair<std::string const,ulong>>,std::less<std::string>,std::allocator<std::pair<std::string const,ulong>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| long long minja::simple_function(long long a1, long long a2, _QWORD *a3, long long a4)
{
long long v5; // rbp
long long v6; // rbp
long long v7; // rbx
long long v8; // r12
long long v9; // r12
long long v10; // rax
long long v11; // rdx
int v12; // ecx
int *v13; // r8
int *v14; // rsi
long long *v15; // rdx
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
__int128 v21; // [rsp+0h] [rbp-118h] BYREF
__int128 v22; // [rsp+10h] [rbp-108h]
long long v23; // [rsp+20h] [rbp-F8h]
long long v24; // [rsp+28h] [rbp-F0h]
_QWORD v25[3]; // [rsp+30h] [rbp-E8h] BYREF
void *v26[2]; // [rsp+48h] [rbp-D0h] BYREF
_QWORD v27[2]; // [rsp+58h] [rbp-C0h] BYREF
_BYTE v28[8]; // [rsp+68h] [rbp-B0h] BYREF
int v29; // [rsp+70h] [rbp-A8h] BYREF
long long v30; // [rsp+78h] [rbp-A0h]
int *v31; // [rsp+80h] [rbp-98h]
int *v32; // [rsp+88h] [rbp-90h]
long long v33; // [rsp+90h] [rbp-88h] BYREF
_BYTE v34[16]; // [rsp+98h] [rbp-80h] BYREF
void ( *v35)(_BYTE *, _BYTE *, long long); // [rsp+A8h] [rbp-70h]
_BYTE v36[8]; // [rsp+B8h] [rbp-60h] BYREF
int v37; // [rsp+C0h] [rbp-58h] BYREF
long long v38; // [rsp+C8h] [rbp-50h]
int *v39; // [rsp+D0h] [rbp-48h]
int *v40; // [rsp+D8h] [rbp-40h]
long long v41; // [rsp+E0h] [rbp-38h]
v24 = a4;
v23 = a1;
v37 = 0;
v38 = 0LL;
v39 = &v37;
v40 = &v37;
v41 = 0LL;
v5 = a3[1] - *a3;
if ( v5 )
{
v6 = (v5 >> 5 == 0) + (v5 >> 5);
v7 = 0LL;
v8 = 0LL;
do
{
*(_QWORD *)std::map<std::string,unsigned long>::operator[](v36, v7 + *a3) = v8++;
v7 += 32LL;
}
while ( v6 != v8 );
}
std::vector<std::string>::vector((long long)v25, a3);
v26[0] = v27;
std::string::_M_construct<char *>((long long)v26, *(_BYTE **)a2, *(_QWORD *)a2 + *(_QWORD *)(a2 + 8));
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::_Rb_tree(
v28,
v36);
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v34, v24);
v22 = 0LL;
v21 = 0LL;
v9 = operator new(0x88uLL);
std::vector<std::string>::vector(v9, v25);
*(_QWORD *)(v9 + 24) = v9 + 40;
std::string::_M_construct<char *>(v9 + 24, (_BYTE *)v26[0], (long long)v26[0] + (unsigned long long)v26[1]);
v10 = v9 + 64;
v11 = v30;
if ( v30 )
{
v12 = v29;
*(_QWORD *)(v9 + 72) = v30;
v13 = v31;
v14 = v32;
*(_QWORD *)(v11 + 8) = v10;
v15 = &v33;
*(_QWORD *)(v9 + 96) = v33;
v30 = 0LL;
v31 = &v29;
v32 = &v29;
v10 = (long long)v13;
}
else
{
*(_QWORD *)(v9 + 72) = 0LL;
v15 = (long long *)(v9 + 96);
v12 = 0;
v14 = (int *)(v9 + 64);
}
*(_QWORD *)(v9 + 80) = v10;
*(_QWORD *)(v9 + 88) = v14;
*v15 = 0LL;
*(_DWORD *)(v9 + 64) = v12;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)>::function(v9 + 104, v34);
*((_QWORD *)&v22 + 1) = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_invoke;
*(_QWORD *)&v22 = std::_Function_handler<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &),minja::simple_function(std::string const&,std::vector<std::string> const&,std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::Value&)> const&)::$_0>::_M_manager;
minja::Value::callable(v23, (unsigned int)&v21, v16, v17, v18, v19, v9, *((long long *)&v21 + 1));
if ( (_QWORD)v22 )
((void ( *)(__int128 *, __int128 *, long long))v22)(&v21, &v21, 3LL);
if ( v35 )
v35(v34, v34, 3LL);
std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v28);
if ( v26[0] != v27 )
operator delete(v26[0], v27[0] + 1LL);
std::vector<std::string>::~vector((long long)v25);
return std::_Rb_tree<std::string,std::pair<std::string const,unsigned long>,std::_Select1st<std::pair<std::string const,unsigned long>>,std::less<std::string>,std::allocator<std::pair<std::string const,unsigned long>>>::~_Rb_tree(v36);
}
| simple_function:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x28],RCX
MOV R15,RDX
MOV R14,RSI
MOV qword ptr [RSP + 0x20],RDI
LEA RAX,[RSP + 0xc0]
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 RBP,qword ptr [RDX + 0x8]
SUB RBP,qword ptr [RDX]
JZ 0x00178346
SAR RBP,0x5
CMP RBP,0x1
ADC RBP,0x0
XOR EBX,EBX
LEA R13,[RSP + 0xb8]
XOR R12D,R12D
LAB_00178329:
MOV RSI,qword ptr [R15]
ADD RSI,RBX
LAB_0017832f:
MOV RDI,R13
CALL 0x001ac244
MOV qword ptr [RAX],R12
INC R12
ADD RBX,0x20
CMP RBP,R12
JNZ 0x00178329
LAB_00178346:
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x00154c34
LEA RDI,[RSP + 0x48]
LEA R13,[RSP + 0x58]
MOV qword ptr [R13 + -0x10],R13
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
LAB_0017836b:
CALL 0x00121da0
LEA R14,[RSP + 0x68]
LAB_00178375:
LEA RSI,[RSP + 0xb8]
MOV RDI,R14
CALL 0x001ac69e
LEA R15,[RSP + 0x98]
LAB_0017838d:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001ac2c0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP],XMM0
LAB_001783a6:
MOV EDI,0x88
CALL 0x0011a8d0
LAB_001783b0:
MOV R12,RAX
LEA RSI,[RSP + 0x30]
MOV RDI,RAX
CALL 0x00154c34
LEA RDI,[R12 + 0x18]
LEA RBP,[R12 + 0x28]
MOV qword ptr [R12 + 0x18],RBP
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
ADD RDX,RSI
LAB_001783dc:
CALL 0x00121da0
LEA RAX,[R12 + 0x40]
MOV RDX,qword ptr [RSP + 0x78]
TEST RDX,RDX
JZ 0x0017842d
LEA RDI,[RSP + 0x70]
MOV ECX,dword ptr [RDI]
MOV qword ptr [R12 + 0x48],RDX
MOV R8,qword ptr [RDI + 0x10]
MOV RSI,qword ptr [RDI + 0x18]
MOV qword ptr [RDX + 0x8],RAX
LEA RDX,[RSP + 0x90]
MOV RAX,qword ptr [RDX]
MOV qword ptr [R12 + 0x60],RAX
MOV qword ptr [RDX + -0x18],0x0
MOV qword ptr [RDX + -0x10],RDI
MOV qword ptr [RDX + -0x8],RDI
MOV RAX,R8
JMP 0x00178440
LAB_0017842d:
MOV qword ptr [R12 + 0x48],0x0
LEA RDX,[R12 + 0x60]
XOR ECX,ECX
MOV RSI,RAX
LAB_00178440:
MOV qword ptr [R12 + 0x50],RAX
MOV qword ptr [R12 + 0x58],RSI
MOV qword ptr [RDX],0x0
MOV dword ptr [R12 + 0x40],ECX
LEA RDI,[R12 + 0x68]
LAB_0017845b:
MOV RSI,R15
CALL 0x001ac2c0
MOV RSI,RSP
MOV qword ptr [RSI],R12
LEA RAX,[0x178638]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x178cb6]
MOV qword ptr [RSI + 0x10],RAX
LAB_0017847f:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00195e5e
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001784a0
LAB_00178493:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001784a0:
MOV RAX,qword ptr [RSP + 0xa8]
TEST RAX,RAX
JZ 0x001784ba
LAB_001784ad:
MOV RDI,R15
MOV RSI,R15
MOV EDX,0x3
CALL RAX
LAB_001784ba:
MOV RDI,R14
CALL 0x001ac900
MOV RDI,qword ptr [RSP + 0x48]
CMP RDI,R13
JZ 0x001784d9
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011a8f0
LAB_001784d9:
LEA RDI,[RSP + 0x30]
CALL 0x00120c24
LEA RDI,[RSP + 0xb8]
CALL 0x001ac900
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::simple_function(std::__cxx11::string const&, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&, std::function<minja::Value
(std::shared_ptr<minja::Context> const&, minja::Value&)> const&) */
void __thiscall
minja::simple_function(minja *this,string *param_1,vector *param_2,function *param_3)
{
long *plVar1;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *this_00;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar2;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar3;
long lVar4;
long lVar5;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *pvVar6;
long lVar7;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_118;
int8 uStack_110;
code *local_108;
code *pcStack_100;
minja *local_f8;
function *local_f0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_e8 [24];
long *local_d0;
long local_c8;
long local_c0 [2];
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_b0 [8];
int4 local_a8 [2];
long local_a0;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_98;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_90;
int8 local_88;
function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> local_80 [16];
code *local_70;
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
local_60 [8];
int4 local_58 [2];
int8 local_50;
int4 *local_48;
int4 *local_40;
int8 local_38;
local_48 = local_58;
local_58[0] = 0;
local_50 = 0;
local_38 = 0;
local_f8 = this;
local_f0 = param_3;
local_40 = local_48;
if (*(long *)(param_2 + 8) - *(long *)param_2 != 0) {
lVar5 = *(long *)(param_2 + 8) - *(long *)param_2 >> 5;
lVar4 = 0;
lVar7 = 0;
do {
/* try { // try from 0017832f to 00178336 has its CatchHandler @ 001785d2 */
plVar1 = (long *)std::
map<std::__cxx11::string,unsigned_long,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::operator[](local_60,(string *)(*(long *)param_2 + lVar4));
*plVar1 = lVar7;
lVar7 = lVar7 + 1;
lVar4 = lVar4 + 0x20;
} while (lVar5 + (ulong)(lVar5 == 0) != lVar7);
}
/* try { // try from 00178346 to 00178352 has its CatchHandler @ 001785d0 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_e8,param_2);
local_d0 = local_c0;
/* try { // try from 0017836b to 0017836f has its CatchHandler @ 001785c1 */
std::__cxx11::string::_M_construct<char*>
(&local_d0,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 00178375 to 00178384 has its CatchHandler @ 001785a5 */
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::_Rb_tree(local_b0,(_Rb_tree *)local_60);
/* try { // try from 0017838d to 00178399 has its CatchHandler @ 00178598 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
(local_80,local_f0);
local_108 = (code *)0x0;
pcStack_100 = (code *)0x0;
local_118 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)0x0;
uStack_110 = 0;
/* try { // try from 001783a6 to 001783af has its CatchHandler @ 00178589 */
this_00 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)operator_new(0x88);
/* try { // try from 001783b0 to 001783bf has its CatchHandler @ 00178558 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(this_00,(vector *)local_e8);
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x18) =
this_00 + 0x28;
/* try { // try from 001783dc to 001783e0 has its CatchHandler @ 0017854b */
std::__cxx11::string::_M_construct<char*>(this_00 + 0x18,local_d0,local_c8 + (long)local_d0);
pvVar2 = this_00 + 0x40;
if (local_a0 == 0) {
*(int8 *)(this_00 + 0x48) = 0;
pvVar3 = this_00 + 0x60;
local_a8[0] = 0;
pvVar6 = pvVar2;
}
else {
*(long *)(this_00 + 0x48) = local_a0;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(local_a0 + 8) = pvVar2;
pvVar3 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_88;
*(int8 *)(this_00 + 0x60) = local_88;
local_a0 = 0;
pvVar2 = local_98;
pvVar6 = local_90;
local_98 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_a8;
local_90 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_a8;
}
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x50) = pvVar2;
*(vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> **)(this_00 + 0x58) = pvVar6;
*(int8 *)pvVar3 = 0;
*(int4 *)(this_00 + 0x40) = local_a8[0];
/* try { // try from 0017845b to 00178462 has its CatchHandler @ 00178524 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>::function
((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)> *)
(this_00 + 0x68),local_80);
pcStack_100 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_invoke;
local_108 = std::
_Function_handler<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&),minja::simple_function(std::__cxx11::string_const&,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&,std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::Value&)>const&)::$_0>
::_M_manager;
local_118 = this_00;
/* try { // try from 0017847f to 00178488 has its CatchHandler @ 00178506 */
Value::callable((Value *)local_f8,(function *)&local_118);
if (local_108 != (code *)0x0) {
/* try { // try from 00178493 to 0017849f has its CatchHandler @ 00178504 */
(*local_108)(&local_118,&local_118,3);
}
if (local_70 != (code *)0x0) {
/* try { // try from 001784ad to 001784b9 has its CatchHandler @ 00178502 */
(*local_70)(local_80,local_80,3);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree(local_b0);
if (local_d0 != local_c0) {
operator_delete(local_d0,local_c0[0] + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_e8);
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
::~_Rb_tree((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::_Select1st<std::pair<std::__cxx11::string_const,unsigned_long>>,std::less<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>>
*)local_60);
return;
}
|
|
1,905 | ma_copy_key | eloqsql/storage/maria/ma_key.c | void _ma_copy_key(MARIA_KEY *to, const MARIA_KEY *from)
{
memcpy(to->data, from->data, from->data_length + from->ref_length);
to->keyinfo= from->keyinfo;
to->data_length= from->data_length;
to->ref_length= from->ref_length;
to->flag= from->flag;
} | O3 | c | ma_copy_key:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
movl 0x14(%rbx), %edx
addl 0x10(%rbx), %edx
callq 0x2a0a0
movq 0x8(%rbx), %rax
movq %rax, 0x8(%r14)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r14)
movl 0x14(%rbx), %eax
movl %eax, 0x14(%r14)
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
| _ma_copy_key:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi]
mov rsi, [rsi]
mov edx, [rbx+14h]
add edx, [rbx+10h]
call _memcpy
mov rax, [rbx+8]
mov [r14+8], rax
mov eax, [rbx+10h]
mov [r14+10h], eax
mov eax, [rbx+14h]
mov [r14+14h], eax
mov eax, [rbx+18h]
mov [r14+18h], eax
pop rbx
pop r14
pop rbp
retn
| long long ma_copy_key(long long a1, long long a2)
{
long long result; // rax
memcpy(*(_QWORD *)a1, *(_QWORD *)a2, (unsigned int)(*(_DWORD *)(a2 + 16) + *(_DWORD *)(a2 + 20)));
*(_QWORD *)(a1 + 8) = *(_QWORD *)(a2 + 8);
*(_DWORD *)(a1 + 16) = *(_DWORD *)(a2 + 16);
*(_DWORD *)(a1 + 20) = *(_DWORD *)(a2 + 20);
result = *(unsigned int *)(a2 + 24);
*(_DWORD *)(a1 + 24) = result;
return result;
}
| _ma_copy_key:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI]
MOV RSI,qword ptr [RSI]
MOV EDX,dword ptr [RBX + 0x14]
ADD EDX,dword ptr [RBX + 0x10]
CALL 0x0012a0a0
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [R14 + 0x8],RAX
MOV EAX,dword ptr [RBX + 0x10]
MOV dword ptr [R14 + 0x10],EAX
MOV EAX,dword ptr [RBX + 0x14]
MOV dword ptr [R14 + 0x14],EAX
MOV EAX,dword ptr [RBX + 0x18]
MOV dword ptr [R14 + 0x18],EAX
POP RBX
POP R14
POP RBP
RET
|
void _ma_copy_key(int8 *param_1,int8 *param_2)
{
memcpy((void *)*param_1,(void *)*param_2,
(ulong)(uint)(*(int *)((long)param_2 + 0x14) + *(int *)(param_2 + 2)));
param_1[1] = param_2[1];
*(int4 *)(param_1 + 2) = *(int4 *)(param_2 + 2);
*(int4 *)((long)param_1 + 0x14) = *(int4 *)((long)param_2 + 0x14);
*(int4 *)(param_1 + 3) = *(int4 *)(param_2 + 3);
return;
}
|
|
1,906 | cs_leave | eloqsql/strings/ctype.c | static int cs_leave(MY_XML_PARSER *st,const char *attr, size_t len)
{
struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
const struct my_cs_file_section_st *s= cs_file_sec(attr,len);
int state= s ? s->state : 0;
int rc;
switch(state){
case _CS_COLLATION:
if (i->tailoring_length)
i->cs.tailoring= i->tailoring;
rc= i->loader->add_collation ? i->loader->add_collation(&i->cs) : MY_XML_OK;
break;
/* Rules: Logical Reset Positions */
case _CS_RESET_FIRST_NON_IGNORABLE:
rc= tailoring_append(st, "[first non-ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_NON_IGNORABLE:
rc= tailoring_append(st, "[last non-ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[first primary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_PRIMARY_IGNORABLE:
rc= tailoring_append(st, "[last primary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[first secondary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_SECONDARY_IGNORABLE:
rc= tailoring_append(st, "[last secondary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[first tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_LAST_TERTIARY_IGNORABLE:
rc= tailoring_append(st, "[last tertiary ignorable]", 0, NULL);
break;
case _CS_RESET_FIRST_TRAILING:
rc= tailoring_append(st, "[first trailing]", 0, NULL);
break;
case _CS_RESET_LAST_TRAILING:
rc= tailoring_append(st, "[last trailing]", 0, NULL);
break;
case _CS_RESET_FIRST_VARIABLE:
rc= tailoring_append(st, "[first variable]", 0, NULL);
break;
case _CS_RESET_LAST_VARIABLE:
rc= tailoring_append(st, "[last variable]", 0, NULL);
break;
default:
rc=MY_XML_OK;
}
return rc;
} | O0 | c | cs_leave:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x140(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa49e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa37d6
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0xa37dd
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0xa37dd
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
subl $0x9, %eax
je 0xa38b7
jmp 0xa37f4
movl -0x38(%rbp), %eax
subl $0x191, %eax # imm = 0x191
je 0xa3964
jmp 0xa3804
movl -0x38(%rbp), %eax
subl $0x192, %eax # imm = 0x192
je 0xa3983
jmp 0xa3814
movl -0x38(%rbp), %eax
subl $0x193, %eax # imm = 0x193
je 0xa39a2
jmp 0xa3824
movl -0x38(%rbp), %eax
subl $0x194, %eax # imm = 0x194
je 0xa39c1
jmp 0xa3834
movl -0x38(%rbp), %eax
subl $0x195, %eax # imm = 0x195
je 0xa39e0
jmp 0xa3844
movl -0x38(%rbp), %eax
subl $0x196, %eax # imm = 0x196
je 0xa39ff
jmp 0xa3854
movl -0x38(%rbp), %eax
subl $0x197, %eax # imm = 0x197
je 0xa3a1b
jmp 0xa3864
movl -0x38(%rbp), %eax
subl $0x198, %eax # imm = 0x198
je 0xa3a37
jmp 0xa3874
movl -0x38(%rbp), %eax
subl $0x199, %eax # imm = 0x199
je 0xa3a53
jmp 0xa3884
movl -0x38(%rbp), %eax
subl $0x19a, %eax # imm = 0x19A
je 0xa3a6f
jmp 0xa3894
movl -0x38(%rbp), %eax
subl $0x19b, %eax # imm = 0x19B
je 0xa3926
jmp 0xa38a4
movl -0x38(%rbp), %eax
subl $0x19c, %eax # imm = 0x19C
je 0xa3945
jmp 0xa3a8b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x690(%rax)
je 0xa38db
movq -0x20(%rbp), %rax
movq 0x688(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x718(%rax)
movq -0x20(%rbp), %rax
movq 0x7a8(%rax), %rax
cmpq $0x0, 0xa8(%rax)
je 0xa3914
movq -0x20(%rbp), %rax
movq 0x7a8(%rax), %rax
movq 0xa8(%rax), %rax
movq -0x20(%rbp), %rdi
addq $0x6e0, %rdi # imm = 0x6E0
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0xa391b
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xa391b
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bff(%rip), %rsi # 0xb4530
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bf6(%rip), %rsi # 0xb4546
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bec(%rip), %rsi # 0xb455b
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10be7(%rip), %rsi # 0xb4575
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10be1(%rip), %rsi # 0xb458e
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bde(%rip), %rsi # 0xb45aa
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bda(%rip), %rsi # 0xb45c5
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bd6(%rip), %rsi # 0xb45e0
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bd4(%rip), %rsi # 0xb45fa
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bc9(%rip), %rsi # 0xb460b
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bbd(%rip), %rsi # 0xb461b
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movq -0x8(%rbp), %rdi
leaq 0x10bb2(%rip), %rsi # 0xb462c
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xa4a70
movl %eax, -0x30(%rbp)
jmp 0xa3a92
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| cs_leave:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax+140h]
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call cs_file_sec
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_A37D6
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_34], eax
jmp short loc_A37DD
loc_A37D6:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_A37DD:
mov eax, [rbp+var_34]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
mov [rbp+var_38], eax
sub eax, 9
jz loc_A38B7
jmp short $+2
loc_A37F4:
mov eax, [rbp+var_38]
sub eax, 191h
jz loc_A3964
jmp short $+2
loc_A3804:
mov eax, [rbp+var_38]
sub eax, 192h
jz loc_A3983
jmp short $+2
loc_A3814:
mov eax, [rbp+var_38]
sub eax, 193h
jz loc_A39A2
jmp short $+2
loc_A3824:
mov eax, [rbp+var_38]
sub eax, 194h
jz loc_A39C1
jmp short $+2
loc_A3834:
mov eax, [rbp+var_38]
sub eax, 195h
jz loc_A39E0
jmp short $+2
loc_A3844:
mov eax, [rbp+var_38]
sub eax, 196h
jz loc_A39FF
jmp short $+2
loc_A3854:
mov eax, [rbp+var_38]
sub eax, 197h
jz loc_A3A1B
jmp short $+2
loc_A3864:
mov eax, [rbp+var_38]
sub eax, 198h
jz loc_A3A37
jmp short $+2
loc_A3874:
mov eax, [rbp+var_38]
sub eax, 199h
jz loc_A3A53
jmp short $+2
loc_A3884:
mov eax, [rbp+var_38]
sub eax, 19Ah
jz loc_A3A6F
jmp short $+2
loc_A3894:
mov eax, [rbp+var_38]
sub eax, 19Bh
jz loc_A3926
jmp short $+2
loc_A38A4:
mov eax, [rbp+var_38]
sub eax, 19Ch
jz loc_A3945
jmp loc_A3A8B
loc_A38B7:
mov rax, [rbp+var_20]
cmp qword ptr [rax+690h], 0
jz short loc_A38DB
mov rax, [rbp+var_20]
mov rcx, [rax+688h]
mov rax, [rbp+var_20]
mov [rax+718h], rcx
loc_A38DB:
mov rax, [rbp+var_20]
mov rax, [rax+7A8h]
cmp qword ptr [rax+0A8h], 0
jz short loc_A3914
mov rax, [rbp+var_20]
mov rax, [rax+7A8h]
mov rax, [rax+0A8h]
mov rdi, [rbp+var_20]
add rdi, 6E0h
call rax
mov [rbp+var_3C], eax
jmp short loc_A391B
loc_A3914:
xor eax, eax
mov [rbp+var_3C], eax
jmp short $+2
loc_A391B:
mov eax, [rbp+var_3C]
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A3926:
mov rdi, [rbp+var_8]
lea rsi, aFirstNonIgnora; "[first non-ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A3945:
mov rdi, [rbp+var_8]
lea rsi, aLastNonIgnorab; "[last non-ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A3964:
mov rdi, [rbp+var_8]
lea rsi, aFirstPrimaryIg; "[first primary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A3983:
mov rdi, [rbp+var_8]
lea rsi, aLastPrimaryIgn; "[last primary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A39A2:
mov rdi, [rbp+var_8]
lea rsi, aFirstSecondary; "[first secondary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A39C1:
mov rdi, [rbp+var_8]
lea rsi, aLastSecondaryI; "[last secondary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A39E0:
mov rdi, [rbp+var_8]
lea rsi, aFirstTertiaryI; "[first tertiary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp loc_A3A92
loc_A39FF:
mov rdi, [rbp+var_8]
lea rsi, aLastTertiaryIg; "[last tertiary ignorable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_A3A92
loc_A3A1B:
mov rdi, [rbp+var_8]
lea rsi, aFirstTrailing; "[first trailing]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_A3A92
loc_A3A37:
mov rdi, [rbp+var_8]
lea rsi, aLastTrailing; "[last trailing]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_A3A92
loc_A3A53:
mov rdi, [rbp+var_8]
lea rsi, aFirstVariable; "[first variable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_A3A92
loc_A3A6F:
mov rdi, [rbp+var_8]
lea rsi, aLastVariable; "[last variable]"
xor eax, eax
mov ecx, eax
mov rdx, rcx
call tailoring_append
mov [rbp+var_30], eax
jmp short loc_A3A92
loc_A3A8B:
mov [rbp+var_30], 0
loc_A3A92:
mov eax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
| long long cs_leave(long long a1, long long a2, long long a3)
{
int v5; // [rsp+Ch] [rbp-34h]
int *v7; // [rsp+18h] [rbp-28h]
_QWORD *v8; // [rsp+20h] [rbp-20h]
v8 = *(_QWORD **)(a1 + 320);
v7 = (int *)cs_file_sec(a2, a3);
if ( v7 )
v5 = *v7;
else
v5 = 0;
switch ( v5 )
{
case 9:
if ( v8[210] )
v8[227] = v8[209];
if ( *(_QWORD *)(v8[245] + 168LL) )
return (unsigned int)(*(long long ( **)(_QWORD *))(v8[245] + 168LL))(v8 + 220);
else
return 0;
case 401:
return (unsigned int)tailoring_append(a1, "[first primary ignorable]", 0LL);
case 402:
return (unsigned int)tailoring_append(a1, "[last primary ignorable]", 0LL);
case 403:
return (unsigned int)tailoring_append(a1, "[first secondary ignorable]", 0LL);
case 404:
return (unsigned int)tailoring_append(a1, "[last secondary ignorable]", 0LL);
case 405:
return (unsigned int)tailoring_append(a1, "[first tertiary ignorable]", 0LL);
case 406:
return (unsigned int)tailoring_append(a1, "[last tertiary ignorable]", 0LL);
case 407:
return (unsigned int)tailoring_append(a1, "[first trailing]", 0LL);
case 408:
return (unsigned int)tailoring_append(a1, "[last trailing]", 0LL);
case 409:
return (unsigned int)tailoring_append(a1, "[first variable]", 0LL);
case 410:
return (unsigned int)tailoring_append(a1, "[last variable]", 0LL);
case 411:
return (unsigned int)tailoring_append(a1, "[first non-ignorable]", 0LL);
case 412:
return (unsigned int)tailoring_append(a1, "[last non-ignorable]", 0LL);
default:
return 0;
}
}
| cs_leave:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x140]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001a49e0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001a37d6
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001a37dd
LAB_001a37d6:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001a37dd
LAB_001a37dd:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x38],EAX
SUB EAX,0x9
JZ 0x001a38b7
JMP 0x001a37f4
LAB_001a37f4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x191
JZ 0x001a3964
JMP 0x001a3804
LAB_001a3804:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x192
JZ 0x001a3983
JMP 0x001a3814
LAB_001a3814:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x193
JZ 0x001a39a2
JMP 0x001a3824
LAB_001a3824:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x194
JZ 0x001a39c1
JMP 0x001a3834
LAB_001a3834:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x195
JZ 0x001a39e0
JMP 0x001a3844
LAB_001a3844:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x196
JZ 0x001a39ff
JMP 0x001a3854
LAB_001a3854:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x197
JZ 0x001a3a1b
JMP 0x001a3864
LAB_001a3864:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x198
JZ 0x001a3a37
JMP 0x001a3874
LAB_001a3874:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x199
JZ 0x001a3a53
JMP 0x001a3884
LAB_001a3884:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19a
JZ 0x001a3a6f
JMP 0x001a3894
LAB_001a3894:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19b
JZ 0x001a3926
JMP 0x001a38a4
LAB_001a38a4:
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x19c
JZ 0x001a3945
JMP 0x001a3a8b
LAB_001a38b7:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x690],0x0
JZ 0x001a38db
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x688]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x718],RCX
LAB_001a38db:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x7a8]
CMP qword ptr [RAX + 0xa8],0x0
JZ 0x001a3914
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x7a8]
MOV RAX,qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x6e0
CALL RAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001a391b
LAB_001a3914:
XOR EAX,EAX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001a391b
LAB_001a391b:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3926:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b4530]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3945:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b4546]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3964:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b455b]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3983:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b4575]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a39a2:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b458e]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a39c1:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b45aa]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a39e0:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b45c5]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a39ff:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b45e0]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3a1b:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b45fa]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3a37:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b460b]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3a53:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b461b]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3a6f:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1b462c]
XOR EAX,EAX
MOV ECX,EAX
MOV RDX,RCX
CALL 0x001a4a70
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001a3a92
LAB_001a3a8b:
MOV dword ptr [RBP + -0x30],0x0
LAB_001a3a92:
MOV EAX,dword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
int4 cs_leave(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int *piVar2;
int4 local_44;
int local_3c;
int4 local_38;
lVar1 = *(long *)(param_1 + 0x140);
piVar2 = (int *)cs_file_sec(param_2,param_3);
if (piVar2 == (int *)0x0) {
local_3c = 0;
}
else {
local_3c = *piVar2;
}
if (local_3c == 9) {
if (*(long *)(lVar1 + 0x690) != 0) {
*(int8 *)(lVar1 + 0x718) = *(int8 *)(lVar1 + 0x688);
}
if (*(long *)(*(long *)(lVar1 + 0x7a8) + 0xa8) == 0) {
local_44 = 0;
}
else {
local_44 = (**(code **)(*(long *)(lVar1 + 0x7a8) + 0xa8))(lVar1 + 0x6e0);
}
local_38 = local_44;
}
else if (local_3c == 0x191) {
local_38 = tailoring_append(param_1,"[first primary ignorable]",0);
}
else if (local_3c == 0x192) {
local_38 = tailoring_append(param_1,"[last primary ignorable]",0);
}
else if (local_3c == 0x193) {
local_38 = tailoring_append(param_1,"[first secondary ignorable]",0);
}
else if (local_3c == 0x194) {
local_38 = tailoring_append(param_1,"[last secondary ignorable]",0);
}
else if (local_3c == 0x195) {
local_38 = tailoring_append(param_1,"[first tertiary ignorable]",0);
}
else if (local_3c == 0x196) {
local_38 = tailoring_append(param_1,"[last tertiary ignorable]",0);
}
else if (local_3c == 0x197) {
local_38 = tailoring_append(param_1,"[first trailing]",0);
}
else if (local_3c == 0x198) {
local_38 = tailoring_append(param_1,"[last trailing]",0);
}
else if (local_3c == 0x199) {
local_38 = tailoring_append(param_1,"[first variable]",0);
}
else if (local_3c == 0x19a) {
local_38 = tailoring_append(param_1,"[last variable]",0);
}
else if (local_3c == 0x19b) {
local_38 = tailoring_append(param_1,"[first non-ignorable]",0);
}
else if (local_3c == 0x19c) {
local_38 = tailoring_append(param_1,"[last non-ignorable]",0);
}
else {
local_38 = 0;
}
return local_38;
}
|
|
1,907 | ftxui::(anonymous namespace)::FallbackSize() | Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/screen/terminal.cpp | Dimensions& FallbackSize() {
#if defined(__EMSCRIPTEN__)
// This dimension was chosen arbitrarily to be able to display:
// https://arthursonzogni.com/FTXUI/examples
// This will have to be improved when someone has time to implement and need
// it.
constexpr int fallback_width = 140;
constexpr int fallback_height = 43;
#else
// The terminal size in VT100 was 80x24. It is still used nowadays by
// default in many terminal emulator. That's a good choice for a fallback
// value.
constexpr int fallback_width = 80;
constexpr int fallback_height = 24;
#endif
static Dimensions g_fallback_size{
fallback_width,
fallback_height,
};
return g_fallback_size;
} | O0 | cpp | ftxui::(anonymous namespace)::FallbackSize():
pushq %rbp
movq %rsp, %rbp
movl $0x50, -0x4(%rbp)
movl $0x18, -0x8(%rbp)
leaq 0xa6327(%rip), %rax # 0xdf610
popq %rbp
retq
nopl (%rax,%rax)
| _ZN5ftxui12_GLOBAL__N_112FallbackSizeEv:
push rbp
mov rbp, rsp
mov [rbp+var_4], 50h ; 'P'
mov [rbp+var_8], 18h
lea rax, _ZZN5ftxui12_GLOBAL__N_112FallbackSizeEvE15g_fallback_size; ftxui::`anonymous namespace'::FallbackSize(void)::g_fallback_size
pop rbp
retn
| void * ftxui::`anonymous namespace'::FallbackSize(ftxui::_anonymous_namespace_ *this)
{
return &ftxui::`anonymous namespace'::FallbackSize(void)::g_fallback_size;
}
| FallbackSize:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],0x50
MOV dword ptr [RBP + -0x8],0x18
LEA RAX,[0x1df610]
POP RBP
RET
|
/* ftxui::(anonymous namespace)::FallbackSize() */
int8 * ftxui::(anonymous_namespace)::FallbackSize(void)
{
return &FallbackSize()::g_fallback_size;
}
|
|
1,908 | ggml_backend_cpu_set_n_threads | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.cpp | void ggml_backend_cpu_set_n_threads(ggml_backend_t backend_cpu, int n_threads) {
GGML_ASSERT(ggml_backend_is_cpu(backend_cpu));
struct ggml_backend_cpu_context * ctx = (struct ggml_backend_cpu_context *)backend_cpu->context;
ctx->n_threads = n_threads;
} | O3 | cpp | ggml_backend_cpu_set_n_threads:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x26da5
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x3e8a2(%rip), %rsi # 0x65630
callq 0x84d0
testb %al, %al
je 0x26da5
movq 0x78(%r14), %rax
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2dca1(%rip), %rdi # 0x54a4d
leaq 0x2cb0e(%rip), %rdx # 0x538c1
leaq 0x2dcec(%rip), %rcx # 0x54aa6
movl $0xda, %esi
xorl %eax, %eax
callq 0x8950
| ggml_backend_cpu_set_n_threads:
push r14
push rbx
push rax
test rdi, rdi
jz short loc_26DA5
mov ebx, esi
mov r14, rdi
mov rdi, [rdi]
lea rsi, _ZZL21ggml_backend_cpu_guidvE4guid; ggml_backend_cpu_guid(void)::guid
call _ggml_guid_matches
test al, al
jz short loc_26DA5
mov rax, [r14+78h]
mov [rax], ebx
add rsp, 8
pop rbx
pop r14
retn
loc_26DA5:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlBackendIsC_0; "ggml_backend_is_cpu(backend_cpu)"
mov esi, 0DAh
xor eax, eax
call _ggml_abort
| _DWORD * ggml_backend_cpu_set_n_threads(_QWORD *a1, int a2)
{
_DWORD *result; // rax
double v3; // xmm0_8
if ( a1 && (unsigned __int8)ggml_guid_matches(*a1, &ggml_backend_cpu_guid(void)::guid) )
{
result = (_DWORD *)a1[15];
*result = a2;
}
else
{
v3 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.cpp",
218LL,
"GGML_ASSERT(%s) failed",
"ggml_backend_is_cpu(backend_cpu)");
return (_DWORD *)ggml_backend_cpu_set_threadpool(v3);
}
return result;
}
| ggml_backend_cpu_set_n_threads:
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00126da5
MOV EBX,ESI
MOV R14,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[0x165630]
CALL 0x001084d0
TEST AL,AL
JZ 0x00126da5
MOV RAX,qword ptr [R14 + 0x78]
MOV dword ptr [RAX],EBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00126da5:
LEA RDI,[0x154a4d]
LEA RDX,[0x1538c1]
LEA RCX,[0x154aa6]
MOV ESI,0xda
XOR EAX,EAX
CALL 0x00108950
|
void ggml_backend_cpu_set_n_threads(int8 *param_1,int4 param_2)
{
char cVar1;
if (param_1 != (int8 *)0x0) {
cVar1 = ggml_guid_matches(*param_1,ggml_backend_cpu_guid()::guid);
if (cVar1 != '\0') {
*(int4 *)param_1[0xf] = param_2;
return;
}
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.cpp"
,0xda,"GGML_ASSERT(%s) failed","ggml_backend_is_cpu(backend_cpu)");
}
|
|
1,909 | ma_make_key | eloqsql/storage/maria/ma_key.c | MARIA_KEY *_ma_make_key(MARIA_HA *info, MARIA_KEY *int_key, uint keynr,
uchar *key, const uchar *record,
MARIA_RECORD_POS filepos, ulonglong trid)
{
const uchar *pos;
reg1 HA_KEYSEG *keyseg;
my_bool is_ft;
DBUG_ENTER("_ma_make_key");
int_key->data= key;
int_key->flag= 0; /* Always return full key */
int_key->keyinfo= info->s->keyinfo + keynr;
is_ft= int_key->keyinfo->flag & HA_FULLTEXT;
for (keyseg= int_key->keyinfo->seg ; keyseg->type ;keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
uint length=keyseg->length;
uint char_length;
CHARSET_INFO *cs=keyseg->charset;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
*key++= 0; /* NULL in key */
continue;
}
*key++=1; /* Not NULL */
}
char_length= ((!is_ft && cs && cs->mbmaxlen > 1) ? length/cs->mbmaxlen :
length);
pos= record+keyseg->start;
if (type == HA_KEYTYPE_BIT)
{
if (keyseg->bit_length)
{
uchar bits= get_rec_bits(record + keyseg->bit_pos,
keyseg->bit_start, keyseg->bit_length);
*key++= (char) bits;
length--;
}
memcpy(key, pos, length);
key+= length;
continue;
}
if (keyseg->flag & HA_SPACE_PACK)
{
if (type != HA_KEYTYPE_NUM)
{
length= (uint) my_ci_lengthsp(cs, (const char*)pos, length);
}
else
{
const uchar *end= pos + length;
while (pos < end && pos[0] == ' ')
pos++;
length= (uint) (end-pos);
}
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, pos, (size_t) char_length);
key+=char_length;
continue;
}
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= (keyseg->bit_start == 1 ? 1 : 2);
uint tmp_length= (pack_length == 1 ? (uint) *pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key,pos,(size_t) char_length);
key+= char_length;
continue;
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length= _ma_calc_blob_length(keyseg->bit_start,pos);
uchar *blob_pos;
memcpy(&blob_pos, pos+keyseg->bit_start,sizeof(char*));
set_if_smaller(length,tmp_length);
FIX_LENGTH(cs, blob_pos, length, char_length);
store_key_length_inc(key,char_length);
memcpy(key, blob_pos, (size_t) char_length);
key+= char_length;
continue;
}
else if (keyseg->flag & HA_SWAP_KEY)
{ /* Numerical column */
if (type == HA_KEYTYPE_FLOAT)
{
float nr;
float4get(nr,pos);
if (isnan(nr))
{
/* Replace NAN with zero */
bzero(key,length);
key+=length;
continue;
}
}
else if (type == HA_KEYTYPE_DOUBLE)
{
double nr;
float8get(nr,pos);
if (isnan(nr))
{
bzero(key,length);
key+=length;
continue;
}
}
pos+=length;
while (length--)
{
*key++ = *--pos;
}
continue;
}
FIX_LENGTH(cs, pos, length, char_length);
memcpy(key, pos, char_length);
if (length > char_length)
my_ci_fill(cs, (char*) key+char_length, length-char_length, ' ');
key+= length;
}
_ma_dpointer(info->s, key, filepos);
int_key->data_length= (uint)(key - int_key->data);
int_key->ref_length= info->s->rec_reflength;
int_key->flag= 0;
if (_ma_have_versioning(info) && trid)
{
int_key->ref_length+= transid_store_packed(info,
key + int_key->ref_length,
(TrID) trid);
int_key->flag|= SEARCH_USER_KEY_HAS_TRANSID;
}
DBUG_PRINT("exit",("keynr: %d",keynr));
DBUG_DUMP_KEY("key", int_key);
DBUG_EXECUTE("key", _ma_print_key(DBUG_FILE, int_key););
DBUG_RETURN(int_key);
} | O3 | c | ma_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x58(%rbp)
movq %rcx, (%rsi)
movl $0x0, 0x18(%rsi)
movq %rdi, -0x60(%rbp)
movq (%rdi), %rax
movq 0x570(%rax), %rdi
movl %edx, %eax
imulq $0x118, %rax, %rdx # imm = 0x118
leaq (%rdi,%rdx), %rax
movq %rsi, -0x68(%rbp)
movq %rax, 0x8(%rsi)
movq 0xc0(%rdi,%rdx), %r13
movb 0x18(%r13), %sil
testb %sil, %sil
je 0x42dfb
movq %r8, %r14
movzwl 0xa2(%rax), %eax
movw %ax, -0x32(%rbp)
leaq -0x1(%r8), %rax
movq %rax, -0x50(%rbp)
movq %r8, -0x40(%rbp)
movzwl 0x14(%r13), %ebx
movq (%r13), %r15
movb 0x19(%r13), %al
testb %al, %al
je 0x42a5f
movl 0xc(%r13), %edx
leaq 0x1(%rcx), %rdi
testb %al, (%r14,%rdx)
je 0x42a64
movb $0x0, (%rcx)
jmp 0x42d47
movq %rcx, %rdi
jmp 0x42a67
movb $0x1, (%rcx)
cmpb $0x0, -0x32(%rbp)
setns %al
testq %r15, %r15
setne %cl
andb %al, %cl
movl %ebx, %edx
cmpb $0x1, %cl
jne 0x42a93
movl 0x9c(%r15), %ecx
movl %ebx, %edx
cmpl $0x2, %ecx
jb 0x42a93
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
movl %eax, %edx
movl 0x8(%r13), %eax
leaq (%r14,%rax), %r12
cmpb $0x13, %sil
jne 0x42b04
movzbl 0x1b(%r13), %eax
testl %eax, %eax
je 0x42ae9
movq %rdi, %r8
movzwl 0x10(%r13), %esi
movzbl 0x1a(%r13), %ecx
movzbl (%r14,%rsi), %edx
leal (%rcx,%rax), %edi
cmpl $0x9, %edi
jb 0x42acf
movzbl 0x1(%r14,%rsi), %esi
shll $0x8, %esi
orl %esi, %edx
movq %r8, %rdi
shrl %cl, %edx
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl %eax, %ecx
shll %cl, %esi
notl %esi
andl %edx, %esi
movb %sil, (%r8)
incq %rdi
decl %ebx
movl %ebx, %ebx
movq %rdi, %r15
movq %r12, %rsi
movq %rbx, %rdx
callq 0x29080
movq %r15, %rdi
addq %rbx, %rdi
jmp 0x42d47
movzwl 0x12(%r13), %ecx
testb $0x1, %cl
jne 0x42ba5
testb $0x8, %cl
jne 0x42bcc
movq %rdx, -0x48(%rbp)
testb $0x20, %cl
jne 0x42c6a
testb $0x40, %cl
jne 0x42d60
movq -0x48(%rbp), %rax
cmpl %ebx, %eax
jae 0x42b55
leaq (%r12,%rbx), %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %rdi, %r14
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %r14, %rdi
cmpl %ebx, %eax
movl %ebx, %r14d
cmovbl %eax, %r14d
movq %rdi, -0x30(%rbp)
movq %r12, %rsi
movq %rax, %r12
movq %r14, %rdx
callq 0x29080
cmpl %ebx, %r12d
movq -0x30(%rbp), %r12
jae 0x42b96
movq %r14, %rsi
addq %r12, %rsi
movl %ebx, %edx
subl %r14d, %edx
movq 0xb8(%r15), %rax
movq %r15, %rdi
movl $0x20, %ecx
callq *0x78(%rax)
addq %rbx, %r12
movq -0x40(%rbp), %r14
movq %r12, %rdi
jmp 0x42d47
cmpb $0x7, %sil
movq %rdi, -0x30(%rbp)
jne 0x42be6
leaq (%r12,%rbx), %r14
testq %rbx, %rbx
je 0x42bc7
cmpb $0x20, (%r12)
jne 0x42bc7
incq %r12
cmpq %r14, %r12
jb 0x42bb8
subq %r12, %r14
jmp 0x42c02
cmpb $0x1, 0x1a(%r13)
jne 0x42cd1
movzbl (%r12), %eax
movl $0x1, %ecx
jmp 0x42cdb
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rdx, %r14
movq %rbx, %rdx
callq *0x18(%rax)
movq %r14, %rdx
movq %rax, %r14
cmpl %r14d, %edx
jae 0x42c25
movq %rdx, %rax
movl %r14d, %edx
addq %r12, %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %rax, %rdx
movq -0x30(%rbp), %rcx
cmpl %r14d, %edx
cmovael %r14d, %edx
cmpl $0xff, %edx
jae 0x42c40
leaq 0x1(%rcx), %rbx
movl %edx, %eax
jmp 0x42c4c
movb %dl, 0x2(%rcx)
movb %dh, 0x1(%rcx)
leaq 0x3(%rcx), %rbx
movb $-0x1, %al
movb %al, (%rcx)
movl %edx, %r14d
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x29080
addq %r14, %rbx
movq %rbx, %rdi
jmp 0x42d43
movq %rdi, -0x30(%rbp)
movzbl 0x1a(%r13), %edi
movq %r12, %rsi
callq 0x4a0eb
movq %rax, %rdx
movzbl 0x1a(%r13), %eax
movq (%r12,%rax), %r14
cmpl %edx, %ebx
cmovbl %ebx, %edx
movq -0x48(%rbp), %rax
cmpl %eax, %edx
jbe 0x42cb1
movq %rdx, %rbx
movl %ebx, %edx
addq %r14, %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rbx, %rdx
movq -0x30(%rbp), %rcx
cmpl %edx, %eax
cmovbl %eax, %edx
cmpl $0xff, %edx
jae 0x42d8d
leaq 0x1(%rcx), %rbx
movl %edx, %eax
jmp 0x42d99
movzwl (%r12), %eax
movl $0x2, %ecx
addq %rcx, %r12
cmpl %ebx, %eax
cmovbl %eax, %ebx
cmpl %edx, %ebx
jbe 0x42d0a
movq %rdx, %rax
movl %ebx, %edx
addq %r12, %rdx
movl %eax, %ecx
movq 0xb8(%r15), %rax
movq %rdi, %r14
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rdx
cmpl %ebx, %edx
cmovbl %edx, %ebx
cmpl $0xff, %ebx
jae 0x42d1f
leaq 0x1(%rdi), %r14
movl %ebx, %eax
jmp 0x42d2b
movb %bl, 0x2(%rdi)
movb %bh, 0x1(%rdi)
leaq 0x3(%rdi), %r14
movb $-0x1, %al
movb %al, (%rdi)
movl %ebx, %ebx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x29080
addq %rbx, %r14
movq %r14, %rdi
movq -0x40(%rbp), %r14
movb 0x38(%r13), %sil
addq $0x20, %r13
movq %rdi, %rcx
testb %sil, %sil
jne 0x42a38
jmp 0x42dfe
cmpb $0x6, %sil
je 0x42db4
movzbl %sil, %ecx
cmpl $0x5, %ecx
jne 0x42dc0
movss (%r12), %xmm0
ucomiss %xmm0, %xmm0
jnp 0x42dc0
movq %rdi, %r15
xorl %esi, %esi
movq %rbx, %rdx
callq 0x292a0
leaq (%rbx,%r15), %rdi
jmp 0x42d47
movb %dl, 0x2(%rcx)
movb %dh, 0x1(%rcx)
leaq 0x3(%rcx), %rbx
movb $-0x1, %al
movb %al, (%rcx)
movl %edx, %r15d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x29080
addq %r15, %rbx
jmp 0x42c62
movsd (%r12), %xmm0
ucomisd %xmm0, %xmm0
jp 0x42de9
testl %ebx, %ebx
je 0x42d47
addq %rbx, %rax
addq -0x50(%rbp), %rax
xorl %edx, %edx
xorl %ecx, %ecx
movb (%rax,%rcx), %sil
movb %sil, (%rdi,%rdx)
decq %rcx
incq %rdx
cmpl %edx, %ebx
jne 0x42dcf
subq %rcx, %rdi
jmp 0x42d47
movq %rdi, %r15
xorl %esi, %esi
movq %rbx, %rdx
callq 0x292a0
jmp 0x42af9
movq %rcx, %rdi
movq -0x60(%rbp), %r14
movq %rdi, %rbx
movq (%r14), %rdi
movq %rbx, %rsi
movq -0x58(%rbp), %rdx
callq 0x6e94c
movq %rbx, %rsi
movq -0x68(%rbp), %rbx
movl (%rbx), %eax
movl %esi, %ecx
subl %eax, %ecx
movl %ecx, 0x10(%rbx)
movq (%r14), %rax
movl 0x740(%rax), %eax
movl %eax, 0x14(%rbx)
movl $0x0, 0x18(%rbx)
movq 0x10(%rbp), %rdx
testq %rdx, %rdx
je 0x42e5e
movl 0x618(%r14), %ecx
andl $0x1, %ecx
je 0x42e5e
addq %rax, %rsi
movq %r14, %rdi
callq 0x428f4
addl %eax, 0x14(%rbx)
orb $0x8, 0x1a(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rbp+var_58], r9
mov [rsi], rcx
mov dword ptr [rsi+18h], 0
mov [rbp+var_60], rdi
mov rax, [rdi]
mov rdi, [rax+570h]
mov eax, edx
imul rdx, rax, 118h
lea rax, [rdi+rdx]
mov [rbp+var_68], rsi
mov [rsi+8], rax
mov r13, [rdi+rdx+0C0h]
mov sil, [r13+18h]
test sil, sil
jz loc_42DFB
mov r14, r8
movzx eax, word ptr [rax+0A2h]
mov [rbp+var_32], ax
lea rax, [r8-1]
mov [rbp+var_50], rax
mov [rbp+var_40], r8
loc_42A38:
movzx ebx, word ptr [r13+14h]
mov r15, [r13+0]
mov al, [r13+19h]
test al, al
jz short loc_42A5F
mov edx, [r13+0Ch]
lea rdi, [rcx+1]
test [r14+rdx], al
jz short loc_42A64
mov byte ptr [rcx], 0
jmp loc_42D47
loc_42A5F:
mov rdi, rcx
jmp short loc_42A67
loc_42A64:
mov byte ptr [rcx], 1
loc_42A67:
cmp byte ptr [rbp+var_32], 0
setns al
test r15, r15
setnz cl
and cl, al
mov edx, ebx
cmp cl, 1
jnz short loc_42A93
mov ecx, [r15+9Ch]
mov edx, ebx
cmp ecx, 2
jb short loc_42A93
mov eax, ebx
xor edx, edx
div ecx
mov edx, eax
loc_42A93:
mov eax, [r13+8]
lea r12, [r14+rax]
cmp sil, 13h
jnz short loc_42B04
movzx eax, byte ptr [r13+1Bh]
test eax, eax
jz short loc_42AE9
mov r8, rdi
movzx esi, word ptr [r13+10h]
movzx ecx, byte ptr [r13+1Ah]
movzx edx, byte ptr [r14+rsi]
lea edi, [rcx+rax]
cmp edi, 9
jb short loc_42ACF
movzx esi, byte ptr [r14+rsi+1]
shl esi, 8
or edx, esi
loc_42ACF:
mov rdi, r8
shr edx, cl
mov esi, 0FFFFFFFFh
mov ecx, eax
shl esi, cl
not esi
and esi, edx
mov [r8], sil
inc rdi
dec ebx
loc_42AE9:
mov ebx, ebx
mov r15, rdi
mov rsi, r12
mov rdx, rbx
call _memcpy
loc_42AF9:
mov rdi, r15
add rdi, rbx
jmp loc_42D47
loc_42B04:
movzx ecx, word ptr [r13+12h]
test cl, 1
jnz loc_42BA5
test cl, 8
jnz loc_42BCC
mov [rbp+var_48], rdx
test cl, 20h
jnz loc_42C6A
test cl, 40h
jnz loc_42D60
mov rax, [rbp+var_48]
cmp eax, ebx
jnb short loc_42B55
lea rdx, [r12+rbx]
mov ecx, eax
mov rax, [r15+0B8h]
mov r14, rdi
mov rdi, r15
mov rsi, r12
call qword ptr [rax+10h]
mov rdi, r14
loc_42B55:
cmp eax, ebx
mov r14d, ebx
cmovb r14d, eax
mov [rbp+var_30], rdi
mov rsi, r12
mov r12, rax
mov rdx, r14
call _memcpy
cmp r12d, ebx
mov r12, [rbp+var_30]
jnb short loc_42B96
mov rsi, r14
add rsi, r12
mov edx, ebx
sub edx, r14d
mov rax, [r15+0B8h]
mov rdi, r15
mov ecx, 20h ; ' '
call qword ptr [rax+78h]
loc_42B96:
add r12, rbx
mov r14, [rbp+var_40]
mov rdi, r12
jmp loc_42D47
loc_42BA5:
cmp sil, 7
mov [rbp+var_30], rdi
jnz short loc_42BE6
lea r14, [r12+rbx]
test rbx, rbx
jz short loc_42BC7
loc_42BB8:
cmp byte ptr [r12], 20h ; ' '
jnz short loc_42BC7
inc r12
cmp r12, r14
jb short loc_42BB8
loc_42BC7:
sub r14, r12
jmp short loc_42C02
loc_42BCC:
cmp byte ptr [r13+1Ah], 1
jnz loc_42CD1
movzx eax, byte ptr [r12]
mov ecx, 1
jmp loc_42CDB
loc_42BE6:
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
mov r14, rdx
mov rdx, rbx
call qword ptr [rax+18h]
mov rdx, r14
mov r14, rax
loc_42C02:
cmp edx, r14d
jnb short loc_42C25
mov rax, rdx
mov edx, r14d
add rdx, r12
mov ecx, eax
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r12
call qword ptr [rax+10h]
mov rdx, rax
loc_42C25:
mov rcx, [rbp+var_30]
cmp edx, r14d
cmovnb edx, r14d
cmp edx, 0FFh
jnb short loc_42C40
lea rbx, [rcx+1]
mov eax, edx
jmp short loc_42C4C
loc_42C40:
mov [rcx+2], dl
mov [rcx+1], dh
lea rbx, [rcx+3]
mov al, 0FFh
loc_42C4C:
mov [rcx], al
mov r14d, edx
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _memcpy
add rbx, r14
loc_42C62:
mov rdi, rbx
jmp loc_42D43
loc_42C6A:
mov [rbp+var_30], rdi
movzx edi, byte ptr [r13+1Ah]
mov rsi, r12
call _ma_calc_blob_length
mov rdx, rax
movzx eax, byte ptr [r13+1Ah]
mov r14, [r12+rax]
cmp ebx, edx
cmovb edx, ebx
mov rax, [rbp+var_48]
cmp edx, eax
jbe short loc_42CB1
mov rbx, rdx
mov edx, ebx
add rdx, r14
mov ecx, eax
mov rax, [r15+0B8h]
mov rdi, r15
mov rsi, r14
call qword ptr [rax+10h]
mov rdx, rbx
loc_42CB1:
mov rcx, [rbp+var_30]
cmp eax, edx
cmovb edx, eax
cmp edx, 0FFh
jnb loc_42D8D
lea rbx, [rcx+1]
mov eax, edx
jmp loc_42D99
loc_42CD1:
movzx eax, word ptr [r12]
mov ecx, 2
loc_42CDB:
add r12, rcx
cmp eax, ebx
cmovb ebx, eax
cmp ebx, edx
jbe short loc_42D0A
mov rax, rdx
mov edx, ebx
add rdx, r12
mov ecx, eax
mov rax, [r15+0B8h]
mov r14, rdi
mov rdi, r15
mov rsi, r12
call qword ptr [rax+10h]
mov rdi, r14
mov rdx, rax
loc_42D0A:
cmp edx, ebx
cmovb ebx, edx
cmp ebx, 0FFh
jnb short loc_42D1F
lea r14, [rdi+1]
mov eax, ebx
jmp short loc_42D2B
loc_42D1F:
mov [rdi+2], bl
mov [rdi+1], bh
lea r14, [rdi+3]
mov al, 0FFh
loc_42D2B:
mov [rdi], al
mov ebx, ebx
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call _memcpy
add r14, rbx
mov rdi, r14
loc_42D43:
mov r14, [rbp+var_40]
loc_42D47:
mov sil, [r13+38h]
add r13, 20h ; ' '
mov rcx, rdi
test sil, sil
jnz loc_42A38
jmp loc_42DFE
loc_42D60:
cmp sil, 6
jz short loc_42DB4
movzx ecx, sil
cmp ecx, 5
jnz short loc_42DC0
movss xmm0, dword ptr [r12]
ucomiss xmm0, xmm0
jnp short loc_42DC0
mov r15, rdi
xor esi, esi
mov rdx, rbx
call _memset
lea rdi, [rbx+r15]
jmp short loc_42D47
loc_42D8D:
mov [rcx+2], dl
mov [rcx+1], dh
lea rbx, [rcx+3]
mov al, 0FFh
loc_42D99:
mov [rcx], al
mov r15d, edx
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call _memcpy
add rbx, r15
jmp loc_42C62
loc_42DB4:
movsd xmm0, qword ptr [r12]
ucomisd xmm0, xmm0
jp short loc_42DE9
loc_42DC0:
test ebx, ebx
jz short loc_42D47
add rax, rbx
add rax, [rbp+var_50]
xor edx, edx
xor ecx, ecx
loc_42DCF:
mov sil, [rax+rcx]
mov [rdi+rdx], sil
dec rcx
inc rdx
cmp ebx, edx
jnz short loc_42DCF
sub rdi, rcx
jmp loc_42D47
loc_42DE9:
mov r15, rdi
xor esi, esi
mov rdx, rbx
call _memset
jmp loc_42AF9
loc_42DFB:
mov rdi, rcx
loc_42DFE:
mov r14, [rbp+var_60]
mov rbx, rdi
mov rdi, [r14]
mov rsi, rbx
mov rdx, [rbp+var_58]
call _ma_dpointer
mov rsi, rbx
mov rbx, [rbp+var_68]
mov eax, [rbx]
mov ecx, esi
sub ecx, eax
mov [rbx+10h], ecx
mov rax, [r14]
mov eax, [rax+740h]
mov [rbx+14h], eax
mov dword ptr [rbx+18h], 0
mov rdx, [rbp+arg_0]
test rdx, rdx
jz short loc_42E5E
mov ecx, [r14+618h]
and ecx, 1
jz short loc_42E5E
add rsi, rax
mov rdi, r14
call transid_store_packed
add [rbx+14h], eax
or byte ptr [rbx+1Ah], 8
loc_42E5E:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_make_key(_DWORD *a1, long long a2, unsigned int a3, char *a4, long long a5, long long a6, long long a7)
{
long long v7; // rax
long long *v8; // r13
char v9; // si
long long v10; // r14
long long v11; // rbx
long long v12; // r15
unsigned __int8 v13; // al
char *v14; // rdi
unsigned int v15; // edx
unsigned int v16; // ecx
long long v17; // rax
_BYTE *v18; // r12
int v19; // eax
long long v20; // rsi
int v21; // ecx
unsigned int v22; // edx
__int16 v23; // cx
unsigned int v24; // eax
long long v25; // r14
_BYTE *v26; // rsi
unsigned int v27; // r12d
_BYTE *v28; // r14
unsigned int v29; // r14d
unsigned int v30; // eax
long long v31; // rcx
unsigned int v32; // r14d
unsigned int v33; // eax
_BYTE *v34; // rbx
char v35; // al
long long v36; // r14
char *v37; // rbx
unsigned int v38; // edx
long long v39; // r14
unsigned int v40; // eax
unsigned int v41; // ebx
_BYTE *v42; // rbx
char v43; // al
_BYTE *v44; // r12
_BYTE *v45; // r14
char v46; // al
long long v47; // r15
long long v48; // rax
long long v49; // rdx
long long v50; // rcx
long long v51; // rax
long long v56; // [rsp+20h] [rbp-50h]
unsigned int v57; // [rsp+28h] [rbp-48h]
__int16 v59; // [rsp+3Eh] [rbp-32h]
*(_QWORD *)a2 = a4;
*(_DWORD *)(a2 + 24) = 0;
v7 = *(_QWORD *)(*(_QWORD *)a1 + 1392LL) + 280LL * a3;
*(_QWORD *)(a2 + 8) = v7;
v8 = *(long long **)(v7 + 192);
v9 = *((_BYTE *)v8 + 24);
if ( v9 )
{
v10 = a5;
v59 = *(_WORD *)(v7 + 162);
v56 = a5 - 1;
while ( 1 )
{
v11 = *((unsigned __int16 *)v8 + 10);
v12 = *v8;
v13 = *((_BYTE *)v8 + 25);
if ( !v13 )
break;
v14 = a4 + 1;
if ( (v13 & *(_BYTE *)(v10 + *((unsigned int *)v8 + 3))) == 0 )
{
*a4 = 1;
goto LABEL_8;
}
*a4 = 0;
LABEL_65:
v9 = *((_BYTE *)v8 + 56);
v8 += 4;
a4 = v14;
if ( !v9 )
goto LABEL_75;
}
v14 = a4;
LABEL_8:
v15 = v11;
if ( (v59 & 0x80u) == 0 && v12 != 0 )
{
v16 = *(_DWORD *)(v12 + 156);
v15 = v11;
if ( v16 >= 2 )
v15 = (unsigned int)v11 / v16;
}
v17 = *((unsigned int *)v8 + 2);
v18 = (_BYTE *)(v10 + v17);
if ( v9 == 19 )
{
v19 = *((unsigned __int8 *)v8 + 27);
if ( *((_BYTE *)v8 + 27) )
{
v20 = *((unsigned __int16 *)v8 + 8);
v21 = *((unsigned __int8 *)v8 + 26);
v22 = *(unsigned __int8 *)(v10 + v20);
if ( (unsigned int)(v21 + v19) >= 9 )
v22 = *(unsigned __int16 *)(v10 + v20);
*v14++ = (v22 >> v21) & ~(-1 << v19);
LODWORD(v11) = v11 - 1;
}
memcpy(v14, v18, (unsigned int)v11);
v14 += (unsigned int)v11;
goto LABEL_65;
}
v23 = *((_WORD *)v8 + 9);
if ( (v23 & 1) != 0 )
{
if ( v9 == 7 )
{
v28 = &v18[v11];
if ( v11 )
{
do
{
if ( *v18 != 32 )
break;
++v18;
}
while ( v18 < v28 );
}
v29 = (_DWORD)v28 - (_DWORD)v18;
}
else
{
v32 = v15;
v33 = (*(long long ( **)(long long, _BYTE *, long long))(*(_QWORD *)(v12 + 184) + 24LL))(v12, v18, v11);
v15 = v32;
v29 = v33;
}
if ( v15 < v29 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v18,
&v18[v29],
v15);
if ( v15 >= v29 )
v15 = v29;
if ( v15 >= 0xFF )
{
v14[2] = v15;
v14[1] = BYTE1(v15);
v34 = v14 + 3;
v35 = -1;
}
else
{
v34 = v14 + 1;
v35 = v15;
}
*v14 = v35;
v36 = v15;
memcpy(v34, v18, v15);
v37 = &v34[v36];
}
else
{
if ( (v23 & 8) != 0 )
{
if ( *((_BYTE *)v8 + 26) == 1 )
{
v30 = (unsigned __int8)*v18;
v31 = 1LL;
}
else
{
v30 = *(unsigned __int16 *)v18;
v31 = 2LL;
}
v44 = &v18[v31];
if ( v30 < (unsigned int)v11 )
LODWORD(v11) = v30;
if ( (unsigned int)v11 > v15 )
v15 = (*(long long ( **)(long long, _BYTE *, _BYTE *, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v44,
&v44[(unsigned int)v11],
v15);
if ( v15 < (unsigned int)v11 )
LODWORD(v11) = v15;
if ( (unsigned int)v11 >= 0xFF )
{
v14[2] = v11;
v14[1] = BYTE1(v11);
v45 = v14 + 3;
v46 = -1;
}
else
{
v45 = v14 + 1;
v46 = v11;
}
*v14 = v46;
memcpy(v45, v44, (unsigned int)v11);
v14 = &v45[(unsigned int)v11];
goto LABEL_64;
}
v57 = v15;
if ( (v23 & 0x20) == 0 )
{
if ( (v23 & 0x40) != 0 )
{
if ( (_DWORD)v11 )
{
v48 = v56 + v11 + v17;
v49 = 0LL;
v50 = 0LL;
do
v14[v49++] = *(_BYTE *)(v48 + v50--);
while ( (_DWORD)v11 != (_DWORD)v49 );
v14 -= v50;
}
}
else
{
v24 = v15;
if ( v15 < (unsigned int)v11 )
v24 = (*(long long ( **)(long long, _BYTE *, _BYTE *, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v18,
&v18[v11],
v15);
v25 = (unsigned int)v11;
if ( v24 < (unsigned int)v11 )
v25 = v24;
v26 = v18;
v27 = v24;
memcpy(v14, v26, v25);
if ( v27 < (unsigned int)v11 )
(*(void ( **)(long long, char *, _QWORD, long long))(*(_QWORD *)(v12 + 184) + 120LL))(
v12,
&v14[v25],
(unsigned int)(v11 - v25),
32LL);
v10 = a5;
v14 += v11;
}
goto LABEL_65;
}
v38 = ma_calc_blob_length(*((unsigned __int8 *)v8 + 26), v10 + v17);
v39 = *(_QWORD *)&v18[*((unsigned __int8 *)v8 + 26)];
if ( (unsigned int)v11 < v38 )
v38 = v11;
v40 = v57;
if ( v38 > v57 )
{
v41 = v38;
v40 = (*(long long ( **)(long long, long long, long long, _QWORD))(*(_QWORD *)(v12 + 184) + 16LL))(
v12,
v39,
v39 + v38,
v57);
v38 = v41;
}
if ( v40 < v38 )
v38 = v40;
if ( v38 >= 0xFF )
{
v14[2] = v38;
v14[1] = BYTE1(v38);
v42 = v14 + 3;
v43 = -1;
}
else
{
v42 = v14 + 1;
v43 = v38;
}
*v14 = v43;
v47 = v38;
memcpy(v42, v39, v38);
v37 = &v42[v47];
}
v14 = v37;
LABEL_64:
v10 = a5;
goto LABEL_65;
}
v14 = a4;
LABEL_75:
ma_dpointer(*(_QWORD *)a1, v14, a6, a4);
*(_DWORD *)(a2 + 16) = (_DWORD)v14 - *(_DWORD *)a2;
v51 = *(unsigned int *)(*(_QWORD *)a1 + 1856LL);
*(_QWORD *)(a2 + 20) = (unsigned int)v51;
if ( a7 && (a1[390] & 1) != 0 )
{
*(_DWORD *)(a2 + 20) += transid_store_packed((long long)a1, &v14[v51], a7);
*(_BYTE *)(a2 + 26) |= 8u;
}
return a2;
}
| _ma_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x58],R9
MOV qword ptr [RSI],RCX
MOV dword ptr [RSI + 0x18],0x0
MOV qword ptr [RBP + -0x60],RDI
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RAX + 0x570]
MOV EAX,EDX
IMUL RDX,RAX,0x118
LEA RAX,[RDI + RDX*0x1]
MOV qword ptr [RBP + -0x68],RSI
MOV qword ptr [RSI + 0x8],RAX
MOV R13,qword ptr [RDI + RDX*0x1 + 0xc0]
MOV SIL,byte ptr [R13 + 0x18]
TEST SIL,SIL
JZ 0x00142dfb
MOV R14,R8
MOVZX EAX,word ptr [RAX + 0xa2]
MOV word ptr [RBP + -0x32],AX
LEA RAX,[R8 + -0x1]
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],R8
LAB_00142a38:
MOVZX EBX,word ptr [R13 + 0x14]
MOV R15,qword ptr [R13]
MOV AL,byte ptr [R13 + 0x19]
TEST AL,AL
JZ 0x00142a5f
MOV EDX,dword ptr [R13 + 0xc]
LEA RDI,[RCX + 0x1]
TEST byte ptr [R14 + RDX*0x1],AL
JZ 0x00142a64
MOV byte ptr [RCX],0x0
JMP 0x00142d47
LAB_00142a5f:
MOV RDI,RCX
JMP 0x00142a67
LAB_00142a64:
MOV byte ptr [RCX],0x1
LAB_00142a67:
CMP byte ptr [RBP + -0x32],0x0
SETNS AL
TEST R15,R15
SETNZ CL
AND CL,AL
MOV EDX,EBX
CMP CL,0x1
JNZ 0x00142a93
MOV ECX,dword ptr [R15 + 0x9c]
MOV EDX,EBX
CMP ECX,0x2
JC 0x00142a93
MOV EAX,EBX
XOR EDX,EDX
DIV ECX
MOV EDX,EAX
LAB_00142a93:
MOV EAX,dword ptr [R13 + 0x8]
LEA R12,[R14 + RAX*0x1]
CMP SIL,0x13
JNZ 0x00142b04
MOVZX EAX,byte ptr [R13 + 0x1b]
TEST EAX,EAX
JZ 0x00142ae9
MOV R8,RDI
MOVZX ESI,word ptr [R13 + 0x10]
MOVZX ECX,byte ptr [R13 + 0x1a]
MOVZX EDX,byte ptr [R14 + RSI*0x1]
LEA EDI,[RCX + RAX*0x1]
CMP EDI,0x9
JC 0x00142acf
MOVZX ESI,byte ptr [R14 + RSI*0x1 + 0x1]
SHL ESI,0x8
OR EDX,ESI
LAB_00142acf:
MOV RDI,R8
SHR EDX,CL
MOV ESI,0xffffffff
MOV ECX,EAX
SHL ESI,CL
NOT ESI
AND ESI,EDX
MOV byte ptr [R8],SIL
INC RDI
DEC EBX
LAB_00142ae9:
MOV EBX,EBX
MOV R15,RDI
MOV RSI,R12
MOV RDX,RBX
CALL 0x00129080
LAB_00142af9:
MOV RDI,R15
ADD RDI,RBX
JMP 0x00142d47
LAB_00142b04:
MOVZX ECX,word ptr [R13 + 0x12]
TEST CL,0x1
JNZ 0x00142ba5
TEST CL,0x8
JNZ 0x00142bcc
MOV qword ptr [RBP + -0x48],RDX
TEST CL,0x20
JNZ 0x00142c6a
TEST CL,0x40
JNZ 0x00142d60
MOV RAX,qword ptr [RBP + -0x48]
CMP EAX,EBX
JNC 0x00142b55
LEA RDX,[R12 + RBX*0x1]
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV R14,RDI
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,R14
LAB_00142b55:
CMP EAX,EBX
MOV R14D,EBX
CMOVC R14D,EAX
MOV qword ptr [RBP + -0x30],RDI
MOV RSI,R12
MOV R12,RAX
MOV RDX,R14
CALL 0x00129080
CMP R12D,EBX
MOV R12,qword ptr [RBP + -0x30]
JNC 0x00142b96
MOV RSI,R14
ADD RSI,R12
MOV EDX,EBX
SUB EDX,R14D
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV ECX,0x20
CALL qword ptr [RAX + 0x78]
LAB_00142b96:
ADD R12,RBX
MOV R14,qword ptr [RBP + -0x40]
MOV RDI,R12
JMP 0x00142d47
LAB_00142ba5:
CMP SIL,0x7
MOV qword ptr [RBP + -0x30],RDI
JNZ 0x00142be6
LEA R14,[R12 + RBX*0x1]
TEST RBX,RBX
JZ 0x00142bc7
LAB_00142bb8:
CMP byte ptr [R12],0x20
JNZ 0x00142bc7
INC R12
CMP R12,R14
JC 0x00142bb8
LAB_00142bc7:
SUB R14,R12
JMP 0x00142c02
LAB_00142bcc:
CMP byte ptr [R13 + 0x1a],0x1
JNZ 0x00142cd1
MOVZX EAX,byte ptr [R12]
MOV ECX,0x1
JMP 0x00142cdb
LAB_00142be6:
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
MOV R14,RDX
MOV RDX,RBX
CALL qword ptr [RAX + 0x18]
MOV RDX,R14
MOV R14,RAX
LAB_00142c02:
CMP EDX,R14D
JNC 0x00142c25
MOV RAX,RDX
MOV EDX,R14D
ADD RDX,R12
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x10]
MOV RDX,RAX
LAB_00142c25:
MOV RCX,qword ptr [RBP + -0x30]
CMP EDX,R14D
CMOVNC EDX,R14D
CMP EDX,0xff
JNC 0x00142c40
LEA RBX,[RCX + 0x1]
MOV EAX,EDX
JMP 0x00142c4c
LAB_00142c40:
MOV byte ptr [RCX + 0x2],DL
MOV byte ptr [RCX + 0x1],DH
LEA RBX,[RCX + 0x3]
MOV AL,0xff
LAB_00142c4c:
MOV byte ptr [RCX],AL
MOV R14D,EDX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x00129080
ADD RBX,R14
LAB_00142c62:
MOV RDI,RBX
JMP 0x00142d43
LAB_00142c6a:
MOV qword ptr [RBP + -0x30],RDI
MOVZX EDI,byte ptr [R13 + 0x1a]
MOV RSI,R12
CALL 0x0014a0eb
MOV RDX,RAX
MOVZX EAX,byte ptr [R13 + 0x1a]
MOV R14,qword ptr [R12 + RAX*0x1]
CMP EBX,EDX
CMOVC EDX,EBX
MOV RAX,qword ptr [RBP + -0x48]
CMP EDX,EAX
JBE 0x00142cb1
MOV RBX,RDX
MOV EDX,EBX
ADD RDX,R14
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RSI,R14
CALL qword ptr [RAX + 0x10]
MOV RDX,RBX
LAB_00142cb1:
MOV RCX,qword ptr [RBP + -0x30]
CMP EAX,EDX
CMOVC EDX,EAX
CMP EDX,0xff
JNC 0x00142d8d
LEA RBX,[RCX + 0x1]
MOV EAX,EDX
JMP 0x00142d99
LAB_00142cd1:
MOVZX EAX,word ptr [R12]
MOV ECX,0x2
LAB_00142cdb:
ADD R12,RCX
CMP EAX,EBX
CMOVC EBX,EAX
CMP EBX,EDX
JBE 0x00142d0a
MOV RAX,RDX
MOV EDX,EBX
ADD RDX,R12
MOV ECX,EAX
MOV RAX,qword ptr [R15 + 0xb8]
MOV R14,RDI
MOV RDI,R15
MOV RSI,R12
CALL qword ptr [RAX + 0x10]
MOV RDI,R14
MOV RDX,RAX
LAB_00142d0a:
CMP EDX,EBX
CMOVC EBX,EDX
CMP EBX,0xff
JNC 0x00142d1f
LEA R14,[RDI + 0x1]
MOV EAX,EBX
JMP 0x00142d2b
LAB_00142d1f:
MOV byte ptr [RDI + 0x2],BL
MOV byte ptr [RDI + 0x1],BH
LEA R14,[RDI + 0x3]
MOV AL,0xff
LAB_00142d2b:
MOV byte ptr [RDI],AL
MOV EBX,EBX
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x00129080
ADD R14,RBX
MOV RDI,R14
LAB_00142d43:
MOV R14,qword ptr [RBP + -0x40]
LAB_00142d47:
MOV SIL,byte ptr [R13 + 0x38]
ADD R13,0x20
MOV RCX,RDI
TEST SIL,SIL
JNZ 0x00142a38
JMP 0x00142dfe
LAB_00142d60:
CMP SIL,0x6
JZ 0x00142db4
MOVZX ECX,SIL
CMP ECX,0x5
JNZ 0x00142dc0
MOVSS XMM0,dword ptr [R12]
UCOMISS XMM0,XMM0
JNP 0x00142dc0
MOV R15,RDI
XOR ESI,ESI
MOV RDX,RBX
CALL 0x001292a0
LEA RDI,[RBX + R15*0x1]
JMP 0x00142d47
LAB_00142d8d:
MOV byte ptr [RCX + 0x2],DL
MOV byte ptr [RCX + 0x1],DH
LEA RBX,[RCX + 0x3]
MOV AL,0xff
LAB_00142d99:
MOV byte ptr [RCX],AL
MOV R15D,EDX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x00129080
ADD RBX,R15
JMP 0x00142c62
LAB_00142db4:
MOVSD XMM0,qword ptr [R12]
UCOMISD XMM0,XMM0
JP 0x00142de9
LAB_00142dc0:
TEST EBX,EBX
JZ 0x00142d47
ADD RAX,RBX
ADD RAX,qword ptr [RBP + -0x50]
XOR EDX,EDX
XOR ECX,ECX
LAB_00142dcf:
MOV SIL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RDI + RDX*0x1],SIL
DEC RCX
INC RDX
CMP EBX,EDX
JNZ 0x00142dcf
SUB RDI,RCX
JMP 0x00142d47
LAB_00142de9:
MOV R15,RDI
XOR ESI,ESI
MOV RDX,RBX
CALL 0x001292a0
JMP 0x00142af9
LAB_00142dfb:
MOV RDI,RCX
LAB_00142dfe:
MOV R14,qword ptr [RBP + -0x60]
MOV RBX,RDI
MOV RDI,qword ptr [R14]
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x58]
CALL 0x0016e94c
MOV RSI,RBX
MOV RBX,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RBX]
MOV ECX,ESI
SUB ECX,EAX
MOV dword ptr [RBX + 0x10],ECX
MOV RAX,qword ptr [R14]
MOV EAX,dword ptr [RAX + 0x740]
MOV dword ptr [RBX + 0x14],EAX
MOV dword ptr [RBX + 0x18],0x0
MOV RDX,qword ptr [RBP + 0x10]
TEST RDX,RDX
JZ 0x00142e5e
MOV ECX,dword ptr [R14 + 0x618]
AND ECX,0x1
JZ 0x00142e5e
ADD RSI,RAX
MOV RDI,R14
CALL 0x001428f4
ADD dword ptr [RBX + 0x14],EAX
OR byte ptr [RBX + 0x1a],0x8
LAB_00142e5e:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int * _ma_make_key(long *param_1,int *param_2,ulong param_3,byte *param_4,long param_5,
int8 param_6,long param_7)
{
double *pdVar1;
byte bVar2;
int2 uVar3;
ushort uVar4;
byte bVar5;
uint uVar6;
uint uVar7;
int iVar8;
ulong uVar9;
long lVar10;
uint uVar11;
long lVar12;
long lVar13;
uint uVar14;
ulong __n;
byte *pbVar15;
char cVar16;
double *__src;
void *pvVar17;
long *plVar18;
size_t __n_00;
char local_3a;
*(byte **)param_2 = param_4;
param_2[6] = 0;
lVar13 = *(long *)(*param_1 + 0x570);
lVar12 = (param_3 & 0xffffffff) * 0x118;
lVar10 = lVar13 + lVar12;
*(long *)(param_2 + 2) = lVar10;
plVar18 = *(long **)(lVar13 + 0xc0 + lVar12);
cVar16 = (char)plVar18[3];
if (cVar16 != '\0') {
uVar3 = *(int2 *)(lVar10 + 0xa2);
do {
uVar4 = *(ushort *)((long)plVar18 + 0x14);
__n = (ulong)uVar4;
lVar10 = *plVar18;
if (*(byte *)((long)plVar18 + 0x19) == 0) {
LAB_00142a67:
local_3a = (char)uVar3;
uVar11 = (uint)uVar4;
uVar9 = __n;
if (lVar10 != 0 && -1 < local_3a) {
uVar9 = (ulong)uVar4;
if (1 < *(uint *)(lVar10 + 0x9c)) {
uVar9 = (ulong)uVar11 / (ulong)*(uint *)(lVar10 + 0x9c);
}
}
uVar7 = (uint)uVar9;
uVar6 = *(uint *)(plVar18 + 1);
__src = (double *)(param_5 + (ulong)uVar6);
uVar14 = (uint)uVar4;
if (cVar16 == '\x13') {
bVar5 = *(byte *)((long)plVar18 + 0x1b);
if (bVar5 != 0) {
bVar2 = *(byte *)(param_5 + (ulong)*(ushort *)(plVar18 + 2));
uVar11 = (uint)bVar2;
if (8 < (uint)*(byte *)((long)plVar18 + 0x1a) + (uint)bVar5) {
uVar11 = (uint)CONCAT11(*(int1 *)(param_5 + 1 + (ulong)*(ushort *)(plVar18 + 2))
,bVar2);
}
*param_4 = ~(byte)(-1 << (bVar5 & 0x1f)) &
(byte)(uVar11 >> (*(byte *)((long)plVar18 + 0x1a) & 0x1f));
param_4 = param_4 + 1;
__n = (ulong)(uVar14 - 1);
}
memcpy(param_4,__src,__n);
LAB_00142af9:
param_4 = param_4 + __n;
}
else {
uVar4 = *(ushort *)((long)plVar18 + 0x12);
if ((uVar4 & 1) == 0) {
if ((uVar4 & 8) == 0) {
if ((uVar4 & 0x20) == 0) {
if ((uVar4 & 0x40) == 0) {
if (uVar7 < uVar14) {
uVar9 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,__src,(long)__src + __n,uVar9);
}
__n_00 = (size_t)uVar11;
if ((uint)uVar9 < uVar14) {
__n_00 = uVar9 & 0xffffffff;
}
memcpy(param_4,__src,__n_00);
if ((uint)uVar9 < uVar11) {
(**(code **)(*(long *)(lVar10 + 0xb8) + 0x78))
(lVar10,param_4 + __n_00,uVar14 - (int)__n_00,0x20);
}
param_4 = param_4 + __n;
}
else {
if (cVar16 == '\x06') {
if (NAN(*__src)) {
memset(param_4,0,__n);
goto LAB_00142af9;
}
}
else if ((cVar16 == '\x05') && (NAN(*(float *)__src))) {
memset(param_4,0,__n);
param_4 = param_4 + __n;
goto LAB_00142d47;
}
if (uVar14 != 0) {
lVar13 = 0;
lVar10 = 0;
do {
param_4[lVar13] = *(byte *)(uVar6 + __n + param_5 + -1 + lVar10);
lVar10 = lVar10 + -1;
lVar13 = lVar13 + 1;
} while (uVar14 != (uint)lVar13);
param_4 = param_4 + -lVar10;
}
}
}
else {
uVar6 = _ma_calc_blob_length(*(int1 *)((long)plVar18 + 0x1a),__src);
pvVar17 = *(void **)((long)__src + (ulong)*(byte *)((long)plVar18 + 0x1a));
if (uVar11 < uVar6) {
uVar6 = uVar14;
}
if (uVar7 < uVar6) {
uVar7 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,pvVar17,(ulong)uVar6 + (long)pvVar17,uVar9);
}
if (uVar7 < uVar6) {
uVar6 = uVar7;
}
bVar5 = (byte)uVar6;
if (uVar6 < 0xff) {
pbVar15 = param_4 + 1;
}
else {
param_4[2] = bVar5;
param_4[1] = (byte)(uVar6 >> 8);
pbVar15 = param_4 + 3;
bVar5 = 0xff;
}
*param_4 = bVar5;
memcpy(pbVar15,pvVar17,(ulong)uVar6);
param_4 = pbVar15 + uVar6;
}
}
else {
if (*(char *)((long)plVar18 + 0x1a) == '\x01') {
uVar6 = (uint)*(byte *)__src;
lVar13 = 1;
}
else {
uVar6 = (uint)*(ushort *)__src;
lVar13 = 2;
}
pvVar17 = (void *)((long)__src + lVar13);
if (uVar6 < uVar11) {
uVar11 = uVar6;
}
if (uVar7 < uVar11) {
uVar7 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,pvVar17,(ulong)uVar11 + (long)pvVar17,uVar9);
}
if (uVar7 < uVar11) {
uVar11 = uVar7;
}
bVar5 = (byte)uVar11;
if (uVar11 < 0xff) {
pbVar15 = param_4 + 1;
}
else {
param_4[2] = bVar5;
param_4[1] = (byte)(uVar11 >> 8);
pbVar15 = param_4 + 3;
bVar5 = 0xff;
}
*param_4 = bVar5;
memcpy(pbVar15,pvVar17,(ulong)uVar11);
param_4 = pbVar15 + uVar11;
}
}
else {
if (cVar16 == '\a') {
pdVar1 = (double *)((long)__src + __n);
if (__n != 0) {
do {
if (*(char *)__src != ' ') break;
__src = (double *)((long)__src + 1);
} while (__src < pdVar1);
}
uVar11 = (int)pdVar1 - (int)__src;
}
else {
uVar11 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x18))(lVar10,__src,__n);
}
if (uVar7 < uVar11) {
uVar7 = (**(code **)(*(long *)(lVar10 + 0xb8) + 0x10))
(lVar10,__src,(ulong)uVar11 + (long)__src,uVar9);
}
if (uVar11 <= uVar7) {
uVar7 = uVar11;
}
bVar5 = (byte)uVar7;
if (uVar7 < 0xff) {
pbVar15 = param_4 + 1;
}
else {
param_4[2] = bVar5;
param_4[1] = (byte)(uVar7 >> 8);
pbVar15 = param_4 + 3;
bVar5 = 0xff;
}
*param_4 = bVar5;
memcpy(pbVar15,__src,(ulong)uVar7);
param_4 = pbVar15 + uVar7;
}
}
}
else {
if ((*(byte *)(param_5 + (ulong)*(uint *)((long)plVar18 + 0xc)) &
*(byte *)((long)plVar18 + 0x19)) == 0) {
*param_4 = 1;
param_4 = param_4 + 1;
goto LAB_00142a67;
}
*param_4 = 0;
param_4 = param_4 + 1;
}
LAB_00142d47:
cVar16 = (char)plVar18[7];
plVar18 = plVar18 + 4;
} while (cVar16 != '\0');
}
_ma_dpointer(*param_1,param_4,param_6);
param_2[4] = (int)param_4 - *param_2;
uVar11 = *(uint *)(*param_1 + 0x740);
param_2[5] = uVar11;
param_2[6] = 0;
if ((param_7 != 0) && ((*(uint *)(param_1 + 0xc3) & 1) != 0)) {
iVar8 = transid_store_packed(param_1,param_4 + uVar11);
param_2[5] = param_2[5] + iVar8;
*(byte *)((long)param_2 + 0x1a) = *(byte *)((long)param_2 + 0x1a) | 8;
}
return param_2;
}
|
|
1,910 | stbi__check_png_header(stbi__context*) | llama.cpp/examples/llava/../../common/stb_image.h | static int stbi__check_png_header(stbi__context *s)
{
static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 };
int i;
for (i=0; i < 8; ++i)
if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG");
return 1;
} | O3 | c | stbi__check_png_header(stbi__context*):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
xorl %r14d, %r14d
leaq 0x1f8a7(%rip), %r15 # 0x46000
cmpq 0xc8(%rbx), %rax
jb 0x26777
cmpl $0x0, 0x30(%rbx)
je 0x26798
movq %rbx, %rdi
callq 0x26801
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0xc0(%rbx)
movb (%rax), %cl
movq %rdx, %rax
cmpb (%r14,%r15), %cl
jne 0x2679c
incq %r14
cmpq $0x8, %r14
jne 0x26759
jmp 0x267ba
xorl %ecx, %ecx
jmp 0x26787
movq %fs:0x0, %rax
leaq 0x1fd02(%rip), %rcx # 0x464b1
movq %rcx, -0x20(%rax)
xorl %eax, %eax
jmp 0x267bf
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
| _ZL22stbi__check_png_headerP13stbi__context:
push r15
push r14
push rbx
mov rbx, rdi
mov rax, [rdi+0C0h]
xor r14d, r14d
lea r15, _ZZL22stbi__check_png_headerP13stbi__contextE7png_sig; stbi__check_png_header(stbi__context *)::png_sig
loc_26759:
cmp rax, [rbx+0C8h]
jb short loc_26777
cmp dword ptr [rbx+30h], 0
jz short loc_26798
mov rdi, rbx
call _ZL19stbi__refill_bufferP13stbi__context; stbi__refill_buffer(stbi__context *)
mov rax, [rbx+0C0h]
loc_26777:
lea rdx, [rax+1]
mov [rbx+0C0h], rdx
mov cl, [rax]
mov rax, rdx
loc_26787:
cmp cl, [r14+r15]
jnz short loc_2679C
inc r14
cmp r14, 8
jnz short loc_26759
jmp short loc_267BA
loc_26798:
xor ecx, ecx
jmp short loc_26787
loc_2679C:
mov rax, fs:0
lea rcx, aBadPngSig; "bad png sig"
mov [rax-20h], rcx
xor eax, eax
jmp short loc_267BF
loc_267BA:
mov eax, 1
loc_267BF:
pop rbx
pop r14
pop r15
retn
| long long stbi__check_png_header(long long a1)
{
char *v1; // rax
long long v2; // r14
char v3; // cl
v1 = *(char **)(a1 + 192);
v2 = 0LL;
while ( 1 )
{
if ( (unsigned long long)v1 < *(_QWORD *)(a1 + 200) )
goto LABEL_5;
if ( *(_DWORD *)(a1 + 48) )
{
stbi__refill_buffer(a1);
v1 = *(char **)(a1 + 192);
LABEL_5:
*(_QWORD *)(a1 + 192) = v1 + 1;
v3 = *v1++;
goto LABEL_6;
}
v3 = 0;
LABEL_6:
if ( v3 != stbi__check_png_header(stbi__context *)::png_sig[v2] )
break;
if ( ++v2 == 8 )
return 1LL;
}
*(_QWORD *)(__readfsqword(0) - 32) = "bad png sig";
return 0LL;
}
| stbi__check_png_header:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0xc0]
XOR R14D,R14D
LEA R15,[0x146000]
LAB_00126759:
CMP RAX,qword ptr [RBX + 0xc8]
JC 0x00126777
CMP dword ptr [RBX + 0x30],0x0
JZ 0x00126798
MOV RDI,RBX
CALL 0x00126801
MOV RAX,qword ptr [RBX + 0xc0]
LAB_00126777:
LEA RDX,[RAX + 0x1]
MOV qword ptr [RBX + 0xc0],RDX
MOV CL,byte ptr [RAX]
MOV RAX,RDX
LAB_00126787:
CMP CL,byte ptr [R14 + R15*0x1]
JNZ 0x0012679c
INC R14
CMP R14,0x8
JNZ 0x00126759
JMP 0x001267ba
LAB_00126798:
XOR ECX,ECX
JMP 0x00126787
LAB_0012679c:
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x1464b1]
MOV qword ptr [RAX + -0x20],RCX
XOR EAX,EAX
JMP 0x001267bf
LAB_001267ba:
MOV EAX,0x1
LAB_001267bf:
POP RBX
POP R14
POP R15
RET
|
/* stbi__check_png_header(stbi__context*) */
int8 stbi__check_png_header(stbi__context *param_1)
{
char *pcVar1;
char cVar2;
long lVar3;
long *in_FS_OFFSET;
pcVar1 = *(char **)(param_1 + 0xc0);
lVar3 = 0;
do {
if (pcVar1 < *(char **)(param_1 + 200)) {
LAB_00126777:
*(char **)(param_1 + 0xc0) = pcVar1 + 1;
cVar2 = *pcVar1;
pcVar1 = pcVar1 + 1;
}
else {
if (*(int *)(param_1 + 0x30) != 0) {
stbi__refill_buffer(param_1);
pcVar1 = *(char **)(param_1 + 0xc0);
goto LAB_00126777;
}
cVar2 = '\0';
}
if (cVar2 != (&stbi__check_png_header(stbi__context*)::png_sig)[lVar3]) {
*(char **)(*in_FS_OFFSET + -0x20) = "bad png sig";
return 0;
}
lVar3 = lVar3 + 1;
if (lVar3 == 8) {
return 1;
}
} while( true );
}
|
|
1,911 | escape_quotes_for_mysql | eloqsql/mysys/charset.c | size_t escape_quotes_for_mysql(CHARSET_INFO *charset_info,
char *to, size_t to_length,
const char *from, size_t length,
my_bool *overflow)
{
const char *to_start= to;
const char *end, *to_end=to_start + (to_length ? to_length-1 : 2*length);
#ifdef USE_MB
my_bool use_mb_flag= my_ci_use_mb(charset_info);
#endif
*overflow= FALSE;
for (end= from + length; from < end; from++)
{
#ifdef USE_MB
int tmp_length;
if (use_mb_flag && (tmp_length= my_ismbchar(charset_info, from, end)))
{
if (to + tmp_length > to_end)
{
*overflow= TRUE;
break;
}
while (tmp_length--)
*to++= *from++;
from--;
continue;
}
/*
We don't have the same issue here with a non-multi-byte character being
turned into a multi-byte character by the addition of an escaping
character, because we are only escaping the ' character with itself.
*/
#endif
if (*from == '\'')
{
if (to + 2 > to_end)
{
*overflow= TRUE;
break;
}
*to++= '\'';
*to++= '\'';
}
else
{
if (to + 1 > to_end)
{
*overflow= TRUE;
break;
}
*to++= *from;
}
}
*to= 0;
return (size_t) (to - to_start);
} | O0 | c | escape_quotes_for_mysql:
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 %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x28e35
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x28e40
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28fb0
movb %al, -0x49(%rbp)
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x28f89
movsbl -0x49(%rbp), %eax
cmpl $0x0, %eax
je 0x28eff
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x28fe0
movl %eax, -0x50(%rbp)
cmpl $0x0, %eax
je 0x28eff
movq -0x10(%rbp), %rax
movslq -0x50(%rbp), %rcx
addq %rcx, %rax
cmpq -0x48(%rbp), %rax
jbe 0x28ebb
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0x28f89
jmp 0x28ebd
movl -0x50(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x50(%rbp)
cmpl $0x0, %eax
je 0x28ef1
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x28ebd
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x28f78
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x28f48
movq -0x10(%rbp), %rax
addq $0x2, %rax
cmpq -0x48(%rbp), %rax
jbe 0x28f22
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0x28f89
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x27, (%rax)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x27, (%rax)
jmp 0x28f76
movq -0x10(%rbp), %rax
addq $0x1, %rax
cmpq -0x48(%rbp), %rax
jbe 0x28f5f
movq -0x30(%rbp), %rax
movb $0x1, (%rax)
jmp 0x28f89
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x28f78
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x28e6e
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| escape_quotes_for_mysql:
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], r9
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
cmp [rbp+var_18], 0
jz short loc_28E35
mov rax, [rbp+var_18]
sub rax, 1
mov [rbp+var_60], rax
jmp short loc_28E40
loc_28E35:
mov rax, [rbp+var_28]
shl rax, 1
mov [rbp+var_60], rax
loc_28E40:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_60]
add rax, rcx
mov [rbp+var_48], rax
mov rdi, [rbp+var_8]
call my_ci_use_mb
mov [rbp+var_49], al
mov rax, [rbp+var_30]
mov byte ptr [rax], 0
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_40], rax
loc_28E6E:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_40]
jnb loc_28F89
movsx eax, [rbp+var_49]
cmp eax, 0
jz short loc_28EFF
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_40]
call my_ismbchar
mov [rbp+var_50], eax
cmp eax, 0
jz short loc_28EFF
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_50]
add rax, rcx
cmp rax, [rbp+var_48]
jbe short loc_28EBB
mov rax, [rbp+var_30]
mov byte ptr [rax], 1
jmp loc_28F89
loc_28EBB:
jmp short $+2
loc_28EBD:
mov eax, [rbp+var_50]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_50], ecx
cmp eax, 0
jz short loc_28EF1
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
mov cl, [rax]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
jmp short loc_28EBD
loc_28EF1:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_20], rax
jmp short loc_28F78
loc_28EFF:
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 27h ; '''
jnz short loc_28F48
mov rax, [rbp+var_10]
add rax, 2
cmp rax, [rbp+var_48]
jbe short loc_28F22
mov rax, [rbp+var_30]
mov byte ptr [rax], 1
jmp short loc_28F89
loc_28F22:
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 27h ; '''
mov rax, [rbp+var_10]
mov rcx, rax
add rcx, 1
mov [rbp+var_10], rcx
mov byte ptr [rax], 27h ; '''
jmp short loc_28F76
loc_28F48:
mov rax, [rbp+var_10]
add rax, 1
cmp rax, [rbp+var_48]
jbe short loc_28F5F
mov rax, [rbp+var_30]
mov byte ptr [rax], 1
jmp short loc_28F89
loc_28F5F:
mov rax, [rbp+var_20]
mov cl, [rax]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
loc_28F76:
jmp short $+2
loc_28F78:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_28E6E
loc_28F89:
mov rax, [rbp+var_10]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * escape_quotes_for_mysql(long long a1, char *a2, long long a3, char *a4, long long a5, _BYTE *a6)
{
char *v7; // rax
char v8; // cl
char *v9; // rax
_BYTE *v10; // rax
char *v11; // rax
long long v13; // [rsp+0h] [rbp-60h]
int v14; // [rsp+10h] [rbp-50h]
char v15; // [rsp+17h] [rbp-49h]
unsigned long long v16; // [rsp+18h] [rbp-48h]
char *v17; // [rsp+20h] [rbp-40h]
char *v21; // [rsp+50h] [rbp-10h]
v21 = a2;
if ( a3 )
v13 = a3 - 1;
else
v13 = 2 * a5;
v16 = (unsigned long long)&a2[v13];
v15 = my_ci_use_mb(a1);
*a6 = 0;
v17 = &a4[a5];
while ( a4 < v17 )
{
if ( v15 && (v14 = my_ismbchar(a1, a4, v17)) != 0 )
{
if ( (unsigned long long)&v21[v14] > v16 )
{
*a6 = 1;
break;
}
while ( v14-- )
{
v7 = a4++;
v8 = *v7;
v9 = v21++;
*v9 = v8;
}
--a4;
}
else if ( *a4 == 39 )
{
if ( (unsigned long long)(v21 + 2) > v16 )
{
*a6 = 1;
break;
}
*v21 = 39;
v10 = v21 + 1;
v21 += 2;
*v10 = 39;
}
else
{
if ( (unsigned long long)(v21 + 1) > v16 )
{
*a6 = 1;
break;
}
v11 = v21++;
*v11 = *a4;
}
++a4;
}
*v21 = 0;
return (_BYTE *)(v21 - a2);
}
| escape_quotes_for_mysql:
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],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00128e35
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00128e40
LAB_00128e35:
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
LAB_00128e40:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00128fb0
MOV byte ptr [RBP + -0x49],AL
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
LAB_00128e6e:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00128f89
MOVSX EAX,byte ptr [RBP + -0x49]
CMP EAX,0x0
JZ 0x00128eff
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x00128fe0
MOV dword ptr [RBP + -0x50],EAX
CMP EAX,0x0
JZ 0x00128eff
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x50]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x00128ebb
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x1
JMP 0x00128f89
LAB_00128ebb:
JMP 0x00128ebd
LAB_00128ebd:
MOV EAX,dword ptr [RBP + -0x50]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x50],ECX
CMP EAX,0x0
JZ 0x00128ef1
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
JMP 0x00128ebd
LAB_00128ef1:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00128f78
LAB_00128eff:
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x27
JNZ 0x00128f48
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x00128f22
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x1
JMP 0x00128f89
LAB_00128f22:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x27
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x10],RCX
MOV byte ptr [RAX],0x27
JMP 0x00128f76
LAB_00128f48:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x48]
JBE 0x00128f5f
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],0x1
JMP 0x00128f89
LAB_00128f5f:
MOV RAX,qword ptr [RBP + -0x20]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
LAB_00128f76:
JMP 0x00128f78
LAB_00128f78:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00128e6e
LAB_00128f89:
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long escape_quotes_for_mysql
(int8 param_1,char *param_2,long param_3,char *param_4,long param_5,
int1 *param_6)
{
char cVar1;
char *pcVar2;
long local_68;
int local_58;
char *local_28;
char *local_18;
if (param_3 == 0) {
local_68 = param_5 << 1;
}
else {
local_68 = param_3 + -1;
}
pcVar2 = param_2 + local_68;
cVar1 = my_ci_use_mb(param_1);
*param_6 = 0;
local_28 = param_4;
local_18 = param_2;
do {
if (param_4 + param_5 <= local_28) {
LAB_00128f89:
*local_18 = '\0';
return (long)local_18 - (long)param_2;
}
if ((cVar1 == '\0') ||
(local_58 = my_ismbchar(param_1,local_28,param_4 + param_5), local_58 == 0)) {
if (*local_28 == '\'') {
if (pcVar2 < local_18 + 2) {
*param_6 = 1;
goto LAB_00128f89;
}
*local_18 = '\'';
local_18[1] = '\'';
local_18 = local_18 + 2;
}
else {
if (pcVar2 < local_18 + 1) {
*param_6 = 1;
goto LAB_00128f89;
}
*local_18 = *local_28;
local_18 = local_18 + 1;
}
}
else {
if (pcVar2 < local_18 + local_58) {
*param_6 = 1;
goto LAB_00128f89;
}
while (local_58 != 0) {
*local_18 = *local_28;
local_58 = local_58 + -1;
local_28 = local_28 + 1;
local_18 = local_18 + 1;
}
local_28 = local_28 + -1;
}
local_28 = local_28 + 1;
} while( true );
}
|
|
1,912 | ma_read_bitmap_page | eloqsql/storage/maria/ma_bitmap.c | static my_bool _ma_read_bitmap_page(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page)
{
MARIA_SHARE *share= info->s;
my_bool res;
DBUG_ENTER("_ma_read_bitmap_page");
DBUG_PRINT("enter", ("page: %lld data_file_length: %lld",
(longlong) page,
(longlong) share->state.state.data_file_length));
DBUG_ASSERT(page % bitmap->pages_covered == 0);
DBUG_ASSERT(!bitmap->changed);
bitmap->page= page;
if ((page + 1) * bitmap->block_size > share->state.state.data_file_length)
{
/* Inexistent or half-created page */
res= _ma_bitmap_create_missing(info, bitmap, page);
if (!res)
adjust_total_size(info, page);
DBUG_RETURN(res);
}
adjust_total_size(info, page);
bitmap->full_head_size= bitmap->full_tail_size= 0;
DBUG_ASSERT(share->pagecache->block_size == bitmap->block_size);
res= pagecache_read(share->pagecache,
&bitmap->file, page, 0,
bitmap->map, PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED, 0) == NULL;
if (!res)
{
/* Calculate used_size */
const uchar *data, *end= bitmap->map;
for (data= bitmap->map + bitmap->total_size; --data >= end && *data == 0; )
{}
bitmap->used_size= (uint) ((data + 1) - end);
DBUG_ASSERT(bitmap->used_size <= bitmap->total_size);
}
else
{
_ma_set_fatal_error(info, my_errno);
}
/*
We can't check maria_bitmap_marker here as if the bitmap page
previously had a true checksum and the user switched mode to not checksum
this may have any value, except maria_normal_page_marker.
Using maria_normal_page_marker gives us a protection against bugs
when running without any checksums.
*/
#ifndef DBUG_OFF
if (!res)
{
memcpy(bitmap->map + bitmap->block_size, bitmap->map, bitmap->block_size);
_ma_check_bitmap(bitmap);
}
#endif
DBUG_RETURN(res);
} | O0 | c | ma_read_bitmap_page:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb5fc21
jmp 0xb5fc23
jmp 0xb5fc25
jmp 0xb5fc27
jmp 0xb5fc29
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
movl 0x134(%rcx), %ecx
imulq %rcx, %rax
movq -0x28(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0xb5fc89
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xb5fda0
movb %al, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0xb5fc7c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb60020
jmp 0xb5fc7e
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xb5fd94
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb60020
movq -0x18(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x28(%rax)
jmp 0xb5fcae
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0xb20c60
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0xb5fd74
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x128(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jb 0xb5fd4d
movq -0x38(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xb5fd56
jmp 0xb5fd58
jmp 0xb5fd26
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq -0x40(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0xb5fd72
jmp 0xb5fd8c
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xc1dab0
movq -0x50(%rbp), %rdi
movl (%rax), %esi
callq 0xaf54d0
jmp 0xb5fd8e
movb -0x29(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_read_bitmap_page:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_B5FC21:
jmp short $+2
loc_B5FC23:
jmp short $+2
loc_B5FC25:
jmp short $+2
loc_B5FC27:
jmp short $+2
loc_B5FC29:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
add rax, 1
mov rcx, [rbp+var_18]
mov ecx, [rcx+134h]
imul rax, rcx
mov rcx, [rbp+var_28]
cmp rax, [rcx+40h]
jbe short loc_B5FC89
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _ma_bitmap_create_missing
mov [rbp+var_29], al
cmp [rbp+var_29], 0
jnz short loc_B5FC7C
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call adjust_total_size
loc_B5FC7C:
jmp short $+2
loc_B5FC7E:
mov al, [rbp+var_29]
mov [rbp+var_1], al
jmp loc_B5FD94
loc_B5FC89:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call adjust_total_size
mov rax, [rbp+var_18]
mov dword ptr [rax+2Ch], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+28h], 0
jmp short $+2
loc_B5FCAE:
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_18]
add rsi, 40h ; '@'
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
mov r8, [rax+8]
xor ecx, ecx
mov r9d, 1
xor eax, eax
mov [rsp+60h+var_60], 0
mov [rsp+60h+var_58], 0
call pagecache_read
cmp rax, 0
setz al
and al, 1
movzx eax, al
mov [rbp+var_29], al
cmp [rbp+var_29], 0
jnz short loc_B5FD74
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rcx, [rbp+var_18]
mov ecx, [rcx+128h]
add rax, rcx
mov [rbp+var_38], rax
loc_B5FD26:
mov rcx, [rbp+var_38]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_38], rcx
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jb short loc_B5FD4D
mov rax, [rbp+var_38]
movzx eax, byte ptr [rax]
cmp eax, 0
setz al
mov [rbp+var_41], al
loc_B5FD4D:
mov al, [rbp+var_41]
test al, 1
jnz short loc_B5FD56
jmp short loc_B5FD58
loc_B5FD56:
jmp short loc_B5FD26
loc_B5FD58:
mov rax, [rbp+var_38]
add rax, 1
mov rcx, [rbp+var_40]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax+24h], ecx
jmp short $+2
loc_B5FD72:
jmp short loc_B5FD8C
loc_B5FD74:
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
call _my_thread_var
mov rdi, [rbp+var_50]
mov esi, [rax]
call _ma_set_fatal_error
loc_B5FD8C:
jmp short $+2
loc_B5FD8E:
mov al, [rbp+var_29]
mov [rbp+var_1], al
loc_B5FD94:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
| bool ma_read_bitmap_page(_DWORD *a1, long long a2, long long a3)
{
_QWORD *v3; // rdi
const char *v4; // rsi
long long v5; // rax
unsigned int *v6; // rax
long long v7; // rdx
long long v8; // rcx
long long v9; // r8
int v10; // r9d
bool v12; // [rsp+1Fh] [rbp-41h]
unsigned long long v13; // [rsp+20h] [rbp-40h]
_BYTE *v14; // [rsp+28h] [rbp-38h]
char missing; // [rsp+37h] [rbp-29h]
bool v16; // [rsp+37h] [rbp-29h]
long long v17; // [rsp+38h] [rbp-28h]
v17 = *(_QWORD *)a1;
*(_QWORD *)(a2 + 16) = a3;
if ( (unsigned long long)*(unsigned int *)(a2 + 308) * (a3 + 1) <= *(_QWORD *)(v17 + 64) )
{
adjust_total_size(a1, a3);
*(_DWORD *)(a2 + 44) = 0;
*(_DWORD *)(a2 + 40) = 0;
v3 = *(_QWORD **)(v17 + 1536);
v4 = (const char *)(a2 + 64);
v5 = pagecache_read(v3, (const char *)(a2 + 64), a3, 0, *(_QWORD *)(a2 + 8), 1, 0, 0LL);
v16 = v5 == 0;
if ( v5 )
{
v13 = *(_QWORD *)(a2 + 8);
v14 = (_BYTE *)(*(unsigned int *)(a2 + 296) + v13);
do
{
--v14;
v12 = 0;
if ( (unsigned long long)v14 >= v13 )
v12 = *v14 == 0;
}
while ( v12 );
*(_DWORD *)(a2 + 36) = (_DWORD)v14 + 1 - v13;
}
else
{
v6 = (unsigned int *)my_thread_var(v3, v4);
ma_set_fatal_error(a1, *v6, v7, v8, v9, v10);
}
return v16;
}
else
{
missing = ma_bitmap_create_missing(a1, a2, a3);
if ( !missing )
adjust_total_size(a1, a3);
return missing;
}
}
| get_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x58]
MOV RSI,qword ptr [RAX + 0x38]
CALL 0x0074b310
ADD RSP,0x10
POP RBP
RET
|
/* FT_SELECT::get_next() */
void __thiscall FT_SELECT::get_next(FT_SELECT *this)
{
handler::ha_ft_read(*(handler **)(this + 0x58),*(uchar **)(this + 0x38));
return;
}
|
|
1,913 | write_hook_for_redo | eloqsql/storage/maria/ma_blockrec.c | my_bool write_hook_for_redo(enum translog_record_type type
__attribute__ ((unused)),
TRN *trn, MARIA_HA *tbl_info
__attribute__ ((unused)),
LSN *lsn, void *hook_arg
__attribute__ ((unused)))
{
/*
Users of dummy_transaction_object must keep this TRN clean as it
is used by many threads (like those manipulating non-transactional
tables). It might be dangerous if one user sets rec_lsn or some other
member and it is picked up by another user (like putting this rec_lsn into
a page of a non-transactional table); it's safer if all members stay 0. So
non-transactional log records (REPAIR, CREATE, RENAME, DROP) should not
call this hook; we trust them but verify ;)
*/
DBUG_ASSERT(trn->trid != 0);
/*
If the hook stays so simple, it would be faster to pass
!trn->rec_lsn ? trn->rec_lsn : some_dummy_lsn
to translog_write_record(), like Monty did in his original code, and not
have a hook. For now we keep it like this.
*/
if (trn->rec_lsn == 0)
trn->rec_lsn= *lsn;
return 0;
} | O3 | c | write_hook_for_redo:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x90(%rsi)
jne 0x4dc3c
movq (%rcx), %rax
movq %rax, 0x90(%rsi)
xorl %eax, %eax
popq %rbp
retq
| write_hook_for_redo:
push rbp
mov rbp, rsp
cmp qword ptr [rsi+90h], 0
jnz short loc_4DC3C
mov rax, [rcx]
mov [rsi+90h], rax
loc_4DC3C:
xor eax, eax
pop rbp
retn
| long long write_hook_for_redo(long long a1, long long a2, long long a3, _QWORD *a4)
{
if ( !*(_QWORD *)(a2 + 144) )
*(_QWORD *)(a2 + 144) = *a4;
return 0LL;
}
| write_hook_for_redo:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RSI + 0x90],0x0
JNZ 0x0014dc3c
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSI + 0x90],RAX
LAB_0014dc3c:
XOR EAX,EAX
POP RBP
RET
|
int8
write_hook_for_redo(int8 param_1,long param_2,int8 param_3,int8 *param_4)
{
if (*(long *)(param_2 + 0x90) == 0) {
*(int8 *)(param_2 + 0x90) = *param_4;
}
return 0;
}
|
|
1,914 | ch2x | eloqsql/strings/ctype-uca.c | static int ch2x(int ch)
{
if (ch >= '0' && ch <= '9')
return ch - '0';
if (ch >= 'a' && ch <= 'f')
return 10 + ch - 'a';
if (ch >= 'A' && ch <= 'F')
return 10 + ch - 'A';
return -1;
} | O0 | c | ch2x:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x30, -0x8(%rbp)
jl 0x4ec6e
cmpl $0x39, -0x8(%rbp)
jg 0x4ec6e
movl -0x8(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x4eca9
cmpl $0x61, -0x8(%rbp)
jl 0x4ec88
cmpl $0x66, -0x8(%rbp)
jg 0x4ec88
movl -0x8(%rbp), %eax
addl $0xa, %eax
subl $0x61, %eax
movl %eax, -0x4(%rbp)
jmp 0x4eca9
cmpl $0x41, -0x8(%rbp)
jl 0x4eca2
cmpl $0x46, -0x8(%rbp)
jg 0x4eca2
movl -0x8(%rbp), %eax
addl $0xa, %eax
subl $0x41, %eax
movl %eax, -0x4(%rbp)
jmp 0x4eca9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
| ch2x:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 30h ; '0'
jl short loc_4EC6E
cmp [rbp+var_8], 39h ; '9'
jg short loc_4EC6E
mov eax, [rbp+var_8]
sub eax, 30h ; '0'
mov [rbp+var_4], eax
jmp short loc_4ECA9
loc_4EC6E:
cmp [rbp+var_8], 61h ; 'a'
jl short loc_4EC88
cmp [rbp+var_8], 66h ; 'f'
jg short loc_4EC88
mov eax, [rbp+var_8]
add eax, 0Ah
sub eax, 61h ; 'a'
mov [rbp+var_4], eax
jmp short loc_4ECA9
loc_4EC88:
cmp [rbp+var_8], 41h ; 'A'
jl short loc_4ECA2
cmp [rbp+var_8], 46h ; 'F'
jg short loc_4ECA2
mov eax, [rbp+var_8]
add eax, 0Ah
sub eax, 41h ; 'A'
mov [rbp+var_4], eax
jmp short loc_4ECA9
loc_4ECA2:
mov [rbp+var_4], 0FFFFFFFFh
loc_4ECA9:
mov eax, [rbp+var_4]
pop rbp
retn
| long long ch2x(int a1)
{
if ( a1 < 48 || a1 > 57 )
{
if ( a1 < 97 || a1 > 102 )
{
if ( a1 < 65 || a1 > 70 )
return (unsigned int)-1;
else
return (unsigned int)(a1 - 55);
}
else
{
return (unsigned int)(a1 - 87);
}
}
else
{
return (unsigned int)(a1 - 48);
}
}
| ch2x:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0x30
JL 0x0014ec6e
CMP dword ptr [RBP + -0x8],0x39
JG 0x0014ec6e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x30
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014eca9
LAB_0014ec6e:
CMP dword ptr [RBP + -0x8],0x61
JL 0x0014ec88
CMP dword ptr [RBP + -0x8],0x66
JG 0x0014ec88
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0xa
SUB EAX,0x61
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014eca9
LAB_0014ec88:
CMP dword ptr [RBP + -0x8],0x41
JL 0x0014eca2
CMP dword ptr [RBP + -0x8],0x46
JG 0x0014eca2
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0xa
SUB EAX,0x41
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014eca9
LAB_0014eca2:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_0014eca9:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int ch2x(int param_1)
{
int4 local_c;
if ((param_1 < 0x30) || (0x39 < param_1)) {
if ((param_1 < 0x61) || (0x66 < param_1)) {
if ((param_1 < 0x41) || (0x46 < param_1)) {
local_c = -1;
}
else {
local_c = param_1 + -0x37;
}
}
else {
local_c = param_1 + -0x57;
}
}
else {
local_c = param_1 + -0x30;
}
return local_c;
}
|
|
1,915 | maria_rtree_add_key | eloqsql/storage/maria/ma_rt_key.c | int maria_rtree_add_key(const MARIA_KEY *key, MARIA_PAGE *page,
my_off_t *new_page)
{
MARIA_HA *info= page->info;
MARIA_SHARE *share= info->s;
uint page_size= page->size;
uint nod_flag= page->node;
uchar *key_pos= rt_PAGE_END(page);
uint tot_key_length= key->data_length + key->ref_length + nod_flag;
DBUG_ENTER("maria_rtree_add_key");
if (page_size + tot_key_length <=
(uint)(key->keyinfo->block_length - KEYPAGE_CHECKSUM_SIZE))
{
/* split won't be necessary */
if (nod_flag)
{
DBUG_ASSERT(_ma_kpos(nod_flag, key->data) <
info->state->key_file_length);
/* We don't store reference to row on nod pages for rtree index */
tot_key_length-= key->ref_length;
}
/* save key */
memcpy(key_pos, key->data - nod_flag, tot_key_length);
page->size+= tot_key_length;
page_store_size(share, page);
if (share->now_transactional &&
_ma_log_add(page, (uint)(key_pos - page->buff),
key_pos, tot_key_length, tot_key_length, 0,
KEY_OP_DEBUG_LOG_ADD_1))
DBUG_RETURN(-1);
DBUG_RETURN(0);
}
DBUG_RETURN(maria_rtree_split_page(key, page, new_page) ? -1 : 1);
} | O3 | c | maria_rtree_add_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x20(%rsi), %r14d
movl 0x28(%rsi), %eax
movl 0x14(%rdi), %esi
movl 0x10(%rdi), %ecx
addl %esi, %ecx
leal (%rcx,%rax), %r15d
leal (%r14,%r15), %r8d
movq 0x8(%rdi), %r9
movzwl 0xa6(%r9), %r9d
addl $-0x4, %r9d
cmpl %r9d, %r8d
jbe 0x6ca4e
movq %rbx, %rsi
callq 0x6f950
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x1, %eax
jmp 0x6cad7
addq 0x10(%rbx), %r14
movq (%rbx), %rdx
movq (%rdx), %r12
subl %esi, %r15d
testq %rax, %rax
cmovel %ecx, %r15d
movq (%rdi), %rsi
subq %rax, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x29080
movl 0x20(%rbx), %eax
addl %r15d, %eax
movl %eax, 0x20(%rbx)
movq 0x10(%rbx), %rcx
movl 0x744(%r12), %edx
movb %al, -0x1(%rcx,%rdx)
movq 0x10(%rbx), %rcx
movl 0x744(%r12), %edx
movb %ah, -0x2(%rcx,%rdx)
cmpb $0x0, 0x7e7(%r12)
je 0x6cad5
movl 0x10(%rbx), %eax
movl %r14d, %esi
subl %eax, %esi
movl $0x6, (%rsp)
movq %rbx, %rdi
movq %r14, %rdx
movl %r15d, %ecx
movl %r15d, %r8d
xorl %r9d, %r9d
callq 0x59a16
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0x6cad7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| maria_rtree_add_key:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rsi
mov r14d, [rsi+20h]
mov eax, [rsi+28h]
mov esi, [rdi+14h]
mov ecx, [rdi+10h]
add ecx, esi
lea r15d, [rcx+rax]
lea r8d, [r14+r15]
mov r9, [rdi+8]
movzx r9d, word ptr [r9+0A6h]
add r9d, 0FFFFFFFCh
cmp r8d, r9d
jbe short loc_6CA4E
mov rsi, rbx
call maria_rtree_split_page
mov ecx, eax
xor eax, eax
neg ecx
sbb eax, eax
or eax, 1
jmp loc_6CAD7
loc_6CA4E:
add r14, [rbx+10h]
mov rdx, [rbx]
mov r12, [rdx]
sub r15d, esi
test rax, rax
cmovz r15d, ecx
mov rsi, [rdi]
sub rsi, rax
mov rdi, r14
mov rdx, r15
call _memcpy
mov eax, [rbx+20h]
add eax, r15d
mov [rbx+20h], eax
mov rcx, [rbx+10h]
mov edx, [r12+744h]
mov [rcx+rdx-1], al
mov rcx, [rbx+10h]
mov edx, [r12+744h]
mov [rcx+rdx-2], ah
cmp byte ptr [r12+7E7h], 0
jz short loc_6CAD5
mov eax, [rbx+10h]
mov esi, r14d
sub esi, eax
mov [rsp+30h+var_30], 6
mov rdi, rbx
mov rdx, r14
mov ecx, r15d
mov r8d, r15d
xor r9d, r9d
call _ma_log_add
mov ecx, eax
mov eax, 0FFFFFFFFh
test cl, cl
jnz short loc_6CAD7
loc_6CAD5:
xor eax, eax
loc_6CAD7:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long maria_rtree_add_key(long long a1, long long a2)
{
long long v2; // r14
long long v3; // rax
unsigned int v4; // ecx
long long result; // rax
long long v6; // r14
long long v7; // r12
long long v8; // r15
int v9; // eax
char v10; // cl
v2 = *(unsigned int *)(a2 + 32);
v3 = *(unsigned int *)(a2 + 40);
v4 = *(_DWORD *)(a1 + 20) + *(_DWORD *)(a1 + 16);
if ( (unsigned int)v2 + v4 + (_DWORD)v3 > (unsigned int)*(unsigned __int16 *)(*(_QWORD *)(a1 + 8) + 166LL) - 4 )
return (unsigned int)maria_rtree_split_page(a1, a2) != 0 ? -1 : 1;
v6 = *(_QWORD *)(a2 + 16) + v2;
v7 = **(_QWORD **)a2;
v8 = (unsigned int)(*(_DWORD *)(a1 + 16) + v3);
if ( !*(_DWORD *)(a2 + 40) )
v8 = v4;
memcpy(v6, *(_QWORD *)a1 - v3, v8);
v9 = v8 + *(_DWORD *)(a2 + 32);
*(_DWORD *)(a2 + 32) = v9;
*(_BYTE *)(*(_QWORD *)(a2 + 16) + *(unsigned int *)(v7 + 1860) - 1LL) = v9;
*(_BYTE *)(*(_QWORD *)(a2 + 16) + *(unsigned int *)(v7 + 1860) - 2LL) = BYTE1(v9);
if ( !*(_BYTE *)(v7 + 2023) )
return 0LL;
v10 = ma_log_add(a2, (unsigned int)(v6 - *(_DWORD *)(a2 + 16)), v6, v8, v8);
result = 0xFFFFFFFFLL;
if ( !v10 )
return 0LL;
return result;
}
| maria_rtree_add_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV RBX,RSI
MOV R14D,dword ptr [RSI + 0x20]
MOV EAX,dword ptr [RSI + 0x28]
MOV ESI,dword ptr [RDI + 0x14]
MOV ECX,dword ptr [RDI + 0x10]
ADD ECX,ESI
LEA R15D,[RCX + RAX*0x1]
LEA R8D,[R14 + R15*0x1]
MOV R9,qword ptr [RDI + 0x8]
MOVZX R9D,word ptr [R9 + 0xa6]
ADD R9D,-0x4
CMP R8D,R9D
JBE 0x0016ca4e
MOV RSI,RBX
CALL 0x0016f950
MOV ECX,EAX
XOR EAX,EAX
NEG ECX
SBB EAX,EAX
OR EAX,0x1
JMP 0x0016cad7
LAB_0016ca4e:
ADD R14,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX]
MOV R12,qword ptr [RDX]
SUB R15D,ESI
TEST RAX,RAX
CMOVZ R15D,ECX
MOV RSI,qword ptr [RDI]
SUB RSI,RAX
MOV RDI,R14
MOV RDX,R15
CALL 0x00129080
MOV EAX,dword ptr [RBX + 0x20]
ADD EAX,R15D
MOV dword ptr [RBX + 0x20],EAX
MOV RCX,qword ptr [RBX + 0x10]
MOV EDX,dword ptr [R12 + 0x744]
MOV byte ptr [RCX + RDX*0x1 + -0x1],AL
MOV RCX,qword ptr [RBX + 0x10]
MOV EDX,dword ptr [R12 + 0x744]
MOV byte ptr [RCX + RDX*0x1 + -0x2],AH
CMP byte ptr [R12 + 0x7e7],0x0
JZ 0x0016cad5
MOV EAX,dword ptr [RBX + 0x10]
MOV ESI,R14D
SUB ESI,EAX
MOV dword ptr [RSP],0x6
MOV RDI,RBX
MOV RDX,R14
MOV ECX,R15D
MOV R8D,R15D
XOR R9D,R9D
CALL 0x00159a16
MOV ECX,EAX
MOV EAX,0xffffffff
TEST CL,CL
JNZ 0x0016cad7
LAB_0016cad5:
XOR EAX,EAX
LAB_0016cad7:
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
uint maria_rtree_add_key(long *param_1,int8 *param_2)
{
long lVar1;
uint uVar2;
char cVar3;
uint uVar4;
uint uVar5;
void *__dest;
int iVar6;
uVar4 = *(uint *)(param_2 + 5);
uVar5 = (int)param_1[2] + *(int *)((long)param_1 + 0x14);
iVar6 = uVar5 + uVar4;
if (*(ushort *)(param_1[1] + 0xa6) - 4 < *(uint *)(param_2 + 4) + iVar6) {
iVar6 = maria_rtree_split_page(param_1,param_2);
uVar4 = -(uint)(iVar6 != 0) | 1;
}
else {
__dest = (void *)((ulong)*(uint *)(param_2 + 4) + param_2[2]);
lVar1 = *(long *)*param_2;
uVar2 = iVar6 - *(int *)((long)param_1 + 0x14);
if ((ulong)uVar4 == 0) {
uVar2 = uVar5;
}
memcpy(__dest,(void *)(*param_1 - (ulong)uVar4),(ulong)uVar2);
iVar6 = *(int *)(param_2 + 4) + uVar2;
*(int *)(param_2 + 4) = iVar6;
*(char *)(param_2[2] + -1 + (ulong)*(uint *)(lVar1 + 0x744)) = (char)iVar6;
*(char *)(param_2[2] + -2 + (ulong)*(uint *)(lVar1 + 0x744)) = (char)((uint)iVar6 >> 8);
if ((*(char *)(lVar1 + 0x7e7) != '\0') &&
(cVar3 = _ma_log_add(param_2,(int)__dest - *(int *)(param_2 + 2),__dest,uVar2,(ulong)uVar2,0,
6), cVar3 != '\0')) {
return 0xffffffff;
}
uVar4 = 0;
}
return uVar4;
}
|
|
1,916 | common_params_sampling::print[abi:cxx11]() const | monkey531[P]llama/common/sampling.cpp | std::string common_params_sampling::print() const {
char result[1024];
snprintf(result, sizeof(result),
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n"
"\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n"
"\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
penalty_last_n, penalty_repeat, penalty_freq, penalty_present,
dry_multiplier, dry_base, dry_allowed_length, dry_penalty_last_n,
top_k, top_p, min_p, xtc_probability, xtc_threshold, typ_p, temp,
mirostat, mirostat_eta, mirostat_tau);
return std::string(result);
} | O2 | cpp | common_params_sampling::print[abi:cxx11]() const:
pushq %r14
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cvtss2sd 0x38(%rsi), %xmm0
cvtss2sd 0x3c(%rsi), %xmm1
cvtss2sd 0x40(%rsi), %xmm2
cvtss2sd 0x44(%rsi), %xmm3
cvtss2sd 0x48(%rsi), %xmm4
movl 0x34(%rsi), %ecx
movl 0x4c(%rsi), %r8d
cvtss2sd 0x14(%rsi), %xmm5
cvtss2sd 0x18(%rsi), %xmm6
cvtss2sd 0x1c(%rsi), %xmm7
cvtss2sd 0x20(%rsi), %xmm8
cvtss2sd 0x24(%rsi), %xmm9
movl 0x50(%rsi), %r9d
cvtss2sd 0x28(%rsi), %xmm10
movl 0x54(%rsi), %edx
cvtss2sd 0x5c(%rsi), %xmm11
cvtss2sd 0x58(%rsi), %xmm12
movsd %xmm12, 0x30(%rsp)
movsd %xmm11, 0x28(%rsp)
movl %edx, 0x20(%rsp)
movsd %xmm10, 0x18(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x8(%rsp)
movl %eax, (%rsp)
leaq 0x1b165(%rip), %rdx # 0x1078c2
leaq 0x40(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movb $0x8, %al
callq 0x29190
leaq 0x3f(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bddc
movq %rbx, %rax
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r14
retq
| _ZNK22common_params_sampling5printB5cxx11Ev:
push r14
push rbx
sub rsp, 448h
mov rbx, rdi
mov eax, [rsi+10h]
cvtss2sd xmm0, dword ptr [rsi+38h]
cvtss2sd xmm1, dword ptr [rsi+3Ch]
cvtss2sd xmm2, dword ptr [rsi+40h]
cvtss2sd xmm3, dword ptr [rsi+44h]
cvtss2sd xmm4, dword ptr [rsi+48h]
mov ecx, [rsi+34h]
mov r8d, [rsi+4Ch]
cvtss2sd xmm5, dword ptr [rsi+14h]
cvtss2sd xmm6, dword ptr [rsi+18h]
cvtss2sd xmm7, dword ptr [rsi+1Ch]
cvtss2sd xmm8, dword ptr [rsi+20h]
cvtss2sd xmm9, dword ptr [rsi+24h]
mov r9d, [rsi+50h]
cvtss2sd xmm10, dword ptr [rsi+28h]
mov edx, [rsi+54h]
cvtss2sd xmm11, dword ptr [rsi+5Ch]
cvtss2sd xmm12, dword ptr [rsi+58h]
movsd [rsp+458h+var_428], xmm12
movsd [rsp+458h+var_430], xmm11
mov [rsp+458h+var_438], edx
movsd [rsp+458h+var_440], xmm10
movsd [rsp+458h+var_448], xmm9
movsd [rsp+458h+var_450], xmm8
mov [rsp+458h+var_458], eax
lea rdx, aDkpmYtxieRepea+0Ah; "\trepeat_last_n = %d, repeat_penalty = "...
lea r14, [rsp+458h+var_418]
mov esi, 400h
mov rdi, r14
mov al, 8
call _snprintf
lea rdx, [rsp+458h+var_419]
mov rdi, rbx
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, rbx
add rsp, 448h
pop rbx
pop r14
retn
| _QWORD * common_params_sampling::print[abi:cxx11](_QWORD *a1, long long a2)
{
_BYTE v3[1048]; // [rsp+40h] [rbp-418h] BYREF
snprintf(
v3,
1024LL,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
*(_DWORD *)(a2 + 52),
*(float *)(a2 + 56),
*(float *)(a2 + 60),
*(float *)(a2 + 64),
*(float *)(a2 + 68),
*(float *)(a2 + 72),
*(_DWORD *)(a2 + 76),
*(_DWORD *)(a2 + 80),
*(_DWORD *)(a2 + 16),
*(float *)(a2 + 20),
*(float *)(a2 + 24),
*(float *)(a2 + 28),
*(float *)(a2 + 32),
*(float *)(a2 + 36),
*(float *)(a2 + 40),
*(_DWORD *)(a2 + 84),
*(float *)(a2 + 92),
*(float *)(a2 + 88));
std::string::basic_string<std::allocator<char>>(a1, (long long)v3);
return a1;
}
| print[abi:cxx11]:
PUSH R14
PUSH RBX
SUB RSP,0x448
MOV RBX,RDI
MOV EAX,dword ptr [RSI + 0x10]
CVTSS2SD XMM0,dword ptr [RSI + 0x38]
CVTSS2SD XMM1,dword ptr [RSI + 0x3c]
CVTSS2SD XMM2,dword ptr [RSI + 0x40]
CVTSS2SD XMM3,dword ptr [RSI + 0x44]
CVTSS2SD XMM4,dword ptr [RSI + 0x48]
MOV ECX,dword ptr [RSI + 0x34]
MOV R8D,dword ptr [RSI + 0x4c]
CVTSS2SD XMM5,dword ptr [RSI + 0x14]
CVTSS2SD XMM6,dword ptr [RSI + 0x18]
CVTSS2SD XMM7,dword ptr [RSI + 0x1c]
CVTSS2SD XMM8,dword ptr [RSI + 0x20]
CVTSS2SD XMM9,dword ptr [RSI + 0x24]
MOV R9D,dword ptr [RSI + 0x50]
CVTSS2SD XMM10,dword ptr [RSI + 0x28]
MOV EDX,dword ptr [RSI + 0x54]
CVTSS2SD XMM11,dword ptr [RSI + 0x5c]
CVTSS2SD XMM12,dword ptr [RSI + 0x58]
MOVSD qword ptr [RSP + 0x30],XMM12
MOVSD qword ptr [RSP + 0x28],XMM11
MOV dword ptr [RSP + 0x20],EDX
MOVSD qword ptr [RSP + 0x18],XMM10
MOVSD qword ptr [RSP + 0x10],XMM9
MOVSD qword ptr [RSP + 0x8],XMM8
MOV dword ptr [RSP],EAX
LEA RDX,[0x2078c2]
LEA R14,[RSP + 0x40]
MOV ESI,0x400
MOV RDI,R14
MOV AL,0x8
CALL 0x00129190
LEA RDX,[RSP + 0x3f]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0013bddc
MOV RAX,RBX
ADD RSP,0x448
POP RBX
POP R14
RET
|
/* common_params_sampling::print[abi:cxx11]() const */
void common_params_sampling::print_abi_cxx11_(void)
{
long in_RSI;
string *in_RDI;
allocator local_419;
char local_418 [1032];
snprintf(local_418,0x400,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f"
,(double)*(float *)(in_RSI + 0x38),(double)*(float *)(in_RSI + 0x3c),
(double)*(float *)(in_RSI + 0x40),(double)*(float *)(in_RSI + 0x44),
(double)*(float *)(in_RSI + 0x48),(double)*(float *)(in_RSI + 0x14),
(double)*(float *)(in_RSI + 0x18),(double)*(float *)(in_RSI + 0x1c),
(ulong)*(uint *)(in_RSI + 0x34),(ulong)*(uint *)(in_RSI + 0x4c),
(ulong)*(uint *)(in_RSI + 0x50),*(int4 *)(in_RSI + 0x10),
(double)*(float *)(in_RSI + 0x20),(double)*(float *)(in_RSI + 0x24),
(double)*(float *)(in_RSI + 0x28),*(int4 *)(in_RSI + 0x54),
(double)*(float *)(in_RSI + 0x5c),(double)*(float *)(in_RSI + 0x58));
std::__cxx11::string::string<std::allocator<char>>(in_RDI,local_418,&local_419);
return;
}
|
|
1,917 | common_params_sampling::print[abi:cxx11]() const | monkey531[P]llama/common/sampling.cpp | std::string common_params_sampling::print() const {
char result[1024];
snprintf(result, sizeof(result),
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n"
"\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n"
"\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n"
"\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
penalty_last_n, penalty_repeat, penalty_freq, penalty_present,
dry_multiplier, dry_base, dry_allowed_length, dry_penalty_last_n,
top_k, top_p, min_p, xtc_probability, xtc_threshold, typ_p, temp,
mirostat, mirostat_eta, mirostat_tau);
return std::string(result);
} | O3 | cpp | common_params_sampling::print[abi:cxx11]() const:
pushq %r14
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cvtss2sd 0x38(%rsi), %xmm0
cvtss2sd 0x3c(%rsi), %xmm1
cvtss2sd 0x40(%rsi), %xmm2
cvtss2sd 0x44(%rsi), %xmm3
cvtss2sd 0x48(%rsi), %xmm4
movl 0x34(%rsi), %ecx
movl 0x4c(%rsi), %r8d
cvtss2sd 0x14(%rsi), %xmm5
cvtss2sd 0x18(%rsi), %xmm6
cvtss2sd 0x1c(%rsi), %xmm7
cvtss2sd 0x20(%rsi), %xmm8
cvtss2sd 0x24(%rsi), %xmm9
movl 0x50(%rsi), %r9d
cvtss2sd 0x28(%rsi), %xmm10
movl 0x54(%rsi), %edx
cvtss2sd 0x5c(%rsi), %xmm11
cvtss2sd 0x58(%rsi), %xmm12
movsd %xmm12, 0x30(%rsp)
movsd %xmm11, 0x28(%rsp)
movl %edx, 0x20(%rsp)
movsd %xmm10, 0x18(%rsp)
movsd %xmm9, 0x10(%rsp)
movsd %xmm8, 0x8(%rsp)
movl %eax, (%rsp)
leaq 0x1b41d(%rip), %rdx # 0x15b8aa
leaq 0x40(%rsp), %r14
movl $0x400, %esi # imm = 0x400
movq %r14, %rdi
movb $0x8, %al
callq 0x20140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1f4d0
leaq (%rsp,%rax), %rdx
addq $0x40, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b514
movq %rbx, %rax
addq $0x448, %rsp # imm = 0x448
popq %rbx
popq %r14
retq
| _ZNK22common_params_sampling5printB5cxx11Ev:
push r14
push rbx
sub rsp, 448h
mov rbx, rdi
mov eax, [rsi+10h]
cvtss2sd xmm0, dword ptr [rsi+38h]
cvtss2sd xmm1, dword ptr [rsi+3Ch]
cvtss2sd xmm2, dword ptr [rsi+40h]
cvtss2sd xmm3, dword ptr [rsi+44h]
cvtss2sd xmm4, dword ptr [rsi+48h]
mov ecx, [rsi+34h]
mov r8d, [rsi+4Ch]
cvtss2sd xmm5, dword ptr [rsi+14h]
cvtss2sd xmm6, dword ptr [rsi+18h]
cvtss2sd xmm7, dword ptr [rsi+1Ch]
cvtss2sd xmm8, dword ptr [rsi+20h]
cvtss2sd xmm9, dword ptr [rsi+24h]
mov r9d, [rsi+50h]
cvtss2sd xmm10, dword ptr [rsi+28h]
mov edx, [rsi+54h]
cvtss2sd xmm11, dword ptr [rsi+5Ch]
cvtss2sd xmm12, dword ptr [rsi+58h]
movsd [rsp+458h+var_428], xmm12
movsd [rsp+458h+var_430], xmm11
mov [rsp+458h+var_438], edx
movsd [rsp+458h+var_440], xmm10
movsd [rsp+458h+var_448], xmm9
movsd [rsp+458h+var_450], xmm8
mov [rsp+458h+var_458], eax
lea rdx, aDkpmYtxieRepea+0Ah; "\trepeat_last_n = %d, repeat_penalty = "...
lea r14, [rsp+458h+var_418]
mov esi, 400h
mov rdi, r14
mov al, 8
call _snprintf
lea rax, [rbx+10h]
mov [rbx], rax
mov rdi, r14
call _strlen
lea rdx, [rsp+rax+458h+var_458]
add rdx, 40h ; '@'
mov rdi, rbx
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
add rsp, 448h
pop rbx
pop r14
retn
| _QWORD * common_params_sampling::print[abi:cxx11](_QWORD *a1, long long a2)
{
long long v2; // rax
_BYTE v4[1048]; // [rsp+40h] [rbp-418h] BYREF
snprintf(
v4,
1024LL,
"\trepeat_last_n = %d, repeat_penalty = %.3f, frequency_penalty = %.3f, presence_penalty = %.3f\n\tdry_multiplier = %.3f, dry_base = %.3f, dry_allowed_length = %d, dry_penalty_last_n = %d\n\ttop_k = %d, top_p = %.3f, min_p = %.3f, xtc_probability = %.3f, xtc_threshold = %.3f, typical_p = %.3f, temp = %.3f\n\tmirostat = %d, mirostat_lr = %.3f, mirostat_ent = %.3f",
*(_DWORD *)(a2 + 52),
*(float *)(a2 + 56),
*(float *)(a2 + 60),
*(float *)(a2 + 64),
*(float *)(a2 + 68),
*(float *)(a2 + 72),
*(_DWORD *)(a2 + 76),
*(_DWORD *)(a2 + 80),
*(_DWORD *)(a2 + 16),
*(float *)(a2 + 20),
*(float *)(a2 + 24),
*(float *)(a2 + 28),
*(float *)(a2 + 32),
*(float *)(a2 + 36),
*(float *)(a2 + 40),
*(_DWORD *)(a2 + 84),
*(float *)(a2 + 92),
*(float *)(a2 + 88));
*a1 = a1 + 2;
v2 = strlen(v4);
std::string::_M_construct<char const*>((long long)a1, v4, (long long)&v4[v2]);
return a1;
}
| |||
1,918 | mi_ck_write_tree | eloqsql/storage/myisam/mi_write.c | int _mi_ck_write_tree(register MI_INFO *info, uint keynr, uchar *key,
uint key_length)
{
int error;
DBUG_ENTER("_mi_ck_write_tree");
error= tree_insert(&info->bulk_insert[keynr], key,
key_length + info->s->rec_reflength,
info->bulk_insert[keynr].custom_arg) ? 0 : HA_ERR_OUT_OF_MEM ;
DBUG_RETURN(error);
} | O3 | c | mi_ck_write_tree:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x80(%rdi), %r8
movl %esi, %esi
imulq $0x298, %rsi, %rsi # imm = 0x298
leaq (%r8,%rsi), %rdi
addl 0x338(%rax), %ecx
movq 0x230(%r8,%rsi), %rax
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq 0xc421e
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
shll $0x7, %ecx
movl %ecx, %eax
popq %rbp
retq
| _mi_ck_write_tree:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov r8, [rdi+80h]
mov esi, esi
imul rsi, 298h
lea rdi, [r8+rsi]
add ecx, [rax+338h]
mov rax, [r8+rsi+230h]
mov rsi, rdx
mov edx, ecx
mov rcx, rax
call tree_insert
xor ecx, ecx
test rax, rax
setz cl
shl ecx, 7
mov eax, ecx
pop rbp
retn
| long long mi_ck_write_tree(long long *a1, unsigned int a2, long long a3, int a4)
{
long long v4; // rax
long long v5; // rdi
v4 = *a1;
v5 = a1[16] + 664LL * a2;
return (unsigned __int8)(tree_insert(v5, a3, (unsigned int)(*(_DWORD *)(v4 + 824) + a4), *(_QWORD *)(v5 + 560)) == 0) << 7;
}
| _mi_ck_write_tree:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV R8,qword ptr [RDI + 0x80]
MOV ESI,ESI
IMUL RSI,RSI,0x298
LEA RDI,[R8 + RSI*0x1]
ADD ECX,dword ptr [RAX + 0x338]
MOV RAX,qword ptr [R8 + RSI*0x1 + 0x230]
MOV RSI,RDX
MOV EDX,ECX
MOV RCX,RAX
CALL 0x001c421e
XOR ECX,ECX
TEST RAX,RAX
SETZ CL
SHL ECX,0x7
MOV EAX,ECX
POP RBP
RET
|
long _mi_ck_write_tree(long *param_1,uint param_2,int8 param_3,int param_4)
{
long lVar1;
lVar1 = tree_insert(param_1[0x10] + (ulong)param_2 * 0x298,param_3,
param_4 + *(int *)(*param_1 + 0x338),
*(int8 *)(param_1[0x10] + 0x230 + (ulong)param_2 * 0x298));
return (ulong)(lVar1 == 0) << 7;
}
|
|
1,919 | llava_eval_image_embed | monkey531[P]llama/examples/llava/llava.cpp | bool llava_eval_image_embed(llama_context * ctx_llama, const struct llava_image_embed * image_embed, int n_batch, int * n_past) {
int n_embd = llama_model_n_embd(llama_get_model(ctx_llama));
for (int i = 0; i < image_embed->n_image_pos; i += n_batch) {
int n_eval = image_embed->n_image_pos - i;
if (n_eval > n_batch) {
n_eval = n_batch;
}
float * embd = image_embed->embed+i*n_embd;
llava_embd_batch llava_batch = llava_embd_batch(embd, n_eval, *n_past, 0);
if (llama_decode(ctx_llama, llava_batch.batch)) {
LOG_ERR("%s : failed to eval\n", __func__);
return false;
}
*n_past += n_eval;
}
return true;
} | O2 | cpp | llava_eval_image_embed:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, 0x40(%rsp)
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, 0x58(%rsp)
callq 0x26a90
movq %rax, %rdi
callq 0x262f0
movl %ebx, 0x3c(%rsp)
movslq %ebx, %rbx
cltq
imulq %rbx, %rax
shlq $0x2, %rax
movq %rax, 0x48(%rsp)
movq %rbx, 0x60(%rsp)
negq %rbx
xorl %r14d, %r14d
xorl %r12d, %r12d
movq %r15, 0x50(%rsp)
movslq 0x8(%r15), %rbp
addq 0x60(%rsp), %rbx
cmpq %rbp, %rbx
jge 0x2d521
leal (%r12,%rbp), %r13d
movl 0x3c(%rsp), %eax
cmpl %eax, %r13d
cmovgel %eax, %r13d
movq (%r15), %rsi
addq %r14, %rsi
movq 0x40(%rsp), %rax
movl (%rax), %ecx
leaq 0x68(%rsp), %rdi
movl %r13d, %edx
xorl %r8d, %r8d
callq 0x2d7ee
leaq 0xe0(%rsp), %rcx
movq 0x30(%rcx), %rax
movq %rax, 0x30(%rsp)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x27420
movl %eax, %r15d
testl %eax, %eax
jne 0x2d500
movq 0x40(%rsp), %rax
addl %r13d, (%rax)
subl 0x3c(%rsp), %r12d
addq 0x48(%rsp), %r14
leaq 0x68(%rsp), %rdi
callq 0x2d96e
testl %r15d, %r15d
movq 0x50(%rsp), %r15
je 0x2d45b
jmp 0x2d521
movq 0xf4a81(%rip), %rax # 0x121f88
movq (%rax), %rdi
leaq 0x991c5(%rip), %rsi # 0xc66d6
leaq 0x9935a(%rip), %rdx # 0xc6872
xorl %eax, %eax
callq 0x271f0
jmp 0x2d4dc
cmpq %rbp, %rbx
setge %al
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2d96e
movq %rbx, %rdi
callq 0x27660
| llava_eval_image_embed:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 118h
mov [rsp+148h+var_108], rcx
mov ebx, edx
mov r15, rsi
mov [rsp+148h+var_F0], rdi
call _llama_get_model
mov rdi, rax
call _llama_model_n_embd
mov [rsp+148h+var_10C], ebx
movsxd rbx, ebx
cdqe
imul rax, rbx
shl rax, 2
mov [rsp+148h+var_100], rax
mov [rsp+148h+var_E8], rbx
neg rbx
xor r14d, r14d
xor r12d, r12d
mov [rsp+148h+var_F8], r15
loc_2D45B:
movsxd rbp, dword ptr [r15+8]
add rbx, [rsp+148h+var_E8]
cmp rbx, rbp
jge loc_2D521
lea r13d, [r12+rbp]
mov eax, [rsp+148h+var_10C]
cmp r13d, eax
cmovge r13d, eax
mov rsi, [r15]
add rsi, r14; float *
mov rax, [rsp+148h+var_108]
mov ecx, [rax]; int
lea rdi, [rsp+148h+var_E0]; this
mov edx, r13d; int
xor r8d, r8d; int
call _ZN16llava_embd_batchC2EPfiii; llava_embd_batch::llava_embd_batch(float *,int,int,int)
lea rcx, [rsp+148h+var_68]
mov rax, [rcx+30h]
mov [rsp+148h+var_118], rax
movups xmm0, xmmword ptr [rcx]
movups xmm1, xmmword ptr [rcx+10h]
movups xmm2, xmmword ptr [rcx+20h]
movups [rsp+148h+var_128], xmm2
movups [rsp+148h+var_138], xmm1
movups [rsp+148h+var_148], xmm0
mov rdi, [rsp+148h+var_F0]
call _llama_decode
mov r15d, eax
test eax, eax
jnz short loc_2D500
mov rax, [rsp+148h+var_108]
add [rax], r13d
loc_2D4DC:
sub r12d, [rsp+148h+var_10C]
add r14, [rsp+148h+var_100]
lea rdi, [rsp+148h+var_E0]; this
call _ZN16llava_embd_batchD2Ev; llava_embd_batch::~llava_embd_batch()
test r15d, r15d
mov r15, [rsp+148h+var_F8]
jz loc_2D45B
jmp short loc_2D521
loc_2D500:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aSFailedToEval; "%s : failed to eval\n"
lea rdx, aLlavaEvalImage; "llava_eval_image_embed"
xor eax, eax
call _fprintf
jmp short loc_2D4DC
loc_2D521:
cmp rbx, rbp
setnl al
add rsp, 118h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_60]; this
call _ZN16llava_embd_batchD2Ev; llava_embd_batch::~llava_embd_batch()
mov rdi, rbx
call __Unwind_Resume
| bool llava_eval_image_embed(long long a1, long long a2, int a3, int *a4)
{
long long v5; // r15
long long model; // rax
long long v7; // rbx
long long v8; // r14
int v9; // r12d
long long v10; // rbp
int v11; // r13d
int v12; // r15d
bool v13; // zf
int v15; // [rsp+3Ch] [rbp-10Ch]
long long v17; // [rsp+48h] [rbp-100h]
long long v18; // [rsp+60h] [rbp-E8h]
_BYTE v19[120]; // [rsp+68h] [rbp-E0h] BYREF
v5 = a2;
model = llama_get_model(a1);
v15 = a3;
v17 = 4 * a3 * (long long)(int)llama_model_n_embd(model);
v18 = a3;
v7 = -(long long)a3;
v8 = 0LL;
v9 = 0;
do
{
v10 = *(int *)(v5 + 8);
v7 += v18;
if ( v7 >= v10 )
break;
v11 = v9 + v10;
if ( v9 + (int)v10 >= v15 )
v11 = v15;
llava_embd_batch::llava_embd_batch((llava_embd_batch *)v19, (float *)(v8 + *(_QWORD *)v5), v11, *a4, 0);
v12 = llama_decode(a1);
if ( v12 )
fprintf(stderr, "%s : failed to eval\n", "llava_eval_image_embed");
else
*a4 += v11;
v9 -= v15;
v8 += v17;
llava_embd_batch::~llava_embd_batch((llava_embd_batch *)v19);
v13 = v12 == 0;
v5 = a2;
}
while ( v13 );
return v7 >= v10;
}
| llava_eval_image_embed:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x118
MOV qword ptr [RSP + 0x40],RCX
MOV EBX,EDX
MOV R15,RSI
MOV qword ptr [RSP + 0x58],RDI
CALL 0x00126a90
MOV RDI,RAX
CALL 0x001262f0
MOV dword ptr [RSP + 0x3c],EBX
MOVSXD RBX,EBX
CDQE
IMUL RAX,RBX
SHL RAX,0x2
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x60],RBX
NEG RBX
XOR R14D,R14D
XOR R12D,R12D
MOV qword ptr [RSP + 0x50],R15
LAB_0012d45b:
MOVSXD RBP,dword ptr [R15 + 0x8]
ADD RBX,qword ptr [RSP + 0x60]
CMP RBX,RBP
JGE 0x0012d521
LEA R13D,[R12 + RBP*0x1]
MOV EAX,dword ptr [RSP + 0x3c]
CMP R13D,EAX
CMOVGE R13D,EAX
MOV RSI,qword ptr [R15]
ADD RSI,R14
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX]
LEA RDI,[RSP + 0x68]
MOV EDX,R13D
XOR R8D,R8D
CALL 0x0012d7ee
LAB_0012d499:
LEA RCX,[RSP + 0xe0]
MOV RAX,qword ptr [RCX + 0x30]
MOV qword ptr [RSP + 0x30],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS XMM1,xmmword ptr [RCX + 0x10]
MOVUPS XMM2,xmmword ptr [RCX + 0x20]
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00127420
LAB_0012d4cd:
MOV R15D,EAX
TEST EAX,EAX
JNZ 0x0012d500
MOV RAX,qword ptr [RSP + 0x40]
ADD dword ptr [RAX],R13D
LAB_0012d4dc:
SUB R12D,dword ptr [RSP + 0x3c]
ADD R14,qword ptr [RSP + 0x48]
LEA RDI,[RSP + 0x68]
CALL 0x0012d96e
TEST R15D,R15D
MOV R15,qword ptr [RSP + 0x50]
JZ 0x0012d45b
JMP 0x0012d521
LAB_0012d500:
MOV RAX,qword ptr [0x00221f88]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1c66d6]
LEA RDX,[0x1c6872]
XOR EAX,EAX
CALL 0x001271f0
JMP 0x0012d4dc
LAB_0012d521:
CMP RBX,RBP
SETGE AL
ADD RSP,0x118
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool llava_eval_image_embed(int8 param_1,long *param_2,int param_3,int *param_4)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int8 uVar5;
long lVar6;
long lVar7;
int iVar8;
long lVar9;
llava_embd_batch local_e0 [176];
uVar5 = llama_get_model();
iVar3 = llama_model_n_embd(uVar5);
lVar6 = (long)param_3;
lVar7 = -lVar6;
lVar9 = 0;
iVar8 = 0;
do {
iVar1 = (int)param_2[1];
lVar7 = lVar7 + lVar6;
if (iVar1 <= lVar7) break;
iVar2 = iVar8 + iVar1;
if (param_3 <= iVar8 + iVar1) {
iVar2 = param_3;
}
llava_embd_batch::llava_embd_batch(local_e0,(float *)(*param_2 + lVar9),iVar2,*param_4,0);
/* try { // try from 0012d499 to 0012d4cc has its CatchHandler @ 0012d539 */
iVar4 = llama_decode(param_1);
if (iVar4 == 0) {
*param_4 = *param_4 + iVar2;
}
else {
fprintf(*(FILE **)PTR_stderr_00221f88,"%s : failed to eval\n","llava_eval_image_embed");
}
iVar8 = iVar8 - param_3;
lVar9 = lVar9 + iVar3 * lVar6 * 4;
llava_embd_batch::~llava_embd_batch(local_e0);
} while (iVar4 == 0);
return iVar1 <= lVar7;
}
|
|
1,920 | llava_eval_image_embed | monkey531[P]llama/examples/llava/llava.cpp | bool llava_eval_image_embed(llama_context * ctx_llama, const struct llava_image_embed * image_embed, int n_batch, int * n_past) {
int n_embd = llama_model_n_embd(llama_get_model(ctx_llama));
for (int i = 0; i < image_embed->n_image_pos; i += n_batch) {
int n_eval = image_embed->n_image_pos - i;
if (n_eval > n_batch) {
n_eval = n_batch;
}
float * embd = image_embed->embed+i*n_embd;
llava_embd_batch llava_batch = llava_embd_batch(embd, n_eval, *n_past, 0);
if (llama_decode(ctx_llama, llava_batch.batch)) {
LOG_ERR("%s : failed to eval\n", __func__);
return false;
}
*n_past += n_eval;
}
return true;
} | O3 | cpp | llava_eval_image_embed:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rcx, 0x48(%rsp)
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, 0x60(%rsp)
callq 0x1da70
movq %rax, %rdi
callq 0x1d2b0
movl 0x8(%r12), %r15d
testl %r15d, %r15d
jle 0x27e98
movslq %ebp, %rcx
cltq
movq %rcx, 0x58(%rsp)
imulq %rcx, %rax
shlq $0x2, %rax
movq %rax, 0x50(%rsp)
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r13d, %r13d
movl %ebp, 0x44(%rsp)
addl %ebx, %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movq %r12, %rbp
movq (%r12), %rsi
addq %r14, %rsi
movq 0x48(%rsp), %rax
movl (%rax), %ecx
leaq 0x68(%rsp), %rdi
movl %r15d, %edx
xorl %r8d, %r8d
callq 0x2810c
leaq 0xe0(%rsp), %rcx
movq 0x30(%rcx), %rax
movq %rax, 0x30(%rsp)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x60(%rsp), %rdi
callq 0x1e400
movl %eax, %r12d
testl %eax, %eax
sete 0x43(%rsp)
jne 0x27e8e
movq 0x48(%rsp), %rax
addl %r15d, (%rax)
movq 0xc8(%rsp), %rdi
testq %rdi, %rdi
je 0x27df9
movq 0xd8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x27e16
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x27e33
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x27e50
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x27e67
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x1dc50
testl %r12d, %r12d
jne 0x27e9d
addq 0x58(%rsp), %r13
movq %rbp, %r12
movslq 0x8(%rbp), %r15
addq 0x50(%rsp), %r14
movl 0x44(%rsp), %ebp
subl %ebp, %ebx
cmpq %r15, %r13
jl 0x27d65
jmp 0x27e9d
callq 0x1ebcf
jmp 0x27ddc
movb $0x1, 0x43(%rsp)
movb 0x43(%rsp), %al
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x28292
movq %rbx, %rdi
callq 0x1e660
| llava_eval_image_embed:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 118h
mov [rsp+148h+var_100], rcx
mov ebp, edx
mov r12, rsi
mov [rsp+148h+var_E8], rdi
call _llama_get_model
mov rdi, rax
call _llama_model_n_embd
mov r15d, [r12+8]
test r15d, r15d
jle loc_27E98
movsxd rcx, ebp
cdqe
mov [rsp+148h+var_F0], rcx
imul rax, rcx
shl rax, 2
mov [rsp+148h+var_F8], rax
xor ebx, ebx
xor r14d, r14d
xor r13d, r13d
mov [rsp+148h+var_104], ebp
loc_27D65:
add r15d, ebx
cmp r15d, ebp
cmovge r15d, ebp
mov rbp, r12
mov rsi, [r12]
add rsi, r14; float *
mov rax, [rsp+148h+var_100]
mov ecx, [rax]; int
lea rdi, [rsp+148h+var_E0]; this
mov edx, r15d; int
xor r8d, r8d; int
call _ZN16llava_embd_batchC2EPfiii; llava_embd_batch::llava_embd_batch(float *,int,int,int)
lea rcx, [rsp+148h+var_68]
mov rax, [rcx+30h]
mov [rsp+148h+var_118], rax
movups xmm0, xmmword ptr [rcx]
movups xmm1, xmmword ptr [rcx+10h]
movups xmm2, xmmword ptr [rcx+20h]
movups [rsp+148h+var_128], xmm2
movups [rsp+148h+var_138], xmm1
movups [rsp+148h+var_148], xmm0
mov rdi, [rsp+148h+var_E8]
call _llama_decode
mov r12d, eax
test eax, eax
setz [rsp+148h+var_105]
jnz loc_27E8E
mov rax, [rsp+148h+var_100]
add [rax], r15d
loc_27DDC:
mov rdi, [rsp+148h+var_80]; void *
test rdi, rdi
jz short loc_27DF9
mov rsi, [rsp+148h+var_70]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27DF9:
mov rdi, [rsp+148h+var_98]; void *
test rdi, rdi
jz short loc_27E16
mov rsi, [rsp+148h+var_88]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27E16:
mov rdi, [rsp+148h+var_B0]; void *
test rdi, rdi
jz short loc_27E33
mov rsi, [rsp+148h+var_A0]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27E33:
mov rdi, [rsp+148h+var_C8]; void *
test rdi, rdi
jz short loc_27E50
mov rsi, [rsp+148h+var_B8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27E50:
mov rdi, [rsp+148h+var_E0]; void *
test rdi, rdi
jz short loc_27E67
mov rsi, [rsp+148h+var_D0]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27E67:
test r12d, r12d
jnz short loc_27E9D
add r13, [rsp+148h+var_F0]
mov r12, rbp
movsxd r15, dword ptr [rbp+8]
add r14, [rsp+148h+var_F8]
mov ebp, [rsp+148h+var_104]
sub ebx, ebp
cmp r13, r15
jl loc_27D65
jmp short loc_27E9D
loc_27E8E:
call llava_eval_image_embed_cold_1
jmp loc_27DDC
loc_27E98:
mov [rsp+148h+var_105], 1
loc_27E9D:
mov al, [rsp+148h+var_105]
add rsp, 118h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_60]; this
call _ZN16llava_embd_batchD2Ev; llava_embd_batch::~llava_embd_batch()
mov rdi, rbx
call __Unwind_Resume
| char llava_eval_image_embed(long long a1, long long a2, int a3, int *a4)
{
_QWORD *v5; // r12
long long model; // rax
int v7; // eax
long long v8; // r15
int v9; // ebx
long long v10; // r14
long long v11; // r13
int v12; // r15d
_QWORD *v13; // rbp
float *v14; // rsi
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
int v19; // r12d
long long v21; // [rsp+0h] [rbp-148h]
bool v22; // [rsp+43h] [rbp-105h]
int v23; // [rsp+44h] [rbp-104h]
long long v25; // [rsp+50h] [rbp-F8h]
long long v26; // [rsp+58h] [rbp-F0h]
void *v27[3]; // [rsp+68h] [rbp-E0h] BYREF
void *v28; // [rsp+80h] [rbp-C8h]
long long v29; // [rsp+90h] [rbp-B8h]
void *v30; // [rsp+98h] [rbp-B0h]
long long v31; // [rsp+A8h] [rbp-A0h]
void *v32; // [rsp+B0h] [rbp-98h]
long long v33; // [rsp+C0h] [rbp-88h]
void *v34; // [rsp+C8h] [rbp-80h]
long long v35; // [rsp+D8h] [rbp-70h]
long long v36; // [rsp+E0h] [rbp-68h]
v5 = (_QWORD *)a2;
model = llama_get_model(a1);
v7 = llama_model_n_embd(model);
LODWORD(v8) = *(_DWORD *)(a2 + 8);
if ( (int)v8 <= 0 )
return 1;
v26 = a3;
v25 = 4 * a3 * (long long)v7;
v9 = 0;
v10 = 0LL;
v11 = 0LL;
v23 = a3;
do
{
v12 = v9 + v8;
if ( v12 >= a3 )
v12 = a3;
v13 = v5;
v14 = (float *)(v10 + *v5);
llava_embd_batch::llava_embd_batch((llava_embd_batch *)v27, v14, v12, *a4, 0);
v21 = v36;
v19 = llama_decode(a1);
v22 = v19 == 0;
if ( v19 )
llava_eval_image_embed_cold_1(a1, v14, v15, v16, v17, v18, v21);
else
*a4 += v12;
if ( v34 )
operator delete(v34, v35 - (_QWORD)v34);
if ( v32 )
operator delete(v32, v33 - (_QWORD)v32);
if ( v30 )
operator delete(v30, v31 - (_QWORD)v30);
if ( v28 )
operator delete(v28, v29 - (_QWORD)v28);
if ( v27[0] )
operator delete(v27[0], (char *)v27[2] - (char *)v27[0]);
if ( v19 )
break;
v11 += v26;
v5 = v13;
v8 = *((int *)v13 + 2);
v10 += v25;
a3 = v23;
v9 -= v23;
}
while ( v11 < v8 );
return v22;
}
| llava_eval_image_embed:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x118
MOV qword ptr [RSP + 0x48],RCX
MOV EBP,EDX
MOV R12,RSI
MOV qword ptr [RSP + 0x60],RDI
CALL 0x0011da70
MOV RDI,RAX
CALL 0x0011d2b0
MOV R15D,dword ptr [R12 + 0x8]
TEST R15D,R15D
JLE 0x00127e98
MOVSXD RCX,EBP
CDQE
MOV qword ptr [RSP + 0x58],RCX
IMUL RAX,RCX
SHL RAX,0x2
MOV qword ptr [RSP + 0x50],RAX
XOR EBX,EBX
XOR R14D,R14D
XOR R13D,R13D
MOV dword ptr [RSP + 0x44],EBP
LAB_00127d65:
ADD R15D,EBX
CMP R15D,EBP
CMOVGE R15D,EBP
MOV RBP,R12
MOV RSI,qword ptr [R12]
ADD RSI,R14
MOV RAX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RAX]
LEA RDI,[RSP + 0x68]
MOV EDX,R15D
XOR R8D,R8D
CALL 0x0012810c
LAB_00127d90:
LEA RCX,[RSP + 0xe0]
MOV RAX,qword ptr [RCX + 0x30]
MOV qword ptr [RSP + 0x30],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS XMM1,xmmword ptr [RCX + 0x10]
MOVUPS XMM2,xmmword ptr [RCX + 0x20]
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,qword ptr [RSP + 0x60]
CALL 0x0011e400
LAB_00127dc4:
MOV R12D,EAX
TEST EAX,EAX
SETZ byte ptr [RSP + 0x43]
JNZ 0x00127e8e
MOV RAX,qword ptr [RSP + 0x48]
ADD dword ptr [RAX],R15D
LAB_00127ddc:
MOV RDI,qword ptr [RSP + 0xc8]
TEST RDI,RDI
JZ 0x00127df9
MOV RSI,qword ptr [RSP + 0xd8]
SUB RSI,RDI
CALL 0x0011dc50
LAB_00127df9:
MOV RDI,qword ptr [RSP + 0xb0]
TEST RDI,RDI
JZ 0x00127e16
MOV RSI,qword ptr [RSP + 0xc0]
SUB RSI,RDI
CALL 0x0011dc50
LAB_00127e16:
MOV RDI,qword ptr [RSP + 0x98]
TEST RDI,RDI
JZ 0x00127e33
MOV RSI,qword ptr [RSP + 0xa8]
SUB RSI,RDI
CALL 0x0011dc50
LAB_00127e33:
MOV RDI,qword ptr [RSP + 0x80]
TEST RDI,RDI
JZ 0x00127e50
MOV RSI,qword ptr [RSP + 0x90]
SUB RSI,RDI
CALL 0x0011dc50
LAB_00127e50:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x00127e67
MOV RSI,qword ptr [RSP + 0x78]
SUB RSI,RDI
CALL 0x0011dc50
LAB_00127e67:
TEST R12D,R12D
JNZ 0x00127e9d
ADD R13,qword ptr [RSP + 0x58]
MOV R12,RBP
MOVSXD R15,dword ptr [RBP + 0x8]
ADD R14,qword ptr [RSP + 0x50]
MOV EBP,dword ptr [RSP + 0x44]
SUB EBX,EBP
CMP R13,R15
JL 0x00127d65
JMP 0x00127e9d
LAB_00127e8e:
CALL 0x0011ebcf
JMP 0x00127ddc
LAB_00127e98:
MOV byte ptr [RSP + 0x43],0x1
LAB_00127e9d:
MOV AL,byte ptr [RSP + 0x43]
ADD RSP,0x118
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool llava_eval_image_embed(int8 param_1,long *param_2,int param_3,int *param_4)
{
int iVar1;
int iVar2;
int8 uVar3;
int iVar4;
long lVar5;
long lVar6;
int iVar7;
ulong uVar8;
bool local_105;
void *local_e0 [2];
long local_d0;
void *local_c8;
long local_b8;
void *local_b0;
long local_a0;
void *local_98;
long local_88;
void *local_80;
long local_70;
uVar3 = llama_get_model();
iVar1 = llama_model_n_embd(uVar3);
uVar8 = (ulong)*(uint *)(param_2 + 1);
if ((int)*(uint *)(param_2 + 1) < 1) {
local_105 = true;
}
else {
iVar4 = 0;
lVar6 = 0;
lVar5 = 0;
do {
iVar7 = (int)uVar8 + iVar4;
if (param_3 <= iVar7) {
iVar7 = param_3;
}
llava_embd_batch::llava_embd_batch
((llava_embd_batch *)local_e0,(float *)(*param_2 + lVar6),iVar7,*param_4,0);
/* try { // try from 00127d90 to 00127dc3 has its CatchHandler @ 00127eb3 */
iVar2 = llama_decode(param_1);
local_105 = iVar2 == 0;
if (local_105) {
*param_4 = *param_4 + iVar7;
}
else {
llava_eval_image_embed_cold_1();
}
if (local_80 != (void *)0x0) {
operator_delete(local_80,local_70 - (long)local_80);
}
if (local_98 != (void *)0x0) {
operator_delete(local_98,local_88 - (long)local_98);
}
if (local_b0 != (void *)0x0) {
operator_delete(local_b0,local_a0 - (long)local_b0);
}
if (local_c8 != (void *)0x0) {
operator_delete(local_c8,local_b8 - (long)local_c8);
}
if (local_e0[0] != (void *)0x0) {
operator_delete(local_e0[0],local_d0 - (long)local_e0[0]);
}
if (iVar2 != 0) {
return local_105;
}
lVar5 = lVar5 + param_3;
uVar8 = (ulong)(int)param_2[1];
lVar6 = lVar6 + (long)iVar1 * (long)param_3 * 4;
iVar4 = iVar4 - param_3;
} while (lVar5 < (long)uVar8);
}
return local_105;
}
|
|
1,921 | wnlog_handler | qoraal-tictactoe/src/services/www/html/wnlog.c | int32_t
wnlog_handler (HTTP_USER_T *user, uint32_t method, char* endpoint)
{
QORAAL_LOG_IT_T * it = 0 ;
int32_t res = HTTP_SERVER_WSERVER_E_OK ;
int syslog = 1 ;
const char * name = "" ;
#if 0
if (strncmp(endpoint, "log/1", 5) == 0) {
it = syslog_platform_it_create (1) ;
name = "Debug" ;
}
else
#endif
if (strncmp(endpoint, "log/2", 5) == 0) {
it = mlog_platform_it_create (MLOG_DBG) ;
syslog = 0 ;
name = "Memory" ;
}
else if (strncmp(endpoint, "log/3", 5) == 0) {
it = mlog_platform_it_create (MLOG_ASSERT) ;
syslog = 0 ;
name = "Assert" ;
}
httpserver_chunked_append_fmtstr (user,
"<A style=\"width:110%\" class=\"button\" href=\"/log/0\" >System</A>\r\n"
"<A style=\"width:110%\" class=\"button\" href=\"/log/1\" >Assert</A>\r\n"
"<A style=\"width:110%\" class=\"button\" href=\"/log/2\" >Memory</A>\r\n"
);
if (it) {
res = wnlog_handler_get (user, method, endpoint, it, name) ;
//if (syslog) syslog_platform_it_destroy (it) ;
#if 1
mlog_platform_it_destroy (it) ;
#endif
}
return res ;
} | O0 | c | wnlog_handler:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x1, -0x28(%rbp)
leaq 0x1af63(%rip), %rax # 0x34f93
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1dfd6(%rip), %rsi # 0x38015
movl $0x5, %edx
callq 0x60a0
cmpl $0x0, %eax
jne 0x1a06d
xorl %edi, %edi
callq 0x25be0
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
leaq 0x1903e(%rip), %rax # 0x330a5
movq %rax, -0x30(%rbp)
jmp 0x1a0a9
movq -0x18(%rbp), %rdi
leaq 0x1dfa3(%rip), %rsi # 0x3801b
movl $0x5, %edx
callq 0x60a0
cmpl $0x0, %eax
jne 0x1a0a7
movl $0x1, %edi
callq 0x25be0
movq %rax, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
leaq 0x1df7e(%rip), %rax # 0x38021
movq %rax, -0x30(%rbp)
jmp 0x1a0a9
movq -0x8(%rbp), %rdi
leaq 0x1df74(%rip), %rsi # 0x38028
movb $0x0, %al
callq 0x2a850
cmpq $0x0, -0x20(%rbp)
je 0x1a0e6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x198c0
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25da0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| wnlog_handler:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], 0
mov [rbp+var_24], 0
mov [rbp+var_28], 1
lea rax, asc_34F8E+5; ""
mov [rbp+var_30], rax
mov rdi, [rbp+var_18]
lea rsi, aLog2; "log/2"
mov edx, 5
call _strncmp
cmp eax, 0
jnz short loc_1A06D
xor edi, edi
call mlog_platform_it_create
mov [rbp+var_20], rax
mov [rbp+var_28], 0
lea rax, aMemory; "Memory"
mov [rbp+var_30], rax
jmp short loc_1A0A9
loc_1A06D:
mov rdi, [rbp+var_18]
lea rsi, aLog3; "log/3"
mov edx, 5
call _strncmp
cmp eax, 0
jnz short loc_1A0A7
mov edi, 1
call mlog_platform_it_create
mov [rbp+var_20], rax
mov [rbp+var_28], 0
lea rax, aAssert; "Assert"
mov [rbp+var_30], rax
loc_1A0A7:
jmp short $+2
loc_1A0A9:
mov rdi, [rbp+var_8]
lea rsi, aAStyleWidth110; "<A style=\"width:110%\" class=\"button"...
mov al, 0
call httpserver_chunked_append_fmtstr
cmp [rbp+var_20], 0
jz short loc_1A0E6
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_30]
call wnlog_handler_get
mov [rbp+var_24], eax
mov rdi, [rbp+var_20]
call mlog_platform_it_destroy
loc_1A0E6:
mov eax, [rbp+var_24]
add rsp, 30h
pop rbp
retn
| long long wnlog_handler(long long a1, int a2, long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
char *v8; // [rsp+0h] [rbp-30h]
unsigned int v9; // [rsp+Ch] [rbp-24h]
long long v10; // [rsp+10h] [rbp-20h]
v10 = 0LL;
v9 = 0;
v8 = &asc_34F8E[5];
if ( !(unsigned int)strncmp(a3, aLog2, 5LL) )
{
v10 = mlog_platform_it_create(0LL);
v8 = aMemory;
}
else if ( !(unsigned int)strncmp(a3, aLog3, 5LL) )
{
v10 = mlog_platform_it_create(1LL);
v8 = aAssert;
}
httpserver_chunked_append_fmtstr(a1, (unsigned int)aAStyleWidth110, v3, v4, v5, v6);
if ( v10 )
{
v9 = wnlog_handler_get(a1, a2, a3, v10, (long long)v8);
mlog_platform_it_destroy(v10);
}
return v9;
}
| wnlog_handler:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x28],0x1
LEA RAX,[0x134f93]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x138015]
MOV EDX,0x5
CALL 0x001060a0
CMP EAX,0x0
JNZ 0x0011a06d
XOR EDI,EDI
CALL 0x00125be0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x28],0x0
LEA RAX,[0x1330a5]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0011a0a9
LAB_0011a06d:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x13801b]
MOV EDX,0x5
CALL 0x001060a0
CMP EAX,0x0
JNZ 0x0011a0a7
MOV EDI,0x1
CALL 0x00125be0
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x28],0x0
LEA RAX,[0x138021]
MOV qword ptr [RBP + -0x30],RAX
LAB_0011a0a7:
JMP 0x0011a0a9
LAB_0011a0a9:
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x138028]
MOV AL,0x0
CALL 0x0012a850
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0011a0e6
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x001198c0
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00125da0
LAB_0011a0e6:
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x30
POP RBP
RET
|
int4
wnlog_handler(int8 param_1,int4 param_2,char *param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int iVar1;
char *pcVar2;
int4 uVar3;
int4 local_2c;
long local_28;
local_28 = 0;
local_2c = 0;
uVar3 = 1;
pcVar2 = &DAT_00134f93;
iVar1 = strncmp(param_3,s_log_2_00138015,5);
if (iVar1 == 0) {
local_28 = mlog_platform_it_create(0);
uVar3 = 0;
pcVar2 = s_Memory_001330a5;
}
else {
iVar1 = strncmp(param_3,s_log_3_0013801b,5);
if (iVar1 == 0) {
local_28 = mlog_platform_it_create(1);
uVar3 = 0;
pcVar2 = s_Assert_00138021;
}
}
httpserver_chunked_append_fmtstr(param_1,s_<A_style__width:110___class__but_00138028);
if (local_28 != 0) {
local_2c = wnlog_handler_get(param_1,param_2,param_3,local_28,pcVar2,param_6,pcVar2,uVar3);
mlog_platform_it_destroy(local_28);
}
return local_2c;
}
|
|
1,922 | sp_get_polygon_mbr | eloqsql/storage/myisam/sp_key.c | static int sp_get_polygon_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_linear_rings;
uint n_points;
n_linear_rings = uint4korr((*wkb));
(*wkb) += 4;
for (; n_linear_rings > 0; --n_linear_rings)
{
n_points = uint4korr((*wkb));
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
}
return 0;
} | O0 | c | sp_get_polygon_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x2c(%rbp)
jbe 0xd66fe
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x30(%rbp)
jbe 0xd66f1
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x1d(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0xd6710
cmpl $0x0, %eax
je 0xd66e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd6705
jmp 0xd66e6
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xd66b6
jmp 0xd66f3
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd6696
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| sp_get_polygon_mbr_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, cl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_1D], al
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_D6696:
cmp [rbp+var_2C], 0
jbe short loc_D66FE
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_30], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_D66B6:
cmp [rbp+var_30], 0
jbe short loc_D66F1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_1D]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_add_point_to_mbr_0
cmp eax, 0
jz short loc_D66E4
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_D6705
loc_D66E4:
jmp short $+2
loc_D66E6:
mov eax, [rbp+var_30]
add eax, 0FFFFFFFFh
mov [rbp+var_30], eax
jmp short loc_D66B6
loc_D66F1:
jmp short $+2
loc_D66F3:
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
jmp short loc_D6696
loc_D66FE:
mov [rbp+var_4], 0
loc_D6705:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long sp_get_polygon_mbr_0(_DWORD **a1, long long a2, unsigned int a3, unsigned __int8 a4, long long a5)
{
int j; // [rsp+0h] [rbp-30h]
int i; // [rsp+4h] [rbp-2Ch]
for ( i = *(*a1)++; i; --i )
{
for ( j = *(*a1)++; j; --j )
{
if ( (unsigned int)sp_add_point_to_mbr_0(a1, a2, a3, a4, a5) )
return (unsigned int)-1;
}
}
return 0;
}
| sp_get_polygon_mbr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,CL
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV byte ptr [RBP + -0x1d],AL
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_001d6696:
CMP dword ptr [RBP + -0x2c],0x0
JBE 0x001d66fe
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x30],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_001d66b6:
CMP dword ptr [RBP + -0x30],0x0
JBE 0x001d66f1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x1d]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x001d6710
CMP EAX,0x0
JZ 0x001d66e4
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001d6705
LAB_001d66e4:
JMP 0x001d66e6
LAB_001d66e6:
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001d66b6
LAB_001d66f1:
JMP 0x001d66f3
LAB_001d66f3:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001d6696
LAB_001d66fe:
MOV dword ptr [RBP + -0x4],0x0
LAB_001d6705:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4
sp_get_polygon_mbr(long *param_1,int8 param_2,int4 param_3,int1 param_4,
int8 param_5)
{
int iVar1;
int local_38;
int local_34;
local_34 = *(int *)*param_1;
*param_1 = *param_1 + 4;
do {
if (local_34 == 0) {
return 0;
}
local_38 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_38 != 0; local_38 = local_38 + -1) {
iVar1 = sp_add_point_to_mbr(param_1,param_2,param_3,param_4,param_5);
if (iVar1 != 0) {
return 0xffffffff;
}
}
local_34 = local_34 + -1;
} while( true );
}
|
|
1,923 | minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op) | monkey531[P]llama/common/minja.hpp | Expression(const Location & location) : location(location) {} | O1 | cpp | minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op):
leaq 0xa75c3(%rip), %rax # 0x13b3a8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x93e16
movq 0xa9179(%rip), %r8 # 0x13cf80
cmpb $0x0, (%r8)
je 0x93e12
incl 0x8(%rax)
jmp 0x93e16
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0xa7533(%rip), %rax # 0x13b358
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movups (%rdx), %xmm0
movq %rax, 0x8(%rdx)
movups %xmm0, 0x20(%rdi)
movq %rax, (%rdx)
movl %ecx, 0x30(%rdi)
retq
| _ZN5minja11UnaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEENS0_2OpE:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_93E16
mov r8, cs:__libc_single_threaded_ptr
cmp byte ptr [r8], 0
jz short loc_93E12
inc dword ptr [rax+8]
jmp short loc_93E16
loc_93E12:
lock inc dword ptr [rax+8]
loc_93E16:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja11UnaryOpExprE; `vtable for'minja::UnaryOpExpr
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+28h], rax
movups xmm0, xmmword ptr [rdx]
mov [rdx+8], rax
movups xmmword ptr [rdi+20h], xmm0
mov [rdx], rax
mov [rdi+30h], ecx
retn
| long long minja::UnaryOpExpr::UnaryOpExpr(long long a1, _QWORD *a2, __int128 *a3, int a4)
{
long long v4; // rax
long long result; // rax
__int128 v6; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::Expression + 2;
*(_QWORD *)(a1 + 8) = *a2;
v4 = a2[1];
*(_QWORD *)(a1 + 16) = v4;
if ( v4 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v4 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v4 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::UnaryOpExpr + 2;
result = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v6;
*(_QWORD *)a3 = 0LL;
*(_DWORD *)(a1 + 48) = a4;
return result;
}
| UnaryOpExpr:
LEA RAX,[0x23b3a8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x00193e16
MOV R8,qword ptr [0x0023cf80]
CMP byte ptr [R8],0x0
JZ 0x00193e12
INC dword ptr [RAX + 0x8]
JMP 0x00193e16
LAB_00193e12:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00193e16:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x23b358]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOV qword ptr [RDX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV qword ptr [RDX],RAX
MOV dword ptr [RDI + 0x30],ECX
RET
|
/* minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
minja::UnaryOpExpr::Op) */
void __thiscall
minja::UnaryOpExpr::UnaryOpExpr
(UnaryOpExpr *this,int8 *param_1,int8 *param_2,int4 param_4)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_0023b3b8;
*(int8 *)(this + 8) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0023cf80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = param_1[2];
*(int ***)this = &PTR_do_evaluate_0023b368;
*(int8 *)(this + 0x28) = 0;
uVar2 = param_2[1];
param_2[1] = 0;
*(int8 *)(this + 0x20) = *param_2;
*(int8 *)(this + 0x28) = uVar2;
*param_2 = 0;
*(int4 *)(this + 0x30) = param_4;
return;
}
|
|
1,924 | minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op) | monkey531[P]llama/common/minja.hpp | Expression(const Location & location) : location(location) {} | O3 | cpp | minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op):
leaq 0x9bf3b(%rip), %rax # 0x1393a8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x9d49e
movq 0x9daf1(%rip), %r8 # 0x13af80
cmpb $0x0, (%r8)
je 0x9d49a
incl 0x8(%rax)
jmp 0x9d49e
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x9c2bb(%rip), %rax # 0x139768
addq $0x10, %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movups (%rdx), %xmm0
movq %rax, 0x8(%rdx)
movups %xmm0, 0x20(%rdi)
movq %rax, (%rdx)
movq %rax, 0x38(%rdi)
movups (%rcx), %xmm0
movq %rax, 0x8(%rcx)
movups %xmm0, 0x30(%rdi)
movq %rax, (%rcx)
retq
nop
| _ZN5minja13SubscriptExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEES7_:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_9D49E
mov r8, cs:__libc_single_threaded_ptr
cmp byte ptr [r8], 0
jz short loc_9D49A
inc dword ptr [rax+8]
jmp short loc_9D49E
loc_9D49A:
lock inc dword ptr [rax+8]
loc_9D49E:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, _ZTVN5minja13SubscriptExprE; `vtable for'minja::SubscriptExpr
add rax, 10h
mov [rdi], rax
xor eax, eax
mov [rdi+28h], rax
movups xmm0, xmmword ptr [rdx]
mov [rdx+8], rax
movups xmmword ptr [rdi+20h], xmm0
mov [rdx], rax
mov [rdi+38h], rax
movups xmm0, xmmword ptr [rcx]
mov [rcx+8], rax
movups xmmword ptr [rdi+30h], xmm0
mov [rcx], rax
retn
| long long minja::SubscriptExpr::SubscriptExpr(long long a1, _QWORD *a2, __int128 *a3, __int128 *a4)
{
long long v4; // rax
long long result; // rax
__int128 v6; // xmm0
__int128 v7; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::Expression + 2;
*(_QWORD *)(a1 + 8) = *a2;
v4 = a2[1];
*(_QWORD *)(a1 + 16) = v4;
if ( v4 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v4 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v4 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::SubscriptExpr + 2;
result = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v6;
*(_QWORD *)a3 = 0LL;
*(_QWORD *)(a1 + 56) = 0LL;
v7 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v7;
*(_QWORD *)a4 = 0LL;
return result;
}
| SubscriptExpr:
LEA RAX,[0x2393a8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0019d49e
MOV R8,qword ptr [0x0023af80]
CMP byte ptr [R8],0x0
JZ 0x0019d49a
INC dword ptr [RAX + 0x8]
JMP 0x0019d49e
LAB_0019d49a:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019d49e:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x239768]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOV qword ptr [RDX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV qword ptr [RDX],RAX
MOV qword ptr [RDI + 0x38],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOV qword ptr [RCX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [RCX],RAX
RET
|
/* minja::SubscriptExpr::SubscriptExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::SubscriptExpr::SubscriptExpr
(SubscriptExpr *this,Location *param_1,shared_ptr *param_2,shared_ptr *param_3)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_002393b8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0023af80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_evaluate_00239778;
*(int8 *)(this + 0x28) = 0;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)param_2 = 0;
*(int8 *)(this + 0x38) = 0;
uVar2 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar2;
*(int8 *)param_3 = 0;
return;
}
|
|
1,925 | JS_ExecutePendingJob | bluesky950520[P]quickjs/quickjs.c | int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
{
JSContext *ctx;
JSJobEntry *e;
JSValue res;
int i, ret;
if (list_empty(&rt->job_list)) {
*pctx = NULL;
return 0;
}
/* get the first pending job and execute it */
e = list_entry(rt->job_list.next, JSJobEntry, link);
list_del(&e->link);
ctx = e->ctx;
res = e->job_func(e->ctx, e->argc, e->argv);
for(i = 0; i < e->argc; i++)
JS_FreeValue(ctx, e->argv[i]);
if (JS_IsException(res))
ret = -1;
else
ret = 1;
JS_FreeValue(ctx, res);
js_free(ctx, e);
*pctx = ctx;
return ret;
} | O0 | c | JS_ExecutePendingJob:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
addq $0x130, %rdi # imm = 0x130
callq 0x23ab0
cmpl $0x0, %eax
je 0x23b0d
movq 0x40(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x54(%rsp)
jmp 0x23c20
movq 0x48(%rsp), %rax
movq 0x138(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x23c30
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rdi
movq 0x30(%rsp), %rcx
movl 0x20(%rcx), %esi
movq 0x30(%rsp), %rdx
addq $0x28, %rdx
callq *%rax
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x23bc2
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
addq $0x28, %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x23c90
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x23b81
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x23be0
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
jmp 0x23be8
movl $0x1, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x23c90
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x21db0
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movl 0x18(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
| JS_ExecutePendingJob:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov rdi, [rsp+58h+var_10]
add rdi, 130h
call list_empty_0
cmp eax, 0
jz short loc_23B0D
mov rax, [rsp+58h+var_18]
mov qword ptr [rax], 0
mov [rsp+58h+var_4], 0
jmp loc_23C20
loc_23B0D:
mov rax, [rsp+58h+var_10]
mov rax, [rax+138h]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_28]
call list_del_0
mov rax, [rsp+58h+var_28]
mov rax, [rax+10h]
mov [rsp+58h+var_20], rax
mov rax, [rsp+58h+var_28]
mov rax, [rax+18h]
mov rcx, [rsp+58h+var_28]
mov rdi, [rcx+10h]
mov rcx, [rsp+58h+var_28]
mov esi, [rcx+20h]
mov rdx, [rsp+58h+var_28]
add rdx, 28h ; '('
call rax
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
mov rax, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_30], rax
mov [rsp+58h+var_3C], 0
loc_23B81:
mov eax, [rsp+58h+var_3C]
mov rcx, [rsp+58h+var_28]
cmp eax, [rcx+20h]
jge short loc_23BC2
mov rdi, [rsp+58h+var_20]
mov rax, [rsp+58h+var_28]
add rax, 28h ; '('
movsxd rcx, [rsp+58h+var_3C]
shl rcx, 4
add rax, rcx
mov rsi, [rax]
mov rdx, [rax+8]
call JS_FreeValue
mov eax, [rsp+58h+var_3C]
add eax, 1
mov [rsp+58h+var_3C], eax
jmp short loc_23B81
loc_23BC2:
mov rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_23BE0
mov [rsp+58h+var_40], 0FFFFFFFFh
jmp short loc_23BE8
loc_23BE0:
mov [rsp+58h+var_40], 1
loc_23BE8:
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
call JS_FreeValue
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
call js_free
mov rcx, [rsp+58h+var_20]
mov rax, [rsp+58h+var_18]
mov [rax], rcx
mov eax, [rsp+58h+var_40]
mov [rsp+58h+var_4], eax
loc_23C20:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long JS_ExecutePendingJob(long long a1, long long *a2)
{
long long v2; // rdx
long long v4; // [rsp+8h] [rbp-50h]
unsigned int v5; // [rsp+18h] [rbp-40h]
int i; // [rsp+1Ch] [rbp-3Ch]
long long v7; // [rsp+28h] [rbp-30h]
long long v8; // [rsp+30h] [rbp-28h]
long long v9; // [rsp+38h] [rbp-20h]
if ( list_empty_0(a1 + 304) )
{
*a2 = 0LL;
return 0;
}
else
{
v8 = *(_QWORD *)(a1 + 312);
list_del_0(v8);
v9 = *(_QWORD *)(v8 + 16);
v4 = (*(long long ( **)(long long, _QWORD, long long))(v8 + 24))(v9, *(unsigned int *)(v8 + 32), v8 + 40);
v7 = v2;
for ( i = 0; i < *(_DWORD *)(v8 + 32); ++i )
JS_FreeValue(v9, *(_QWORD *)(16LL * i + v8 + 40), *(_QWORD *)(16LL * i + v8 + 40 + 8));
if ( (unsigned int)JS_IsException_1(v4, v7) )
v5 = -1;
else
v5 = 1;
JS_FreeValue(v9, v4, v7);
js_free(v9, v8);
*a2 = v9;
return v5;
}
}
| JS_ExecutePendingJob:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV RDI,qword ptr [RSP + 0x48]
ADD RDI,0x130
CALL 0x00123ab0
CMP EAX,0x0
JZ 0x00123b0d
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],0x0
MOV dword ptr [RSP + 0x54],0x0
JMP 0x00123c20
LAB_00123b0d:
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x138]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x00123c30
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RCX + 0x10]
MOV RCX,qword ptr [RSP + 0x30]
MOV ESI,dword ptr [RCX + 0x20]
MOV RDX,qword ptr [RSP + 0x30]
ADD RDX,0x28
CALL RAX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV dword ptr [RSP + 0x1c],0x0
LAB_00123b81:
MOV EAX,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x30]
CMP EAX,dword ptr [RCX + 0x20]
JGE 0x00123bc2
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,0x28
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00123c90
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x00123b81
LAB_00123bc2:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00123be0
MOV dword ptr [RSP + 0x18],0xffffffff
JMP 0x00123be8
LAB_00123be0:
MOV dword ptr [RSP + 0x18],0x1
LAB_00123be8:
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x00121db0
MOV RCX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RSP + 0x18]
MOV dword ptr [RSP + 0x54],EAX
LAB_00123c20:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 JS_ExecutePendingJob(long param_1,int8 *param_2)
{
long lVar1;
int8 uVar2;
int iVar3;
int8 *puVar4;
int1 auVar5 [16];
int4 local_40;
int local_3c;
int4 local_4;
iVar3 = list_empty(param_1 + 0x130);
if (iVar3 == 0) {
lVar1 = *(long *)(param_1 + 0x138);
list_del(lVar1);
uVar2 = *(int8 *)(lVar1 + 0x10);
auVar5 = (**(code **)(lVar1 + 0x18))
(*(int8 *)(lVar1 + 0x10),*(int4 *)(lVar1 + 0x20),lVar1 + 0x28);
for (local_3c = 0; local_3c < *(int *)(lVar1 + 0x20); local_3c = local_3c + 1) {
puVar4 = (int8 *)(lVar1 + 0x28 + (long)local_3c * 0x10);
JS_FreeValue(uVar2,*puVar4,puVar4[1]);
}
iVar3 = JS_IsException(auVar5._0_8_,auVar5._8_8_);
if (iVar3 == 0) {
local_40 = 1;
}
else {
local_40 = 0xffffffff;
}
JS_FreeValue(uVar2,auVar5._0_8_,auVar5._8_8_);
js_free(uVar2,lVar1);
*param_2 = uVar2;
local_4 = local_40;
}
else {
*param_2 = 0;
local_4 = 0;
}
return local_4;
}
|
|
1,926 | JS_ExecutePendingJob | bluesky950520[P]quickjs/quickjs.c | int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
{
JSContext *ctx;
JSJobEntry *e;
JSValue res;
int i, ret;
if (list_empty(&rt->job_list)) {
*pctx = NULL;
return 0;
}
/* get the first pending job and execute it */
e = list_entry(rt->job_list.next, JSJobEntry, link);
list_del(&e->link);
ctx = e->ctx;
res = e->job_func(e->ctx, e->argc, e->argv);
for(i = 0; i < e->argc; i++)
JS_FreeValue(ctx, e->argv[i]);
if (JS_IsException(res))
ret = -1;
else
ret = 1;
JS_FreeValue(ctx, res);
js_free(ctx, e);
*pctx = ctx;
return ret;
} | O1 | c | JS_ExecutePendingJob:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x130(%rdi), %rax
cmpq %rax, 0x138(%rdi)
je 0x1d89a
movq 0x138(%rdi), %r15
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x10(%r15), %r14
movl 0x20(%r15), %esi
leaq 0x28(%r15), %rdx
movq %r14, %rdi
callq *0x18(%r15)
movq %rax, (%rsp)
movq %rdx, %r13
cmpl $0x0, 0x20(%r15)
jle 0x1d86d
leaq 0x30(%r15), %rbp
xorl %r12d, %r12d
movq -0x8(%rbp), %rsi
movq (%rbp), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
incq %r12
movslq 0x20(%r15), %rax
addq $0x10, %rbp
cmpq %rax, %r12
jl 0x1d84c
xorl %eax, %eax
cmpl $0x6, %r13d
setne %al
leal -0x1(,%rax,2), %ebp
movq 0x18(%r14), %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x1d8c6
movq %r14, %rdi
movq %r15, %rsi
callq 0x1cb99
jmp 0x1d89f
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r14, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_ExecutePendingJob:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
lea rax, [rdi+130h]
cmp [rdi+138h], rax
jz loc_1D89A
mov r15, [rdi+138h]
mov rax, [r15]
mov rcx, [r15+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r15], xmm0
mov r14, [r15+10h]
mov esi, [r15+20h]
lea rdx, [r15+28h]
mov rdi, r14
call qword ptr [r15+18h]
mov [rsp+38h+var_38], rax
mov r13, rdx
cmp dword ptr [r15+20h], 0
jle short loc_1D86D
lea rbp, [r15+30h]
xor r12d, r12d
loc_1D84C:
mov rsi, [rbp-8]
mov rdx, [rbp+0]
mov rdi, [r14+18h]
call JS_FreeValueRT
inc r12
movsxd rax, dword ptr [r15+20h]
add rbp, 10h
cmp r12, rax
jl short loc_1D84C
loc_1D86D:
xor eax, eax
cmp r13d, 6
setnz al
lea ebp, ds:0FFFFFFFFFFFFFFFFh[rax*2]
mov rdi, [r14+18h]
mov rsi, [rsp+38h+var_38]
mov rdx, r13
call JS_FreeValueRT
mov rdi, r14
mov rsi, r15
call js_free
jmp short loc_1D89F
loc_1D89A:
xor r14d, r14d
xor ebp, ebp
loc_1D89F:
mov [rbx], r14
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_ExecutePendingJob(long long a1, long long *a2)
{
long long v2; // r15
long long v3; // rax
_QWORD *v4; // rcx
long long v5; // r14
int v6; // edx
int v7; // r13d
long long v8; // rbp
long long v9; // r12
unsigned int v10; // ebp
long long v12; // [rsp+0h] [rbp-38h]
if ( *(_QWORD *)(a1 + 312) == a1 + 304 )
{
v5 = 0LL;
v10 = 0;
}
else
{
v2 = *(_QWORD *)(a1 + 312);
v3 = *(_QWORD *)v2;
v4 = *(_QWORD **)(v2 + 8);
*(_QWORD *)(v3 + 8) = v4;
*v4 = v3;
*(_OWORD *)v2 = 0LL;
v5 = *(_QWORD *)(v2 + 16);
v12 = (*(long long ( **)(long long, _QWORD, long long))(v2 + 24))(v5, *(unsigned int *)(v2 + 32), v2 + 40);
v7 = v6;
if ( *(int *)(v2 + 32) > 0 )
{
v8 = v2 + 48;
v9 = 0LL;
do
{
JS_FreeValueRT(*(_QWORD *)(v5 + 24), *(_QWORD *)(v8 - 8));
++v9;
v8 += 16LL;
}
while ( v9 < *(int *)(v2 + 32) );
}
v10 = 2 * (v7 != 6) - 1;
JS_FreeValueRT(*(_QWORD *)(v5 + 24), v12);
js_free(v5, v2);
}
*a2 = v5;
return v10;
}
| JS_ExecutePendingJob:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
LEA RAX,[RDI + 0x130]
CMP qword ptr [RDI + 0x138],RAX
JZ 0x0011d89a
MOV R15,qword ptr [RDI + 0x138]
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15],XMM0
MOV R14,qword ptr [R15 + 0x10]
MOV ESI,dword ptr [R15 + 0x20]
LEA RDX,[R15 + 0x28]
MOV RDI,R14
CALL qword ptr [R15 + 0x18]
MOV qword ptr [RSP],RAX
MOV R13,RDX
CMP dword ptr [R15 + 0x20],0x0
JLE 0x0011d86d
LEA RBP,[R15 + 0x30]
XOR R12D,R12D
LAB_0011d84c:
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP]
MOV RDI,qword ptr [R14 + 0x18]
CALL 0x0011d8c6
INC R12
MOVSXD RAX,dword ptr [R15 + 0x20]
ADD RBP,0x10
CMP R12,RAX
JL 0x0011d84c
LAB_0011d86d:
XOR EAX,EAX
CMP R13D,0x6
SETNZ AL
LEA EBP,[-0x1 + RAX*0x2]
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP]
MOV RDX,R13
CALL 0x0011d8c6
MOV RDI,R14
MOV RSI,R15
CALL 0x0011cb99
JMP 0x0011d89f
LAB_0011d89a:
XOR R14D,R14D
XOR EBP,EBP
LAB_0011d89f:
MOV qword ptr [RBX],R14
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int JS_ExecutePendingJob(long param_1,long *param_2)
{
long *plVar1;
int iVar2;
long *plVar3;
long lVar4;
long lVar5;
int1 auVar6 [16];
if (*(long *)(param_1 + 0x138) == param_1 + 0x130) {
lVar5 = 0;
iVar2 = 0;
}
else {
plVar1 = *(long **)(param_1 + 0x138);
lVar5 = *plVar1;
plVar3 = (long *)plVar1[1];
*(long **)(lVar5 + 8) = plVar3;
*plVar3 = lVar5;
*plVar1 = 0;
plVar1[1] = 0;
lVar5 = plVar1[2];
auVar6 = (*(code *)plVar1[3])(lVar5,(int)plVar1[4],plVar1 + 5);
if (0 < (int)plVar1[4]) {
plVar3 = plVar1 + 6;
lVar4 = 0;
do {
JS_FreeValueRT(*(int8 *)(lVar5 + 0x18),plVar3[-1],*plVar3);
lVar4 = lVar4 + 1;
plVar3 = plVar3 + 2;
} while (lVar4 < (int)plVar1[4]);
}
iVar2 = (uint)(auVar6._8_4_ != 6) * 2 + -1;
JS_FreeValueRT(*(int8 *)(lVar5 + 0x18),auVar6._0_8_,auVar6._8_8_);
js_free(lVar5,plVar1);
}
*param_2 = lVar5;
return iVar2;
}
|
|
1,927 | JS_ExecutePendingJob | bluesky950520[P]quickjs/quickjs.c | int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
{
JSContext *ctx;
JSJobEntry *e;
JSValue res;
int i, ret;
if (list_empty(&rt->job_list)) {
*pctx = NULL;
return 0;
}
/* get the first pending job and execute it */
e = list_entry(rt->job_list.next, JSJobEntry, link);
list_del(&e->link);
ctx = e->ctx;
res = e->job_func(e->ctx, e->argc, e->argv);
for(i = 0; i < e->argc; i++)
JS_FreeValue(ctx, e->argv[i]);
if (JS_IsException(res))
ret = -1;
else
ret = 1;
JS_FreeValue(ctx, res);
js_free(ctx, e);
*pctx = ctx;
return ret;
} | O2 | c | JS_ExecutePendingJob:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x138(%rdi), %r15
addq $0x130, %rdi # imm = 0x130
cmpq %rdi, %r15
je 0x18005
movq %rsi, (%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x10(%r15), %r14
movl 0x20(%r15), %esi
leaq 0x28(%r15), %rdx
movq %r14, %rdi
callq *0x18(%r15)
movq %rax, %r13
movq %rdx, %r12
leaq 0x30(%r15), %rbp
xorl %ebx, %ebx
movslq 0x20(%r15), %rax
cmpq %rax, %rbx
jge 0x17fd6
movq -0x8(%rbp), %rsi
movq (%rbp), %rdx
movq %r14, %rdi
callq 0x1801e
incq %rbx
addq $0x10, %rbp
jmp 0x17fb4
xorl %eax, %eax
cmpl $0x6, %r12d
setne %al
leal -0x1(,%rax,2), %ebp
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1801e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1726e
movq (%rsp), %rsi
jmp 0x1800a
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r14, (%rsi)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_ExecutePendingJob:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, [rdi+138h]
add rdi, 130h
cmp r15, rdi
jz loc_18005
mov [rsp+38h+var_38], rsi
mov rax, [r15]
mov rcx, [r15+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r15], xmm0
mov r14, [r15+10h]
mov esi, [r15+20h]
lea rdx, [r15+28h]
mov rdi, r14
call qword ptr [r15+18h]
mov r13, rax
mov r12, rdx
lea rbp, [r15+30h]
xor ebx, ebx
loc_17FB4:
movsxd rax, dword ptr [r15+20h]
cmp rbx, rax
jge short loc_17FD6
mov rsi, [rbp-8]
mov rdx, [rbp+0]
mov rdi, r14
call JS_FreeValue
inc rbx
add rbp, 10h
jmp short loc_17FB4
loc_17FD6:
xor eax, eax
cmp r12d, 6
setnz al
lea ebp, ds:0FFFFFFFFFFFFFFFFh[rax*2]
mov rdi, r14
mov rsi, r13
mov rdx, r12
call JS_FreeValue
mov rdi, r14
mov rsi, r15
call js_free
mov rsi, [rsp+38h+var_38]
jmp short loc_1800A
loc_18005:
xor r14d, r14d
xor ebp, ebp
loc_1800A:
mov [rsi], r14
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_ExecutePendingJob(long long a1, long long *a2)
{
long long v2; // r15
long long v3; // rax
_QWORD *v4; // rcx
long long v5; // r14
long long v6; // r13
long long v7; // rdx
long long v8; // r12
_QWORD *v9; // rbp
long long i; // rbx
unsigned int v11; // ebp
v2 = *(_QWORD *)(a1 + 312);
if ( v2 == a1 + 304 )
{
v5 = 0LL;
v11 = 0;
}
else
{
v3 = *(_QWORD *)v2;
v4 = *(_QWORD **)(v2 + 8);
*(_QWORD *)(v3 + 8) = v4;
*v4 = v3;
*(_OWORD *)v2 = 0LL;
v5 = *(_QWORD *)(v2 + 16);
v6 = (*(long long ( **)(long long, _QWORD, long long))(v2 + 24))(v5, *(unsigned int *)(v2 + 32), v2 + 40);
v8 = v7;
v9 = (_QWORD *)(v2 + 48);
for ( i = 0LL; i < *(int *)(v2 + 32); ++i )
{
JS_FreeValue(v5, *(v9 - 1), *v9);
v9 += 2;
}
v11 = 2 * ((_DWORD)v8 != 6) - 1;
JS_FreeValue(v5, v6, v8);
js_free(v5, v2);
}
*a2 = v5;
return v11;
}
| JS_ExecutePendingJob:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,qword ptr [RDI + 0x138]
ADD RDI,0x130
CMP R15,RDI
JZ 0x00118005
MOV qword ptr [RSP],RSI
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15],XMM0
MOV R14,qword ptr [R15 + 0x10]
MOV ESI,dword ptr [R15 + 0x20]
LEA RDX,[R15 + 0x28]
MOV RDI,R14
CALL qword ptr [R15 + 0x18]
MOV R13,RAX
MOV R12,RDX
LEA RBP,[R15 + 0x30]
XOR EBX,EBX
LAB_00117fb4:
MOVSXD RAX,dword ptr [R15 + 0x20]
CMP RBX,RAX
JGE 0x00117fd6
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP]
MOV RDI,R14
CALL 0x0011801e
INC RBX
ADD RBP,0x10
JMP 0x00117fb4
LAB_00117fd6:
XOR EAX,EAX
CMP R12D,0x6
SETNZ AL
LEA EBP,[-0x1 + RAX*0x2]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R12
CALL 0x0011801e
MOV RDI,R14
MOV RSI,R15
CALL 0x0011726e
MOV RSI,qword ptr [RSP]
JMP 0x0011800a
LAB_00118005:
XOR R14D,R14D
XOR EBP,EBP
LAB_0011800a:
MOV qword ptr [RSI],R14
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int JS_ExecutePendingJob(long param_1,long *param_2)
{
long *plVar1;
long lVar2;
int iVar3;
long *plVar4;
long lVar5;
int1 auVar6 [16];
plVar1 = *(long **)(param_1 + 0x138);
if (plVar1 == (long *)(param_1 + 0x130)) {
lVar5 = 0;
iVar3 = 0;
}
else {
lVar5 = *plVar1;
plVar4 = (long *)plVar1[1];
*(long **)(lVar5 + 8) = plVar4;
*plVar4 = lVar5;
*plVar1 = 0;
plVar1[1] = 0;
lVar5 = plVar1[2];
auVar6 = (*(code *)plVar1[3])(lVar5,(int)plVar1[4],plVar1 + 5);
plVar4 = plVar1 + 6;
for (lVar2 = 0; lVar2 < (int)plVar1[4]; lVar2 = lVar2 + 1) {
JS_FreeValue(lVar5,plVar4[-1],*plVar4);
plVar4 = plVar4 + 2;
}
iVar3 = (uint)(auVar6._8_4_ != 6) * 2 + -1;
JS_FreeValue(lVar5,auVar6._0_8_,auVar6._8_8_);
js_free(lVar5,plVar1);
}
*param_2 = lVar5;
return iVar3;
}
|
|
1,928 | JS_ExecutePendingJob | bluesky950520[P]quickjs/quickjs.c | int JS_ExecutePendingJob(JSRuntime *rt, JSContext **pctx)
{
JSContext *ctx;
JSJobEntry *e;
JSValue res;
int i, ret;
if (list_empty(&rt->job_list)) {
*pctx = NULL;
return 0;
}
/* get the first pending job and execute it */
e = list_entry(rt->job_list.next, JSJobEntry, link);
list_del(&e->link);
ctx = e->ctx;
res = e->job_func(e->ctx, e->argc, e->argv);
for(i = 0; i < e->argc; i++)
JS_FreeValue(ctx, e->argv[i]);
if (JS_IsException(res))
ret = -1;
else
ret = 1;
JS_FreeValue(ctx, res);
js_free(ctx, e);
*pctx = ctx;
return ret;
} | O3 | c | JS_ExecutePendingJob:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x138(%rdi), %r15
addq $0x130, %rdi # imm = 0x130
cmpq %rdi, %r15
je 0x1e1bc
movq %rsi, (%rsp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x10(%r15), %r14
movl 0x20(%r15), %esi
leaq 0x28(%r15), %rdx
movq %r14, %rdi
callq *0x18(%r15)
movq %rax, %r12
movq %rdx, %r13
cmpl $0x0, 0x20(%r15)
jle 0x1e176
leaq 0x30(%r15), %rbp
xorl %ebx, %ebx
movq (%rbp), %rdx
cmpl $-0x9, %edx
jb 0x1e166
movq -0x8(%rbp), %rsi
movq 0x18(%r14), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x1e166
callq 0x219cc
incq %rbx
movslq 0x20(%r15), %rax
addq $0x10, %rbp
cmpq %rax, %rbx
jl 0x1e144
xorl %ebx, %ebx
cmpl $0x6, %r13d
setne %bl
cmpl $-0x9, %r13d
jb 0x1e1a4
movq 0x18(%r14), %rdi
movl (%r12), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r12)
cmpl $0x1, %eax
jg 0x1e1a4
movq %r12, %rsi
movq %r13, %rdx
callq 0x219cc
leal -0x1(,%rbx,2), %ebp
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d481
movq (%rsp), %rsi
jmp 0x1e1c1
xorl %r14d, %r14d
xorl %ebp, %ebp
movq %r14, (%rsi)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| JS_ExecutePendingJob:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, [rdi+138h]
add rdi, 130h
cmp r15, rdi
jz loc_1E1BC
mov [rsp+38h+var_38], rsi
mov rax, [r15]
mov rcx, [r15+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r15], xmm0
mov r14, [r15+10h]
mov esi, [r15+20h]
lea rdx, [r15+28h]
mov rdi, r14
call qword ptr [r15+18h]
mov r12, rax
mov r13, rdx
cmp dword ptr [r15+20h], 0
jle short loc_1E176
lea rbp, [r15+30h]
xor ebx, ebx
loc_1E144:
mov rdx, [rbp+0]
cmp edx, 0FFFFFFF7h
jb short loc_1E166
mov rsi, [rbp-8]
mov rdi, [r14+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_1E166
call js_free_value_rt
loc_1E166:
inc rbx
movsxd rax, dword ptr [r15+20h]
add rbp, 10h
cmp rbx, rax
jl short loc_1E144
loc_1E176:
xor ebx, ebx
cmp r13d, 6
setnz bl
cmp r13d, 0FFFFFFF7h
jb short loc_1E1A4
mov rdi, [r14+18h]
mov eax, [r12]
lea ecx, [rax-1]
mov [r12], ecx
cmp eax, 1
jg short loc_1E1A4
mov rsi, r12
mov rdx, r13
call js_free_value_rt
loc_1E1A4:
lea ebp, ds:0FFFFFFFFFFFFFFFFh[rbx*2]
mov rdi, r14
mov rsi, r15
call js_free
mov rsi, [rsp+38h+var_38]
jmp short loc_1E1C1
loc_1E1BC:
xor r14d, r14d
xor ebp, ebp
loc_1E1C1:
mov [rsi], r14
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long JS_ExecutePendingJob(long long a1, long long *a2)
{
long long v2; // r15
long long v3; // rax
_QWORD *v4; // rcx
long long v5; // r14
_DWORD *v6; // r12
unsigned int v7; // edx
unsigned int v8; // r13d
_QWORD *v9; // rbp
long long v10; // rbx
_DWORD *v11; // rsi
long long v12; // rdi
int v13; // eax
long long v14; // rdi
int v15; // eax
unsigned int v16; // ebp
long long *v18; // [rsp+0h] [rbp-38h]
v2 = *(_QWORD *)(a1 + 312);
if ( v2 == a1 + 304 )
{
v5 = 0LL;
v16 = 0;
}
else
{
v18 = a2;
v3 = *(_QWORD *)v2;
v4 = *(_QWORD **)(v2 + 8);
*(_QWORD *)(v3 + 8) = v4;
*v4 = v3;
*(_OWORD *)v2 = 0LL;
v5 = *(_QWORD *)(v2 + 16);
v6 = (_DWORD *)(*(long long ( **)(long long, _QWORD, long long))(v2 + 24))(
v5,
*(unsigned int *)(v2 + 32),
v2 + 40);
v8 = v7;
if ( *(int *)(v2 + 32) > 0 )
{
v9 = (_QWORD *)(v2 + 48);
v10 = 0LL;
do
{
if ( (unsigned int)*v9 >= 0xFFFFFFF7 )
{
v11 = (_DWORD *)*(v9 - 1);
v12 = *(_QWORD *)(v5 + 24);
v13 = (*v11)--;
if ( v13 <= 1 )
js_free_value_rt(v12, v11);
}
++v10;
v9 += 2;
}
while ( v10 < *(int *)(v2 + 32) );
}
if ( v8 >= 0xFFFFFFF7 )
{
v14 = *(_QWORD *)(v5 + 24);
v15 = (*v6)--;
if ( v15 <= 1 )
js_free_value_rt(v14, v6);
}
v16 = 2 * (v8 != 6) - 1;
js_free(v5, v2);
a2 = v18;
}
*a2 = v5;
return v16;
}
| JS_ExecutePendingJob:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,qword ptr [RDI + 0x138]
ADD RDI,0x130
CMP R15,RDI
JZ 0x0011e1bc
MOV qword ptr [RSP],RSI
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15],XMM0
MOV R14,qword ptr [R15 + 0x10]
MOV ESI,dword ptr [R15 + 0x20]
LEA RDX,[R15 + 0x28]
MOV RDI,R14
CALL qword ptr [R15 + 0x18]
MOV R12,RAX
MOV R13,RDX
CMP dword ptr [R15 + 0x20],0x0
JLE 0x0011e176
LEA RBP,[R15 + 0x30]
XOR EBX,EBX
LAB_0011e144:
MOV RDX,qword ptr [RBP]
CMP EDX,-0x9
JC 0x0011e166
MOV RSI,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0011e166
CALL 0x001219cc
LAB_0011e166:
INC RBX
MOVSXD RAX,dword ptr [R15 + 0x20]
ADD RBP,0x10
CMP RBX,RAX
JL 0x0011e144
LAB_0011e176:
XOR EBX,EBX
CMP R13D,0x6
SETNZ BL
CMP R13D,-0x9
JC 0x0011e1a4
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [R12]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R12],ECX
CMP EAX,0x1
JG 0x0011e1a4
MOV RSI,R12
MOV RDX,R13
CALL 0x001219cc
LAB_0011e1a4:
LEA EBP,[-0x1 + RBX*0x2]
MOV RDI,R14
MOV RSI,R15
CALL 0x0011d481
MOV RSI,qword ptr [RSP]
JMP 0x0011e1c1
LAB_0011e1bc:
XOR R14D,R14D
XOR EBP,EBP
LAB_0011e1c1:
MOV qword ptr [RSI],R14
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int JS_ExecutePendingJob(long param_1,long *param_2)
{
long *plVar1;
int8 uVar2;
int *piVar3;
long lVar4;
int iVar5;
long *plVar6;
long lVar7;
int1 auVar8 [16];
plVar1 = *(long **)(param_1 + 0x138);
if (plVar1 == (long *)(param_1 + 0x130)) {
lVar7 = 0;
iVar5 = 0;
}
else {
lVar7 = *plVar1;
plVar6 = (long *)plVar1[1];
*(long **)(lVar7 + 8) = plVar6;
*plVar6 = lVar7;
*plVar1 = 0;
plVar1[1] = 0;
lVar7 = plVar1[2];
auVar8 = (*(code *)plVar1[3])(lVar7,(int)plVar1[4],plVar1 + 5);
piVar3 = auVar8._0_8_;
if (0 < (int)plVar1[4]) {
plVar6 = plVar1 + 6;
lVar4 = 0;
do {
if (0xfffffff6 < (uint)*plVar6) {
uVar2 = *(int8 *)(lVar7 + 0x18);
iVar5 = *(int *)plVar6[-1];
*(int *)plVar6[-1] = iVar5 + -1;
if (iVar5 < 2) {
js_free_value_rt(uVar2);
}
}
lVar4 = lVar4 + 1;
plVar6 = plVar6 + 2;
} while (lVar4 < (int)plVar1[4]);
}
if (0xfffffff6 < auVar8._8_4_) {
uVar2 = *(int8 *)(lVar7 + 0x18);
iVar5 = *piVar3;
*piVar3 = iVar5 + -1;
if (iVar5 < 2) {
js_free_value_rt(uVar2,piVar3,auVar8._8_8_);
}
}
iVar5 = (uint)(auVar8._8_4_ != 6) * 2 + -1;
js_free(lVar7,plVar1);
}
*param_2 = lVar7;
return iVar5;
}
|
|
1,929 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>) | monkey531[P]llama/common/json.hpp | void push_back(initializer_list_t init)
{
if (is_object() && init.size() == 2 && (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
}
else
{
push_back(basic_json(init));
}
} | 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>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2d8ca
movq 0x10(%r14), %rax
testq %rax, %rax
cmoveq %r14, %rax
cmpb $0x3, (%rax)
jne 0x2d8ca
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5db14
movq %r15, %rdi
callq 0x6ecba
movq %rax, %r15
addq $0x18, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x5db14
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x6ea2c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e960
leaq 0x20(%rsp), %rdi
callq 0x3f12e
movq %rsp, %rdi
callq 0x2d78e
leaq 0x10(%rsp), %rdi
jmp 0x2d8f1
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rcx
pushq $0x2
popq %r8
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e00a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ea52
leaq 0x20(%rsp), %rdi
callq 0x2d78e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3f12e
movq %rsp, %rdi
callq 0x2d78e
jmp 0x2d91c
jmp 0x2d919
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x2d92b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2d78e
movq %rbx, %rdi
callq 0x20bf0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backESt16initializer_listINS0_6detail8json_refISD_EEE:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
cmp byte ptr [rdi], 1
setz al
cmp rdx, 2
setz cl
and cl, al
cmp cl, 1
jnz short loc_2D8CA
mov rax, [r14+10h]
test rax, rax
cmovz rax, r14
cmp byte ptr [rax], 3
jnz short loc_2D8CA
lea r15, [rsp+68h+var_58]
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov r15, rax
add r14, 18h
mov rdi, rsp
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
lea r14, [rsp+68h+var_48]
mov rdx, rsp
mov rdi, r14
mov rsi, r15
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSt4pairIKS9_SD_E; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::push_back(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
lea rdi, [rsp+68h+var_48]; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov rdi, rsp
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()
lea rdi, [rsp+68h+var_58]
jmp short loc_2D8F1
loc_2D8CA:
lea r15, [rsp+68h+var_48]
push 1
pop rcx
push 2
pop r8
mov rdi, r15
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::push_back(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
lea rdi, [rsp+68h+var_48]
loc_2D8F1:
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 rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov rdi, rsp
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_2D91C
jmp short $+2
loc_2D919:
mov rbx, rax
loc_2D91C:
lea rdi, [rsp+arg_8]
jmp short loc_2D92B
mov rbx, rax
lea rdi, [rsp+arg_18]
loc_2D92B:
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
_BYTE *a1,
long long a2,
long long a3)
{
_BYTE *v3; // rax
long long v4; // r15
_BYTE *v5; // rdi
_BYTE v7[16]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v8[16]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v9[72]; // [rsp+20h] [rbp-48h] BYREF
if ( *a1 != 1 || a3 != 2 )
goto LABEL_6;
v3 = *(_BYTE **)(a2 + 16);
if ( !v3 )
v3 = (_BYTE *)a2;
if ( *v3 == 3 )
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v8,
a2);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<std::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(v8);
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v7,
a2 + 24);
ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v9,
v4,
v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
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>>::~pair(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>::~basic_json((long long)v7);
v5 = v8;
}
else
{
LABEL_6:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v9,
a2,
a3,
1LL,
2LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
v5 = v9;
}
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v5);
}
| push_back:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
CMP byte ptr [RDI],0x1
SETZ AL
CMP RDX,0x2
SETZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x0012d8ca
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
CMOVZ RAX,R14
CMP byte ptr [RAX],0x3
JNZ 0x0012d8ca
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,R14
CALL 0x0015db14
LAB_0012d879:
MOV RDI,R15
CALL 0x0016ecba
MOV R15,RAX
ADD R14,0x18
LAB_0012d888:
MOV RDI,RSP
MOV RSI,R14
CALL 0x0015db14
LEA R14,[RSP + 0x20]
MOV RDX,RSP
MOV RDI,R14
MOV RSI,R15
CALL 0x0016ea2c
LAB_0012d8a6:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0016e960
LAB_0012d8b1:
LEA RDI,[RSP + 0x20]
CALL 0x0013f12e
MOV RDI,RSP
CALL 0x0012d78e
LEA RDI,[RSP + 0x10]
JMP 0x0012d8f1
LAB_0012d8ca:
LEA R15,[RSP + 0x20]
PUSH 0x1
POP RCX
PUSH 0x2
POP R8
MOV RDI,R15
MOV RSI,R14
CALL 0x0012e00a
LAB_0012d8e1:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0016ea52
LAB_0012d8ec:
LEA RDI,[RSP + 0x20]
LAB_0012d8f1:
CALL 0x0012d78e
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >) */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2,long param_3)
{
char *pcVar1;
string *psVar2;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
abStack_68 [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_58 [16];
pair local_48 [48];
if (param_3 == 2 &&
*param_1 ==
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
pcVar1 = *(char **)(param_2 + 0x10);
if (*(char **)(param_2 + 0x10) == (char *)0x0) {
pcVar1 = param_2;
}
if (*pcVar1 == '\x03') {
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 0012d879 to 0012d880 has its CatchHandler @ 0012d919 */
psVar2 = get_ref_impl<std::__cxx11::string&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(local_58);
/* try { // try from 0012d888 to 0012d892 has its CatchHandler @ 0012d917 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
_ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_48,psVar2,abStack_68);
/* try { // try from 0012d8a6 to 0012d8b0 has its CatchHandler @ 0012d900 */
push_back(param_1,local_48);
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>>
::~pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)local_48);
~basic_json(abStack_68);
this = local_58;
goto LAB_0012d8f1;
}
}
basic_json(local_48,param_2,param_3,1,2);
/* try { // try from 0012d8e1 to 0012d8eb has its CatchHandler @ 0012d923 */
push_back(param_1,local_48);
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>
*)local_48;
LAB_0012d8f1:
~basic_json(this);
return;
}
|
|
1,930 | ma_tls_verify_server_cert | eloqsql/libmariadb/libmariadb/secure/openssl.c | int ma_tls_verify_server_cert(MARIADB_TLS *ctls)
{
X509 *cert;
MYSQL *mysql;
SSL *ssl;
MARIADB_PVIO *pvio;
#if !defined(HAVE_OPENSSL_CHECK_HOST)
X509_NAME *x509sn;
int cn_pos;
X509_NAME_ENTRY *cn_entry;
ASN1_STRING *cn_asn1;
const char *cn_str;
#endif
if (!ctls || !ctls->ssl)
return 1;
ssl= (SSL *)ctls->ssl;
mysql= (MYSQL *)SSL_get_app_data(ssl);
pvio= mysql->net.pvio;
if (!mysql->host)
{
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR), "Invalid (empty) hostname");
return 1;
}
if (!(cert= SSL_get_peer_certificate(ssl)))
{
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR), "Unable to get server certificate");
return 1;
}
#ifdef HAVE_OPENSSL_CHECK_HOST
if (X509_check_host(cert, mysql->host, 0, 0, 0) != 1
&& X509_check_ip_asc(cert, mysql->host, 0) != 1)
goto error;
#else
x509sn= X509_get_subject_name(cert);
if ((cn_pos= X509_NAME_get_index_by_NID(x509sn, NID_commonName, -1)) < 0)
goto error;
if (!(cn_entry= X509_NAME_get_entry(x509sn, cn_pos)))
goto error;
if (!(cn_asn1 = X509_NAME_ENTRY_get_data(cn_entry)))
goto error;
cn_str = (char *)ASN1_STRING_data(cn_asn1);
/* Make sure there is no embedded \0 in the CN */
if ((size_t)ASN1_STRING_length(cn_asn1) != strlen(cn_str))
goto error;
if (strcmp(cn_str, mysql->host))
goto error;
#endif
X509_free(cert);
return 0;
error:
X509_free(cert);
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR), "Validation of SSL server certificate failed");
return 1;
} | O0 | c | ma_tls_verify_server_cert:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbfd0e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xbfd1a
movl $0x1, -0x4(%rbp)
jmp 0xbfe7a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x3a300
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x2b0(%rax)
jne 0xbfd8f
movq -0x30(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x20(%rbp), %rdi
leaq 0x1f2c8f(%rip), %rax # 0x2b29f0
movq (%rax), %rdx
leaq 0x1f2c95(%rip), %rax # 0x2b2a00
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x871df(%rip), %r8 # 0x146f5d
movb $0x0, %al
callq *%r9
movl $0x1, -0x4(%rbp)
jmp 0xbfe7a
movq -0x28(%rbp), %rdi
callq 0x3aad0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xbfde3
movq -0x30(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x20(%rbp), %rdi
leaq 0x1f2c3b(%rip), %rax # 0x2b29f0
movq (%rax), %rdx
leaq 0x1f2c41(%rip), %rax # 0x2b2a00
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x871a4(%rip), %r8 # 0x146f76
movb $0x0, %al
callq *%r9
movl $0x1, -0x4(%rbp)
jmp 0xbfe7a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x2b0(%rax), %rsi
xorl %eax, %eax
movl %eax, %r8d
xorl %ecx, %ecx
movq %r8, %rdx
callq 0x3a620
cmpl $0x1, %eax
je 0xbfe23
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x2b0(%rax), %rsi
xorl %edx, %edx
callq 0x3a860
cmpl $0x1, %eax
je 0xbfe23
jmp 0xbfe35
movq -0x18(%rbp), %rdi
callq 0x3ac00
movl $0x0, -0x4(%rbp)
jmp 0xbfe7a
movq -0x18(%rbp), %rdi
callq 0x3ac00
movq -0x30(%rbp), %rax
movq 0x50(%rax), %r9
movq -0x20(%rbp), %rdi
leaq 0x1f2b9f(%rip), %rax # 0x2b29f0
movq (%rax), %rdx
leaq 0x1f2ba5(%rip), %rax # 0x2b2a00
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x87129(%rip), %r8 # 0x146f97
movb $0x0, %al
callq *%r9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_tls_verify_server_cert:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jz short loc_BFD0E
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jnz short loc_BFD1A
loc_BFD0E:
mov [rbp+var_4], 1
jmp loc_BFE7A
loc_BFD1A:
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
xor esi, esi
call _SSL_get_ex_data
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
cmp qword ptr [rax+2B0h], 0
jnz short loc_BFD8F
mov rax, [rbp+var_30]
mov r9, [rax+50h]
mov rdi, [rbp+var_20]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aInvalidEmptyHo; "Invalid (empty) hostname"
mov al, 0
call r9
mov [rbp+var_4], 1
jmp loc_BFE7A
loc_BFD8F:
mov rdi, [rbp+var_28]
call _SSL_get1_peer_certificate
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_BFDE3
mov rax, [rbp+var_30]
mov r9, [rax+50h]
mov rdi, [rbp+var_20]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aUnableToGetSer; "Unable to get server certificate"
mov al, 0
call r9
mov [rbp+var_4], 1
jmp loc_BFE7A
loc_BFDE3:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rsi, [rax+2B0h]
xor eax, eax
mov r8d, eax
xor ecx, ecx
mov rdx, r8
call _X509_check_host
cmp eax, 1
jz short loc_BFE23
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov rsi, [rax+2B0h]
xor edx, edx
call _X509_check_ip_asc
cmp eax, 1
jz short loc_BFE23
jmp short loc_BFE35
loc_BFE23:
mov rdi, [rbp+var_18]
call _X509_free
mov [rbp+var_4], 0
jmp short loc_BFE7A
loc_BFE35:
mov rdi, [rbp+var_18]
call _X509_free
mov rax, [rbp+var_30]
mov r9, [rax+50h]
mov rdi, [rbp+var_20]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aValidationOfSs; "Validation of SSL server certificate fa"...
mov al, 0
call r9
mov [rbp+var_4], 1
loc_BFE7A:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long ma_tls_verify_server_cert(long long a1)
{
long long v2; // [rsp+0h] [rbp-30h]
long long v3; // [rsp+8h] [rbp-28h]
long long *v4; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
if ( a1 && *(_QWORD *)(a1 + 16) )
{
v3 = *(_QWORD *)(a1 + 16);
v4 = (long long *)SSL_get_ex_data(v3, 0LL);
v2 = *v4;
if ( v4[86] )
{
v5 = SSL_get1_peer_certificate(v3);
if ( v5 )
{
if ( (unsigned int)X509_check_host(v5, v4[86], 0LL, 0LL) == 1
|| (unsigned int)X509_check_ip_asc(v5, v4[86], 0LL) == 1 )
{
X509_free(v5);
return 0;
}
else
{
X509_free(v5);
(*(void ( **)(long long *, long long, char *, char *, const char *))(v2 + 80))(
v4,
2026LL,
SQLSTATE_UNKNOWN,
client_errors[26],
"Validation of SSL server certificate failed");
return 1;
}
}
else
{
(*(void ( **)(long long *, long long, char *, char *, const char *))(v2 + 80))(
v4,
2026LL,
SQLSTATE_UNKNOWN,
client_errors[26],
"Unable to get server certificate");
return 1;
}
}
else
{
(*(void ( **)(long long *, long long, char *, char *, const char *))(v2 + 80))(
v4,
2026LL,
SQLSTATE_UNKNOWN,
client_errors[26],
"Invalid (empty) hostname");
return 1;
}
}
else
{
return 1;
}
}
| ma_tls_verify_server_cert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001bfd0e
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x001bfd1a
LAB_001bfd0e:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001bfe7a
LAB_001bfd1a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
XOR ESI,ESI
CALL 0x0013a300
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x2b0],0x0
JNZ 0x001bfd8f
MOV RAX,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x20]
LEA RAX,[0x3b29f0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3b2a00]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x246f5d]
MOV AL,0x0
CALL R9
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001bfe7a
LAB_001bfd8f:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013aad0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x001bfde3
MOV RAX,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x20]
LEA RAX,[0x3b29f0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3b2a00]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x246f76]
MOV AL,0x0
CALL R9
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001bfe7a
LAB_001bfde3:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x2b0]
XOR EAX,EAX
MOV R8D,EAX
XOR ECX,ECX
MOV RDX,R8
CALL 0x0013a620
CMP EAX,0x1
JZ 0x001bfe23
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x2b0]
XOR EDX,EDX
CALL 0x0013a860
CMP EAX,0x1
JZ 0x001bfe23
JMP 0x001bfe35
LAB_001bfe23:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0013ac00
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001bfe7a
LAB_001bfe35:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0013ac00
MOV RAX,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RAX + 0x50]
MOV RDI,qword ptr [RBP + -0x20]
LEA RAX,[0x3b29f0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x3b2a00]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x246f97]
MOV AL,0x0
CALL R9
MOV dword ptr [RBP + -0x4],0x1
LAB_001bfe7a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 ma_tls_verify_server_cert(long param_1)
{
SSL *ssl;
long lVar1;
int iVar2;
long *plVar3;
X509 *a;
int4 local_c;
if ((param_1 == 0) || (*(long *)(param_1 + 0x10) == 0)) {
local_c = 1;
}
else {
ssl = *(SSL **)(param_1 + 0x10);
plVar3 = (long *)SSL_get_ex_data(ssl,0);
lVar1 = *plVar3;
if (plVar3[0x56] == 0) {
(**(code **)(lVar1 + 0x50))
(plVar3,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_003b2ad0,
"Invalid (empty) hostname");
local_c = 1;
}
else {
a = (X509 *)SSL_get1_peer_certificate(ssl);
if (a == (X509 *)0x0) {
(**(code **)(lVar1 + 0x50))
(plVar3,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_003b2ad0,
"Unable to get server certificate");
local_c = 1;
}
else {
iVar2 = X509_check_host(a,plVar3[0x56],0,0);
if ((iVar2 != 1) && (iVar2 = X509_check_ip_asc(a,plVar3[0x56],0), iVar2 != 1)) {
X509_free(a);
(**(code **)(lVar1 + 0x50))
(plVar3,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_003b2ad0,
"Validation of SSL server certificate failed");
return 1;
}
X509_free(a);
local_c = 0;
}
}
}
return local_c;
}
|
|
1,931 | ma_tls_verify_server_cert | eloqsql/libmariadb/libmariadb/secure/openssl.c | int ma_tls_verify_server_cert(MARIADB_TLS *ctls)
{
X509 *cert;
MYSQL *mysql;
SSL *ssl;
MARIADB_PVIO *pvio;
#if !defined(HAVE_OPENSSL_CHECK_HOST)
X509_NAME *x509sn;
int cn_pos;
X509_NAME_ENTRY *cn_entry;
ASN1_STRING *cn_asn1;
const char *cn_str;
#endif
if (!ctls || !ctls->ssl)
return 1;
ssl= (SSL *)ctls->ssl;
mysql= (MYSQL *)SSL_get_app_data(ssl);
pvio= mysql->net.pvio;
if (!mysql->host)
{
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR), "Invalid (empty) hostname");
return 1;
}
if (!(cert= SSL_get_peer_certificate(ssl)))
{
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR), "Unable to get server certificate");
return 1;
}
#ifdef HAVE_OPENSSL_CHECK_HOST
if (X509_check_host(cert, mysql->host, 0, 0, 0) != 1
&& X509_check_ip_asc(cert, mysql->host, 0) != 1)
goto error;
#else
x509sn= X509_get_subject_name(cert);
if ((cn_pos= X509_NAME_get_index_by_NID(x509sn, NID_commonName, -1)) < 0)
goto error;
if (!(cn_entry= X509_NAME_get_entry(x509sn, cn_pos)))
goto error;
if (!(cn_asn1 = X509_NAME_ENTRY_get_data(cn_entry)))
goto error;
cn_str = (char *)ASN1_STRING_data(cn_asn1);
/* Make sure there is no embedded \0 in the CN */
if ((size_t)ASN1_STRING_length(cn_asn1) != strlen(cn_str))
goto error;
if (strcmp(cn_str, mysql->host))
goto error;
#endif
X509_free(cert);
return 0;
error:
X509_free(cert);
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR), "Validation of SSL server certificate failed");
return 1;
} | O3 | c | ma_tls_verify_server_cert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x1, %r14d
testq %rdi, %rdi
je 0x995c4
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0x995c4
movq %r15, %rdi
xorl %esi, %esi
callq 0x39300
movq %rax, %rbx
movq (%rax), %r12
cmpq $0x0, 0x2b0(%rax)
je 0x99546
movq %r15, %rdi
callq 0x39b00
testq %rax, %rax
je 0x99567
movq %rax, %r15
movq 0x2b0(%rbx), %rsi
xorl %r14d, %r14d
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x39640
cmpl $0x1, %eax
je 0x9953c
movq 0x2b0(%rbx), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x39870
cmpl $0x1, %eax
jne 0x99588
movq %r15, %rdi
callq 0x39c20
jmp 0x995c4
leaq 0x30a073(%rip), %rax # 0x3a35c0
movq (%rax), %rdx
leaq 0x30a079(%rip), %rax # 0x3a35d0
movq 0xd0(%rax), %rcx
leaq 0x5eb26(%rip), %r8 # 0xf808b
jmp 0x995af
leaq 0x30a052(%rip), %rax # 0x3a35c0
movq (%rax), %rdx
leaq 0x30a058(%rip), %rax # 0x3a35d0
movq 0xd0(%rax), %rcx
leaq 0x5eb1e(%rip), %r8 # 0xf80a4
jmp 0x995af
movq %r15, %rdi
callq 0x39c20
leaq 0x30a029(%rip), %rax # 0x3a35c0
movq (%rax), %rdx
leaq 0x30a02f(%rip), %rax # 0x3a35d0
movq 0xd0(%rax), %rcx
leaq 0x5eb16(%rip), %r8 # 0xf80c5
movq %rbx, %rdi
movl $0x7ea, %esi # imm = 0x7EA
xorl %eax, %eax
callq *0x50(%r12)
movl $0x1, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| ma_tls_verify_server_cert:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14d, 1
test rdi, rdi
jz loc_995C4
mov r15, [rdi+10h]
test r15, r15
jz loc_995C4
mov rdi, r15
xor esi, esi
call _SSL_get_ex_data
mov rbx, rax
mov r12, [rax]
cmp qword ptr [rax+2B0h], 0
jz short loc_99546
mov rdi, r15
call _SSL_get1_peer_certificate
test rax, rax
jz short loc_99567
mov r15, rax
mov rsi, [rbx+2B0h]
xor r14d, r14d
mov rdi, rax
xor edx, edx
xor ecx, ecx
xor r8d, r8d
call _X509_check_host
cmp eax, 1
jz short loc_9953C
mov rsi, [rbx+2B0h]
mov rdi, r15
xor edx, edx
call _X509_check_ip_asc
cmp eax, 1
jnz short loc_99588
loc_9953C:
mov rdi, r15
call _X509_free
jmp short loc_995C4
loc_99546:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
lea r8, aInvalidEmptyHo; "Invalid (empty) hostname"
jmp short loc_995AF
loc_99567:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
lea r8, aUnableToGetSer; "Unable to get server certificate"
jmp short loc_995AF
loc_99588:
mov rdi, r15
call _X509_free
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
lea r8, aValidationOfSs; "Validation of SSL server certificate fa"...
loc_995AF:
mov rdi, rbx
mov esi, 7EAh
xor eax, eax
call qword ptr [r12+50h]
mov r14d, 1
loc_995C4:
mov eax, r14d
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ma_tls_verify_server_cert(long long a1)
{
unsigned int v1; // r14d
long long v2; // r15
long long *v3; // rbx
long long v4; // r12
long long v5; // rax
long long v6; // r15
char *v7; // rdx
char *v8; // rcx
const char *v9; // r8
v1 = 1;
if ( a1 )
{
v2 = *(_QWORD *)(a1 + 16);
if ( v2 )
{
v3 = (long long *)SSL_get_ex_data(*(_QWORD *)(a1 + 16), 0LL);
v4 = *v3;
if ( v3[86] )
{
v5 = SSL_get1_peer_certificate(v2);
if ( v5 )
{
v6 = v5;
v1 = 0;
if ( (unsigned int)X509_check_host(v5, v3[86], 0LL, 0LL, 0LL) == 1
|| (unsigned int)X509_check_ip_asc(v6, v3[86], 0LL) == 1 )
{
X509_free(v6);
return v1;
}
X509_free(v6);
v7 = SQLSTATE_UNKNOWN;
v8 = client_errors[26];
v9 = "Validation of SSL server certificate failed";
}
else
{
v7 = SQLSTATE_UNKNOWN;
v8 = client_errors[26];
v9 = "Unable to get server certificate";
}
}
else
{
v7 = SQLSTATE_UNKNOWN;
v8 = client_errors[26];
v9 = "Invalid (empty) hostname";
}
(*(void ( **)(long long *, long long, char *, char *, const char *))(v4 + 80))(v3, 2026LL, v7, v8, v9);
return 1;
}
}
return v1;
}
| ma_tls_verify_server_cert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14D,0x1
TEST RDI,RDI
JZ 0x001995c4
MOV R15,qword ptr [RDI + 0x10]
TEST R15,R15
JZ 0x001995c4
MOV RDI,R15
XOR ESI,ESI
CALL 0x00139300
MOV RBX,RAX
MOV R12,qword ptr [RAX]
CMP qword ptr [RAX + 0x2b0],0x0
JZ 0x00199546
MOV RDI,R15
CALL 0x00139b00
TEST RAX,RAX
JZ 0x00199567
MOV R15,RAX
MOV RSI,qword ptr [RBX + 0x2b0]
XOR R14D,R14D
MOV RDI,RAX
XOR EDX,EDX
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00139640
CMP EAX,0x1
JZ 0x0019953c
MOV RSI,qword ptr [RBX + 0x2b0]
MOV RDI,R15
XOR EDX,EDX
CALL 0x00139870
CMP EAX,0x1
JNZ 0x00199588
LAB_0019953c:
MOV RDI,R15
CALL 0x00139c20
JMP 0x001995c4
LAB_00199546:
LEA RAX,[0x4a35c0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x4a35d0]
MOV RCX,qword ptr [RAX + 0xd0]
LEA R8,[0x1f808b]
JMP 0x001995af
LAB_00199567:
LEA RAX,[0x4a35c0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x4a35d0]
MOV RCX,qword ptr [RAX + 0xd0]
LEA R8,[0x1f80a4]
JMP 0x001995af
LAB_00199588:
MOV RDI,R15
CALL 0x00139c20
LEA RAX,[0x4a35c0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x4a35d0]
MOV RCX,qword ptr [RAX + 0xd0]
LEA R8,[0x1f80c5]
LAB_001995af:
MOV RDI,RBX
MOV ESI,0x7ea
XOR EAX,EAX
CALL qword ptr [R12 + 0x50]
MOV R14D,0x1
LAB_001995c4:
MOV EAX,R14D
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 ma_tls_verify_server_cert(long param_1)
{
SSL *ssl;
long lVar1;
int iVar2;
long *plVar3;
X509 *a;
char *pcVar4;
if (param_1 == 0) {
return 1;
}
ssl = *(SSL **)(param_1 + 0x10);
if (ssl != (SSL *)0x0) {
plVar3 = (long *)SSL_get_ex_data(ssl,0);
lVar1 = *plVar3;
if (plVar3[0x56] == 0) {
pcVar4 = "Invalid (empty) hostname";
}
else {
a = (X509 *)SSL_get1_peer_certificate(ssl);
if (a == (X509 *)0x0) {
pcVar4 = "Unable to get server certificate";
}
else {
iVar2 = X509_check_host(a,plVar3[0x56],0,0,0);
if ((iVar2 == 1) || (iVar2 = X509_check_ip_asc(a,plVar3[0x56],0), iVar2 == 1)) {
X509_free(a);
return 0;
}
X509_free(a);
pcVar4 = "Validation of SSL server certificate failed";
}
}
(**(code **)(lVar1 + 0x50))
(plVar3,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_004a36a0,pcVar4);
return 1;
}
return 1;
}
|
|
1,932 | LefDefParser::lefiGeometries::getRectIter(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMisc.cpp | lefiGeomRectIter *
lefiGeometries::getRectIter(int index) const
{
char msg[160];
if (index < 0 || index >= numItems_) {
sprintf(msg, "ERROR (LEFPARS-1362): The index number %d given for the geometry RECTANGLE ITERATE is invalid.\nValid index is from 0 to %d", index, numItems_);
lefiError(0, 1362, msg);
return 0;
}
return (lefiGeomRectIter*) (items_[index]);
} | O3 | cpp | LefDefParser::lefiGeometries::getRectIter(int) const:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movl %esi, %edx
testl %esi, %esi
setns %al
movl (%rdi), %ecx
cmpl %esi, %ecx
setg %sil
testb %sil, %al
je 0x11824
movq 0x10(%rdi), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rbx
jmp 0x11849
leaq 0x3b9cc(%rip), %rsi # 0x4d1f7
xorl %ebx, %ebx
movq %rsp, %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movl $0x552, %esi # imm = 0x552
movq %r14, %rdx
callq 0x27ae8
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZNK12LefDefParser14lefiGeometries11getRectIterEi:
push r14
push rbx
sub rsp, 0A8h
mov edx, esi
test esi, esi
setns al
mov ecx, [rdi]
cmp ecx, esi
setnle sil
test al, sil
jz short loc_11824
mov rax, [rdi+10h]
mov ecx, edx
mov rbx, [rax+rcx*8]
jmp short loc_11849
loc_11824:
lea rsi, aErrorLefpars13_1; "ERROR (LEFPARS-1362): The index number "...
xor ebx, ebx
mov r14, rsp
mov rdi, r14
xor eax, eax
call _sprintf
xor edi, edi; this
mov esi, 552h; int
mov rdx, r14; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
loc_11849:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r14
retn
| long long LefDefParser::lefiGeometries::getRectIter(LefDefParser::lefiGeometries *this, signed int a2)
{
long long v2; // rbx
const char *v3; // rcx
_BYTE v5[184]; // [rsp+0h] [rbp-B8h] BYREF
if ( *(_DWORD *)this > a2 && a2 >= 0 )
return *(_QWORD *)(*((_QWORD *)this + 2) + 8LL * (unsigned int)a2);
v2 = 0LL;
sprintf(
v5,
"ERROR (LEFPARS-1362): The index number %d given for the geometry RECTANGLE ITERATE is invalid.\n"
"Valid index is from 0 to %d",
a2,
*(_DWORD *)this);
LefDefParser::lefiError(0LL, 1362, (int)v5, v3);
return v2;
}
| getRectIter:
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV EDX,ESI
TEST ESI,ESI
SETNS AL
MOV ECX,dword ptr [RDI]
CMP ECX,ESI
SETG SIL
TEST AL,SIL
JZ 0x00111824
MOV RAX,qword ptr [RDI + 0x10]
MOV ECX,EDX
MOV RBX,qword ptr [RAX + RCX*0x8]
JMP 0x00111849
LAB_00111824:
LEA RSI,[0x14d1f7]
XOR EBX,EBX
MOV R14,RSP
MOV RDI,R14
XOR EAX,EAX
CALL 0x00102050
XOR EDI,EDI
MOV ESI,0x552
MOV RDX,R14
CALL 0x00127ae8
LAB_00111849:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R14
RET
|
/* LefDefParser::lefiGeometries::getRectIter(int) const */
int8 __thiscall LefDefParser::lefiGeometries::getRectIter(lefiGeometries *this,int param_1)
{
int8 uVar1;
char acStack_b8 [168];
if (param_1 < 0 || *(int *)this <= param_1) {
uVar1 = 0;
sprintf(acStack_b8,
"ERROR (LEFPARS-1362): The index number %d given for the geometry RECTANGLE ITERATE is invalid.\nValid index is from 0 to %d"
);
lefiError(0,0x552,acStack_b8);
}
else {
uVar1 = *(int8 *)(*(long *)(this + 0x10) + (ulong)(uint)param_1 * 8);
}
return uVar1;
}
|
|
1,933 | void ImPlot3D::PlotQuadEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>>>(char const*, ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>> const&, int) | zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d_items.cpp | void PlotQuadEx(const char* label_id, const _Getter& getter, ImPlot3DQuadFlags flags) {
if (BeginItemEx(label_id, getter, flags, ImPlot3DCol_Fill)) {
const ImPlot3DNextItemData& n = GetItemData();
// Render fill
if (getter.Count >= 4 && n.RenderFill) {
const ImU32 col_fill = ImGui::GetColorU32(n.Colors[ImPlot3DCol_Fill]);
RenderPrimitives<RendererQuadFill>(getter, col_fill);
}
// Render lines
if (getter.Count >= 2 && n.RenderLine) {
const ImU32 col_line = ImGui::GetColorU32(n.Colors[ImPlot3DCol_Line]);
RenderPrimitives<RendererLineSegments>(GetterQuadLines<_Getter>(getter), col_line, n.LineWeight);
}
// Render markers
if (n.Marker != ImPlot3DMarker_None) {
const ImU32 col_line = ImGui::GetColorU32(n.Colors[ImPlot3DCol_MarkerOutline]);
const ImU32 col_fill = ImGui::GetColorU32(n.Colors[ImPlot3DCol_MarkerFill]);
RenderMarkers<_Getter>(getter, n.Marker, n.MarkerSize, n.RenderMarkerFill, col_fill, n.RenderMarkerLine, col_line, n.MarkerWeight);
}
EndItem();
}
} | O1 | cpp | void ImPlot3D::PlotQuadEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>>>(char const*, ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>, ImPlot3D::IndexerIdx<signed char>> const&, int):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movl $0x1, %ecx
callq 0x64f83
testb %al, %al
je 0x5a2f6
callq 0x5459e
movq %rax, %r14
cmpl $0x4, 0x48(%rbx)
jl 0x5a259
cmpb $0x1, 0x55(%r14)
jne 0x5a259
leaq 0x10(%r14), %rdi
callq 0x215ebe
movq %rbx, %rdi
movl %eax, %esi
callq 0x9a1ac
cmpl $0x2, 0x48(%rbx)
jl 0x5a29e
cmpb $0x1, 0x54(%r14)
jne 0x5a29e
movq %r14, %rdi
callq 0x215ebe
leaq 0x8(%rsp), %rdx
movl $0x9, %ecx
movq %rdx, %rdi
movq %rbx, %rsi
rep movsq (%rsi), %es:(%rdi)
movq 0x48(%rbx), %rcx
movq %rcx, 0x48(%rdx)
addl %ecx, %ecx
movl %ecx, 0x50(%rdx)
movss 0x40(%r14), %xmm0
movq %rdx, %rdi
movl %eax, %esi
callq 0x9ade8
cmpl $-0x1, 0x44(%r14)
je 0x5a2e3
leaq 0x20(%r14), %rdi
callq 0x215ebe
movl %eax, %ebp
movq %r14, %rdi
addq $0x30, %rdi
callq 0x215ebe
movl 0x44(%r14), %esi
movss 0x48(%r14), %xmm0
movzbl 0x57(%r14), %edx
movzbl 0x56(%r14), %r8d
movss 0x4c(%r14), %xmm1
movq %rbx, %rdi
movl %eax, %ecx
movl %ebp, %r9d
callq 0x6528e
leaq 0x2dc9ae(%rip), %rax # 0x336c98
movq (%rax), %rdi
addq $0x38, %rdi
callq 0x55a36
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| _ZN8ImPlot3D10PlotQuadExINS_9GetterXYZINS_10IndexerIdxIdEES3_S3_EEEEvPKcRKT_i:
push rbp
push r14
push rbx
sub rsp, 60h
mov rbx, rsi
mov ecx, 1
call _ZN8ImPlot3D11BeginItemExINS_9GetterXYZINS_10IndexerIdxIdEES3_S3_EEEEbPKcRKT_ii; ImPlot3D::BeginItemEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>(char const*,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>> const&,int,int)
test al, al
jz loc_5A2F6
call _ZN8ImPlot3D11GetItemDataEv; ImPlot3D::GetItemData(void)
mov r14, rax
cmp dword ptr [rbx+48h], 4
jl short loc_5A259
cmp byte ptr [r14+55h], 1
jnz short loc_5A259
lea rdi, [r14+10h]
call _ZN5ImGui11GetColorU32ERK6ImVec4; ImGui::GetColorU32(ImVec4 const&)
mov rdi, rbx
mov esi, eax
call _ZN8ImPlot3D16RenderPrimitivesINS_16RendererQuadFillENS_9GetterXYZINS_10IndexerIdxIdEES4_S4_EEJjEEEvRKT0_DpT1_; ImPlot3D::RenderPrimitives<ImPlot3D::RendererQuadFill,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,uint>(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>> const&,uint)
loc_5A259:
cmp dword ptr [rbx+48h], 2
jl short loc_5A29E
cmp byte ptr [r14+54h], 1
jnz short loc_5A29E
mov rdi, r14
call _ZN5ImGui11GetColorU32ERK6ImVec4; ImGui::GetColorU32(ImVec4 const&)
lea rdx, [rsp+78h+var_70]
mov ecx, 9
mov rdi, rdx
mov rsi, rbx
rep movsq
mov rcx, [rbx+48h]
mov [rdx+48h], rcx
add ecx, ecx
mov [rdx+50h], ecx
movss xmm0, dword ptr [r14+40h]
mov rdi, rdx
mov esi, eax
call _ZN8ImPlot3D16RenderPrimitivesINS_20RendererLineSegmentsENS_15GetterQuadLinesINS_9GetterXYZINS_10IndexerIdxIdEES5_S5_EEEEJjfEEEvRKT0_DpT1_; ImPlot3D::RenderPrimitives<ImPlot3D::RendererLineSegments,ImPlot3D::GetterQuadLines<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>,uint,float>(ImPlot3D::GetterQuadLines<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>> const&,uint,float)
loc_5A29E:
cmp dword ptr [r14+44h], 0FFFFFFFFh
jz short loc_5A2E3
lea rdi, [r14+20h]
call _ZN5ImGui11GetColorU32ERK6ImVec4; ImGui::GetColorU32(ImVec4 const&)
mov ebp, eax
mov rdi, r14
add rdi, 30h ; '0'
call _ZN5ImGui11GetColorU32ERK6ImVec4; ImGui::GetColorU32(ImVec4 const&)
mov esi, [r14+44h]
movss xmm0, dword ptr [r14+48h]
movzx edx, byte ptr [r14+57h]
movzx r8d, byte ptr [r14+56h]
movss xmm1, dword ptr [r14+4Ch]
mov rdi, rbx
mov ecx, eax
mov r9d, ebp
call _ZN8ImPlot3D13RenderMarkersINS_9GetterXYZINS_10IndexerIdxIdEES3_S3_EEEEvRKT_ifbjbjf; ImPlot3D::RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>(ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>> const&,int,float,bool,uint,bool,uint,float)
loc_5A2E3:
lea rax, _ZN8ImPlot3D9GImPlot3DE; ImPlot3D::GImPlot3D
mov rdi, [rax]
add rdi, 38h ; '8'; this
call _ZN20ImPlot3DNextItemData5ResetEv; ImPlot3DNextItemData::Reset(void)
loc_5A2F6:
add rsp, 60h
pop rbx
pop r14
pop rbp
retn
| long long ImPlot3D::PlotQuadEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>(
ImPlot3D *a1,
int *a2,
long long a3)
{
long long result; // rax
long long ItemData; // rax
long long v5; // r14
unsigned int ColorU32; // eax
unsigned int v7; // eax
unsigned int v8; // ebp
unsigned int v9; // eax
_DWORD v10[28]; // [rsp+8h] [rbp-70h] BYREF
result = ImPlot3D::BeginItemEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>(
a1,
a2,
a3,
1LL);
if ( (_BYTE)result )
{
ItemData = ImPlot3D::GetItemData(a1);
v5 = ItemData;
if ( a2[18] >= 4 && *(_BYTE *)(ItemData + 85) == 1 )
{
ColorU32 = ImGui::GetColorU32(ItemData + 16);
ImPlot3D::RenderPrimitives<ImPlot3D::RendererQuadFill,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,unsigned int>(
a2,
ColorU32);
}
if ( a2[18] >= 2 && *(_BYTE *)(v5 + 84) == 1 )
{
v7 = ImGui::GetColorU32(v5);
qmemcpy(v10, a2, 0x50uLL);
v10[20] = 2 * v10[18];
ImPlot3D::RenderPrimitives<ImPlot3D::RendererLineSegments,ImPlot3D::GetterQuadLines<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>,unsigned int,float>(
v10,
v7,
*(float *)(v5 + 64));
}
if ( *(_DWORD *)(v5 + 68) != -1 )
{
v8 = ImGui::GetColorU32(v5 + 32);
v9 = ImGui::GetColorU32(v5 + 48);
ImPlot3D::RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>(
a2,
*(unsigned int *)(v5 + 68),
*(unsigned __int8 *)(v5 + 87),
v9,
*(unsigned __int8 *)(v5 + 86),
v8,
*(float *)(v5 + 72),
*(float *)(v5 + 76));
}
return ImPlot3DNextItemData::Reset((ImGui *)((char *)ImPlot3D::GImPlot3D + 56));
}
return result;
}
| PlotQuadEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RSI
MOV ECX,0x1
CALL 0x00164f83
TEST AL,AL
JZ 0x0015a2f6
CALL 0x0015459e
MOV R14,RAX
CMP dword ptr [RBX + 0x48],0x4
JL 0x0015a259
CMP byte ptr [R14 + 0x55],0x1
JNZ 0x0015a259
LEA RDI,[R14 + 0x10]
CALL 0x00315ebe
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0019a1ac
LAB_0015a259:
CMP dword ptr [RBX + 0x48],0x2
JL 0x0015a29e
CMP byte ptr [R14 + 0x54],0x1
JNZ 0x0015a29e
MOV RDI,R14
CALL 0x00315ebe
LEA RDX,[RSP + 0x8]
MOV ECX,0x9
MOV RDI,RDX
MOV RSI,RBX
MOVSQ.REP RDI,RSI
MOV RCX,qword ptr [RBX + 0x48]
MOV qword ptr [RDX + 0x48],RCX
ADD ECX,ECX
MOV dword ptr [RDX + 0x50],ECX
MOVSS XMM0,dword ptr [R14 + 0x40]
MOV RDI,RDX
MOV ESI,EAX
CALL 0x0019ade8
LAB_0015a29e:
CMP dword ptr [R14 + 0x44],-0x1
JZ 0x0015a2e3
LEA RDI,[R14 + 0x20]
CALL 0x00315ebe
MOV EBP,EAX
MOV RDI,R14
ADD RDI,0x30
CALL 0x00315ebe
MOV ESI,dword ptr [R14 + 0x44]
MOVSS XMM0,dword ptr [R14 + 0x48]
MOVZX EDX,byte ptr [R14 + 0x57]
MOVZX R8D,byte ptr [R14 + 0x56]
MOVSS XMM1,dword ptr [R14 + 0x4c]
MOV RDI,RBX
MOV ECX,EAX
MOV R9D,EBP
CALL 0x0016528e
LAB_0015a2e3:
LEA RAX,[0x436c98]
MOV RDI,qword ptr [RAX]
ADD RDI,0x38
CALL 0x00155a36
LAB_0015a2f6:
ADD RSP,0x60
POP RBX
POP R14
POP RBP
RET
|
/* void ImPlot3D::PlotQuadEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,
ImPlot3D::IndexerIdx<double>, ImPlot3D::IndexerIdx<double> > >(char const*,
ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>, ImPlot3D::IndexerIdx<double>,
ImPlot3D::IndexerIdx<double> > const&, int) */
void ImPlot3D::
PlotQuadEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>
(char *param_1,GetterXYZ *param_2,int param_3)
{
bool bVar1;
uint uVar2;
uint uVar3;
ImVec4 *pIVar4;
long lVar5;
GetterXYZ *pGVar6;
GetterQuadLines *pGVar7;
byte bVar8;
GetterQuadLines local_70 [72];
int8 local_28;
int local_20;
bVar8 = 0;
bVar1 = BeginItemEx<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>
(param_1,param_2,param_3,1);
if (bVar1) {
pIVar4 = (ImVec4 *)GetItemData();
if ((3 < *(int *)(param_2 + 0x48)) && (pIVar4[0x55] == (ImVec4)0x1)) {
uVar2 = ImGui::GetColorU32(pIVar4 + 0x10);
RenderPrimitives<ImPlot3D::RendererQuadFill,ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>,unsigned_int>
(param_2,uVar2);
}
if ((1 < *(int *)(param_2 + 0x48)) && (pIVar4[0x54] == (ImVec4)0x1)) {
uVar2 = ImGui::GetColorU32(pIVar4);
pGVar6 = param_2;
pGVar7 = local_70;
for (lVar5 = 9; lVar5 != 0; lVar5 = lVar5 + -1) {
*(int8 *)pGVar7 = *(int8 *)pGVar6;
pGVar6 = pGVar6 + (ulong)bVar8 * -0x10 + 8;
pGVar7 = pGVar7 + (ulong)bVar8 * -0x10 + 8;
}
local_28 = *(int8 *)(param_2 + 0x48);
local_20 = (int)local_28 * 2;
RenderPrimitives<ImPlot3D::RendererLineSegments,ImPlot3D::GetterQuadLines<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>,unsigned_int,float>
(local_70,uVar2,*(float *)(pIVar4 + 0x40));
}
if (*(int *)(pIVar4 + 0x44) != -1) {
uVar2 = ImGui::GetColorU32(pIVar4 + 0x20);
uVar3 = ImGui::GetColorU32(pIVar4 + 0x30);
RenderMarkers<ImPlot3D::GetterXYZ<ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>,ImPlot3D::IndexerIdx<double>>>
(param_2,*(int *)(pIVar4 + 0x44),*(float *)(pIVar4 + 0x48),(bool)pIVar4[0x57],uVar3,
(bool)pIVar4[0x56],uVar2,*(float *)(pIVar4 + 0x4c));
}
ImPlot3DNextItemData::Reset((ImPlot3DNextItemData *)(GImPlot3D + 0x38));
}
return;
}
|
|
1,934 | CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo const*, VkAllocationCallbacks const*, VkPipeline_T**) | HansKristian-Work[P]pyroveil/layer/pyroveil.cpp | static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator,
VkPipeline *pPipelines)
{
auto *layer = getDeviceLayer(device);
ScratchAllocator scratch;
auto *createInfos = scratch.copy(pCreateInfos, createInfoCount);
for (uint32_t i = 0; i < createInfoCount; i++)
layer->overrideStage(&createInfos[i].stage, scratch);
return layer->getTable()->CreateComputePipelines(device, pipelineCache,
createInfoCount, createInfos, pAllocator,
pPipelines);
} | O0 | cpp | CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo const*, VkAllocationCallbacks const*, VkPipeline_T**):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x188770
movq %rax, -0x38(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x199720
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x19ae40
movq %rax, -0x90(%rbp)
jmp 0x18842d
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x88(%rbp)
movl -0x88(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1884a0
movq -0x38(%rbp), %rdi
movq -0x78(%rbp), %rax
movl -0x88(%rbp), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
leaq 0x18(%rax,%rcx), %rsi
leaq -0x70(%rbp), %rdx
callq 0x186540
jmp 0x188473
jmp 0x188475
movl -0x88(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x88(%rbp)
jmp 0x188442
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1997a0
jmp 0x1884e6
movq -0x38(%rbp), %rdi
callq 0x1990c0
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x78(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq *%rax
movl %eax, -0x9c(%rbp)
jmp 0x1884ce
leaq -0x70(%rbp), %rdi
callq 0x1997a0
movl -0x9c(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x171c30
nop
| _ZL22CreateComputePipelinesP10VkDevice_TP17VkPipelineCache_TjPK27VkComputePipelineCreateInfoPK21VkAllocationCallbacksPP12VkPipeline_T:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rdi, [rbp+var_8]
call _ZL14getDeviceLayerP10VkDevice_T; getDeviceLayer(VkDevice_T *)
mov [rbp+var_38], rax
lea rdi, [rbp+var_70]; this
mov [rbp+var_98], rdi
call _ZN16ScratchAllocatorC2Ev; ScratchAllocator::ScratchAllocator(void)
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_20]
mov eax, [rbp+var_14]
mov edx, eax
call _ZN16ScratchAllocator4copyI27VkComputePipelineCreateInfoEEPT_PKS2_m; ScratchAllocator::copy<VkComputePipelineCreateInfo>(VkComputePipelineCreateInfo const*,ulong)
mov [rbp+var_90], rax
jmp short $+2
loc_18842D:
mov rax, [rbp+var_90]
mov [rbp+var_78], rax
mov [rbp+var_88], 0
loc_188442:
mov eax, [rbp+var_88]
cmp eax, [rbp+var_14]
jnb short loc_1884A0
mov rdi, [rbp+var_38]
mov rax, [rbp+var_78]
mov ecx, [rbp+var_88]
lea rcx, [rcx+rcx*2]
shl rcx, 5
lea rsi, [rax+rcx+18h]
lea rdx, [rbp+var_70]
call _ZNK6Device13overrideStageEP31VkPipelineShaderStageCreateInfoR16ScratchAllocator; Device::overrideStage(VkPipelineShaderStageCreateInfo *,ScratchAllocator &)
jmp short $+2
loc_188473:
jmp short $+2
loc_188475:
mov eax, [rbp+var_88]
add eax, 1
mov [rbp+var_88], eax
jmp short loc_188442
mov rcx, rax
mov eax, edx
mov [rbp+var_80], rcx
mov [rbp+var_84], eax
lea rdi, [rbp+var_70]; this
call _ZN16ScratchAllocatorD2Ev; ScratchAllocator::~ScratchAllocator()
jmp short loc_1884E6
loc_1884A0:
mov rdi, [rbp+var_38]; this
call _ZNK6Device8getTableEv; Device::getTable(void)
mov rax, [rax+30h]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_78]
mov r8, [rbp+var_28]
mov r9, [rbp+var_30]
call rax
mov [rbp+var_9C], eax
jmp short $+2
loc_1884CE:
lea rdi, [rbp+var_70]; this
call _ZN16ScratchAllocatorD2Ev; ScratchAllocator::~ScratchAllocator()
mov eax, [rbp+var_9C]
add rsp, 0A0h
pop rbp
retn
loc_1884E6:
mov rdi, [rbp+var_80]
call __Unwind_Resume
| long long CreateComputePipelines(long long a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6)
{
long long Table; // rax
unsigned int v8; // [rsp+4h] [rbp-9Ch]
unsigned int i; // [rsp+18h] [rbp-88h]
long long v10; // [rsp+28h] [rbp-78h]
_BYTE v11[56]; // [rsp+30h] [rbp-70h] BYREF
Device *DeviceLayer; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+8Ch] [rbp-14h]
long long v17; // [rsp+90h] [rbp-10h]
long long v18; // [rsp+98h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
DeviceLayer = (Device *)getDeviceLayer(a1);
ScratchAllocator::ScratchAllocator((ScratchAllocator *)v11);
v10 = ScratchAllocator::copy<VkComputePipelineCreateInfo>(v11, v15, v16);
for ( i = 0; i < v16; ++i )
Device::overrideStage((long long)DeviceLayer, v10 + 96LL * i + 24, (ScratchAllocator *)v11);
Table = Device::getTable(DeviceLayer);
v8 = (*(long long ( **)(long long, long long, _QWORD, long long, long long, long long))(Table + 48))(
v18,
v17,
v16,
v10,
v14,
v13);
ScratchAllocator::~ScratchAllocator((ScratchAllocator *)v11);
return v8;
}
| |||
1,935 | CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo const*, VkAllocationCallbacks const*, VkPipeline_T**) | HansKristian-Work[P]pyroveil/layer/pyroveil.cpp | static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator,
VkPipeline *pPipelines)
{
auto *layer = getDeviceLayer(device);
ScratchAllocator scratch;
auto *createInfos = scratch.copy(pCreateInfos, createInfoCount);
for (uint32_t i = 0; i < createInfoCount; i++)
layer->overrideStage(&createInfos[i].stage, scratch);
return layer->getTable()->CreateComputePipelines(device, pipelineCache,
createInfoCount, createInfos, pAllocator,
pPipelines);
} | O1 | cpp | CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo const*, VkAllocationCallbacks const*, VkPipeline_T**):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, -0x58(%rbp)
movq (%rdi), %r14
leaq 0x55865d(%rip), %rdi # 0x5e4038
callq 0x80290
testl %eax, %eax
jne 0x8bb34
movq 0x558619(%rip), %rdi # 0x5e4008
xorl %r9d, %r9d
movq %r14, %rax
xorl %edx, %edx
divq %rdi
movq 0x5585ff(%rip), %rax # 0x5e4000
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x8ba48
movq (%rax), %r8
movq %rax, %r9
cmpq %r14, 0x8(%r8)
je 0x8ba48
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x8ba45
movq 0x8(%r8), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x8ba48
movq %r10, %r9
cmpq %r14, %rsi
jne 0x8ba19
jmp 0x8ba48
xorl %r9d, %r9d
testq %r9, %r9
je 0x8ba52
movq (%r9), %rax
jmp 0x8ba54
xorl %eax, %eax
movq %r12, -0x40(%rbp)
movq %r15, -0x48(%rbp)
movq %rbx, -0x50(%rbp)
testq %rax, %rax
je 0x8ba6b
movq 0x10(%rax), %r12
jmp 0x8ba6e
xorl %r12d, %r12d
leaq 0x5585c3(%rip), %rdi # 0x5e4038
callq 0x7efe0
leaq -0x90(%rbp), %rdi
movq %rdi, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
leaq -0x70(%rbp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x10(%rcx)
movl %r13d, -0x2c(%rbp)
movl %r13d, %r15d
movq %r15, %rax
shlq $0x5, %rax
leaq (%rax,%rax,2), %rbx
movq %rbx, %rsi
callq 0x888ec
movq %rax, %r13
testq %rax, %rax
je 0x8bad2
movq %r13, %rdi
movq -0x38(%rbp), %rsi
movq %rbx, %rdx
callq 0x7f1b0
cmpl $0x0, -0x2c(%rbp)
je 0x8bafd
movq %r13, %rbx
addq $0x18, %rbx
leaq -0x90(%rbp), %r14
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8a18e
addq $0x60, %rbx
decq %r15
jne 0x8bae6
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq %r13, %rcx
movq -0x48(%rbp), %r8
movq -0x50(%rbp), %r9
callq *0x48(%r12)
movl %eax, %ebx
leaq -0x70(%rbp), %rdi
callq 0x8ee9a
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7ee10
jmp 0x8bb3d
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x8ee9a
movq %rbx, %rdi
callq 0x809f0
| _ZL22CreateComputePipelinesP10VkDevice_TP17VkPipelineCache_TjPK27VkComputePipelineCreateInfoPK21VkAllocationCallbacksPP12VkPipeline_T:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, r9
mov r15, r8
mov [rbp+var_38], rcx
mov r13d, edx
mov r12, rsi
mov [rbp+var_58], rdi
mov r14, [rdi]
lea rdi, _ZL10globalLock; globalLock
call _pthread_mutex_lock
test eax, eax
jnz loc_8BB34
mov rdi, cs:qword_5E4008
xor r9d, r9d
mov rax, r14
xor edx, edx
div rdi
mov rax, cs:_ZL10deviceData; deviceData
mov rax, [rax+rdx*8]
test rax, rax
jz short loc_8BA48
mov r8, [rax]
mov r9, rax
cmp [r8+8], r14
jz short loc_8BA48
mov rcx, rdx
loc_8BA19:
mov r10, r8
mov r8, [r8]
test r8, r8
jz short loc_8BA45
mov rsi, [r8+8]
mov rax, rsi
xor edx, edx
div rdi
mov r9d, 0
cmp rdx, rcx
jnz short loc_8BA48
mov r9, r10
cmp rsi, r14
jnz short loc_8BA19
jmp short loc_8BA48
loc_8BA45:
xor r9d, r9d
loc_8BA48:
test r9, r9
jz short loc_8BA52
mov rax, [r9]
jmp short loc_8BA54
loc_8BA52:
xor eax, eax
loc_8BA54:
mov [rbp+var_40], r12
mov [rbp+var_48], r15
mov [rbp+var_50], rbx
test rax, rax
jz short loc_8BA6B
mov r12, [rax+10h]
jmp short loc_8BA6E
loc_8BA6B:
xor r12d, r12d
loc_8BA6E:
lea rdi, _ZL10globalLock; globalLock
call _pthread_mutex_unlock
lea rdi, [rbp+var_90]; this
mov [rdi+8], rdi
xor eax, eax
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 1
lea rcx, [rbp+var_70]
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
mov [rcx+10h], rax
mov [rbp+var_2C], r13d
mov r15d, r13d
mov rax, r15
shl rax, 5
lea rbx, [rax+rax*2]
mov rsi, rbx; unsigned __int64
call _ZN16ScratchAllocator10allocBytesEm; ScratchAllocator::allocBytes(ulong)
mov r13, rax
test rax, rax
jz short loc_8BAD2
mov rdi, r13
mov rsi, [rbp+var_38]
mov rdx, rbx
call _memcpy
loc_8BAD2:
cmp [rbp+var_2C], 0
jz short loc_8BAFD
mov rbx, r13
add rbx, 18h
lea r14, [rbp+var_90]
loc_8BAE6:
mov rdi, r12
mov rsi, rbx
mov rdx, r14
call _ZNK6Device13overrideStageEP31VkPipelineShaderStageCreateInfoR16ScratchAllocator; Device::overrideStage(VkPipelineShaderStageCreateInfo *,ScratchAllocator &)
add rbx, 60h ; '`'
dec r15
jnz short loc_8BAE6
loc_8BAFD:
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_40]
mov edx, [rbp+var_2C]
mov rcx, r13
mov r8, [rbp+var_48]
mov r9, [rbp+var_50]
call qword ptr [r12+48h]
mov ebx, eax
lea rdi, [rbp+var_70]
call _ZNSt6vectorISt10unique_ptrIvN16ScratchAllocator13MallocDeleterEESaIS3_EED2Ev; std::vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>::~vector()
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8BB34:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short $+2
loc_8BB3D:
mov rbx, rax
lea rdi, [rbp+var_70]
call _ZNSt6vectorISt10unique_ptrIvN16ScratchAllocator13MallocDeleterEESaIS3_EED2Ev; std::vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| long long CreateComputePipelines(_QWORD *a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6)
{
unsigned long long v9; // r14
int v10; // eax
long long *v11; // r9
long long **v12; // rax
long long *v13; // r8
long long *v14; // r10
long long v15; // rax
ScratchAllocator *v16; // r12
long long v17; // r15
unsigned long long v18; // rax
unsigned long long v19; // r13
_QWORD *v20; // rbx
unsigned int v21; // ebx
char v23[8]; // [rsp+0h] [rbp-90h] BYREF
char *v24; // [rsp+8h] [rbp-88h]
long long v25; // [rsp+10h] [rbp-80h]
long long v26; // [rsp+18h] [rbp-78h]
__int128 v27; // [rsp+20h] [rbp-70h] BYREF
long long v28; // [rsp+30h] [rbp-60h]
_QWORD *v29; // [rsp+38h] [rbp-58h]
long long v30; // [rsp+40h] [rbp-50h]
long long v31; // [rsp+48h] [rbp-48h]
long long v32; // [rsp+50h] [rbp-40h]
long long v33; // [rsp+58h] [rbp-38h]
unsigned int v34; // [rsp+64h] [rbp-2Ch]
v33 = a4;
v29 = a1;
v9 = *a1;
v10 = pthread_mutex_lock(&globalLock);
if ( v10 )
std::__throw_system_error(v10);
v11 = 0LL;
v12 = *(long long ***)(deviceData + 8 * (v9 % qword_5E4008));
if ( v12 )
{
v13 = *v12;
v11 = *(long long **)(deviceData + 8 * (v9 % qword_5E4008));
if ( (*v12)[1] != v9 )
{
while ( 1 )
{
v14 = v13;
v13 = (long long *)*v13;
if ( !v13 )
break;
v11 = 0LL;
if ( v13[1] % (unsigned long long)qword_5E4008 == v9 % qword_5E4008 )
{
v11 = v14;
if ( v13[1] != v9 )
continue;
}
goto LABEL_9;
}
v11 = 0LL;
}
}
LABEL_9:
if ( v11 )
v15 = *v11;
else
v15 = 0LL;
v32 = a2;
v31 = a5;
v30 = a6;
if ( v15 )
v16 = *(ScratchAllocator **)(v15 + 16);
else
v16 = 0LL;
pthread_mutex_unlock(&globalLock);
v24 = v23;
v25 = 0LL;
v26 = 1LL;
v27 = 0LL;
v28 = 0LL;
v34 = a3;
v17 = a3;
v18 = ScratchAllocator::allocBytes((ScratchAllocator *)v23, 96LL * a3);
v19 = v18;
if ( v18 )
memcpy(v18);
if ( v34 )
{
v20 = (_QWORD *)(v19 + 24);
do
{
Device::overrideStage(v16, v20, (ScratchAllocator *)v23);
v20 += 12;
--v17;
}
while ( v17 );
}
v21 = (*((long long ( **)(_QWORD *, long long, _QWORD, unsigned long long, long long, long long))v16 + 9))(
v29,
v32,
v34,
v19,
v31,
v30);
std::vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>::~vector(&v27);
return v21;
}
| CreateComputePipelines:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,R9
MOV R15,R8
MOV qword ptr [RBP + -0x38],RCX
MOV R13D,EDX
MOV R12,RSI
MOV qword ptr [RBP + -0x58],RDI
MOV R14,qword ptr [RDI]
LEA RDI,[0x6e4038]
CALL 0x00180290
TEST EAX,EAX
JNZ 0x0018bb34
MOV RDI,qword ptr [0x006e4008]
XOR R9D,R9D
MOV RAX,R14
XOR EDX,EDX
DIV RDI
MOV RAX,qword ptr [0x006e4000]
MOV RAX,qword ptr [RAX + RDX*0x8]
TEST RAX,RAX
JZ 0x0018ba48
MOV R8,qword ptr [RAX]
MOV R9,RAX
CMP qword ptr [R8 + 0x8],R14
JZ 0x0018ba48
MOV RCX,RDX
LAB_0018ba19:
MOV R10,R8
MOV R8,qword ptr [R8]
TEST R8,R8
JZ 0x0018ba45
MOV RSI,qword ptr [R8 + 0x8]
MOV RAX,RSI
XOR EDX,EDX
DIV RDI
MOV R9D,0x0
CMP RDX,RCX
JNZ 0x0018ba48
MOV R9,R10
CMP RSI,R14
JNZ 0x0018ba19
JMP 0x0018ba48
LAB_0018ba45:
XOR R9D,R9D
LAB_0018ba48:
TEST R9,R9
JZ 0x0018ba52
MOV RAX,qword ptr [R9]
JMP 0x0018ba54
LAB_0018ba52:
XOR EAX,EAX
LAB_0018ba54:
MOV qword ptr [RBP + -0x40],R12
MOV qword ptr [RBP + -0x48],R15
MOV qword ptr [RBP + -0x50],RBX
TEST RAX,RAX
JZ 0x0018ba6b
MOV R12,qword ptr [RAX + 0x10]
JMP 0x0018ba6e
LAB_0018ba6b:
XOR R12D,R12D
LAB_0018ba6e:
LEA RDI,[0x6e4038]
CALL 0x0017efe0
LEA RDI,[RBP + -0x90]
MOV qword ptr [RDI + 0x8],RDI
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x1
LEA RCX,[RBP + -0x70]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
MOV qword ptr [RCX + 0x10],RAX
MOV dword ptr [RBP + -0x2c],R13D
MOV R15D,R13D
MOV RAX,R15
SHL RAX,0x5
LEA RBX,[RAX + RAX*0x2]
LAB_0018bab3:
MOV RSI,RBX
CALL 0x001888ec
LAB_0018babb:
MOV R13,RAX
TEST RAX,RAX
JZ 0x0018bad2
MOV RDI,R13
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,RBX
CALL 0x0017f1b0
LAB_0018bad2:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0018bafd
MOV RBX,R13
ADD RBX,0x18
LEA R14,[RBP + -0x90]
LAB_0018bae6:
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R14
CALL 0x0018a18e
ADD RBX,0x60
DEC R15
JNZ 0x0018bae6
LAB_0018bafd:
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x2c]
MOV RCX,R13
MOV R8,qword ptr [RBP + -0x48]
MOV R9,qword ptr [RBP + -0x50]
CALL qword ptr [R12 + 0x48]
LAB_0018bb18:
MOV EBX,EAX
LEA RDI,[RBP + -0x70]
CALL 0x0018ee9a
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018bb34:
MOV EDI,EAX
CALL 0x0017ee10
|
/* CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo
const*, VkAllocationCallbacks const*, VkPipeline_T**) */
int4
CreateComputePipelines
(VkDevice_T *param_1,VkPipelineCache_T *param_2,uint param_3,
VkComputePipelineCreateInfo *param_4,VkAllocationCallbacks *param_5,VkPipeline_T **param_6
)
{
long *plVar1;
int iVar2;
int4 uVar3;
long lVar4;
void *__dest;
VkPipelineShaderStageCreateInfo *pVVar5;
long *plVar6;
long *plVar7;
Device *this;
ulong uVar8;
ScratchAllocator local_98 [8];
ScratchAllocator *local_90;
int8 local_88;
int8 local_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
VkDevice_T *local_60;
VkPipeline_T **local_58;
VkAllocationCallbacks *local_50;
VkPipelineCache_T *local_48;
VkComputePipelineCreateInfo *local_40;
uint local_34;
uVar8 = *(ulong *)param_1;
local_60 = param_1;
local_40 = param_4;
iVar2 = pthread_mutex_lock((pthread_mutex_t *)globalLock);
if (iVar2 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar2);
}
plVar6 = *(long **)(deviceData + (uVar8 % DAT_006e4008) * 8);
plVar7 = (long *)0x0;
if ((plVar6 != (long *)0x0) &&
(plVar1 = (long *)*plVar6, plVar7 = plVar6, ((long *)*plVar6)[1] != uVar8)) {
while (plVar6 = plVar1, plVar1 = (long *)*plVar6, plVar1 != (long *)0x0) {
plVar7 = (long *)0x0;
if (((ulong)plVar1[1] % DAT_006e4008 != uVar8 % DAT_006e4008) ||
(plVar7 = plVar6, plVar1[1] == uVar8)) goto LAB_0018ba48;
}
plVar7 = (long *)0x0;
}
LAB_0018ba48:
if (plVar7 == (long *)0x0) {
lVar4 = 0;
}
else {
lVar4 = *plVar7;
}
if (lVar4 == 0) {
this = (Device *)0x0;
}
else {
this = *(Device **)(lVar4 + 0x10);
}
local_58 = param_6;
local_50 = param_5;
local_48 = param_2;
pthread_mutex_unlock((pthread_mutex_t *)globalLock);
local_90 = local_98;
local_88 = 0;
local_80 = 1;
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
uVar8 = (ulong)param_3;
local_34 = param_3;
/* try { // try from 0018bab3 to 0018baba has its CatchHandler @ 0018bb3b */
__dest = (void *)ScratchAllocator::allocBytes(local_90,uVar8 * 0x60);
if (__dest != (void *)0x0) {
memcpy(__dest,local_40,uVar8 * 0x60);
}
if (local_34 != 0) {
pVVar5 = (VkPipelineShaderStageCreateInfo *)((long)__dest + 0x18);
do {
/* try { // try from 0018bae6 to 0018baf3 has its CatchHandler @ 0018bb3d */
Device::overrideStage(this,pVVar5,local_98);
pVVar5 = pVVar5 + 0x60;
uVar8 = uVar8 - 1;
} while (uVar8 != 0);
}
/* try { // try from 0018bafd to 0018bb17 has its CatchHandler @ 0018bb3b */
uVar3 = (**(code **)(this + 0x48))(local_60,local_48,local_34,__dest,local_50,local_58);
std::
vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>,std::allocator<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>>
::~vector((vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>,std::allocator<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>>
*)&local_78);
return uVar3;
}
|
|
1,936 | CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo const*, VkAllocationCallbacks const*, VkPipeline_T**) | HansKristian-Work[P]pyroveil/layer/pyroveil.cpp | static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
VkDevice device,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator,
VkPipeline *pPipelines)
{
auto *layer = getDeviceLayer(device);
ScratchAllocator scratch;
auto *createInfos = scratch.copy(pCreateInfos, createInfoCount);
for (uint32_t i = 0; i < createInfoCount; i++)
layer->overrideStage(&createInfos[i].stage, scratch);
return layer->getTable()->CreateComputePipelines(device, pipelineCache,
createInfoCount, createInfos, pAllocator,
pPipelines);
} | O3 | cpp | CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo const*, VkAllocationCallbacks const*, VkPipeline_T**):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movl %edx, %r13d
movq %rsi, -0x58(%rbp)
movq %rdi, -0x50(%rbp)
movq (%rdi), %rbx
leaq 0x54066b(%rip), %rdi # 0x5cafe8
callq 0x7f220
testl %eax, %eax
jne 0x8aa7d
leaq -0x90(%rbp), %r12
movq %rbx, (%r12)
leaq 0x540614(%rip), %rdi # 0x5cafb0
movq %r12, %rsi
callq 0x8da5a
movq %r14, -0x48(%rbp)
testq %rax, %rax
movq %r15, -0x40(%rbp)
je 0x8a9b7
movq 0x10(%rax), %r14
jmp 0x8a9ba
xorl %r14d, %r14d
leaq 0x540627(%rip), %rdi # 0x5cafe8
callq 0x7e000
leaq -0x70(%rbp), %rcx
movq %r12, -0x18(%rcx)
xorl %eax, %eax
movq %rax, -0x10(%rcx)
movq $0x1, -0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x10(%rcx)
movl %r13d, -0x2c(%rbp)
movl %r13d, %ebx
movq %rbx, %rax
shlq $0x5, %rax
leaq (%rax,%rax,2), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x87dac
movq %rax, %r13
testq %rax, %rax
je 0x8aa1a
movq %r13, %rdi
movq -0x38(%rbp), %rsi
movq %r15, %rdx
callq 0x7e1f0
cmpl $0x0, -0x2c(%rbp)
je 0x8aa45
movq %r13, %r12
addq $0x18, %r12
leaq -0x90(%rbp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x895dc
addq $0x60, %r12
decq %rbx
jne 0x8aa2e
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq %r13, %rcx
movq -0x40(%rbp), %r8
movq -0x48(%rbp), %r9
callq *0x48(%r14)
movl %eax, %r14d
leaq -0x70(%rbp), %rdi
callq 0x8de98
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x7de30
movq %rax, %r14
leaq 0x54055a(%rip), %rdi # 0x5cafe8
callq 0x7e000
jmp 0x8aaa3
jmp 0x8aa97
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0x8de98
movq %r14, %rdi
callq 0x7f950
| _ZL22CreateComputePipelinesP10VkDevice_TP17VkPipelineCache_TjPK27VkComputePipelineCreateInfoPK21VkAllocationCallbacksPP12VkPipeline_T:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, r9
mov r15, r8
mov [rbp+var_38], rcx
mov r13d, edx
mov [rbp+var_58], rsi
mov [rbp+var_50], rdi
mov rbx, [rdi]
lea rdi, _ZL10globalLock; globalLock
call _pthread_mutex_lock
test eax, eax
jnz loc_8AA7D
lea r12, [rbp+var_90]
mov [r12], rbx
lea rdi, _ZL10deviceData; deviceData
mov rsi, r12
call _ZNKSt10_HashtableIPvSt4pairIKS0_St10unique_ptrI6DeviceSt14default_deleteIS4_EEESaIS8_ENSt8__detail10_Select1stESt8equal_toIS0_ESt4hashIS0_ENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb0ELb0ELb1EEEE4findERS2_; std::_Hashtable<void *,std::pair<void * const,std::unique_ptr<Device>>,std::allocator<std::pair<void * const,std::unique_ptr<Device>>>,std::__detail::_Select1st,std::equal_to<void *>,std::hash<void *>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(void * const&)
mov [rbp+var_48], r14
test rax, rax
mov [rbp+var_40], r15
jz short loc_8A9B7
mov r14, [rax+10h]
jmp short loc_8A9BA
loc_8A9B7:
xor r14d, r14d
loc_8A9BA:
lea rdi, _ZL10globalLock; globalLock
call _pthread_mutex_unlock
lea rcx, [rbp+var_70]
mov [rcx-18h], r12
xor eax, eax
mov [rcx-10h], rax
mov qword ptr [rcx-8], 1
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
mov [rcx+10h], rax
mov [rbp+var_2C], r13d
mov ebx, r13d
mov rax, rbx
shl rax, 5
lea r15, [rax+rax*2]
mov rdi, r12; this
mov rsi, r15; unsigned __int64
call _ZN16ScratchAllocator10allocBytesEm; ScratchAllocator::allocBytes(ulong)
mov r13, rax
test rax, rax
jz short loc_8AA1A
mov rdi, r13
mov rsi, [rbp+var_38]
mov rdx, r15
call _memcpy
loc_8AA1A:
cmp [rbp+var_2C], 0
jz short loc_8AA45
mov r12, r13
add r12, 18h
lea r15, [rbp+var_90]
loc_8AA2E:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNK6Device13overrideStageEP31VkPipelineShaderStageCreateInfoR16ScratchAllocator; Device::overrideStage(VkPipelineShaderStageCreateInfo *,ScratchAllocator &)
add r12, 60h ; '`'
dec rbx
jnz short loc_8AA2E
loc_8AA45:
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_58]
mov edx, [rbp+var_2C]
mov rcx, r13
mov r8, [rbp+var_40]
mov r9, [rbp+var_48]
call qword ptr [r14+48h]
mov r14d, eax
lea rdi, [rbp+var_70]
call _ZNSt6vectorISt10unique_ptrIvN16ScratchAllocator13MallocDeleterEESaIS3_EED2Ev; std::vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>::~vector()
mov eax, r14d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8AA7D:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r14, rax
lea rdi, _ZL10globalLock; globalLock
call _pthread_mutex_unlock
jmp short loc_8AAA3
jmp short $+2
loc_8AA97:
mov r14, rax
lea rdi, [rbp+var_70]
call _ZNSt6vectorISt10unique_ptrIvN16ScratchAllocator13MallocDeleterEESaIS3_EED2Ev; std::vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>::~vector()
loc_8AAA3:
mov rdi, r14
call __Unwind_Resume
| long long CreateComputePipelines(_QWORD *a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6)
{
long long v9; // rbx
int v10; // eax
long long v11; // rax
long long v12; // r14
long long v13; // rbx
unsigned long long v14; // rax
unsigned long long v15; // r13
long long v16; // r12
unsigned int v17; // r14d
_QWORD v19[4]; // [rsp+0h] [rbp-90h] BYREF
__int128 v20; // [rsp+20h] [rbp-70h] BYREF
long long v21; // [rsp+30h] [rbp-60h]
long long v22; // [rsp+38h] [rbp-58h]
_QWORD *v23; // [rsp+40h] [rbp-50h]
long long v24; // [rsp+48h] [rbp-48h]
long long v25; // [rsp+50h] [rbp-40h]
long long v26; // [rsp+58h] [rbp-38h]
unsigned int v27; // [rsp+64h] [rbp-2Ch]
v26 = a4;
v22 = a2;
v23 = a1;
v9 = *a1;
v10 = pthread_mutex_lock(&globalLock);
if ( v10 )
std::__throw_system_error(v10);
v19[0] = v9;
v11 = std::_Hashtable<void *,std::pair<void * const,std::unique_ptr<Device>>,std::allocator<std::pair<void * const,std::unique_ptr<Device>>>,std::__detail::_Select1st,std::equal_to<void *>,std::hash<void *>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(&deviceData);
v24 = a6;
v25 = a5;
if ( v11 )
v12 = *(_QWORD *)(v11 + 16);
else
v12 = 0LL;
pthread_mutex_unlock(&globalLock);
v19[1] = v19;
v19[2] = 0LL;
v19[3] = 1LL;
v20 = 0LL;
v21 = 0LL;
v27 = a3;
v13 = a3;
v14 = ScratchAllocator::allocBytes((ScratchAllocator *)v19, 96LL * a3);
v15 = v14;
if ( v14 )
memcpy(v14);
if ( v27 )
{
v16 = v15 + 24;
do
{
Device::overrideStage(v12, v16, (ScratchAllocator *)v19);
v16 += 96LL;
--v13;
}
while ( v13 );
}
v17 = (*(long long ( **)(_QWORD *, long long, _QWORD, unsigned long long, long long, long long))(v12 + 72))(
v23,
v22,
v27,
v15,
v25,
v24);
std::vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>::~vector(&v20);
return v17;
}
| CreateComputePipelines:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,R9
MOV R15,R8
MOV qword ptr [RBP + -0x38],RCX
MOV R13D,EDX
MOV qword ptr [RBP + -0x58],RSI
MOV qword ptr [RBP + -0x50],RDI
MOV RBX,qword ptr [RDI]
LEA RDI,[0x6cafe8]
CALL 0x0017f220
TEST EAX,EAX
JNZ 0x0018aa7d
LEA R12,[RBP + -0x90]
MOV qword ptr [R12],RBX
LAB_0018a995:
LEA RDI,[0x6cafb0]
MOV RSI,R12
CALL 0x0018da5a
MOV qword ptr [RBP + -0x48],R14
TEST RAX,RAX
MOV qword ptr [RBP + -0x40],R15
JZ 0x0018a9b7
MOV R14,qword ptr [RAX + 0x10]
JMP 0x0018a9ba
LAB_0018a9b7:
XOR R14D,R14D
LAB_0018a9ba:
LEA RDI,[0x6cafe8]
CALL 0x0017e000
LEA RCX,[RBP + -0x70]
MOV qword ptr [RCX + -0x18],R12
XOR EAX,EAX
MOV qword ptr [RCX + -0x10],RAX
MOV qword ptr [RCX + -0x8],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
MOV qword ptr [RCX + 0x10],RAX
MOV dword ptr [RBP + -0x2c],R13D
MOV EBX,R13D
MOV RAX,RBX
SHL RAX,0x5
LEA R15,[RAX + RAX*0x2]
LAB_0018a9f8:
MOV RDI,R12
MOV RSI,R15
CALL 0x00187dac
LAB_0018aa03:
MOV R13,RAX
TEST RAX,RAX
JZ 0x0018aa1a
MOV RDI,R13
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,R15
CALL 0x0017e1f0
LAB_0018aa1a:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0018aa45
MOV R12,R13
ADD R12,0x18
LEA R15,[RBP + -0x90]
LAB_0018aa2e:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001895dc
ADD R12,0x60
DEC RBX
JNZ 0x0018aa2e
LAB_0018aa45:
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x58]
MOV EDX,dword ptr [RBP + -0x2c]
MOV RCX,R13
MOV R8,qword ptr [RBP + -0x40]
MOV R9,qword ptr [RBP + -0x48]
CALL qword ptr [R14 + 0x48]
LAB_0018aa5f:
MOV R14D,EAX
LEA RDI,[RBP + -0x70]
CALL 0x0018de98
MOV EAX,R14D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018aa7d:
MOV EDI,EAX
CALL 0x0017de30
LAB_0018aa84:
MOV R14,RAX
LEA RDI,[0x6cafe8]
CALL 0x0017e000
JMP 0x0018aaa3
LAB_0018aaa3:
MOV RDI,R14
CALL 0x0017f950
|
/* CreateComputePipelines(VkDevice_T*, VkPipelineCache_T*, unsigned int, VkComputePipelineCreateInfo
const*, VkAllocationCallbacks const*, VkPipeline_T**) */
int4
CreateComputePipelines
(VkDevice_T *param_1,VkPipelineCache_T *param_2,uint param_3,
VkComputePipelineCreateInfo *param_4,VkAllocationCallbacks *param_5,VkPipeline_T **param_6
)
{
int iVar1;
int4 uVar2;
long lVar3;
void *__dest;
int8 uVar4;
ulong uVar5;
VkPipelineShaderStageCreateInfo *pVVar6;
Device *this;
int8 local_98;
ScratchAllocator *local_90;
int8 local_88;
int8 local_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
VkPipelineCache_T *local_60;
VkDevice_T *local_58;
VkPipeline_T **local_50;
VkAllocationCallbacks *local_48;
VkComputePipelineCreateInfo *local_40;
uint local_34;
uVar4 = *(int8 *)param_1;
local_60 = param_2;
local_58 = param_1;
local_40 = param_4;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)globalLock);
if (iVar1 == 0) {
local_98 = uVar4;
/* try { // try from 0018a995 to 0018a9a3 has its CatchHandler @ 0018aa84 */
lVar3 = std::
_Hashtable<void*,std::pair<void*const,std::unique_ptr<Device,std::default_delete<Device>>>,std::allocator<std::pair<void*const,std::unique_ptr<Device,std::default_delete<Device>>>>,std::__detail::_Select1st,std::equal_to<void*>,std::hash<void*>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::find((_Hashtable<void*,std::pair<void*const,std::unique_ptr<Device,std::default_delete<Device>>>,std::allocator<std::pair<void*const,std::unique_ptr<Device,std::default_delete<Device>>>>,std::__detail::_Select1st,std::equal_to<void*>,std::hash<void*>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)deviceData,(void **)&local_98);
if (lVar3 == 0) {
this = (Device *)0x0;
}
else {
this = *(Device **)(lVar3 + 0x10);
}
local_50 = param_6;
local_48 = param_5;
pthread_mutex_unlock((pthread_mutex_t *)globalLock);
local_88 = 0;
local_80 = 1;
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
uVar5 = (ulong)param_3;
local_90 = (ScratchAllocator *)&local_98;
local_34 = param_3;
/* try { // try from 0018a9f8 to 0018aa02 has its CatchHandler @ 0018aa95 */
__dest = (void *)ScratchAllocator::allocBytes((ScratchAllocator *)&local_98,uVar5 * 0x60);
if (__dest != (void *)0x0) {
memcpy(__dest,local_40,uVar5 * 0x60);
}
if (local_34 != 0) {
pVVar6 = (VkPipelineShaderStageCreateInfo *)((long)__dest + 0x18);
do {
/* try { // try from 0018aa2e to 0018aa3b has its CatchHandler @ 0018aa97 */
Device::overrideStage(this,pVVar6,(ScratchAllocator *)&local_98);
pVVar6 = pVVar6 + 0x60;
uVar5 = uVar5 - 1;
} while (uVar5 != 0);
}
/* try { // try from 0018aa45 to 0018aa5e has its CatchHandler @ 0018aa95 */
uVar2 = (**(code **)(this + 0x48))(local_58,local_60,local_34,__dest,local_48,local_50);
std::
vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>,std::allocator<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>>
::~vector((vector<std::unique_ptr<void,ScratchAllocator::MallocDeleter>,std::allocator<std::unique_ptr<void,ScratchAllocator::MallocDeleter>>>
*)&local_78);
return uVar2;
}
uVar4 = std::__throw_system_error(iVar1);
/* catch() { ... } // from try @ 0018a995 with catch @ 0018aa84 */
pthread_mutex_unlock((pthread_mutex_t *)globalLock);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
}
|
|
1,937 | nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>) | ng-log[P]ng-log/src/logging.cc | LogMessageTime::LogMessageTime(std::chrono::system_clock::time_point now)
: timestamp_{now} {
std::time_t timestamp;
std::tie(tm_, timestamp, gmtoffset_) = Breakdown(now);
usecs_ = std::chrono::duration_cast<std::chrono::microseconds>(
now - std::chrono::system_clock::from_time_t(timestamp));
} | O1 | cpp | nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>):
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rsi, 0x38(%rdi)
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
movq %rsi, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
movq %rdx, (%rsp)
leaq 0x2265c(%rip), %rax # 0x31b89
cmpb $0x1, (%rax)
jne 0xf541
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7a70
jmp 0xf54e
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7260
movq 0x30(%rsp), %rax
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, 0x70(%rsp)
imulq $-0x3b9aca00, (%rsp), %rcx # imm = 0xC4653600
movq %rdx, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movabsq $0x48d159e26af37c05, %rdx # imm = 0x48D159E26AF37C05
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xa, %rdx
addq %rax, %rdx
imulq $0xe10, %rdx, %rax # imm = 0xE10
movq %rax, 0x48(%rbx)
addq %r14, %rcx
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, 0x40(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN5nglog14LogMessageTimeC2ENSt6chrono10time_pointINS1_3_V212system_clockENS1_8durationIlSt5ratioILl1ELl1000000000EEEEEE:
push r14; Alternative name is 'nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)'
push rbx
sub rsp, 78h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov dword ptr [rdi+20h], 0
movups xmmword ptr [rdi+28h], xmm0
mov [rdi+38h], rsi
mov rcx, 112E0BE826D694B3h
mov rax, rsi
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 1Ah
add rdx, rax
mov [rsp+88h+var_88], rdx
lea rax, _ZN3fLB18FLAGS_log_utc_timeE; fLB::FLAGS_log_utc_time
cmp byte ptr [rax], 1
jnz short loc_F541
mov rdi, rsp
lea rsi, [rsp+88h+var_80]
call _gmtime_r
jmp short loc_F54E
loc_F541:
mov rdi, rsp
lea rsi, [rsp+88h+var_80]
call _localtime_r
loc_F54E:
mov rax, [rsp+88h+var_58]
movups xmm0, [rsp+88h+var_80]
movups xmm1, [rsp+88h+var_70]
movups xmm2, xmmword ptr [rsp+28h]
movaps [rsp+88h+var_48], xmm0
movaps [rsp+88h+var_38], xmm1
movaps [rsp+88h+var_28], xmm2
mov rdx, [rsp+88h+var_50]
mov [rsp+88h+var_18], rdx
imul rcx, [rsp+88h+var_88], 0FFFFFFFFC4653600h
mov [rbx+30h], rdx
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov rdx, 48D159E26AF37C05h
imul rdx
mov rax, rdx
shr rax, 3Fh
sar rdx, 0Ah
add rdx, rax
imul rax, rdx, 0E10h
mov [rbx+48h], rax
add rcx, r14
mov rdx, 20C49BA5E353F7CFh
mov rax, rcx
imul rdx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
mov [rbx+40h], rdx
add rsp, 78h
pop rbx
pop r14
retn
| unsigned long long nglog::LogMessageTime::LogMessageTime(long long a1, long long a2)
{
long long v2; // rax
__int128 v3; // xmm0
__int128 v4; // xmm1
__int128 v5; // xmm2
long long v6; // rcx
long long v7; // rcx
unsigned long long result; // rax
long long v9; // [rsp+0h] [rbp-88h] BYREF
_OWORD v10[2]; // [rsp+8h] [rbp-80h] BYREF
__int128 v11; // [rsp+28h] [rbp-60h]
long long v12; // [rsp+38h] [rbp-50h]
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 32) = 0;
*(_OWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 56) = a2;
v9 = a2 / 1000000000;
if ( fLB::FLAGS_log_utc_time == 1 )
gmtime_r(&v9, v10);
else
localtime_r(&v9, v10);
v2 = *((_QWORD *)&v11 + 1);
v3 = v10[0];
v4 = v10[1];
v5 = v11;
v6 = -1000000000 * v9;
*(_QWORD *)(a1 + 48) = v12;
*(_OWORD *)(a1 + 32) = v5;
*(_OWORD *)(a1 + 16) = v4;
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 72) = 3600 * (v2 / 3600);
v7 = a2 + v6;
result = (unsigned long long)((unsigned __int128)(0x20C49BA5E353F7CFLL * (__int128)v7) >> 64) >> 63;
*(_QWORD *)(a1 + 64) = v7 / 1000;
return result;
}
| LogMessageTime:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV dword ptr [RDI + 0x20],0x0
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV qword ptr [RDI + 0x38],RSI
MOV RCX,0x112e0be826d694b3
MOV RAX,RSI
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x1a
ADD RDX,RAX
MOV qword ptr [RSP],RDX
LEA RAX,[0x131b89]
CMP byte ptr [RAX],0x1
JNZ 0x0010f541
MOV RDI,RSP
LEA RSI,[RSP + 0x8]
CALL 0x00107a70
JMP 0x0010f54e
LAB_0010f541:
MOV RDI,RSP
LEA RSI,[RSP + 0x8]
CALL 0x00107260
LAB_0010f54e:
MOV RAX,qword ptr [RSP + 0x30]
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS XMM1,xmmword ptr [RSP + 0x18]
MOVUPS XMM2,xmmword ptr [RSP + 0x28]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x70],RDX
IMUL RCX,qword ptr [RSP],-0x3b9aca00
MOV qword ptr [RBX + 0x30],RDX
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV RDX,0x48d159e26af37c05
IMUL RDX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0xa
ADD RDX,RAX
IMUL RAX,RDX,0xe10
MOV qword ptr [RBX + 0x48],RAX
ADD RCX,R14
MOV RDX,0x20c49ba5e353f7cf
MOV RAX,RCX
IMUL RDX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
MOV qword ptr [RBX + 0x40],RDX
ADD RSP,0x78
POP RBX
POP R14
RET
|
/* nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock,
std::chrono::duration<long, std::ratio<1l, 1000000000l> > >) */
void __thiscall nglog::LogMessageTime::LogMessageTime(LogMessageTime *this,long param_2)
{
long local_88;
tm local_80 [2];
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int4 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(long *)(this + 0x38) = param_2;
local_88 = param_2 / 1000000000;
if (fLB::FLAGS_log_utc_time == '\x01') {
gmtime_r(&local_88,local_80);
}
else {
localtime_r(&local_88,local_80);
}
*(char **)(this + 0x30) = local_80[0].tm_zone;
*(int8 *)(this + 0x20) = local_80[0]._32_8_;
*(long *)(this + 0x28) = local_80[0].tm_gmtoff;
*(int8 *)(this + 0x10) = local_80[0]._16_8_;
*(int8 *)(this + 0x18) = local_80[0]._24_8_;
*(int8 *)this = local_80[0]._0_8_;
*(int8 *)(this + 8) = local_80[0]._8_8_;
*(long *)(this + 0x48) = (local_80[0].tm_gmtoff / 0xe10) * 0xe10;
*(long *)(this + 0x40) = (local_88 * -1000000000 + param_2) / 1000;
return;
}
|
|
1,938 | my_hash_sort_8bit_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_8bit_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
/*
Remove trailing spaces. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *end= skip_trailing_space(key, len);
my_hash_sort_bin(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_8bit_bin:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0xac4f4
movq %r9, %rdi
andq $-0x4, %rdi
cmpq %rsi, %rdi
jbe 0xac4f4
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r9, %rax
movb -0x1(%r9), %r10b
cmpq %rdi, %r9
jbe 0xac554
leaq -0x1(%rax), %r9
cmpb $0x20, %r10b
je 0xac4dc
jmp 0xac4f7
movq %r9, %rax
movq %rax, %rdi
subq %rsi, %rdi
movq %rax, %rdx
movq %rdi, %r9
cmpq %rsi, %rax
jbe 0xac516
leaq -0x1(%rdx), %rax
leaq -0x1(%r9), %rdi
cmpb $0x20, -0x1(%rdx)
je 0xac4fd
movq (%rcx), %rax
movq (%r8), %rdi
testq %r9, %r9
jle 0xac54c
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0xac521
movq %rax, (%rcx)
movq %rdi, (%r8)
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdi, %rdx
setae %dil
orb %r9b, %dil
jne 0xac4f7
movq %rax, %rdi
movq %rdi, %rax
cmpq %rdx, %rdi
jbe 0xac4f7
leaq -0x4(%rax), %rdi
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0xac56b
jmp 0xac4f7
| my_hash_sort_8bit_bin:
push rbp
mov rbp, rsp
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_AC4F4
mov rdi, r9
and rdi, 0FFFFFFFFFFFFFFFCh
cmp rdi, rsi
jbe short loc_AC4F4
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_AC4DC:
mov rax, r9
mov r10b, [r9-1]
cmp r9, rdi
jbe short loc_AC554
lea r9, [rax-1]
cmp r10b, 20h ; ' '
jz short loc_AC4DC
jmp short loc_AC4F7
loc_AC4F4:
mov rax, r9
loc_AC4F7:
mov rdi, rax
sub rdi, rsi
loc_AC4FD:
mov rdx, rax
mov r9, rdi
cmp rax, rsi
jbe short loc_AC516
lea rax, [rdx-1]
lea rdi, [r9-1]
cmp byte ptr [rdx-1], 20h ; ' '
jz short loc_AC4FD
loc_AC516:
mov rax, [rcx]
mov rdi, [r8]
test r9, r9
jle short loc_AC54C
loc_AC521:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_AC521
loc_AC54C:
mov [rcx], rax
mov [r8], rdi
pop rbp
retn
loc_AC554:
cmp r10b, 20h ; ' '
setnz r9b
cmp rdx, rdi
setnb dil
or dil, r9b
jnz short loc_AC4F7
mov rdi, rax
loc_AC56B:
mov rax, rdi
cmp rdi, rdx
jbe short loc_AC4F7
lea rdi, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_AC56B
jmp loc_AC4F7
| long long my_hash_sort_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdi
unsigned long long v7; // rdx
unsigned __int8 *v8; // rax
char v9; // r10
long long v10; // rdi
unsigned long long v11; // rdx
long long v12; // r9
long long result; // rax
long long v14; // rdi
unsigned long long v15; // rdi
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = &a2[a3];
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = (unsigned __int8 *)v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v15 = v5;
do
{
v8 = (unsigned __int8 *)v15;
if ( v15 <= v7 )
break;
v15 -= 4LL;
}
while ( *((_DWORD *)v8 - 1) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = (unsigned long long)v8;
v12 = v10;
if ( v8 <= a2 )
break;
--v8;
--v10;
}
while ( *(_BYTE *)(v11 - 1) == 32 );
result = *a4;
v14 = *a5;
if ( v12 > 0 )
{
do
{
result ^= (v14 + (result & 0x3F)) * *a2 + (result << 8);
v14 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v11 );
}
*a4 = result;
*a5 = v14;
return result;
}
| my_hash_sort_8bit_bin:
PUSH RBP
MOV RBP,RSP
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001ac4f4
MOV RDI,R9
AND RDI,-0x4
CMP RDI,RSI
JBE 0x001ac4f4
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_001ac4dc:
MOV RAX,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDI
JBE 0x001ac554
LEA R9,[RAX + -0x1]
CMP R10B,0x20
JZ 0x001ac4dc
JMP 0x001ac4f7
LAB_001ac4f4:
MOV RAX,R9
LAB_001ac4f7:
MOV RDI,RAX
SUB RDI,RSI
LAB_001ac4fd:
MOV RDX,RAX
MOV R9,RDI
CMP RAX,RSI
JBE 0x001ac516
LEA RAX,[RDX + -0x1]
LEA RDI,[R9 + -0x1]
CMP byte ptr [RDX + -0x1],0x20
JZ 0x001ac4fd
LAB_001ac516:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST R9,R9
JLE 0x001ac54c
LAB_001ac521:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x001ac521
LAB_001ac54c:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
POP RBP
RET
LAB_001ac554:
CMP R10B,0x20
SETNZ R9B
CMP RDX,RDI
SETNC DIL
OR DIL,R9B
JNZ 0x001ac4f7
MOV RDI,RAX
LAB_001ac56b:
MOV RAX,RDI
CMP RDI,RDX
JBE 0x001ac4f7
LEA RDI,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x001ac56b
JMP 0x001ac4f7
|
void my_hash_sort_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
byte *pbVar2;
ulong uVar3;
byte *pbVar4;
long lVar5;
long lVar6;
pbVar2 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar2 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar2;
do {
pbVar2 = pbVar1;
if (pbVar2 <= pbVar4) {
pbVar1 = pbVar2;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar2[-1] == 0x20)
goto LAB_001ac56b;
break;
}
pbVar1 = pbVar2 + -1;
} while (pbVar2[-1] == 0x20);
}
goto LAB_001ac4f7;
while (pbVar1 = pbVar2 + -4, *(int *)(pbVar2 + -4) == 0x20202020) {
LAB_001ac56b:
pbVar2 = pbVar1;
if (pbVar2 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_001ac4f7:
lVar6 = (long)pbVar2 - (long)param_2;
do {
lVar5 = lVar6;
pbVar4 = pbVar2;
if (pbVar4 <= param_2) break;
pbVar2 = pbVar4 + -1;
lVar6 = lVar5 + -1;
} while (pbVar4[-1] == 0x20);
uVar3 = *param_4;
lVar6 = *param_5;
if (0 < lVar5) {
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar4);
}
*param_4 = uVar3;
*param_5 = lVar6;
return;
}
|
|
1,939 | mthd_my_read_rows | eloqsql/libmariadb/libmariadb/mariadb_lib.c | MYSQL_DATA *mthd_my_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
uint fields)
{
uint field;
ulong pkt_len;
ulong len;
uchar *cp;
char *to, *end_to;
MYSQL_DATA *result;
MYSQL_ROWS **prev_ptr,*cur;
NET *net = &mysql->net;
if ((pkt_len= ma_net_safe_read(mysql)) == packet_error)
return(0);
if (!(result=(MYSQL_DATA*) calloc(1, sizeof(MYSQL_DATA))))
{
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
ma_init_alloc_root(&result->alloc,8192,0); /* Assume rowlength < 8192 */
result->alloc.min_malloc=sizeof(MYSQL_ROWS);
prev_ptr= &result->data;
result->rows=0;
result->fields=fields;
while (*(cp=net->read_pos) != 254 || pkt_len >= 8)
{
result->rows++;
if (!(cur= (MYSQL_ROWS*) ma_alloc_root(&result->alloc,
sizeof(MYSQL_ROWS))) ||
!(cur->data= ((MYSQL_ROW)
ma_alloc_root(&result->alloc,
(fields+1)*sizeof(char *)+fields+pkt_len))))
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(0);
}
*prev_ptr=cur;
prev_ptr= &cur->next;
to= (char*) (cur->data+fields+1);
end_to=to+fields+pkt_len-1;
for (field=0 ; field < fields ; field++)
{
if ((len=(ulong) net_field_length(&cp)) == NULL_LENGTH)
{ /* null field */
cur->data[field] = 0;
}
else
{
cur->data[field] = to;
if (len > (ulong)(end_to - to) || to > end_to)
{
free_rows(result);
SET_CLIENT_ERROR(mysql, CR_UNKNOWN_ERROR, SQLSTATE_UNKNOWN, 0);
return(0);
}
memcpy(to,(char*) cp,len); to[len]=0;
to+=len+1;
cp+=len;
if (mysql_fields)
{
if (mysql_fields[field].max_length < len)
mysql_fields[field].max_length=len;
}
}
}
cur->data[field]=to; /* End of last field */
if ((pkt_len=ma_net_safe_read(mysql)) == packet_error)
{
free_rows(result);
return(0);
}
}
*prev_ptr=0; /* last pointer is null */
/* save status */
if (pkt_len > 1)
{
cp++;
mysql->warning_count= uint2korr(cp);
cp+= 2;
mysql->server_status= uint2korr(cp);
}
return(result);
} | O3 | c | mthd_my_read_rows:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, -0x60(%rbp)
movq %rdi, %r15
callq 0x19e07
movq %rax, %r14
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x1c8c2
movl $0x1, %edi
movl $0x60, %esi
callq 0x132f0
testq %rax, %rax
je 0x1c8d6
movq %rax, %r12
movq %rax, %rdi
addq $0x10, %rdi
movl $0x2000, %esi # imm = 0x2000
movq %rdi, -0x30(%rbp)
xorl %edx, %edx
callq 0x225d0
movq %r12, %rdx
movq $0x18, 0x28(%r12)
movq $0x0, 0x48(%r12)
movl %ebx, 0x50(%r12)
leal 0x1(%rbx), %eax
movq %rbx, -0x70(%rbp)
movl %ebx, %ecx
leaq (%rcx,%rax,8), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x68(%rbp)
movq %r12, %rbx
movq %r15, -0x58(%rbp)
movq %r12, -0x40(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x20(%r15), %r13
cmpq $0x7, %r14
ja 0x1c6a3
cmpb $-0x2, (%r13)
je 0x1c99b
movq %r15, %r12
incq 0x48(%rdx)
movl $0x18, %esi
movq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x2263f
testq %rax, %rax
je 0x1c92c
movq %rax, %rcx
movq -0x78(%rbp), %rax
leaq (%rax,%r14), %rsi
movq %r15, %rdi
movq %rcx, -0x38(%rbp)
callq 0x2263f
movq -0x38(%rbp), %rdx
movq %rax, 0x8(%rdx)
testq %rax, %rax
je 0x1c92c
movq %rdx, (%rbx)
movq 0x8(%rdx), %rax
movq -0x50(%rbp), %rcx
leaq (%rax,%rcx,8), %rbx
addq $0x8, %rbx
cmpl $0x0, -0x70(%rbp)
je 0x1c80f
leaq (%rax,%rcx,8), %rax
addq %rcx, %rax
addq $0x8, %rax
leaq (%r14,%rax), %r8
decq %r8
movq -0x68(%rbp), %r15
xorl %r12d, %r12d
movq -0x30(%rbp), %rdi
movq %r8, -0x48(%rbp)
movzbl (%r13), %r14d
cmpq $0xfa, %r14
ja 0x1c78f
incq %r13
movq 0x8(%rdx), %rax
movq %rbx, (%rax,%r12,8)
movq %r8, %rax
subq %rbx, %rax
cmpq %rax, %r14
ja 0x1c85d
cmpq %r8, %rbx
ja 0x1c85d
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x133a0
addq %r14, %r13
addq %r14, %rbx
incq %rbx
movb $0x0, -0x1(%rbx)
cmpq $0x0, -0x60(%rbp)
je 0x1c7b5
cmpq %r14, (%r15)
movq -0x50(%rbp), %rcx
jae 0x1c789
movq %r14, (%r15)
movq -0x30(%rbp), %rdi
jmp 0x1c7bd
cmpq $0xfb, %r14
je 0x1c7f1
cmpl $0xfd, %r14d
je 0x1c7d7
cmpl $0xfc, %r14d
jne 0x1c802
movzwl 0x1(%r13), %r14d
addq $0x3, %r13
jmp 0x1c73b
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq -0x48(%rbp), %r8
incq %r12
subq $-0x80, %r15
cmpq %r12, %rcx
jne 0x1c72a
jmp 0x1c816
movzwl 0x1(%r13), %eax
movzbl 0x3(%r13), %r14d
addq $0x4, %r13
shll $0x10, %r14d
orq %rax, %r14
jmp 0x1c73b
incq %r13
movq 0x8(%rdx), %rax
movq $0x0, (%rax,%r12,8)
jmp 0x1c7c5
movl 0x1(%r13), %r14d
addq $0x9, %r13
jmp 0x1c73b
xorl %ecx, %ecx
movq %r12, %r15
jmp 0x1c81e
movq 0x8(%rdx), %rax
movq -0x58(%rbp), %r15
movq %rdx, %r12
movq %rbx, (%rax,%rcx,8)
movq %r15, %rdi
callq 0x19e07
movq %rax, %r14
movq %r12, %rbx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
movq -0x40(%rbp), %rdx
jne 0x1c68e
movq %rdx, %rbx
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x22757
movq %rbx, %rdi
callq 0x13580
jmp 0x1c8c2
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x22757
movq -0x40(%rbp), %rdi
callq 0x13580
movq -0x58(%rbp), %r14
movl $0x7d0, 0x90(%r14) # imm = 0x7D0
leaq 0x297(%r14), %rdi
leaq 0x33774(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
movb %bl, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x33762(%rip), %rax # 0x50010
movq (%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13230
movb %bl, 0x296(%r14)
xorl %edx, %edx
movq %rdx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x7d8, 0x90(%r15) # imm = 0x7D8
leaq 0x297(%r15), %rdi
leaq 0x33711(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
xorl %eax, %eax
movb %al, 0x29c(%r15)
leaq 0x97(%r15), %rdi
leaq 0x336fd(%rip), %rax # 0x50010
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13230
xorl %edx, %edx
movb %dl, 0x296(%r15)
jmp 0x1c8c4
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x22757
movq -0x40(%rbp), %rdi
callq 0x13580
movl $0x7d8, 0x90(%r12) # imm = 0x7D8
leaq 0x297(%r12), %rdi
leaq 0x336a4(%rip), %rax # 0x50000
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13230
movb %bl, 0x29c(%r12)
leaq 0x97(%r12), %rdi
leaq 0x33690(%rip), %rax # 0x50010
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13230
movb %bl, 0x296(%r12)
jmp 0x1c8c2
movq $0x0, (%rbx)
cmpq $0x2, %r14
jb 0x1c8c4
movzwl 0x1(%r13), %eax
movl %eax, 0x388(%r15)
movzwl 0x3(%r13), %eax
movl %eax, 0x380(%r15)
jmp 0x1c8c4
| mthd_my_read_rows:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov ebx, edx
mov [rbp+var_60], rsi
mov r15, rdi
call ma_net_safe_read
mov r14, rax
mov eax, 0FFFFFFFFh
cmp r14, rax
jz loc_1C8C2
mov edi, 1
mov esi, 60h ; '`'
call _calloc
test rax, rax
jz loc_1C8D6
mov r12, rax
mov rdi, rax
add rdi, 10h
mov esi, 2000h
mov [rbp+var_30], rdi
xor edx, edx
call ma_init_alloc_root
mov rdx, r12
mov qword ptr [r12+28h], 18h
mov qword ptr [r12+48h], 0
mov [r12+50h], ebx
lea eax, [rbx+1]
mov [rbp+var_70], rbx
mov ecx, ebx
lea rax, [rcx+rax*8]
mov [rbp+var_78], rax
mov rax, [rbp+var_60]
add rax, 40h ; '@'
mov [rbp+var_68], rax
mov rbx, r12
mov [rbp+var_58], r15
mov [rbp+var_40], r12
mov [rbp+var_50], rcx
loc_1C68E:
mov r13, [r15+20h]
cmp r14, 7
ja short loc_1C6A3
cmp byte ptr [r13+0], 0FEh
jz loc_1C99B
loc_1C6A3:
mov r12, r15
inc qword ptr [rdx+48h]
mov esi, 18h
mov r15, [rbp+var_30]
mov rdi, r15
call ma_alloc_root
test rax, rax
jz loc_1C92C
mov rcx, rax
mov rax, [rbp+var_78]
lea rsi, [rax+r14]
mov rdi, r15
mov [rbp+var_38], rcx
call ma_alloc_root
mov rdx, [rbp+var_38]
mov [rdx+8], rax
test rax, rax
jz loc_1C92C
mov [rbx], rdx
mov rax, [rdx+8]
mov rcx, [rbp+var_50]
lea rbx, [rax+rcx*8]
add rbx, 8
cmp dword ptr [rbp+var_70], 0
jz loc_1C80F
lea rax, [rax+rcx*8]
add rax, rcx
add rax, 8
lea r8, [r14+rax]
dec r8
mov r15, [rbp+var_68]
xor r12d, r12d
mov rdi, [rbp+var_30]
mov [rbp+var_48], r8
loc_1C72A:
movzx r14d, byte ptr [r13+0]
cmp r14, 0FAh
ja short loc_1C78F
inc r13
loc_1C73B:
mov rax, [rdx+8]
mov [rax+r12*8], rbx
mov rax, r8
sub rax, rbx
cmp r14, rax
ja loc_1C85D
cmp rbx, r8
ja loc_1C85D
mov rdi, rbx
mov rsi, r13
mov rdx, r14
call _memcpy
add r13, r14
add rbx, r14
inc rbx
mov byte ptr [rbx-1], 0
cmp [rbp+var_60], 0
jz short loc_1C7B5
cmp [r15], r14
mov rcx, [rbp+var_50]
jnb short loc_1C789
mov [r15], r14
loc_1C789:
mov rdi, [rbp+var_30]
jmp short loc_1C7BD
loc_1C78F:
cmp r14, 0FBh
jz short loc_1C7F1
cmp r14d, 0FDh
jz short loc_1C7D7
cmp r14d, 0FCh
jnz short loc_1C802
movzx r14d, word ptr [r13+1]
add r13, 3
jmp short loc_1C73B
loc_1C7B5:
mov rdi, [rbp+var_30]
mov rcx, [rbp+var_50]
loc_1C7BD:
mov rdx, [rbp+var_38]
mov r8, [rbp+var_48]
loc_1C7C5:
inc r12
sub r15, 0FFFFFFFFFFFFFF80h
cmp rcx, r12
jnz loc_1C72A
jmp short loc_1C816
loc_1C7D7:
movzx eax, word ptr [r13+1]
movzx r14d, byte ptr [r13+3]
add r13, 4
shl r14d, 10h
or r14, rax
jmp loc_1C73B
loc_1C7F1:
inc r13
mov rax, [rdx+8]
mov qword ptr [rax+r12*8], 0
jmp short loc_1C7C5
loc_1C802:
mov r14d, [r13+1]
add r13, 9
jmp loc_1C73B
loc_1C80F:
xor ecx, ecx
mov r15, r12
jmp short loc_1C81E
loc_1C816:
mov rax, [rdx+8]
mov r15, [rbp+var_58]
loc_1C81E:
mov r12, rdx
mov [rax+rcx*8], rbx
mov rdi, r15
call ma_net_safe_read
mov r14, rax
mov rbx, r12
mov eax, 0FFFFFFFFh
cmp r14, rax
mov rdx, [rbp+var_40]
jnz loc_1C68E
mov rbx, rdx
mov rdi, [rbp+var_30]
xor esi, esi
call ma_free_root
mov rdi, rbx
call _free
jmp short loc_1C8C2
loc_1C85D:
xor ebx, ebx
xor esi, esi
call ma_free_root
mov rdi, [rbp+var_40]
call _free
mov r14, [rbp+var_58]
mov dword ptr [r14+90h], 7D0h
lea rdi, [r14+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov [r14+29Ch], bl
lea rdi, [r14+97h]
lea rax, client_errors
mov rsi, [rax]
mov edx, 1FFh
call _strncpy
mov [r14+296h], bl
loc_1C8C2:
xor edx, edx
loc_1C8C4:
mov rax, rdx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1C8D6:
mov dword ptr [r15+90h], 7D8h
lea rdi, [r15+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor eax, eax
mov [r15+29Ch], al
lea rdi, [r15+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
xor edx, edx
mov [r15+296h], dl
jmp short loc_1C8C4
loc_1C92C:
xor ebx, ebx
mov rdi, r15
xor esi, esi
call ma_free_root
mov rdi, [rbp+var_40]
call _free
mov dword ptr [r12+90h], 7D8h
lea rdi, [r12+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov [r12+29Ch], bl
lea rdi, [r12+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov [r12+296h], bl
jmp loc_1C8C2
loc_1C99B:
mov qword ptr [rbx], 0
cmp r14, 2
jb loc_1C8C4
movzx eax, word ptr [r13+1]
mov [r15+388h], eax
movzx eax, word ptr [r13+3]
mov [r15+380h], eax
jmp loc_1C8C4
| long long mthd_my_read_rows(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
unsigned int v6; // ebx
long long v7; // r15
unsigned long long v8; // r14
long long v9; // rax
long long v10; // r12
long long v11; // rdx
long long v12; // rcx
_QWORD *v13; // rbx
unsigned __int8 *v14; // r13
long long v15; // rax
long long v16; // rsi
long long v17; // rax
unsigned long long v18; // r8
int v19; // r9d
long long v20; // rdx
long long v21; // rax
long long v22; // rcx
unsigned long long v23; // rbx
unsigned long long *v24; // r15
long long v25; // r12
long long v26; // rdi
unsigned long long v27; // r14
unsigned __int8 *v28; // r13
long long v29; // rax
int v30; // r14d
_QWORD *v31; // r12
long long v33; // [rsp+8h] [rbp-78h]
unsigned int v34; // [rsp+10h] [rbp-70h]
unsigned long long *v35; // [rsp+18h] [rbp-68h]
long long v38; // [rsp+30h] [rbp-50h]
unsigned long long v39; // [rsp+38h] [rbp-48h]
long long v40; // [rsp+40h] [rbp-40h]
long long v41; // [rsp+48h] [rbp-38h]
long long v42; // [rsp+50h] [rbp-30h]
v6 = a3;
v7 = a1;
v8 = ma_net_safe_read(a1, a2, a3, a4, a5, a6);
if ( v8 == 0xFFFFFFFF )
return 0LL;
v9 = calloc(1LL, 96LL);
if ( v9 )
{
v10 = v9;
v42 = v9 + 16;
ma_init_alloc_root(v9 + 16, 0x2000LL, 0LL);
v11 = v10;
*(_QWORD *)(v10 + 40) = 24LL;
*(_QWORD *)(v10 + 72) = 0LL;
*(_DWORD *)(v10 + 80) = v6;
v34 = v6;
v12 = v6;
v33 = v6 + 8LL * (v6 + 1);
v35 = (unsigned long long *)(a2 + 64);
v13 = (_QWORD *)v10;
v40 = v10;
v38 = v12;
while ( 1 )
{
v14 = *(unsigned __int8 **)(v7 + 32);
if ( v8 <= 7 && *v14 == 0xFE )
break;
++*(_QWORD *)(v11 + 72);
v15 = ma_alloc_root(v42, 24LL);
if ( !v15
|| (v16 = v33 + v8, v41 = v15,
v17 = ma_alloc_root(v42, v33 + v8),
v20 = v41,
(*(_QWORD *)(v41 + 8) = v17) == 0LL) )
{
ma_free_root(v42, 0LL);
free(v40);
*(_DWORD *)(v7 + 144) = 2008;
strncpy(v7 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v7 + 668) = 0;
strncpy(v7 + 151, client_errors[8], 511LL);
*(_BYTE *)(v7 + 662) = 0;
return 0LL;
}
*v13 = v41;
v21 = *(_QWORD *)(v41 + 8);
v22 = v38;
v23 = v21 + 8 * v38 + 8;
if ( v34 )
{
v18 = v8 + v38 + v21 + 8 * v38 + 8 - 1;
v24 = v35;
v25 = 0LL;
v26 = v42;
v39 = v18;
while ( 1 )
{
v27 = *v14;
if ( v27 > 0xFA )
{
if ( v27 == 251 )
{
++v14;
*(_QWORD *)(*(_QWORD *)(v20 + 8) + 8 * v25) = 0LL;
goto LABEL_24;
}
if ( (_DWORD)v27 == 253 )
{
v29 = *(unsigned __int16 *)(v14 + 1);
v30 = v14[3];
v28 = v14 + 4;
v27 = v29 | (unsigned int)(v30 << 16);
}
else if ( (_DWORD)v27 == 252 )
{
v27 = *(unsigned __int16 *)(v14 + 1);
v28 = v14 + 3;
}
else
{
v27 = *(unsigned int *)(v14 + 1);
v28 = v14 + 9;
}
}
else
{
v28 = v14 + 1;
}
*(_QWORD *)(*(_QWORD *)(v20 + 8) + 8 * v25) = v23;
if ( v27 > v18 - v23 || v23 > v18 )
{
ma_free_root(v26, 0LL);
free(v40);
*(_DWORD *)(a1 + 144) = 2000;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[0], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return 0LL;
}
v16 = (long long)v28;
memcpy(v23, v28, v27);
v14 = &v28[v27];
v23 += v27 + 1;
*(_BYTE *)(v23 - 1) = 0;
if ( a2 )
{
v22 = v38;
if ( *v24 < v27 )
*v24 = v27;
v26 = v42;
}
else
{
v26 = v42;
v22 = v38;
}
v20 = v41;
v18 = v39;
LABEL_24:
++v25;
v24 += 16;
if ( v22 == v25 )
{
v21 = *(_QWORD *)(v20 + 8);
v7 = a1;
goto LABEL_30;
}
}
}
v22 = 0LL;
LABEL_30:
v31 = (_QWORD *)v20;
*(_QWORD *)(v21 + 8 * v22) = v23;
v8 = ma_net_safe_read(v7, v16, v20, v22, v18, v19);
v13 = v31;
v11 = v40;
if ( v8 == 0xFFFFFFFF )
{
ma_free_root(v42, 0LL);
free(v40);
return 0LL;
}
}
*v13 = 0LL;
if ( v8 >= 2 )
{
*(_DWORD *)(v7 + 904) = *(unsigned __int16 *)(v14 + 1);
*(_DWORD *)(v7 + 896) = *(unsigned __int16 *)(v14 + 3);
}
}
else
{
*(_DWORD *)(a1 + 144) = 2008;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[8], 511LL);
v11 = 0LL;
*(_BYTE *)(a1 + 662) = 0;
}
return v11;
}
| mthd_my_read_rows:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV EBX,EDX
MOV qword ptr [RBP + -0x60],RSI
MOV R15,RDI
CALL 0x00119e07
MOV R14,RAX
MOV EAX,0xffffffff
CMP R14,RAX
JZ 0x0011c8c2
MOV EDI,0x1
MOV ESI,0x60
CALL 0x001132f0
TEST RAX,RAX
JZ 0x0011c8d6
MOV R12,RAX
MOV RDI,RAX
ADD RDI,0x10
MOV ESI,0x2000
MOV qword ptr [RBP + -0x30],RDI
XOR EDX,EDX
CALL 0x001225d0
MOV RDX,R12
MOV qword ptr [R12 + 0x28],0x18
MOV qword ptr [R12 + 0x48],0x0
MOV dword ptr [R12 + 0x50],EBX
LEA EAX,[RBX + 0x1]
MOV qword ptr [RBP + -0x70],RBX
MOV ECX,EBX
LEA RAX,[RCX + RAX*0x8]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x40
MOV qword ptr [RBP + -0x68],RAX
MOV RBX,R12
MOV qword ptr [RBP + -0x58],R15
MOV qword ptr [RBP + -0x40],R12
MOV qword ptr [RBP + -0x50],RCX
LAB_0011c68e:
MOV R13,qword ptr [R15 + 0x20]
CMP R14,0x7
JA 0x0011c6a3
CMP byte ptr [R13],0xfe
JZ 0x0011c99b
LAB_0011c6a3:
MOV R12,R15
INC qword ptr [RDX + 0x48]
MOV ESI,0x18
MOV R15,qword ptr [RBP + -0x30]
MOV RDI,R15
CALL 0x0012263f
TEST RAX,RAX
JZ 0x0011c92c
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x78]
LEA RSI,[RAX + R14*0x1]
MOV RDI,R15
MOV qword ptr [RBP + -0x38],RCX
CALL 0x0012263f
MOV RDX,qword ptr [RBP + -0x38]
MOV qword ptr [RDX + 0x8],RAX
TEST RAX,RAX
JZ 0x0011c92c
MOV qword ptr [RBX],RDX
MOV RAX,qword ptr [RDX + 0x8]
MOV RCX,qword ptr [RBP + -0x50]
LEA RBX,[RAX + RCX*0x8]
ADD RBX,0x8
CMP dword ptr [RBP + -0x70],0x0
JZ 0x0011c80f
LEA RAX,[RAX + RCX*0x8]
ADD RAX,RCX
ADD RAX,0x8
LEA R8,[R14 + RAX*0x1]
DEC R8
MOV R15,qword ptr [RBP + -0x68]
XOR R12D,R12D
MOV RDI,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],R8
LAB_0011c72a:
MOVZX R14D,byte ptr [R13]
CMP R14,0xfa
JA 0x0011c78f
INC R13
LAB_0011c73b:
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RAX + R12*0x8],RBX
MOV RAX,R8
SUB RAX,RBX
CMP R14,RAX
JA 0x0011c85d
CMP RBX,R8
JA 0x0011c85d
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
CALL 0x001133a0
ADD R13,R14
ADD RBX,R14
INC RBX
MOV byte ptr [RBX + -0x1],0x0
CMP qword ptr [RBP + -0x60],0x0
JZ 0x0011c7b5
CMP qword ptr [R15],R14
MOV RCX,qword ptr [RBP + -0x50]
JNC 0x0011c789
MOV qword ptr [R15],R14
LAB_0011c789:
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0011c7bd
LAB_0011c78f:
CMP R14,0xfb
JZ 0x0011c7f1
CMP R14D,0xfd
JZ 0x0011c7d7
CMP R14D,0xfc
JNZ 0x0011c802
MOVZX R14D,word ptr [R13 + 0x1]
ADD R13,0x3
JMP 0x0011c73b
LAB_0011c7b5:
MOV RDI,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x50]
LAB_0011c7bd:
MOV RDX,qword ptr [RBP + -0x38]
MOV R8,qword ptr [RBP + -0x48]
LAB_0011c7c5:
INC R12
SUB R15,-0x80
CMP RCX,R12
JNZ 0x0011c72a
JMP 0x0011c816
LAB_0011c7d7:
MOVZX EAX,word ptr [R13 + 0x1]
MOVZX R14D,byte ptr [R13 + 0x3]
ADD R13,0x4
SHL R14D,0x10
OR R14,RAX
JMP 0x0011c73b
LAB_0011c7f1:
INC R13
MOV RAX,qword ptr [RDX + 0x8]
MOV qword ptr [RAX + R12*0x8],0x0
JMP 0x0011c7c5
LAB_0011c802:
MOV R14D,dword ptr [R13 + 0x1]
ADD R13,0x9
JMP 0x0011c73b
LAB_0011c80f:
XOR ECX,ECX
MOV R15,R12
JMP 0x0011c81e
LAB_0011c816:
MOV RAX,qword ptr [RDX + 0x8]
MOV R15,qword ptr [RBP + -0x58]
LAB_0011c81e:
MOV R12,RDX
MOV qword ptr [RAX + RCX*0x8],RBX
MOV RDI,R15
CALL 0x00119e07
MOV R14,RAX
MOV RBX,R12
MOV EAX,0xffffffff
CMP R14,RAX
MOV RDX,qword ptr [RBP + -0x40]
JNZ 0x0011c68e
MOV RBX,RDX
MOV RDI,qword ptr [RBP + -0x30]
XOR ESI,ESI
CALL 0x00122757
MOV RDI,RBX
CALL 0x00113580
JMP 0x0011c8c2
LAB_0011c85d:
XOR EBX,EBX
XOR ESI,ESI
CALL 0x00122757
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00113580
MOV R14,qword ptr [RBP + -0x58]
MOV dword ptr [R14 + 0x90],0x7d0
LEA RDI,[R14 + 0x297]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
MOV byte ptr [R14 + 0x29c],BL
LEA RDI,[R14 + 0x97]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX]
MOV EDX,0x1ff
CALL 0x00113230
MOV byte ptr [R14 + 0x296],BL
LAB_0011c8c2:
XOR EDX,EDX
LAB_0011c8c4:
MOV RAX,RDX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011c8d6:
MOV dword ptr [R15 + 0x90],0x7d8
LEA RDI,[R15 + 0x297]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
XOR EAX,EAX
MOV byte ptr [R15 + 0x29c],AL
LEA RDI,[R15 + 0x97]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113230
XOR EDX,EDX
MOV byte ptr [R15 + 0x296],DL
JMP 0x0011c8c4
LAB_0011c92c:
XOR EBX,EBX
MOV RDI,R15
XOR ESI,ESI
CALL 0x00122757
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00113580
MOV dword ptr [R12 + 0x90],0x7d8
LEA RDI,[R12 + 0x297]
LEA RAX,[0x150000]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113230
MOV byte ptr [R12 + 0x29c],BL
LEA RDI,[R12 + 0x97]
LEA RAX,[0x150010]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113230
MOV byte ptr [R12 + 0x296],BL
JMP 0x0011c8c2
LAB_0011c99b:
MOV qword ptr [RBX],0x0
CMP R14,0x2
JC 0x0011c8c4
MOVZX EAX,word ptr [R13 + 0x1]
MOV dword ptr [R15 + 0x388],EAX
MOVZX EAX,word ptr [R13 + 0x3]
MOV dword ptr [R15 + 0x380],EAX
JMP 0x0011c8c4
|
int8 * mthd_my_read_rows(long param_1,long param_2,uint param_3)
{
byte bVar1;
ulong uVar2;
int8 *__ptr;
int8 *puVar3;
long lVar4;
ulong uVar5;
int8 *puVar6;
int1 *__dest;
int1 *puVar7;
int8 *puVar8;
int1 *puVar9;
byte *__src;
byte *pbVar10;
ulong __n;
ulong *puVar11;
uVar2 = ma_net_safe_read();
if (uVar2 != 0xffffffff) {
__ptr = (int8 *)calloc(1,0x60);
if (__ptr == (int8 *)0x0) {
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00150050,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
puVar8 = __ptr + 2;
ma_init_alloc_root(puVar8,0x2000,0);
__ptr[5] = 0x18;
__ptr[9] = 0;
*(uint *)(__ptr + 10) = param_3;
uVar5 = (ulong)param_3;
puVar6 = __ptr;
do {
pbVar10 = *(byte **)(param_1 + 0x20);
if ((uVar2 < 8) && (*pbVar10 == 0xfe)) {
*puVar6 = 0;
if (1 < uVar2) {
*(uint *)(param_1 + 0x388) = (uint)*(ushort *)(pbVar10 + 1);
*(uint *)(param_1 + 0x380) = (uint)*(ushort *)(pbVar10 + 3);
return __ptr;
}
return __ptr;
}
__ptr[9] = __ptr[9] + 1;
puVar3 = (int8 *)ma_alloc_root(puVar8,0x18);
if (puVar3 == (int8 *)0x0) {
LAB_0011c92c:
ma_free_root(puVar8,0);
free(__ptr);
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Client_run_out_of_memory_00150050,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
lVar4 = ma_alloc_root(puVar8,uVar5 + (ulong)(param_3 + 1) * 8 + uVar2);
puVar3[1] = lVar4;
if (lVar4 == 0) goto LAB_0011c92c;
*puVar6 = puVar3;
lVar4 = puVar3[1];
__dest = (int1 *)(lVar4 + uVar5 * 8 + 8);
if (param_3 == 0) {
uVar2 = 0;
}
else {
puVar9 = (int1 *)(uVar2 + lVar4 + uVar5 * 9 + 7);
uVar2 = 0;
puVar11 = (ulong *)(param_2 + 0x40);
do {
bVar1 = *pbVar10;
__n = (ulong)bVar1;
if (__n < 0xfb) {
__src = pbVar10 + 1;
LAB_0011c73b:
*(int1 **)(puVar3[1] + uVar2 * 8) = __dest;
if (((ulong)((long)puVar9 - (long)__dest) < __n) || (puVar9 < __dest)) {
ma_free_root(puVar8,0);
free(__ptr);
*(int4 *)(param_1 + 0x90) = 2000;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),client_errors,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return (int8 *)0x0;
}
memcpy(__dest,__src,__n);
pbVar10 = __src + __n;
puVar7 = __dest + __n;
__dest = puVar7 + 1;
*puVar7 = 0;
if ((param_2 != 0) && (*puVar11 < __n)) {
*puVar11 = __n;
}
}
else {
if (__n != 0xfb) {
if (bVar1 == 0xfd) {
__src = pbVar10 + 4;
__n = (ulong)*(uint3 *)(pbVar10 + 1);
}
else if (bVar1 == 0xfc) {
__n = (ulong)*(ushort *)(pbVar10 + 1);
__src = pbVar10 + 3;
}
else {
__n = (ulong)*(uint *)(pbVar10 + 1);
__src = pbVar10 + 9;
}
goto LAB_0011c73b;
}
pbVar10 = pbVar10 + 1;
*(int8 *)(puVar3[1] + uVar2 * 8) = 0;
}
uVar2 = uVar2 + 1;
puVar11 = puVar11 + 0x10;
} while (uVar5 != uVar2);
lVar4 = puVar3[1];
uVar2 = uVar5;
}
*(int1 **)(lVar4 + uVar2 * 8) = __dest;
uVar2 = ma_net_safe_read(param_1);
puVar6 = puVar3;
} while (uVar2 != 0xffffffff);
ma_free_root(puVar8,0);
free(__ptr);
}
return (int8 *)0x0;
}
|
|
1,940 | common_embd_similarity_cos(float const*, float const*, int) | monkey531[P]llama/common/common.cpp | float common_embd_similarity_cos(const float * embd1, const float * embd2, int n){
double sum = 0.0;
double sum1 = 0.0;
double sum2 = 0.0;
for (int i = 0; i < n; i++) {
sum += embd1[i] * embd2[i];
sum1 += embd1[i] * embd1[i];
sum2 += embd2[i] * embd2[i];
}
// Handle the case where one or both vectors are zero vectors
if (sum1 == 0.0 || sum2 == 0.0) {
if (sum1 == 0.0 && sum2 == 0.0) {
return 1.0f; // two zero vectors are similar
}
return 0.0f;
}
return sum / (sqrt(sum1) * sqrt(sum2));
} | O2 | cpp | common_embd_similarity_cos(float const*, float const*, int):
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
xorpd %xmm4, %xmm4
cmpq %rax, %rdx
je 0x57cdb
movss (%rdi,%rax,4), %xmm1
movss (%rsi,%rax,4), %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
cvtss2sd %xmm3, %xmm3
addsd %xmm3, %xmm4
unpcklps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
mulps %xmm1, %xmm1
cvtps2pd %xmm1, %xmm1
addpd %xmm1, %xmm0
incq %rax
jmp 0x57cab
subq $0x28, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2 # xmm2 = xmm2[1],xmm0[1]
jne 0x57cf3
jnp 0x57d0d
ucomisd %xmm1, %xmm2
jne 0x57cfb
jnp 0x57d0d
ucomisd %xmm1, %xmm0
movsd %xmm4, 0x8(%rsp)
jb 0x57d33
sqrtsd %xmm0, %xmm3
jmp 0x57d4c
cmpeqpd %xmm1, %xmm2
cmpeqpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
testb $0x1, %al
jne 0x57d29
xorpd %xmm0, %xmm0
jmp 0x57d7f
movss 0x523af(%rip), %xmm0 # 0xaa0e0
jmp 0x57d7f
movapd %xmm2, 0x10(%rsp)
callq 0x23730
xorpd %xmm1, %xmm1
movapd 0x10(%rsp), %xmm2
movapd %xmm0, %xmm3
ucomisd %xmm1, %xmm2
jb 0x57d58
sqrtsd %xmm2, %xmm0
jmp 0x57d6d
movapd %xmm2, %xmm0
movsd %xmm3, 0x10(%rsp)
callq 0x23730
movsd 0x10(%rsp), %xmm3
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm3
divsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm0
addq $0x28, %rsp
retq
| _Z26common_embd_similarity_cosPKfS0_i:
xor eax, eax
test edx, edx
cmovle edx, eax
xorpd xmm0, xmm0
xorpd xmm4, xmm4
loc_57CAB:
cmp rdx, rax
jz short loc_57CDB
movss xmm1, dword ptr [rdi+rax*4]
movss xmm2, dword ptr [rsi+rax*4]
movaps xmm3, xmm1
mulss xmm3, xmm2
cvtss2sd xmm3, xmm3
addsd xmm4, xmm3
unpcklps xmm1, xmm2
mulps xmm1, xmm1
cvtps2pd xmm1, xmm1
addpd xmm0, xmm1
inc rax
jmp short loc_57CAB
loc_57CDB:
sub rsp, 28h
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
movapd xmm2, xmm0
unpckhpd xmm2, xmm0
jnz short loc_57CF3
jnp short loc_57D0D
loc_57CF3:
ucomisd xmm2, xmm1
jnz short loc_57CFB
jnp short loc_57D0D
loc_57CFB:
ucomisd xmm0, xmm1
movsd [rsp+28h+var_20], xmm4
jb short loc_57D33
sqrtsd xmm3, xmm0
jmp short loc_57D4C
loc_57D0D:
cmpeqpd xmm2, xmm1
cmpeqpd xmm1, xmm0
andpd xmm1, xmm2
movd eax, xmm1
test al, 1
jnz short loc_57D29
xorpd xmm0, xmm0
jmp short loc_57D7F
loc_57D29:
movss xmm0, cs:dword_AA0E0
jmp short loc_57D7F
loc_57D33:
movapd [rsp+28h+var_18], xmm2
call _sqrt
xorpd xmm1, xmm1
movapd xmm2, [rsp+28h+var_18]
movapd xmm3, xmm0
loc_57D4C:
ucomisd xmm2, xmm1
jb short loc_57D58
sqrtsd xmm0, xmm2
jmp short loc_57D6D
loc_57D58:
movapd xmm0, xmm2
movsd qword ptr [rsp+28h+var_18], xmm3
call _sqrt
movsd xmm3, qword ptr [rsp+28h+var_18]
loc_57D6D:
movsd xmm1, [rsp+28h+var_20]
mulsd xmm3, xmm0
divsd xmm1, xmm3
cvtsd2ss xmm0, xmm1
loc_57D7F:
add rsp, 28h
retn
| float common_embd_similarity_cos(const float *a1, const float *a2, long long a3)
{
long long v3; // rax
__m128d v4; // xmm0
double v5; // xmm4_8
__m128 v6; // xmm2
__m128 v7; // xmm1
__m128d v8; // xmm2
double v9; // xmm3_8
double v11; // xmm0_8
double v12; // [rsp+0h] [rbp-20h]
v3 = 0LL;
if ( (int)a3 <= 0 )
a3 = 0LL;
v4 = 0LL;
v5 = 0.0;
while ( a3 != v3 )
{
v6 = (__m128)LODWORD(a2[v3]);
v5 = v5 + (float)(a1[v3] * v6.m128_f32[0]);
v7 = _mm_unpacklo_ps((__m128)LODWORD(a1[v3]), v6);
v4 = _mm_add_pd(v4, _mm_cvtps_pd(_mm_mul_ps(v7, v7)));
++v3;
}
v8 = _mm_unpackhi_pd(v4, v4);
if ( v4.m128d_f64[0] == 0.0 || v8.m128d_f64[0] == 0.0 )
{
if ( (_mm_cvtsi128_si32((__m128i)_mm_and_pd(_mm_cmpeq_pd((__m128d)0LL, v4), _mm_cmpeq_pd(v8, (__m128d)0LL))) & 1) != 0 )
return 1.0;
else
return 0.0;
}
else
{
v12 = v5;
if ( v4.m128d_f64[0] < 0.0 )
v9 = sqrt(v4.m128d_f64[0]);
else
v9 = sqrt(v4.m128d_f64[0]);
if ( v8.m128d_f64[0] < 0.0 )
v11 = sqrt(v8.m128d_f64[0]);
else
v11 = sqrt(v8.m128d_f64[0]);
return v12 / (v9 * v11);
}
}
| common_embd_similarity_cos:
XOR EAX,EAX
TEST EDX,EDX
CMOVLE EDX,EAX
XORPD XMM0,XMM0
XORPD XMM4,XMM4
LAB_00157cab:
CMP RDX,RAX
JZ 0x00157cdb
MOVSS XMM1,dword ptr [RDI + RAX*0x4]
MOVSS XMM2,dword ptr [RSI + RAX*0x4]
MOVAPS XMM3,XMM1
MULSS XMM3,XMM2
CVTSS2SD XMM3,XMM3
ADDSD XMM4,XMM3
UNPCKLPS XMM1,XMM2
MULPS XMM1,XMM1
CVTPS2PD XMM1,XMM1
ADDPD XMM0,XMM1
INC RAX
JMP 0x00157cab
LAB_00157cdb:
SUB RSP,0x28
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
MOVAPD XMM2,XMM0
UNPCKHPD XMM2,XMM0
JNZ 0x00157cf3
JNP 0x00157d0d
LAB_00157cf3:
UCOMISD XMM2,XMM1
JNZ 0x00157cfb
JNP 0x00157d0d
LAB_00157cfb:
UCOMISD XMM0,XMM1
MOVSD qword ptr [RSP + 0x8],XMM4
JC 0x00157d33
SQRTSD XMM3,XMM0
JMP 0x00157d4c
LAB_00157d0d:
CMPEQPD XMM2,XMM1
CMPEQPD XMM1,XMM0
ANDPD XMM1,XMM2
MOVD EAX,XMM1
TEST AL,0x1
JNZ 0x00157d29
XORPD XMM0,XMM0
JMP 0x00157d7f
LAB_00157d29:
MOVSS XMM0,dword ptr [0x001aa0e0]
JMP 0x00157d7f
LAB_00157d33:
MOVAPD xmmword ptr [RSP + 0x10],XMM2
CALL 0x00123730
XORPD XMM1,XMM1
MOVAPD XMM2,xmmword ptr [RSP + 0x10]
MOVAPD XMM3,XMM0
LAB_00157d4c:
UCOMISD XMM2,XMM1
JC 0x00157d58
SQRTSD XMM0,XMM2
JMP 0x00157d6d
LAB_00157d58:
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x10],XMM3
CALL 0x00123730
MOVSD XMM3,qword ptr [RSP + 0x10]
LAB_00157d6d:
MOVSD XMM1,qword ptr [RSP + 0x8]
MULSD XMM3,XMM0
DIVSD XMM1,XMM3
CVTSD2SS XMM0,XMM1
LAB_00157d7f:
ADD RSP,0x28
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_similarity_cos(float const*, float const*, int) */
float common_embd_similarity_cos(float *param_1,float *param_2,int param_3)
{
float fVar1;
ulong uVar2;
ulong uVar3;
float fVar4;
double dVar5;
double dVar6;
double dVar7;
uVar2 = 0;
uVar3 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar3 = uVar2;
}
dVar5 = 0.0;
dVar6 = 0.0;
dVar7 = 0.0;
for (; uVar3 != uVar2; uVar2 = uVar2 + 1) {
fVar4 = param_1[uVar2];
fVar1 = param_2[uVar2];
dVar7 = dVar7 + (double)(fVar4 * fVar1);
dVar5 = dVar5 + (double)(fVar4 * fVar4);
dVar6 = dVar6 + (double)(fVar1 * fVar1);
}
if (((dVar5 == 0.0) && (!NAN(dVar5))) || ((dVar6 == 0.0 && (!NAN(dVar6))))) {
fVar4 = _DAT_001aa0e0;
if (dVar5 != 0.0 || dVar6 != 0.0) {
fVar4 = 0.0;
}
}
else {
if (dVar5 < 0.0) {
dVar5 = sqrt(dVar5);
}
else {
dVar5 = SQRT(dVar5);
}
if (dVar6 < 0.0) {
dVar6 = sqrt(dVar6);
}
else {
dVar6 = SQRT(dVar6);
}
fVar4 = (float)(dVar7 / (dVar5 * dVar6));
}
return fVar4;
}
|
|
1,941 | ggml_get_max_tensor_size | monkey531[P]llama/ggml/src/ggml.c | struct ggml_tensor * ggml_get_first_tensor(const struct ggml_context * ctx) {
struct ggml_object * obj = ctx->objects_begin;
char * const mem_buffer = ctx->mem_buffer;
while (obj != NULL) {
if (obj->type == GGML_OBJECT_TYPE_TENSOR) {
return (struct ggml_tensor *)(mem_buffer + obj->offs);
}
obj = obj->next;
}
return NULL;
} | O1 | c | ggml_get_max_tensor_size:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %r14
movq 0x18(%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x19bf2
cmpl $0x0, 0x18(%rax)
je 0x19bec
movq 0x10(%rax), %rax
jmp 0x19bdb
movq (%rax), %rbx
addq %r14, %rbx
xorl %eax, %eax
testq %rbx, %rbx
je 0x19c2c
movq %rax, %r15
movq %rbx, %rdi
callq 0x161c0
cmpq %rax, %r15
cmovaq %r15, %rax
movq -0x10(%rbx), %rcx
testq %rcx, %rcx
je 0x19c20
cmpl $0x0, 0x18(%rcx)
je 0x19c24
movq 0x10(%rcx), %rcx
jmp 0x19c0f
xorl %ebx, %ebx
jmp 0x19bf4
movq (%rcx), %rbx
addq %r14, %rbx
jmp 0x19bf4
popq %rbx
popq %r14
popq %r15
retq
| ggml_get_max_tensor_size:
push r15
push r14
push rbx
mov r14, [rdi+8]
mov rax, [rdi+18h]
xor ebx, ebx
loc_19BDB:
test rax, rax
jz short loc_19BF2
cmp dword ptr [rax+18h], 0
jz short loc_19BEC
mov rax, [rax+10h]
jmp short loc_19BDB
loc_19BEC:
mov rbx, [rax]
add rbx, r14
loc_19BF2:
xor eax, eax
loc_19BF4:
test rbx, rbx
jz short loc_19C2C
mov r15, rax
mov rdi, rbx
call _ggml_nbytes
cmp r15, rax
cmova rax, r15
mov rcx, [rbx-10h]
loc_19C0F:
test rcx, rcx
jz short loc_19C20
cmp dword ptr [rcx+18h], 0
jz short loc_19C24
mov rcx, [rcx+10h]
jmp short loc_19C0F
loc_19C20:
xor ebx, ebx
jmp short loc_19BF4
loc_19C24:
mov rbx, [rcx]
add rbx, r14
jmp short loc_19BF4
loc_19C2C:
pop rbx
pop r14
pop r15
retn
| unsigned long long ggml_get_max_tensor_size(long long a1)
{
long long v1; // r14
long long v2; // rax
unsigned int *v3; // rbx
unsigned long long result; // rax
unsigned long long v5; // r15
long long i; // rcx
v1 = *(_QWORD *)(a1 + 8);
v2 = *(_QWORD *)(a1 + 24);
v3 = 0LL;
while ( v2 )
{
if ( !*(_DWORD *)(v2 + 24) )
{
v3 = (unsigned int *)(v1 + *(_QWORD *)v2);
break;
}
v2 = *(_QWORD *)(v2 + 16);
}
result = 0LL;
LABEL_7:
while ( v3 )
{
v5 = result;
result = ggml_nbytes(v3);
if ( v5 > result )
result = v5;
for ( i = *((_QWORD *)v3 - 2); ; i = *(_QWORD *)(i + 16) )
{
if ( !i )
{
v3 = 0LL;
goto LABEL_7;
}
if ( !*(_DWORD *)(i + 24) )
break;
}
v3 = (unsigned int *)(v1 + *(_QWORD *)i);
}
return result;
}
| ggml_get_max_tensor_size:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RDI + 0x18]
XOR EBX,EBX
LAB_00119bdb:
TEST RAX,RAX
JZ 0x00119bf2
CMP dword ptr [RAX + 0x18],0x0
JZ 0x00119bec
MOV RAX,qword ptr [RAX + 0x10]
JMP 0x00119bdb
LAB_00119bec:
MOV RBX,qword ptr [RAX]
ADD RBX,R14
LAB_00119bf2:
XOR EAX,EAX
LAB_00119bf4:
TEST RBX,RBX
JZ 0x00119c2c
MOV R15,RAX
MOV RDI,RBX
CALL 0x001161c0
CMP R15,RAX
CMOVA RAX,R15
MOV RCX,qword ptr [RBX + -0x10]
LAB_00119c0f:
TEST RCX,RCX
JZ 0x00119c20
CMP dword ptr [RCX + 0x18],0x0
JZ 0x00119c24
MOV RCX,qword ptr [RCX + 0x10]
JMP 0x00119c0f
LAB_00119c20:
XOR EBX,EBX
JMP 0x00119bf4
LAB_00119c24:
MOV RBX,qword ptr [RCX]
ADD RBX,R14
JMP 0x00119bf4
LAB_00119c2c:
POP RBX
POP R14
POP R15
RET
|
void ggml_get_max_tensor_size(long param_1)
{
long lVar1;
long *plVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
lVar1 = *(long *)(param_1 + 8);
plVar2 = *(long **)(param_1 + 0x18);
lVar5 = 0;
do {
if (plVar2 == (long *)0x0) {
LAB_00119bf2:
uVar3 = 0;
LAB_00119bf4:
do {
if (lVar5 == 0) {
return;
}
uVar4 = ggml_nbytes(lVar5);
if (uVar4 < uVar3) {
uVar4 = uVar3;
}
for (plVar2 = *(long **)(lVar5 + -0x10); uVar3 = uVar4, plVar2 != (long *)0x0;
plVar2 = (long *)plVar2[2]) {
if ((int)plVar2[3] == 0) {
lVar5 = *plVar2 + lVar1;
goto LAB_00119bf4;
}
}
lVar5 = 0;
} while( true );
}
if ((int)plVar2[3] == 0) {
lVar5 = *plVar2 + lVar1;
goto LAB_00119bf2;
}
plVar2 = (long *)plVar2[2];
} while( true );
}
|
|
1,942 | stbi__jpeg_decode_block | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant)
{
int diff,dc,k;
int t;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
t = stbi__jpeg_huff_decode(j, hdc);
if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG");
// 0 all the ac values now so we can do it 32-bits at a time
memset(data,0,64*sizeof(data[0]));
diff = t ? stbi__extend_receive(j, t) : 0;
if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG");
dc = j->img_comp[b].dc_pred + diff;
j->img_comp[b].dc_pred = dc;
if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG");
data[0] = (short) (dc * dequant[0]);
// decode AC components, see JPEG spec
k = 1;
do {
unsigned int zig;
int c,r,s;
if (j->code_bits < 16) stbi__grow_buffer_unsafe(j);
c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1);
r = fac[c];
if (r) { // fast-AC path
k += (r >> 4) & 15; // run
s = r & 15; // combined length
if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available");
j->code_buffer <<= s;
j->code_bits -= s;
// decode into unzigzag'd location
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) ((r >> 8) * dequant[zig]);
} else {
int rs = stbi__jpeg_huff_decode(j, hac);
if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG");
s = rs & 15;
r = rs >> 4;
if (s == 0) {
if (rs != 0xf0) break; // end block
k += 16;
} else {
k += r;
// decode into unzigzag'd location
zig = stbi__jpeg_dezigzag[k++];
data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]);
}
}
} while (k < 64);
return 1;
} | O1 | c | stbi__jpeg_decode_block:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
cmpl $0xf, 0x4824(%rdi)
jg 0x188d0
movq %r12, %rdi
callq 0x18b47
movq %r12, %rdi
movq %r13, %rsi
callq 0x18d3d
cmpl $0x10, %eax
jb 0x188f8
movq %fs:0x0, %rax
leaq 0xda56(%rip), %rcx # 0x26349
jmp 0x18b2f
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r15)
movups %xmm0, 0x60(%r15)
movups %xmm0, 0x50(%r15)
movups %xmm0, 0x40(%r15)
movups %xmm0, 0x30(%r15)
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
testl %eax, %eax
je 0x18932
movq %r12, %rdi
movl %eax, %esi
callq 0x18e81
jmp 0x18934
xorl %eax, %eax
movslq %ebp, %rcx
leaq (%rcx,%rcx,2), %rdx
shlq $0x5, %rdx
movl 0x46b8(%r12,%rdx), %ecx
movl %ecx, %esi
xorl %eax, %esi
js 0x18978
movl $0x80000000, %esi # imm = 0x80000000
subl %eax, %esi
xorl %edi, %edi
cmpl %ecx, %esi
setle %dil
movl %eax, %esi
xorl $0x7fffffff, %esi # imm = 0x7FFFFFFF
xorl %r8d, %r8d
cmpl %ecx, %esi
setge %r8b
testl %eax, %ecx
cmovsl %edi, %r8d
testb %r8b, %r8b
je 0x189a7
movq 0x50(%rsp), %rbp
addq %r12, %rdx
addq $0x46b8, %rdx # imm = 0x46B8
addl %eax, %ecx
movl %ecx, (%rdx)
movzwl (%rbp), %esi
testl %esi, %esi
je 0x189d4
testl %ecx, %ecx
js 0x189bf
movl $0x7fff, %eax # imm = 0x7FFF
xorl %edx, %edx
divl %esi
cmpl %ecx, %eax
setge %al
jmp 0x189cc
movq %fs:0x0, %rax
leaq 0xdf20(%rip), %rcx # 0x268da
jmp 0x18b2f
movl $0xffff8000, %eax # imm = 0xFFFF8000
cltd
idivl %esi
cmpl %ecx, %eax
setle %al
testb %al, %al
je 0x18b1c
imull %ecx, %esi
movw %si, (%r15)
movq %fs:0x0, %rax
leaq -0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %r13d
movq %rbx, 0x10(%rsp)
cmpl $0xf, 0x4824(%r12)
jg 0x18a11
movq %r12, %rdi
callq 0x18b47
movl 0x4820(%r12), %eax
movl %eax, %ecx
shrl $0x17, %ecx
movzwl (%rbx,%rcx,2), %edx
testl %edx, %edx
je 0x18a7e
movl %edx, %ecx
shrl $0x4, %ecx
andl $0xf, %ecx
addl %ecx, %r13d
movl %edx, %ecx
andl $0xf, %ecx
movl 0x4824(%r12), %esi
subl %ecx, %esi
jl 0x18ad3
shll %cl, %eax
movswl %dx, %ecx
movl %eax, 0x4820(%r12)
movl %esi, 0x4824(%r12)
movslq %r13d, %rax
incl %r13d
leaq 0xbbb8(%rip), %rdx # 0x24620
movzbl (%rax,%rdx), %eax
shrl $0x8, %ecx
addl %eax, %eax
imulw (%rbp,%rax), %cx
movw %cx, (%r15,%rax)
jmp 0x18acf
movq %r12, %rdi
movq %r14, %rsi
callq 0x18d3d
testl %eax, %eax
js 0x18ad3
movl %eax, %esi
andl $0xf, %esi
je 0x18afc
shrl $0x4, %eax
movslq %r13d, %rcx
addq %rax, %rcx
leal 0x1(%rcx), %r13d
movq %r14, %rbx
leaq 0xbb75(%rip), %rax # 0x24620
movzbl (%rax,%rcx), %r14d
movq %r12, %rdi
callq 0x18e81
addl %r14d, %r14d
imulw (%rbp,%r14), %ax
movw %ax, (%r15,%r14)
movq %rbx, %r14
movq 0x10(%rsp), %rbx
xorl %ecx, %ecx
jmp 0x18ae7
movq 0x8(%rsp), %rax
leaq 0xd86a(%rip), %rcx # 0x26349
movq %rcx, (%rax)
movl $0x1, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x18b15
cmpl $0x40, %r13d
jl 0x189fe
jmp 0x18b38
leal 0x10(%r13), %edx
xorl %ecx, %ecx
cmpl $0xf0, %eax
setne %cl
cmovnel %r13d, %edx
addl %ecx, %ecx
movl %edx, %r13d
jmp 0x18ae7
cmpl $0x2, %ecx
jne 0x18b36
jmp 0x18b38
movq %fs:0x0, %rax
leaq 0xddb5(%rip), %rcx # 0x268e4
movq %rcx, -0x8(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| stbi__jpeg_decode_block:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r9d
mov rbx, r8
mov r14, rcx
mov r13, rdx
mov r15, rsi
mov r12, rdi
cmp dword ptr [rdi+4824h], 0Fh
jg short loc_188D0
mov rdi, r12
call stbi__grow_buffer_unsafe
loc_188D0:
mov rdi, r12
mov rsi, r13
call stbi__jpeg_huff_decode
cmp eax, 10h
jb short loc_188F8
mov rax, fs:0
lea rcx, aBadHuffmanCode; "bad huffman code"
jmp loc_18B2F
loc_188F8:
xorps xmm0, xmm0
movups xmmword ptr [r15+70h], xmm0
movups xmmword ptr [r15+60h], xmm0
movups xmmword ptr [r15+50h], xmm0
movups xmmword ptr [r15+40h], xmm0
movups xmmword ptr [r15+30h], xmm0
movups xmmword ptr [r15+20h], xmm0
movups xmmword ptr [r15+10h], xmm0
movups xmmword ptr [r15], xmm0
test eax, eax
jz short loc_18932
mov rdi, r12
mov esi, eax
call stbi__extend_receive
jmp short loc_18934
loc_18932:
xor eax, eax
loc_18934:
movsxd rcx, ebp
lea rdx, [rcx+rcx*2]
shl rdx, 5
mov ecx, [r12+rdx+46B8h]
mov esi, ecx
xor esi, eax
js short loc_18978
mov esi, 80000000h
sub esi, eax
xor edi, edi
cmp esi, ecx
setle dil
mov esi, eax
xor esi, 7FFFFFFFh
xor r8d, r8d
cmp esi, ecx
setnl r8b
test ecx, eax
cmovs r8d, edi
test r8b, r8b
jz short loc_189A7
loc_18978:
mov rbp, [rsp+48h+arg_0]
add rdx, r12
add rdx, 46B8h
add ecx, eax
mov [rdx], ecx
movzx esi, word ptr [rbp+0]
test esi, esi
jz short loc_189D4
test ecx, ecx
js short loc_189BF
mov eax, 7FFFh
xor edx, edx
div esi
cmp eax, ecx
setnl al
jmp short loc_189CC
loc_189A7:
mov rax, fs:0
lea rcx, aBadDelta; "bad delta"
jmp loc_18B2F
loc_189BF:
mov eax, 0FFFF8000h
cdq
idiv esi
cmp eax, ecx
setle al
loc_189CC:
test al, al
jz loc_18B1C
loc_189D4:
imul esi, ecx
mov [r15], si
mov rax, fs:0
lea rax, [rax-8]
mov [rsp+48h+var_40], rax
mov r13d, 1
mov [rsp+48h+var_38], rbx
loc_189FE:
cmp dword ptr [r12+4824h], 0Fh
jg short loc_18A11
mov rdi, r12
call stbi__grow_buffer_unsafe
loc_18A11:
mov eax, [r12+4820h]
mov ecx, eax
shr ecx, 17h
movzx edx, word ptr [rbx+rcx*2]
test edx, edx
jz short loc_18A7E
mov ecx, edx
shr ecx, 4
and ecx, 0Fh
add r13d, ecx
mov ecx, edx
and ecx, 0Fh
mov esi, [r12+4824h]
sub esi, ecx
jl loc_18AD3
shl eax, cl
movsx ecx, dx
mov [r12+4820h], eax
mov [r12+4824h], esi
movsxd rax, r13d
inc r13d
lea rdx, stbi__jpeg_dezigzag
movzx eax, byte ptr [rax+rdx]
shr ecx, 8
add eax, eax
imul cx, [rbp+rax+0]
mov [r15+rax], cx
jmp short loc_18ACF
loc_18A7E:
mov rdi, r12
mov rsi, r14
call stbi__jpeg_huff_decode
test eax, eax
js short loc_18AD3
mov esi, eax
and esi, 0Fh
jz short loc_18AFC
shr eax, 4
movsxd rcx, r13d
add rcx, rax
lea r13d, [rcx+1]
mov rbx, r14
lea rax, stbi__jpeg_dezigzag
movzx r14d, byte ptr [rax+rcx]
mov rdi, r12
call stbi__extend_receive
add r14d, r14d
imul ax, [rbp+r14+0]
mov [r15+r14], ax
mov r14, rbx
mov rbx, [rsp+48h+var_38]
loc_18ACF:
xor ecx, ecx
jmp short loc_18AE7
loc_18AD3:
mov rax, [rsp+48h+var_40]
lea rcx, aBadHuffmanCode; "bad huffman code"
mov [rax], rcx
mov ecx, 1
loc_18AE7:
mov eax, 1
test ecx, ecx
jnz short loc_18B15
cmp r13d, 40h ; '@'
jl loc_189FE
jmp short loc_18B38
loc_18AFC:
lea edx, [r13+10h]
xor ecx, ecx
cmp eax, 0F0h
setnz cl
cmovnz edx, r13d
add ecx, ecx
mov r13d, edx
jmp short loc_18AE7
loc_18B15:
cmp ecx, 2
jnz short loc_18B36
jmp short loc_18B38
loc_18B1C:
mov rax, fs:0
lea rcx, aCanTMergeDcAnd; "can't merge dc and ac"
loc_18B2F:
mov [rax-8], rcx
loc_18B36:
xor eax, eax
loc_18B38:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long stbi__jpeg_decode_block(
long long a1,
_OWORD *a2,
long long a3,
long long a4,
long long a5,
int a6,
double a7,
_WORD *a8)
{
unsigned int v13; // eax
unsigned long long v14; // rax
const char *v15; // rcx
int v16; // eax
long long v17; // rdx
int v18; // ecx
bool v19; // r8
int v20; // ecx
int v21; // esi
int v23; // r13d
__int16 v24; // dx
int v25; // ecx
int v26; // esi
bool v27; // cc
int v28; // esi
long long v29; // rax
long long v30; // rax
int v31; // eax
long long v32; // rcx
long long v33; // rbx
int v34; // r14d
int v35; // ecx
long long result; // rax
int v37; // edx
_QWORD *v38; // [rsp+8h] [rbp-40h]
long long v39; // [rsp+10h] [rbp-38h]
if ( *(int *)(a1 + 18468) <= 15 )
stbi__grow_buffer_unsafe(a1, a7);
v13 = stbi__jpeg_huff_decode(a1, a3, a7);
if ( v13 >= 0x10 )
{
v14 = __readfsqword(0);
v15 = "bad huffman code";
LABEL_38:
*(_QWORD *)(v14 - 8) = v15;
return 0LL;
}
a2[7] = 0LL;
a2[6] = 0LL;
a2[5] = 0LL;
a2[4] = 0LL;
a2[3] = 0LL;
a2[2] = 0LL;
a2[1] = 0LL;
*a2 = 0LL;
if ( v13 )
v16 = stbi__extend_receive(a1);
else
v16 = 0;
v17 = 96LL * a6;
v18 = *(_DWORD *)(a1 + v17 + 18104);
if ( (v16 ^ v18) >= 0 )
{
v19 = (v16 ^ 0x7FFFFFFF) >= v18;
if ( (v16 & v18) < 0 )
v19 = (int)(0x80000000 - v16) <= v18;
if ( !v19 )
{
v14 = __readfsqword(0);
v15 = "bad delta";
goto LABEL_38;
}
}
v20 = v16 + v18;
*(_DWORD *)(a1 + v17 + 18104) = v20;
v21 = (unsigned __int16)*a8;
if ( *a8 )
{
if ( !(v20 < 0 ? -32768 / v21 <= v20 : (int)(0x7FFFu / v21) >= v20) )
{
v14 = __readfsqword(0);
v15 = "can't merge dc and ac";
goto LABEL_38;
}
}
*(_WORD *)a2 = v20 * v21;
v38 = (_QWORD *)(__readfsqword(0) - 8);
v23 = 1;
v39 = a5;
while ( 1 )
{
if ( *(int *)(a1 + 18468) <= 15 )
stbi__grow_buffer_unsafe(a1, 0.0);
v24 = *(_WORD *)(a5 + 2LL * (*(_DWORD *)(a1 + 18464) >> 23));
if ( v24 )
{
v23 += (unsigned __int8)v24 >> 4;
v25 = v24 & 0xF;
v26 = *(_DWORD *)(a1 + 18468);
v27 = v26 < v25;
v28 = v26 - v25;
if ( !v27 )
{
*(_DWORD *)(a1 + 18464) <<= v25;
*(_DWORD *)(a1 + 18468) = v28;
v29 = v23++;
v30 = stbi__jpeg_dezigzag[v29];
*(_WORD *)((char *)a2 + v30 * 2) = a8[v30] * ((unsigned int)v24 >> 8);
LABEL_27:
v35 = 0;
goto LABEL_29;
}
LABEL_28:
*v38 = "bad huffman code";
v35 = 1;
goto LABEL_29;
}
v31 = stbi__jpeg_huff_decode(a1, a4, 0.0);
if ( v31 < 0 )
goto LABEL_28;
if ( (v31 & 0xF) != 0 )
{
v32 = ((unsigned int)v31 >> 4) + (long long)v23;
v23 = v32 + 1;
v33 = a4;
v34 = stbi__jpeg_dezigzag[v32];
*(_WORD *)((char *)a2 + (unsigned int)(2 * v34)) = *(_WORD *)((char *)a8 + (unsigned int)(2 * v34))
* stbi__extend_receive(a1);
a4 = v33;
a5 = v39;
goto LABEL_27;
}
v37 = v23 + 16;
if ( v31 != 240 )
v37 = v23;
v35 = 2 * (v31 != 240);
v23 = v37;
LABEL_29:
result = 1LL;
if ( v35 )
break;
if ( v23 >= 64 )
return result;
}
if ( v35 != 2 )
return 0LL;
return result;
}
| stbi__jpeg_decode_block:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R9D
MOV RBX,R8
MOV R14,RCX
MOV R13,RDX
MOV R15,RSI
MOV R12,RDI
CMP dword ptr [RDI + 0x4824],0xf
JG 0x001188d0
MOV RDI,R12
CALL 0x00118b47
LAB_001188d0:
MOV RDI,R12
MOV RSI,R13
CALL 0x00118d3d
CMP EAX,0x10
JC 0x001188f8
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x126349]
JMP 0x00118b2f
LAB_001188f8:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x70],XMM0
MOVUPS xmmword ptr [R15 + 0x60],XMM0
MOVUPS xmmword ptr [R15 + 0x50],XMM0
MOVUPS xmmword ptr [R15 + 0x40],XMM0
MOVUPS xmmword ptr [R15 + 0x30],XMM0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
MOVUPS xmmword ptr [R15 + 0x10],XMM0
MOVUPS xmmword ptr [R15],XMM0
TEST EAX,EAX
JZ 0x00118932
MOV RDI,R12
MOV ESI,EAX
CALL 0x00118e81
JMP 0x00118934
LAB_00118932:
XOR EAX,EAX
LAB_00118934:
MOVSXD RCX,EBP
LEA RDX,[RCX + RCX*0x2]
SHL RDX,0x5
MOV ECX,dword ptr [R12 + RDX*0x1 + 0x46b8]
MOV ESI,ECX
XOR ESI,EAX
JS 0x00118978
MOV ESI,0x80000000
SUB ESI,EAX
XOR EDI,EDI
CMP ESI,ECX
SETLE DIL
MOV ESI,EAX
XOR ESI,0x7fffffff
XOR R8D,R8D
CMP ESI,ECX
SETGE R8B
TEST ECX,EAX
CMOVS R8D,EDI
TEST R8B,R8B
JZ 0x001189a7
LAB_00118978:
MOV RBP,qword ptr [RSP + 0x50]
ADD RDX,R12
ADD RDX,0x46b8
ADD ECX,EAX
MOV dword ptr [RDX],ECX
MOVZX ESI,word ptr [RBP]
TEST ESI,ESI
JZ 0x001189d4
TEST ECX,ECX
JS 0x001189bf
MOV EAX,0x7fff
XOR EDX,EDX
DIV ESI
CMP EAX,ECX
SETGE AL
JMP 0x001189cc
LAB_001189a7:
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x1268da]
JMP 0x00118b2f
LAB_001189bf:
MOV EAX,0xffff8000
CDQ
IDIV ESI
CMP EAX,ECX
SETLE AL
LAB_001189cc:
TEST AL,AL
JZ 0x00118b1c
LAB_001189d4:
IMUL ESI,ECX
MOV word ptr [R15],SI
MOV RAX,qword ptr FS:[0x0]
LEA RAX,[RAX + -0x8]
MOV qword ptr [RSP + 0x8],RAX
MOV R13D,0x1
MOV qword ptr [RSP + 0x10],RBX
LAB_001189fe:
CMP dword ptr [R12 + 0x4824],0xf
JG 0x00118a11
MOV RDI,R12
CALL 0x00118b47
LAB_00118a11:
MOV EAX,dword ptr [R12 + 0x4820]
MOV ECX,EAX
SHR ECX,0x17
MOVZX EDX,word ptr [RBX + RCX*0x2]
TEST EDX,EDX
JZ 0x00118a7e
MOV ECX,EDX
SHR ECX,0x4
AND ECX,0xf
ADD R13D,ECX
MOV ECX,EDX
AND ECX,0xf
MOV ESI,dword ptr [R12 + 0x4824]
SUB ESI,ECX
JL 0x00118ad3
SHL EAX,CL
MOVSX ECX,DX
MOV dword ptr [R12 + 0x4820],EAX
MOV dword ptr [R12 + 0x4824],ESI
MOVSXD RAX,R13D
INC R13D
LEA RDX,[0x124620]
MOVZX EAX,byte ptr [RAX + RDX*0x1]
SHR ECX,0x8
ADD EAX,EAX
IMUL CX,word ptr [RBP + RAX*0x1]
MOV word ptr [R15 + RAX*0x1],CX
JMP 0x00118acf
LAB_00118a7e:
MOV RDI,R12
MOV RSI,R14
CALL 0x00118d3d
TEST EAX,EAX
JS 0x00118ad3
MOV ESI,EAX
AND ESI,0xf
JZ 0x00118afc
SHR EAX,0x4
MOVSXD RCX,R13D
ADD RCX,RAX
LEA R13D,[RCX + 0x1]
MOV RBX,R14
LEA RAX,[0x124620]
MOVZX R14D,byte ptr [RAX + RCX*0x1]
MOV RDI,R12
CALL 0x00118e81
ADD R14D,R14D
IMUL AX,word ptr [RBP + R14*0x1]
MOV word ptr [R15 + R14*0x1],AX
MOV R14,RBX
MOV RBX,qword ptr [RSP + 0x10]
LAB_00118acf:
XOR ECX,ECX
JMP 0x00118ae7
LAB_00118ad3:
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x126349]
MOV qword ptr [RAX],RCX
MOV ECX,0x1
LAB_00118ae7:
MOV EAX,0x1
TEST ECX,ECX
JNZ 0x00118b15
CMP R13D,0x40
JL 0x001189fe
JMP 0x00118b38
LAB_00118afc:
LEA EDX,[R13 + 0x10]
XOR ECX,ECX
CMP EAX,0xf0
SETNZ CL
CMOVNZ EDX,R13D
ADD ECX,ECX
MOV R13D,EDX
JMP 0x00118ae7
LAB_00118b15:
CMP ECX,0x2
JNZ 0x00118b36
JMP 0x00118b38
LAB_00118b1c:
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x1268e4]
LAB_00118b2f:
MOV qword ptr [RAX + -0x8],RCX
LAB_00118b36:
XOR EAX,EAX
LAB_00118b38:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
stbi__jpeg_decode_block
(long param_1,short *param_2,int8 param_3,int8 param_4,long param_5,
int param_6,ushort *param_7)
{
byte bVar1;
ushort uVar2;
uint uVar3;
bool bVar4;
int iVar5;
short sVar6;
uint uVar7;
int8 uVar8;
long lVar9;
char cVar10;
int iVar11;
char *pcVar12;
long lVar13;
long *in_FS_OFFSET;
if (*(int *)(param_1 + 0x4824) < 0x10) {
stbi__grow_buffer_unsafe(param_1);
}
uVar7 = stbi__jpeg_huff_decode(param_1,param_3);
if (uVar7 < 0x10) {
param_2[0x38] = 0;
param_2[0x39] = 0;
param_2[0x3a] = 0;
param_2[0x3b] = 0;
param_2[0x3c] = 0;
param_2[0x3d] = 0;
param_2[0x3e] = 0;
param_2[0x3f] = 0;
param_2[0x30] = 0;
param_2[0x31] = 0;
param_2[0x32] = 0;
param_2[0x33] = 0;
param_2[0x34] = 0;
param_2[0x35] = 0;
param_2[0x36] = 0;
param_2[0x37] = 0;
param_2[0x28] = 0;
param_2[0x29] = 0;
param_2[0x2a] = 0;
param_2[0x2b] = 0;
param_2[0x2c] = 0;
param_2[0x2d] = 0;
param_2[0x2e] = 0;
param_2[0x2f] = 0;
param_2[0x20] = 0;
param_2[0x21] = 0;
param_2[0x22] = 0;
param_2[0x23] = 0;
param_2[0x24] = 0;
param_2[0x25] = 0;
param_2[0x26] = 0;
param_2[0x27] = 0;
param_2[0x18] = 0;
param_2[0x19] = 0;
param_2[0x1a] = 0;
param_2[0x1b] = 0;
param_2[0x1c] = 0;
param_2[0x1d] = 0;
param_2[0x1e] = 0;
param_2[0x1f] = 0;
param_2[0x10] = 0;
param_2[0x11] = 0;
param_2[0x12] = 0;
param_2[0x13] = 0;
param_2[0x14] = 0;
param_2[0x15] = 0;
param_2[0x16] = 0;
param_2[0x17] = 0;
param_2[8] = 0;
param_2[9] = 0;
param_2[10] = 0;
param_2[0xb] = 0;
param_2[0xc] = 0;
param_2[0xd] = 0;
param_2[0xe] = 0;
param_2[0xf] = 0;
param_2[0] = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0;
param_2[4] = 0;
param_2[5] = 0;
param_2[6] = 0;
param_2[7] = 0;
if (uVar7 == 0) {
uVar7 = 0;
}
else {
uVar7 = stbi__extend_receive(param_1,uVar7);
}
uVar3 = *(uint *)(param_1 + 0x46b8 + (long)param_6 * 0x60);
if (-1 < (int)(uVar3 ^ uVar7)) {
bVar4 = (int)uVar3 <= (int)(uVar7 ^ 0x7fffffff);
if ((int)(uVar3 & uVar7) < 0) {
bVar4 = (int)(-0x80000000 - uVar7) <= (int)uVar3;
}
if (!bVar4) {
lVar9 = *in_FS_OFFSET;
pcVar12 = "bad delta";
goto LAB_00118b2f;
}
}
iVar11 = uVar3 + uVar7;
*(int *)((long)param_6 * 0x60 + param_1 + 0x46b8) = iVar11;
uVar2 = *param_7;
if (uVar2 != 0) {
if (iVar11 < 0) {
bVar4 = -0x8000 / (int)(uint)uVar2 <= iVar11;
}
else {
bVar4 = iVar11 <= (int)(0x7fff / (ulong)uVar2);
}
if (!bVar4) {
lVar9 = *in_FS_OFFSET;
pcVar12 = "can\'t merge dc and ac";
goto LAB_00118b2f;
}
}
*param_2 = uVar2 * (short)iVar11;
lVar9 = *in_FS_OFFSET;
iVar11 = 1;
do {
if (*(int *)(param_1 + 0x4824) < 0x10) {
stbi__grow_buffer_unsafe(param_1);
}
uVar2 = *(ushort *)(param_5 + (ulong)(*(uint *)(param_1 + 0x4820) >> 0x17) * 2);
if (uVar2 == 0) {
uVar7 = stbi__jpeg_huff_decode(param_1,param_4);
if ((int)uVar7 < 0) goto LAB_00118ad3;
if ((uVar7 & 0xf) != 0) {
lVar13 = (long)iVar11 + (ulong)(uVar7 >> 4);
iVar11 = (int)lVar13;
bVar1 = (&stbi__jpeg_dezigzag)[lVar13];
sVar6 = stbi__extend_receive(param_1);
*(short *)((long)param_2 + (ulong)((uint)bVar1 * 2)) =
sVar6 * *(short *)((long)param_7 + (ulong)((uint)bVar1 * 2));
goto LAB_00118acf;
}
iVar5 = iVar11 + 0x10;
if (uVar7 != 0xf0) {
iVar5 = iVar11;
}
iVar11 = iVar5;
cVar10 = (uVar7 != 0xf0) * '\x02';
}
else {
iVar11 = iVar11 + (uVar2 >> 4 & 0xf);
uVar7 = uVar2 & 0xf;
if (*(int *)(param_1 + 0x4824) < (int)uVar7) {
LAB_00118ad3:
*(char **)(lVar9 + -8) = "bad huffman code";
cVar10 = '\x01';
}
else {
*(uint *)(param_1 + 0x4820) = *(uint *)(param_1 + 0x4820) << (sbyte)uVar7;
*(uint *)(param_1 + 0x4824) = *(int *)(param_1 + 0x4824) - uVar7;
*(short *)((long)param_2 + (ulong)((uint)(byte)(&stbi__jpeg_dezigzag)[iVar11] * 2)) =
(short)(char)(uVar2 >> 8) *
*(short *)((long)param_7 + (ulong)((uint)(byte)(&stbi__jpeg_dezigzag)[iVar11] * 2));
LAB_00118acf:
iVar11 = iVar11 + 1;
cVar10 = '\0';
}
}
uVar8 = 1;
if (cVar10 != '\0') {
if (cVar10 == '\x02') {
return 1;
}
goto LAB_00118b36;
}
} while (iVar11 < 0x40);
}
else {
lVar9 = *in_FS_OFFSET;
pcVar12 = "bad huffman code";
LAB_00118b2f:
*(char **)(lVar9 + -8) = pcVar12;
LAB_00118b36:
uVar8 = 0;
}
return uVar8;
}
|
|
1,943 | stbi__getn | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
{
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
int res, count;
memcpy(buffer, s->img_buffer, blen);
count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen);
res = (count == (n-blen));
s->img_buffer = s->img_buffer_end;
return res;
}
}
if (s->img_buffer+n <= s->img_buffer_end) {
memcpy(buffer, s->img_buffer, n);
s->img_buffer += n;
return 1;
} else
return 0;
} | O1 | c | stbi__getn:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x35bec
movq 0xc0(%rbx), %rsi
movq 0xc8(%rbx), %r13
subq %rsi, %r13
movl %ebp, %r15d
subl %r13d, %r15d
jle 0x35be7
movslq %r13d, %r12
movq %r14, %rdi
movq %r12, %rdx
callq 0xa2a0
movq 0x28(%rbx), %rdi
addq %r14, %r12
movq %r12, %rsi
movl %r15d, %edx
callq *0x10(%rbx)
movl %eax, %ecx
xorl %eax, %eax
cmpl %r15d, %ecx
sete %al
movq 0xc8(%rbx), %rcx
movq %rcx, 0xc0(%rbx)
cmpl %r13d, %ebp
jg 0x35c1c
movq 0xc0(%rbx), %rsi
movslq %ebp, %r15
leaq (%rsi,%r15), %rcx
xorl %eax, %eax
cmpq 0xc8(%rbx), %rcx
ja 0x35c1c
movq %r14, %rdi
movq %r15, %rdx
callq 0xa2a0
addq %r15, 0xc0(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| stbi__getn:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, edx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rdi+10h], 0
jz short loc_35BEC
mov rsi, [rbx+0C0h]
mov r13, [rbx+0C8h]
sub r13, rsi
mov r15d, ebp
sub r15d, r13d
jle short loc_35BE7
movsxd r12, r13d
mov rdi, r14
mov rdx, r12
call _memcpy
mov rdi, [rbx+28h]
add r12, r14
mov rsi, r12
mov edx, r15d
call qword ptr [rbx+10h]
mov ecx, eax
xor eax, eax
cmp ecx, r15d
setz al
mov rcx, [rbx+0C8h]
mov [rbx+0C0h], rcx
loc_35BE7:
cmp ebp, r13d
jg short loc_35C1C
loc_35BEC:
mov rsi, [rbx+0C0h]
movsxd r15, ebp
lea rcx, [rsi+r15]
xor eax, eax
cmp rcx, [rbx+0C8h]
ja short loc_35C1C
mov rdi, r14
mov rdx, r15
call _memcpy
add [rbx+0C0h], r15
mov eax, 1
loc_35C1C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BOOL8 stbi__getn(long long a1, long long a2, int a3)
{
long long v5; // rsi
long long v6; // r13
_BOOL8 result; // rax
long long v8; // rsi
if ( *(_QWORD *)(a1 + 16) && (v5 = *(_QWORD *)(a1 + 192), v6 = *(_QWORD *)(a1 + 200) - v5, a3 > (int)v6) )
{
memcpy(a2, v5, (int)v6);
result = (*(unsigned int ( **)(_QWORD, long long, _QWORD))(a1 + 16))(
*(_QWORD *)(a1 + 40),
a2 + (int)v6,
(unsigned int)(a3 - v6)) == a3 - (_DWORD)v6;
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a1 + 200);
}
else
{
v8 = *(_QWORD *)(a1 + 192);
result = 0LL;
if ( (unsigned long long)(v8 + a3) <= *(_QWORD *)(a1 + 200) )
{
memcpy(a2, v8, a3);
*(_QWORD *)(a1 + 192) += a3;
return 1LL;
}
}
return result;
}
| stbi__getn:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RDI + 0x10],0x0
JZ 0x00135bec
MOV RSI,qword ptr [RBX + 0xc0]
MOV R13,qword ptr [RBX + 0xc8]
SUB R13,RSI
MOV R15D,EBP
SUB R15D,R13D
JLE 0x00135be7
MOVSXD R12,R13D
MOV RDI,R14
MOV RDX,R12
CALL 0x0010a2a0
MOV RDI,qword ptr [RBX + 0x28]
ADD R12,R14
MOV RSI,R12
MOV EDX,R15D
CALL qword ptr [RBX + 0x10]
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,R15D
SETZ AL
MOV RCX,qword ptr [RBX + 0xc8]
MOV qword ptr [RBX + 0xc0],RCX
LAB_00135be7:
CMP EBP,R13D
JG 0x00135c1c
LAB_00135bec:
MOV RSI,qword ptr [RBX + 0xc0]
MOVSXD R15,EBP
LEA RCX,[RSI + R15*0x1]
XOR EAX,EAX
CMP RCX,qword ptr [RBX + 0xc8]
JA 0x00135c1c
MOV RDI,R14
MOV RDX,R15
CALL 0x0010a2a0
ADD qword ptr [RBX + 0xc0],R15
MOV EAX,0x1
LAB_00135c1c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void stbi__getn(long param_1,void *param_2,int param_3)
{
int iVar1;
size_t __n;
if (*(long *)(param_1 + 0x10) != 0) {
iVar1 = (int)*(int8 *)(param_1 + 200) - (int)*(void **)(param_1 + 0xc0);
if (param_3 - iVar1 != 0 && iVar1 <= param_3) {
memcpy(param_2,*(void **)(param_1 + 0xc0),(long)iVar1);
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x28),(long)iVar1 + (long)param_2,param_3 - iVar1);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 200);
}
if (iVar1 < param_3) {
return;
}
}
__n = (size_t)param_3;
if ((long)*(void **)(param_1 + 0xc0) + __n <= *(ulong *)(param_1 + 200)) {
memcpy(param_2,*(void **)(param_1 + 0xc0),__n);
*(long *)(param_1 + 0xc0) = *(long *)(param_1 + 0xc0) + __n;
}
return;
}
|
|
1,944 | lf_pinbox_put_pins | eloqsql/mysys/lf_alloc-pin.c | void lf_pinbox_put_pins(LF_PINS *pins)
{
LF_PINBOX *pinbox= pins->pinbox;
uint32 top_ver, nr;
nr= pins->link;
#ifndef DBUG_OFF
{
/* This thread should not hold any pin. */
int i;
for (i= 0; i < LF_PINBOX_PINS; i++)
DBUG_ASSERT(pins->pin[i] == 0);
}
#endif /* DBUG_OFF */
/*
XXX this will deadlock if other threads will wait for
the caller to do something after lf_pinbox_put_pins(),
and they would have pinned addresses that the caller wants to free.
Thus: only free pins when all work is done and nobody can wait for you!!!
*/
while (pins->purgatory_count)
{
lf_pinbox_real_free(pins);
if (pins->purgatory_count)
pthread_yield();
}
top_ver= pinbox->pinstack_top_ver;
do
{
pins->link= top_ver % LF_PINBOX_MAX_PINS;
} while (!my_atomic_cas32((int32 volatile*) &pinbox->pinstack_top_ver,
(int32*) &top_ver,
top_ver-pins->link+nr+LF_PINBOX_MAX_PINS));
return;
} | O0 | c | lf_pinbox_put_pins:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x5da76
movq -0x8(%rbp), %rdi
callq 0x5daf0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x5da74
callq 0x264b0
jmp 0x5da52
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
andl $0xffff, %ecx # imm = 0xFFFF
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
subl %eax, %esi
movl -0x18(%rbp), %eax
movl %eax, %edx
movl %esi, %eax
leal 0x10000(%rax,%rdx), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %edx
lock
cmpxchgl %edx, 0x3c(%rcx)
movl %eax, %ecx
sete %al
movb %al, -0x25(%rbp)
movl %ecx, -0x24(%rbp)
testb $0x1, %al
jne 0x5dad1
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5da80
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| lf_pinbox_put_pins:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+20h]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov eax, [rax+34h]
mov [rbp+var_18], eax
loc_5DA52:
mov rax, [rbp+var_8]
cmp dword ptr [rax+30h], 0
jz short loc_5DA76
mov rdi, [rbp+var_8]
call lf_pinbox_real_free
mov rax, [rbp+var_8]
cmp dword ptr [rax+30h], 0
jz short loc_5DA74
call _sched_yield
loc_5DA74:
jmp short loc_5DA52
loc_5DA76:
mov rax, [rbp+var_10]
mov eax, [rax+3Ch]
mov [rbp+var_14], eax
loc_5DA80:
mov ecx, [rbp+var_14]
and ecx, 0FFFFh
mov rax, [rbp+var_8]
mov [rax+34h], ecx
mov rcx, [rbp+var_10]
mov esi, [rbp+var_14]
mov rax, [rbp+var_8]
mov eax, [rax+34h]
sub esi, eax
mov eax, [rbp+var_18]
mov edx, eax
mov eax, esi
lea eax, [rax+rdx+10000h]
mov [rbp+var_1C], eax
mov eax, [rbp+var_14]
mov edx, [rbp+var_1C]
lock cmpxchg [rcx+3Ch], edx
mov ecx, eax
setz al
mov [rbp+var_25], al
mov [rbp+var_24], ecx
test al, 1
jnz short loc_5DAD1
mov eax, [rbp+var_24]
mov [rbp+var_14], eax
loc_5DAD1:
mov al, [rbp+var_25]
and al, 1
mov [rbp+var_1D], al
mov al, [rbp+var_1D]
xor al, 0FFh
test al, 1
jnz short loc_5DA80
add rsp, 30h
pop rbp
retn
| char lf_pinbox_put_pins(long long a1)
{
signed __int32 v1; // eax
signed __int32 v2; // ett
char result; // al
bool v4; // [rsp+Bh] [rbp-25h]
int v5; // [rsp+18h] [rbp-18h]
signed __int32 v6; // [rsp+1Ch] [rbp-14h]
long long v7; // [rsp+20h] [rbp-10h]
v7 = *(_QWORD *)(a1 + 32);
v5 = *(_DWORD *)(a1 + 52);
while ( *(_DWORD *)(a1 + 48) )
{
lf_pinbox_real_free(a1);
if ( *(_DWORD *)(a1 + 48) )
sched_yield();
}
v6 = *(_DWORD *)(v7 + 60);
do
{
*(_DWORD *)(a1 + 52) = (unsigned __int16)v6;
v2 = v6;
v1 = _InterlockedCompareExchange((volatile signed __int32 *)(v7 + 60), v6 - *(_DWORD *)(a1 + 52) + v5 + 0x10000, v6);
v4 = v2 == v1;
if ( v2 != v1 )
v6 = v1;
result = ~v4;
}
while ( !v4 );
return result;
}
| lf_pinbox_put_pins:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x34]
MOV dword ptr [RBP + -0x18],EAX
LAB_0015da52:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x30],0x0
JZ 0x0015da76
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0015daf0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x30],0x0
JZ 0x0015da74
CALL 0x001264b0
LAB_0015da74:
JMP 0x0015da52
LAB_0015da76:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x3c]
MOV dword ptr [RBP + -0x14],EAX
LAB_0015da80:
MOV ECX,dword ptr [RBP + -0x14]
AND ECX,0xffff
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x34],ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x34]
SUB ESI,EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV EDX,EAX
MOV EAX,ESI
LEA EAX,[RAX + RDX*0x1 + 0x10000]
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + -0x1c]
CMPXCHG.LOCK dword ptr [RCX + 0x3c],EDX
MOV ECX,EAX
SETZ AL
MOV byte ptr [RBP + -0x25],AL
MOV dword ptr [RBP + -0x24],ECX
TEST AL,0x1
JNZ 0x0015dad1
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x14],EAX
LAB_0015dad1:
MOV AL,byte ptr [RBP + -0x25]
AND AL,0x1
MOV byte ptr [RBP + -0x1d],AL
MOV AL,byte ptr [RBP + -0x1d]
XOR AL,0xff
TEST AL,0x1
JNZ 0x0015da80
ADD RSP,0x30
POP RBP
RET
|
void lf_pinbox_put_pins(long param_1)
{
uint *puVar1;
int iVar2;
long lVar3;
uint uVar4;
bool bVar5;
uint local_1c;
lVar3 = *(long *)(param_1 + 0x20);
iVar2 = *(int *)(param_1 + 0x34);
while (*(int *)(param_1 + 0x30) != 0) {
lf_pinbox_real_free(param_1);
if (*(int *)(param_1 + 0x30) != 0) {
sched_yield();
}
}
local_1c = *(uint *)(lVar3 + 0x3c);
do {
*(uint *)(param_1 + 0x34) = local_1c & 0xffff;
puVar1 = (uint *)(lVar3 + 0x3c);
LOCK();
uVar4 = *puVar1;
bVar5 = local_1c == uVar4;
if (bVar5) {
*puVar1 = (local_1c - *(int *)(param_1 + 0x34)) + 0x10000 + iVar2;
uVar4 = local_1c;
}
UNLOCK();
local_1c = uVar4;
} while (!bVar5);
return;
}
|
|
1,945 | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array() | monkey531[P]llama/common/./json.hpp | bool end_array()
{
bool keep = true;
if (ref_stack.back())
{
keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
if (keep)
{
ref_stack.back()->set_parents();
}
else
{
// discard array
*ref_stack.back() = discarded;
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
// remove discarded value
if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->pop_back();
}
return true;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::end_array():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movb $0x1, 0x2f(%rsp)
addq $0x8, %rdi
callq 0xb9880
cmpq $0x0, (%rax)
je 0xb8b22
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0xb9280
movq 0x10(%rsp), %rdi
subl $0x1, %eax
movl %eax, 0xc(%rsp)
addq $0x8, %rdi
callq 0xb9880
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movq (%rax), %rcx
movl $0x3, %edx
callq 0xb9220
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0xb8ae5
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0x9faf0
jmp 0xb8b20
movq 0x10(%rsp), %rsi
addq $0xa8, %rsi
leaq 0x18(%rsp), %rdi
callq 0x6ed00
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0xb3e10
leaq 0x18(%rsp), %rdi
callq 0x6e0f0
jmp 0xb8b22
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0xb8b38
jmp 0xb8b3a
jmp 0xb8b59
leaq 0x11627b(%rip), %rdi # 0x1cedbc
leaq 0x113dd4(%rip), %rsi # 0x1cc91c
movl $0x1bf5, %edx # imm = 0x1BF5
leaq 0x116a99(%rip), %rcx # 0x1cf5ed
callq 0x50230
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9100
xorb $-0x1, %al
testb $0x1, %al
jne 0xb8b6f
jmp 0xb8b71
jmp 0xb8b90
leaq 0x1160bc(%rip), %rdi # 0x1cec34
leaq 0x113d9d(%rip), %rsi # 0x1cc91c
movl $0x1bf6, %edx # imm = 0x1BF6
leaq 0x116a62(%rip), %rcx # 0x1cf5ed
callq 0x50230
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xba970
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9200
testb $0x1, 0x2f(%rsp)
jne 0xb8bfb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9cd0
testb $0x1, %al
jne 0xb8bfb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c40
testb $0x1, %al
jne 0xb8be1
jmp 0xb8bfb
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xa2c20
movb $0x1, %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9end_arrayEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rdi, [rsp+38h+var_8]
mov [rsp+38h+var_28], rdi
mov [rsp+38h+var_9], 1
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
cmp qword ptr [rax], 0
jz loc_B8B22
mov rdi, [rsp+38h+var_28]
mov rax, rdi
add rax, 80h
mov [rsp+38h+var_38], rax
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::size(void)
mov rdi, [rsp+38h+var_28]
sub eax, 1
mov [rsp+38h+var_2C], eax
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rsp+38h+var_38]
mov esi, [rsp+38h+var_2C]
mov rcx, [rax]
mov edx, 3
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
and al, 1
mov [rsp+38h+var_9], al
test [rsp+38h+var_9], 1
jz short loc_B8AE5
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parents(void)
jmp short loc_B8B20
loc_B8AE5:
mov rsi, [rsp+38h+var_28]
add rsi, 0A8h
lea rdi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
lea rsi, [rsp+38h+var_20]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
lea rdi, [rsp+38h+var_20]
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_B8B20:
jmp short $+2
loc_B8B22:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_B8B38
jmp short loc_B8B3A
loc_B8B38:
jmp short loc_B8B59
loc_B8B3A:
lea rdi, aRefStackEmpty; "!ref_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1BF5h
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
call ___assert_fail
loc_B8B59:
mov rdi, [rsp+38h+var_28]
add rdi, 20h ; ' '
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_B8B6F
jmp short loc_B8B71
loc_B8B6F:
jmp short loc_B8B90
loc_B8B71:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1BF6h
lea rcx, aBoolNlohmannDe_3; "bool nlohmann::detail::json_sax_dom_cal"...
call ___assert_fail
loc_B8B90:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::pop_back(void)
mov rdi, [rsp+38h+var_28]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
test [rsp+38h+var_9], 1
jnz short loc_B8BFB
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
test al, 1
jnz short loc_B8BFB
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
test al, 1
jnz short loc_B8BE1
jmp short loc_B8BFB
loc_B8BE1:
mov rdi, [rsp+38h+var_28]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8pop_backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pop_back(void)
loc_B8BFB:
mov al, 1
and al, 1
add rsp, 38h
retn
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::end_array(
long long a1)
{
_QWORD *v1; // rax
long long *v2; // rax
char v3; // al
_BYTE **v4; // rax
long long v5; // rax
unsigned int v7; // [rsp+Ch] [rbp-2Ch]
_BYTE v8[23]; // [rsp+18h] [rbp-20h] BYREF
char v9; // [rsp+2Fh] [rbp-9h]
long long v10; // [rsp+30h] [rbp-8h]
v10 = a1;
v9 = 1;
if ( *(_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8) )
{
v7 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::size(a1 + 8)
- 1;
v1 = (_QWORD *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
v9 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
v7,
3LL,
*v1) & 1;
if ( v9 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::set_parents();
}
else
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v8,
a1 + 168);
v2 = (long long *)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*v2,
(long long)v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v8);
}
}
if ( (std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::empty(a1 + 8) & 1) != 0 )
__assert_fail(
"!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7157LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::end_array() [Bas"
"icJsonType = nlohmann::basic_json<nlohmann::ordered_map>]");
v3 = std::vector<bool>::empty(a1 + 32);
if ( (v3 & 1) != 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7158LL,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::end_array() [Bas"
"icJsonType = nlohmann::basic_json<nlohmann::ordered_map>]");
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::pop_back(a1 + 8);
std::vector<bool>::pop_back(a1 + 32);
if ( (v9 & 1) == 0
&& (std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::empty(a1 + 8) & 1) == 0 )
{
v4 = (_BYTE **)std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
if ( nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(*v4) )
{
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> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::back(a1 + 8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pop_back(*(_QWORD *)(*(_QWORD *)v5 + 8LL));
}
}
return 1;
}
| end_array:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
MOV byte ptr [RSP + 0x2f],0x1
ADD RDI,0x8
CALL 0x001b9880
CMP qword ptr [RAX],0x0
JZ 0x001b8b22
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP],RAX
ADD RDI,0x8
CALL 0x001b9280
MOV RDI,qword ptr [RSP + 0x10]
SUB EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RAX]
MOV EDX,0x3
CALL 0x001b9220
AND AL,0x1
MOV byte ptr [RSP + 0x2f],AL
TEST byte ptr [RSP + 0x2f],0x1
JZ 0x001b8ae5
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x0019faf0
JMP 0x001b8b20
LAB_001b8ae5:
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0xa8
LEA RDI,[RSP + 0x18]
CALL 0x0016ed00
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
LEA RSI,[RSP + 0x18]
CALL 0x001b3e10
LEA RDI,[RSP + 0x18]
CALL 0x0016e0f0
LAB_001b8b20:
JMP 0x001b8b22
LAB_001b8b22:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9cd0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001b8b38
JMP 0x001b8b3a
LAB_001b8b38:
JMP 0x001b8b59
LAB_001b8b3a:
LEA RDI,[0x2cedbc]
LEA RSI,[0x2cc91c]
MOV EDX,0x1bf5
LEA RCX,[0x2cf5ed]
CALL 0x00150230
LAB_001b8b59:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001b9100
XOR AL,0xff
TEST AL,0x1
JNZ 0x001b8b6f
JMP 0x001b8b71
LAB_001b8b6f:
JMP 0x001b8b90
LAB_001b8b71:
LEA RDI,[0x2cec34]
LEA RSI,[0x2cc91c]
MOV EDX,0x1bf6
LEA RCX,[0x2cf5ed]
CALL 0x00150230
LAB_001b8b90:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001ba970
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x20
CALL 0x001b9200
TEST byte ptr [RSP + 0x2f],0x1
JNZ 0x001b8bfb
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9cd0
TEST AL,0x1
JNZ 0x001b8bfb
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c40
TEST AL,0x1
JNZ 0x001b8be1
JMP 0x001b8bfb
LAB_001b8be1:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x8
CALL 0x001b9880
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001a2c20
LAB_001b8bfb:
MOV AL,0x1
AND AL,0x1
ADD RSP,0x38
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::end_array() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::end_array(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
byte bVar1;
int iVar2;
long *plVar3;
int8 *puVar4;
ulong uVar5;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_20 [23];
byte local_9;
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*local_8;
local_9 = 1;
local_8 = this;
plVar3 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (*plVar3 != 0) {
iVar2 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
puVar4 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_9 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),iVar2 + -1,3,*puVar4);
local_9 = local_9 & 1;
if (local_9 == 0) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_20,(basic_json *)(this + 0xa8));
puVar4 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar4,local_20);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_20);
}
else {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::set_parents();
}
}
bVar1 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (((bVar1 ^ 0xff) & 1) != 0) {
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((bVar1 ^ 0xff) & 1) != 0) {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::pop_back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((local_9 & 1) == 0) &&
(uVar5 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8)), (uVar5 & 1) == 0)) {
puVar4 = (int8 *)
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar5 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::is_array((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar4);
if ((uVar5 & 1) != 0) {
plVar3 = (long *)std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::pop_back(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(*plVar3 + 8));
}
}
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
0x1bf6,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::end_array() [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>]"
);
}
/* WARNING: Subroutine does not return */
__assert_fail("!ref_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",0x1bf5
,
"bool nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::end_array() [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>]"
);
}
|
|
1,946 | recursive_free | eloqsql/mysys/lf_dynarray.c | static void recursive_free(void **alloc, int level)
{
if (!alloc)
return;
if (level)
{
int i;
for (i= 0; i < LF_DYNARRAY_LEVEL_LENGTH; i++)
recursive_free(alloc[i], level-1);
my_free(alloc);
}
else
my_free(alloc[-1]);
} | O3 | c | recursive_free:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5bca
movl %esi, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0xa5bd5
decl %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
movl %r14d, %esi
callq 0xa5b8e
incq %r15
cmpq $0x100, %r15 # imm = 0x100
jne 0xa5bad
movq %rbx, %rdi
jmp 0xa5bd9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq -0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa00ee
| recursive_free:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
test rdi, rdi
jz short loc_A5BCA
mov r14d, esi
mov rbx, rdi
test esi, esi
jz short loc_A5BD5
dec r14d
xor r15d, r15d
loc_A5BAD:
mov rdi, [rbx+r15*8]
mov esi, r14d
call recursive_free
inc r15
cmp r15, 100h
jnz short loc_A5BAD
mov rdi, rbx
jmp short loc_A5BD9
loc_A5BCA:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_A5BD5:
mov rdi, [rbx-8]
loc_A5BD9:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp my_free
| long long recursive_free(long long a1, int a2)
{
long long i; // r15
long long result; // rax
if ( a1 )
{
if ( a2 )
{
for ( i = 0LL; i != 256; ++i )
recursive_free(*(_QWORD *)(a1 + 8 * i), (unsigned int)(a2 - 1));
return my_free(a1);
}
else
{
return my_free(*(_QWORD *)(a1 - 8));
}
}
return result;
}
| recursive_free:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x001a5bca
MOV R14D,ESI
MOV RBX,RDI
TEST ESI,ESI
JZ 0x001a5bd5
DEC R14D
XOR R15D,R15D
LAB_001a5bad:
MOV RDI,qword ptr [RBX + R15*0x8]
MOV ESI,R14D
CALL 0x001a5b8e
INC R15
CMP R15,0x100
JNZ 0x001a5bad
MOV RDI,RBX
JMP 0x001a5bd9
LAB_001a5bca:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001a5bd5:
MOV RDI,qword ptr [RBX + -0x8]
LAB_001a5bd9:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001a00ee
|
void recursive_free(long param_1,int param_2)
{
long lVar1;
if (param_1 == 0) {
return;
}
if (param_2 == 0) {
param_1 = *(long *)(param_1 + -8);
}
else {
lVar1 = 0;
do {
recursive_free(*(int8 *)(param_1 + lVar1 * 8),param_2 + -1);
lVar1 = lVar1 + 1;
} while (lVar1 != 0x100);
}
my_free(param_1);
return;
}
|
|
1,947 | ma_decrement_open_count | eloqsql/storage/maria/ma_locking.c | int _ma_decrement_open_count(MARIA_HA *info, my_bool lock_tables)
{
uchar buff[2];
register MARIA_SHARE *share= info->s;
int lock_error=0,write_error=0;
DBUG_ENTER("_ma_decrement_open_count");
if (share->global_changed)
{
uint old_lock=info->lock_type;
share->global_changed=0;
lock_error= (my_disable_locking || ! lock_tables ? 0 :
maria_lock_database(info, F_WRLCK));
/* Its not fatal even if we couldn't get the lock ! */
if (share->state.open_count > 0)
{
CRASH_IF_S3_TABLE(share);
share->state.open_count--;
share->changed= 1; /* We have to update state */
/*
For temporary tables that will just be deleted, we don't have
to decrement state. For transactional tables the state will be
updated in maria_close().
*/
if (!share->temporary && !share->now_transactional)
{
mi_int2store(buff,share->state.open_count);
write_error= (int) my_pwrite(share->kfile.file, buff, sizeof(buff),
sizeof(share->state.header) +
MARIA_FILE_OPEN_COUNT_OFFSET,
MYF(MY_NABP));
}
}
if (!lock_error && !my_disable_locking && lock_tables)
lock_error=maria_lock_database(info,old_lock);
}
DBUG_RETURN(MY_TEST(lock_error || write_error));
} | O0 | c | ma_decrement_open_count:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x7df(%rax)
je 0x37594
movq -0x8(%rbp), %rax
movl 0x664(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, 0x7df(%rax)
leaq 0xc4d09d(%rip), %rax # 0xc84548
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x374b9
cmpb $0x0, -0x9(%rbp)
jne 0x374c0
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x374d1
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x368c0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x16c(%rax)
jbe 0x37568
jmp 0x374ea
jmp 0x374ec
movq -0x18(%rbp), %rax
movl 0x16c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x16c(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x7de(%rax)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x7d9(%rax)
jne 0x37566
movq -0x18(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
jne 0x37566
movq -0x18(%rbp), %rax
movl 0x16c(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, -0xa(%rbp)
movl -0x28(%rbp), %eax
shrl $0x8, %eax
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movl 0x760(%rax), %edi
leaq -0xb(%rbp), %rsi
movl $0x2, %edx
movl $0x18, %ecx
movl $0x4, %r8d
callq 0xf5c10
movl %eax, -0x20(%rbp)
jmp 0x37568
cmpl $0x0, -0x1c(%rbp)
jne 0x37592
leaq 0xc4cfd3(%rip), %rax # 0xc84548
cmpb $0x0, (%rax)
jne 0x37592
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x37592
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x368c0
movl %eax, -0x1c(%rbp)
jmp 0x37594
jmp 0x37596
movb $0x1, %al
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x2d(%rbp)
jne 0x375ab
cmpl $0x0, -0x20(%rbp)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_decrement_open_count:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov [rbp+var_1C], 0
mov [rbp+var_20], 0
mov rax, [rbp+var_18]
cmp byte ptr [rax+7DFh], 0
jz loc_37594
mov rax, [rbp+var_8]
mov eax, [rax+664h]
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov byte ptr [rax+7DFh], 0
lea rax, my_disable_locking
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_374B9
cmp [rbp+var_9], 0
jnz short loc_374C0
loc_374B9:
xor eax, eax
mov [rbp+var_2C], eax
jmp short loc_374D1
loc_374C0:
mov rdi, [rbp+var_8]
mov esi, 1
call maria_lock_database
mov [rbp+var_2C], eax
loc_374D1:
mov eax, [rbp+var_2C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
cmp dword ptr [rax+16Ch], 0
jbe loc_37568
jmp short $+2
loc_374EA:
jmp short $+2
loc_374EC:
mov rax, [rbp+var_18]
mov ecx, [rax+16Ch]
add ecx, 0FFFFFFFFh
mov [rax+16Ch], ecx
mov rax, [rbp+var_18]
mov byte ptr [rax+7DEh], 1
mov rax, [rbp+var_18]
cmp byte ptr [rax+7D9h], 0
jnz short loc_37566
mov rax, [rbp+var_18]
cmp byte ptr [rax+7E7h], 0
jnz short loc_37566
mov rax, [rbp+var_18]
mov eax, [rax+16Ch]
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
mov [rbp+var_A], al
mov eax, [rbp+var_28]
shr eax, 8
mov [rbp+var_B], al
mov rax, [rbp+var_18]
mov edi, [rax+760h]
lea rsi, [rbp+var_B]
mov edx, 2
mov ecx, 18h
mov r8d, 4
call my_pwrite
mov [rbp+var_20], eax
loc_37566:
jmp short $+2
loc_37568:
cmp [rbp+var_1C], 0
jnz short loc_37592
lea rax, my_disable_locking
cmp byte ptr [rax], 0
jnz short loc_37592
movsx eax, [rbp+var_9]
cmp eax, 0
jz short loc_37592
mov rdi, [rbp+var_8]
mov esi, [rbp+var_24]
call maria_lock_database
mov [rbp+var_1C], eax
loc_37592:
jmp short $+2
loc_37594:
jmp short $+2
loc_37596:
mov al, 1
cmp [rbp+var_1C], 0
mov [rbp+var_2D], al
jnz short loc_375AB
cmp [rbp+var_20], 0
setnz al
mov [rbp+var_2D], al
loc_375AB:
mov dl, [rbp+var_2D]
xor eax, eax
mov ecx, 1
test dl, 1
cmovnz eax, ecx
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| _BOOL8 ma_decrement_open_count(long long a1, char a2)
{
__int16 v2; // kr00_2
bool v4; // [rsp+13h] [rbp-2Dh]
int v5; // [rsp+14h] [rbp-2Ch]
int v6; // [rsp+1Ch] [rbp-24h]
int v7; // [rsp+20h] [rbp-20h]
int v8; // [rsp+24h] [rbp-1Ch]
long long v9; // [rsp+28h] [rbp-18h]
_BYTE v10[2]; // [rsp+35h] [rbp-Bh] BYREF
char v11; // [rsp+37h] [rbp-9h]
long long v12; // [rsp+38h] [rbp-8h]
v12 = a1;
v11 = a2;
v9 = *(_QWORD *)a1;
v8 = 0;
v7 = 0;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2015LL) )
{
v6 = *(_DWORD *)(v12 + 1636);
*(_BYTE *)(v9 + 2015) = 0;
if ( !my_disable_locking && v11 )
v5 = maria_lock_database(v12, 1);
else
v5 = 0;
v8 = v5;
if ( *(_DWORD *)(v9 + 364) )
{
--*(_DWORD *)(v9 + 364);
*(_BYTE *)(v9 + 2014) = 1;
if ( !*(_BYTE *)(v9 + 2009) && !*(_BYTE *)(v9 + 2023) )
{
v2 = *(_DWORD *)(v9 + 364);
v10[0] = HIBYTE(v2);
v10[1] = v2;
v7 = my_pwrite(*(unsigned int *)(v9 + 1888), v10, 2LL, 24LL, 4LL);
}
}
if ( !v5 && !my_disable_locking && v11 )
v8 = maria_lock_database(v12, v6);
}
v4 = 1;
if ( !v8 )
return v7 != 0;
return v4;
}
| _ma_decrement_open_count:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x7df],0x0
JZ 0x00137594
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x664]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x7df],0x0
LEA RAX,[0xd84548]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x001374b9
CMP byte ptr [RBP + -0x9],0x0
JNZ 0x001374c0
LAB_001374b9:
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001374d1
LAB_001374c0:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x1
CALL 0x001368c0
MOV dword ptr [RBP + -0x2c],EAX
LAB_001374d1:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x16c],0x0
JBE 0x00137568
JMP 0x001374ea
LAB_001374ea:
JMP 0x001374ec
LAB_001374ec:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x16c]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x16c],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x7de],0x1
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x7d9],0x0
JNZ 0x00137566
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX + 0x7e7],0x0
JNZ 0x00137566
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x16c]
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0xa],AL
MOV EAX,dword ptr [RBP + -0x28]
SHR EAX,0x8
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,dword ptr [RAX + 0x760]
LEA RSI,[RBP + -0xb]
MOV EDX,0x2
MOV ECX,0x18
MOV R8D,0x4
CALL 0x001f5c10
MOV dword ptr [RBP + -0x20],EAX
LAB_00137566:
JMP 0x00137568
LAB_00137568:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00137592
LEA RAX,[0xd84548]
CMP byte ptr [RAX],0x0
JNZ 0x00137592
MOVSX EAX,byte ptr [RBP + -0x9]
CMP EAX,0x0
JZ 0x00137592
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x24]
CALL 0x001368c0
MOV dword ptr [RBP + -0x1c],EAX
LAB_00137592:
JMP 0x00137594
LAB_00137594:
JMP 0x00137596
LAB_00137596:
MOV AL,0x1
CMP dword ptr [RBP + -0x1c],0x0
MOV byte ptr [RBP + -0x2d],AL
JNZ 0x001375ab
CMP dword ptr [RBP + -0x20],0x0
SETNZ AL
MOV byte ptr [RBP + -0x2d],AL
LAB_001375ab:
MOV DL,byte ptr [RBP + -0x2d]
XOR EAX,EAX
MOV ECX,0x1
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
bool _ma_decrement_open_count(long *param_1,char param_2)
{
int4 uVar1;
long lVar2;
int local_34;
int local_28;
int local_24;
int1 local_13;
int1 local_12;
char local_11;
long *local_10;
lVar2 = *param_1;
local_24 = 0;
local_28 = 0;
if (*(char *)(lVar2 + 0x7df) != '\0') {
uVar1 = *(int4 *)((long)param_1 + 0x664);
*(int1 *)(lVar2 + 0x7df) = 0;
local_11 = param_2;
local_10 = param_1;
if ((my_disable_locking == '\0') && (param_2 != '\0')) {
local_34 = maria_lock_database(param_1,1);
}
else {
local_34 = 0;
}
local_24 = local_34;
if (*(int *)(lVar2 + 0x16c) != 0) {
*(int *)(lVar2 + 0x16c) = *(int *)(lVar2 + 0x16c) + -1;
*(int1 *)(lVar2 + 0x7de) = 1;
if ((*(char *)(lVar2 + 0x7d9) == '\0') && (*(char *)(lVar2 + 0x7e7) == '\0')) {
local_12 = (int1)*(int4 *)(lVar2 + 0x16c);
local_13 = (int1)((uint)*(int4 *)(lVar2 + 0x16c) >> 8);
local_28 = my_pwrite(*(int4 *)(lVar2 + 0x760),&local_13,2,0x18,4);
}
}
if (((local_34 == 0) && (my_disable_locking == '\0')) && (local_11 != '\0')) {
local_24 = maria_lock_database(local_10,uVar1);
}
}
return local_24 != 0 || local_28 != 0;
}
|
|
1,948 | my_hash_sort_utf16_nopad_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf16_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *pos, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= pos + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; pos < end ; pos++)
{
MY_HASH_ADD(m1, m2, (uint)*pos);
}
*nr1= m1;
*nr2= m2;
} | O0 | c | my_hash_sort_utf16_nopad_bin:
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 -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xad3ee
jmp 0xad3a6
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0xad3e0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xad39a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_utf16_nopad_bin:
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_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_40], rax
loc_AD39A:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jnb short loc_AD3EE
jmp short $+2
loc_AD3A6:
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
jmp short $+2
loc_AD3E0:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_AD39A
loc_AD3EE:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
| _QWORD * my_hash_sort_utf16_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-40h]
long long v7; // [rsp+8h] [rbp-38h]
unsigned __int8 *v8; // [rsp+30h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *v8 * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
| my_hash_sort_utf16_nopad_bin:
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 + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_001ad39a:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001ad3ee
JMP 0x001ad3a6
LAB_001ad3a6:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001ad3e0
LAB_001ad3e0:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001ad39a
LAB_001ad3ee:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_utf16_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_48;
ulong local_40;
byte *local_18;
local_40 = *param_4;
local_48 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_40 = ((local_40 & 0x3f) + local_48) * (ulong)*local_18 + local_40 * 0x100 ^ local_40;
local_48 = local_48 + 3;
}
*param_4 = local_40;
*param_5 = local_48;
return;
}
|
|
1,949 | MemoryManager::printInfo() | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | void MemoryManager::printInfo() {
printf("Memory Pages: \n");
for (uint32_t i = 0; i < 1024; ++i) {
if (this->memory[i] == nullptr) {
continue;
}
printf("0x%x-0x%x:\n", i << 22, (i + 1) << 22);
for (uint32_t j = 0; j < 1024; ++j) {
if (this->memory[i][j] == nullptr) {
continue;
}
printf(" 0x%x-0x%x\n", (i << 22) + (j << 12),
(i << 22) + ((j + 1) << 12));
}
}
} | O0 | cpp | MemoryManager::printInfo():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x43db(%rip), %rdi # 0x8204
movb $0x0, %al
callq 0x2040
movl $0x0, 0xc(%rsp)
cmpl $0x400, 0xc(%rsp) # imm = 0x400
jae 0x3ef4
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3e5a
jmp 0x3ee4
movl 0xc(%rsp), %esi
shll $0x16, %esi
movl 0xc(%rsp), %edx
addl $0x1, %edx
shll $0x16, %edx
leaq 0x43a2(%rip), %rdi # 0x8214
movb $0x0, %al
callq 0x2040
movl $0x0, 0x8(%rsp)
cmpl $0x400, 0x8(%rsp) # imm = 0x400
jae 0x3ee2
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl 0x8(%rsp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3ea4
jmp 0x3ed5
movl 0xc(%rsp), %esi
shll $0x16, %esi
movl 0x8(%rsp), %eax
shll $0xc, %eax
addl %eax, %esi
movl 0xc(%rsp), %edx
shll $0x16, %edx
movl 0x8(%rsp), %eax
addl $0x1, %eax
shll $0xc, %eax
addl %eax, %edx
leaq 0x4352(%rip), %rdi # 0x8220
movb $0x0, %al
callq 0x2040
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3e81
jmp 0x3ee4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3e38
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN13MemoryManager9printInfoEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
lea rdi, aMemoryPages; "Memory Pages: \n"
mov al, 0
call _printf
mov [rsp+18h+var_C], 0
loc_3E38:
cmp [rsp+18h+var_C], 400h
jnb loc_3EF4
mov rax, [rsp+18h+var_18]
mov ecx, [rsp+18h+var_C]
cmp qword ptr [rax+rcx*8], 0
jnz short loc_3E5A
jmp loc_3EE4
loc_3E5A:
mov esi, [rsp+18h+var_C]
shl esi, 16h
mov edx, [rsp+18h+var_C]
add edx, 1
shl edx, 16h
lea rdi, a0xX0xX; "0x%x-0x%x:\n"
mov al, 0
call _printf
mov [rsp+18h+var_10], 0
loc_3E81:
cmp [rsp+18h+var_10], 400h
jnb short loc_3EE2
mov rax, [rsp+18h+var_18]
mov ecx, [rsp+18h+var_C]
mov rax, [rax+rcx*8]
mov ecx, [rsp+18h+var_10]
cmp qword ptr [rax+rcx*8], 0
jnz short loc_3EA4
jmp short loc_3ED5
loc_3EA4:
mov esi, [rsp+18h+var_C]
shl esi, 16h
mov eax, [rsp+18h+var_10]
shl eax, 0Ch
add esi, eax
mov edx, [rsp+18h+var_C]
shl edx, 16h
mov eax, [rsp+18h+var_10]
add eax, 1
shl eax, 0Ch
add edx, eax
lea rdi, a0xX0xX_0; " 0x%x-0x%x\n"
mov al, 0
call _printf
loc_3ED5:
mov eax, [rsp+18h+var_10]
add eax, 1
mov [rsp+18h+var_10], eax
jmp short loc_3E81
loc_3EE2:
jmp short $+2
loc_3EE4:
mov eax, [rsp+18h+var_C]
add eax, 1
mov [rsp+18h+var_C], eax
jmp loc_3E38
loc_3EF4:
add rsp, 18h
retn
| long long MemoryManager::printInfo(MemoryManager *this)
{
long long result; // rax
unsigned int j; // [rsp+8h] [rbp-10h]
unsigned int i; // [rsp+Ch] [rbp-Ch]
result = printf("Memory Pages: \n");
for ( i = 0; i < 0x400; ++i )
{
if ( *((_QWORD *)this + i) )
{
printf("0x%x-0x%x:\n", i << 22, (i + 1) << 22);
for ( j = 0; j < 0x400; ++j )
{
if ( *(_QWORD *)(*((_QWORD *)this + i) + 8LL * j) )
printf(" 0x%x-0x%x\n", (j << 12) + (i << 22), ((j + 1) << 12) + (i << 22));
}
}
result = i + 1;
}
return result;
}
| printInfo:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RDI,[0x108204]
MOV AL,0x0
CALL 0x00102040
MOV dword ptr [RSP + 0xc],0x0
LAB_00103e38:
CMP dword ptr [RSP + 0xc],0x400
JNC 0x00103ef4
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RSP + 0xc]
CMP qword ptr [RAX + RCX*0x8],0x0
JNZ 0x00103e5a
JMP 0x00103ee4
LAB_00103e5a:
MOV ESI,dword ptr [RSP + 0xc]
SHL ESI,0x16
MOV EDX,dword ptr [RSP + 0xc]
ADD EDX,0x1
SHL EDX,0x16
LEA RDI,[0x108214]
MOV AL,0x0
CALL 0x00102040
MOV dword ptr [RSP + 0x8],0x0
LAB_00103e81:
CMP dword ptr [RSP + 0x8],0x400
JNC 0x00103ee2
MOV RAX,qword ptr [RSP]
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RSP + 0x8]
CMP qword ptr [RAX + RCX*0x8],0x0
JNZ 0x00103ea4
JMP 0x00103ed5
LAB_00103ea4:
MOV ESI,dword ptr [RSP + 0xc]
SHL ESI,0x16
MOV EAX,dword ptr [RSP + 0x8]
SHL EAX,0xc
ADD ESI,EAX
MOV EDX,dword ptr [RSP + 0xc]
SHL EDX,0x16
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,0x1
SHL EAX,0xc
ADD EDX,EAX
LEA RDI,[0x108220]
MOV AL,0x0
CALL 0x00102040
LAB_00103ed5:
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,0x1
MOV dword ptr [RSP + 0x8],EAX
JMP 0x00103e81
LAB_00103ee2:
JMP 0x00103ee4
LAB_00103ee4:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x00103e38
LAB_00103ef4:
ADD RSP,0x18
RET
|
/* MemoryManager::printInfo() */
void __thiscall MemoryManager::printInfo(MemoryManager *this)
{
uint local_10;
uint local_c;
printf("Memory Pages: \n");
for (local_c = 0; local_c < 0x400; local_c = local_c + 1) {
if (*(long *)(this + (ulong)local_c * 8) != 0) {
printf("0x%x-0x%x:\n",(ulong)(local_c << 0x16),(ulong)((local_c + 1) * 0x400000));
for (local_10 = 0; local_10 < 0x400; local_10 = local_10 + 1) {
if (*(long *)(*(long *)(this + (ulong)local_c * 8) + (ulong)local_10 * 8) != 0) {
printf(" 0x%x-0x%x\n",(ulong)(local_c * 0x400000 + local_10 * 0x1000),
(ulong)(local_c * 0x400000 + (local_10 + 1) * 0x1000));
}
}
}
}
return;
}
|
|
1,950 | MemoryManager::printInfo() | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | void MemoryManager::printInfo() {
printf("Memory Pages: \n");
for (uint32_t i = 0; i < 1024; ++i) {
if (this->memory[i] == nullptr) {
continue;
}
printf("0x%x-0x%x:\n", i << 22, (i + 1) << 22);
for (uint32_t j = 0; j < 1024; ++j) {
if (this->memory[i][j] == nullptr) {
continue;
}
printf(" 0x%x-0x%x\n", (i << 22) + (j << 12),
(i << 22) + ((j + 1) << 12));
}
}
} | O2 | cpp | MemoryManager::printInfo():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x211a(%rip), %rdi # 0x5277
callq 0x2240
movl $0x1000, %ebp # imm = 0x1000
leaq 0x20ec(%rip), %r15 # 0x525a
xorl %r13d, %r13d
cmpq $0x400, %r13 # imm = 0x400
je 0x31e1
cmpq $0x0, (%rbx,%r13,8)
je 0x31d6
movl %r13d, %esi
shll $0x16, %esi
leal 0x400000(%rsi), %edx
leaq 0x20ba(%rip), %rdi # 0x524e
xorl %eax, %eax
callq 0x2040
movl %ebp, %r12d
xorl %r14d, %r14d
cmpq $0x400, %r14 # imm = 0x400
je 0x31d6
movq (%rbx,%r13,8), %rax
cmpq $0x0, (%rax,%r14,8)
je 0x31ca
leal -0x1000(%r12), %esi
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x2040
incq %r14
addl $0x1000, %r12d # imm = 0x1000
jmp 0x31a1
incq %r13
addl $0x400000, %ebp # imm = 0x400000
jmp 0x3171
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN13MemoryManager9printInfoEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rdi, aMemoryPages; "Memory Pages: "
call _puts
mov ebp, 1000h
lea r15, a0xX0xX; " 0x%x-0x%x\n"
xor r13d, r13d
loc_3171:
cmp r13, 400h
jz short loc_31E1
cmp qword ptr [rbx+r13*8], 0
jz short loc_31D6
mov esi, r13d
shl esi, 16h
lea edx, [rsi+400000h]
lea rdi, a0xX0xX_0; "0x%x-0x%x:\n"
xor eax, eax
call _printf
mov r12d, ebp
xor r14d, r14d
loc_31A1:
cmp r14, 400h
jz short loc_31D6
mov rax, [rbx+r13*8]
cmp qword ptr [rax+r14*8], 0
jz short loc_31CA
lea esi, [r12-1000h]
mov rdi, r15
mov edx, r12d
xor eax, eax
call _printf
loc_31CA:
inc r14
add r12d, 1000h
jmp short loc_31A1
loc_31D6:
inc r13
add ebp, 400000h
jmp short loc_3171
loc_31E1:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long MemoryManager::printInfo(MemoryManager *this)
{
long long result; // rax
int v2; // ebp
long long i; // r13
int v4; // r12d
long long j; // r14
result = puts("Memory Pages: ");
v2 = 4096;
for ( i = 0LL; i != 1024; ++i )
{
if ( *((_QWORD *)this + i) )
{
result = printf("0x%x-0x%x:\n", (_DWORD)i << 22, ((_DWORD)i << 22) + 0x400000);
v4 = v2;
for ( j = 0LL; j != 1024; ++j )
{
result = *((_QWORD *)this + i);
if ( *(_QWORD *)(result + 8 * j) )
result = printf(" 0x%x-0x%x\n", v4 - 4096, v4);
v4 += 4096;
}
}
v2 += 0x400000;
}
return result;
}
| printInfo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RDI,[0x105277]
CALL 0x00102240
MOV EBP,0x1000
LEA R15,[0x10525a]
XOR R13D,R13D
LAB_00103171:
CMP R13,0x400
JZ 0x001031e1
CMP qword ptr [RBX + R13*0x8],0x0
JZ 0x001031d6
MOV ESI,R13D
SHL ESI,0x16
LEA EDX,[RSI + 0x400000]
LEA RDI,[0x10524e]
XOR EAX,EAX
CALL 0x00102040
MOV R12D,EBP
XOR R14D,R14D
LAB_001031a1:
CMP R14,0x400
JZ 0x001031d6
MOV RAX,qword ptr [RBX + R13*0x8]
CMP qword ptr [RAX + R14*0x8],0x0
JZ 0x001031ca
LEA ESI,[R12 + -0x1000]
MOV RDI,R15
MOV EDX,R12D
XOR EAX,EAX
CALL 0x00102040
LAB_001031ca:
INC R14
ADD R12D,0x1000
JMP 0x001031a1
LAB_001031d6:
INC R13
ADD EBP,0x400000
JMP 0x00103171
LAB_001031e1:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MemoryManager::printInfo() */
void __thiscall MemoryManager::printInfo(MemoryManager *this)
{
uint uVar1;
uint uVar2;
long lVar3;
long lVar4;
puts("Memory Pages: ");
uVar1 = 0x1000;
for (lVar3 = 0; lVar3 != 0x400; lVar3 = lVar3 + 1) {
if (*(long *)(this + lVar3 * 8) != 0) {
uVar2 = (int)lVar3 * 0x400000;
printf("0x%x-0x%x:\n",(ulong)uVar2,(ulong)(uVar2 + 0x400000));
uVar2 = uVar1;
for (lVar4 = 0; lVar4 != 0x400; lVar4 = lVar4 + 1) {
if (*(long *)(*(long *)(this + lVar3 * 8) + lVar4 * 8) != 0) {
printf(" 0x%x-0x%x\n",(ulong)(uVar2 - 0x1000),(ulong)uVar2);
}
uVar2 = uVar2 + 0x1000;
}
}
uVar1 = uVar1 + 0x400000;
}
return;
}
|
|
1,951 | MemoryManager::printInfo() | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MemoryManager.cpp | void MemoryManager::printInfo() {
printf("Memory Pages: \n");
for (uint32_t i = 0; i < 1024; ++i) {
if (this->memory[i] == nullptr) {
continue;
}
printf("0x%x-0x%x:\n", i << 22, (i + 1) << 22);
for (uint32_t j = 0; j < 1024; ++j) {
if (this->memory[i][j] == nullptr) {
continue;
}
printf(" 0x%x-0x%x\n", (i << 22) + (j << 12),
(i << 22) + ((j + 1) << 12));
}
}
} | O3 | cpp | MemoryManager::printInfo():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1e6a(%rip), %rdi # 0x5277
callq 0x2260
movl $0x1000, %ebp # imm = 0x1000
leaq 0x1e3c(%rip), %r15 # 0x525a
xorl %r13d, %r13d
cmpq $0x0, (%rbx,%r13,8)
je 0x347b
movl %r13d, %esi
shll $0x16, %esi
leal 0x400000(%rsi), %edx
leaq 0x1e13(%rip), %rdi # 0x524e
xorl %eax, %eax
callq 0x2040
movl %ebp, %r12d
xorl %r14d, %r14d
movq (%rbx,%r13,8), %rax
cmpq $0x0, (%rax,%r14,8)
je 0x3468
leal -0x1000(%r12), %esi
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x2040
incq %r14
addl $0x1000, %r12d # imm = 0x1000
cmpq $0x400, %r14 # imm = 0x400
jne 0x3448
incq %r13
addl $0x400000, %ebp # imm = 0x400000
cmpq $0x400, %r13 # imm = 0x400
jne 0x3421
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN13MemoryManager9printInfoEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rdi, aMemoryPages; "Memory Pages: "
call _puts
mov ebp, 1000h
lea r15, a0xX0xX; " 0x%x-0x%x\n"
xor r13d, r13d
loc_3421:
cmp qword ptr [rbx+r13*8], 0
jz short loc_347B
mov esi, r13d
shl esi, 16h
lea edx, [rsi+400000h]
lea rdi, a0xX0xX_0; "0x%x-0x%x:\n"
xor eax, eax
call _printf
mov r12d, ebp
xor r14d, r14d
loc_3448:
mov rax, [rbx+r13*8]
cmp qword ptr [rax+r14*8], 0
jz short loc_3468
lea esi, [r12-1000h]
mov rdi, r15
mov edx, r12d
xor eax, eax
call _printf
loc_3468:
inc r14
add r12d, 1000h
cmp r14, 400h
jnz short loc_3448
loc_347B:
inc r13
add ebp, 400000h
cmp r13, 400h
jnz short loc_3421
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long MemoryManager::printInfo(MemoryManager *this, long long a2, long long a3)
{
long long result; // rax
int v4; // ebp
long long i; // r13
int v6; // r12d
long long j; // r14
result = puts("Memory Pages: ", a2, a3);
v4 = 4096;
for ( i = 0LL; i != 1024; ++i )
{
if ( *((_QWORD *)this + i) )
{
printf("0x%x-0x%x:\n", (_DWORD)i << 22, ((_DWORD)i << 22) + 0x400000);
v6 = v4;
for ( j = 0LL; j != 1024; ++j )
{
result = *((_QWORD *)this + i);
if ( *(_QWORD *)(result + 8 * j) )
result = printf(" 0x%x-0x%x\n", v6 - 4096, v6);
v6 += 4096;
}
}
v4 += 0x400000;
}
return result;
}
| printInfo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RDI,[0x105277]
CALL 0x00102260
MOV EBP,0x1000
LEA R15,[0x10525a]
XOR R13D,R13D
LAB_00103421:
CMP qword ptr [RBX + R13*0x8],0x0
JZ 0x0010347b
MOV ESI,R13D
SHL ESI,0x16
LEA EDX,[RSI + 0x400000]
LEA RDI,[0x10524e]
XOR EAX,EAX
CALL 0x00102040
MOV R12D,EBP
XOR R14D,R14D
LAB_00103448:
MOV RAX,qword ptr [RBX + R13*0x8]
CMP qword ptr [RAX + R14*0x8],0x0
JZ 0x00103468
LEA ESI,[R12 + -0x1000]
MOV RDI,R15
MOV EDX,R12D
XOR EAX,EAX
CALL 0x00102040
LAB_00103468:
INC R14
ADD R12D,0x1000
CMP R14,0x400
JNZ 0x00103448
LAB_0010347b:
INC R13
ADD EBP,0x400000
CMP R13,0x400
JNZ 0x00103421
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MemoryManager::printInfo() */
void __thiscall MemoryManager::printInfo(MemoryManager *this)
{
uint uVar1;
uint uVar2;
long lVar3;
long lVar4;
puts("Memory Pages: ");
uVar1 = 0x1000;
lVar3 = 0;
do {
if (*(long *)(this + lVar3 * 8) != 0) {
uVar2 = (int)lVar3 * 0x400000;
printf("0x%x-0x%x:\n",(ulong)uVar2,(ulong)(uVar2 + 0x400000));
lVar4 = 0;
uVar2 = uVar1;
do {
if (*(long *)(*(long *)(this + lVar3 * 8) + lVar4 * 8) != 0) {
printf(" 0x%x-0x%x\n",(ulong)(uVar2 - 0x1000),(ulong)uVar2);
}
lVar4 = lVar4 + 1;
uVar2 = uVar2 + 0x1000;
} while (lVar4 != 0x400);
}
lVar3 = lVar3 + 1;
uVar1 = uVar1 + 0x400000;
} while (lVar3 != 0x400);
return;
}
|
|
1,952 | minja::Value::set(minja::Value const&, minja::Value const&) | monkey531[P]llama/common/minja.hpp | void set(const Value& key, const Value& value) {
if (!object_) throw std::runtime_error("Value is not an object: " + dump());
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
(*object_)[key.primitive_] = value;
} | O2 | cpp | minja::Value::set(minja::Value const&, minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x69989
movq %rdx, %rbx
movq %rsi, %r15
movq %rsi, %rdi
callq 0x62ef0
testb %al, %al
je 0x699e6
movq 0x20(%r14), %rdi
addq $0x40, %r15
movq %r15, %rsi
callq 0x69aae
movq %rax, %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69b06
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x62f00
leaq 0x4a918(%rip), %rsi # 0xb42c5
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x58626
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e60
xorl %ebp, %ebp
movq 0x9461b(%rip), %rsi # 0xfdff0
movq 0x9457c(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23f30
jmp 0x69a41
pushq $0x10
popq %rdi
callq 0x23480
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x62f00
leaq 0x4a8d4(%rip), %rsi # 0xb42de
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x58626
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e60
xorl %ebp, %ebp
movq 0x945be(%rip), %rsi # 0xfdff0
movq 0x9451f(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23f30
jmp 0x69a45
jmp 0x69a54
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x24208
jmp 0x69a5a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x24208
testb %bpl, %bpl
jne 0x69a70
jmp 0x69a78
jmp 0x69a6d
movq %rax, %r14
movq %rbx, %rdi
callq 0x236b0
movq %r14, %rdi
callq 0x23fd0
| _ZN5minja5Value3setERKS0_S2_:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov r14, rdi
cmp qword ptr [rdi+20h], 0
jz short loc_69989
mov rbx, rdx
mov r15, rsi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz loc_699E6
mov rdi, [r14+20h]
add r15, 40h ; '@'
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator[](nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, rax
mov rsi, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN5minja5ValueaSERKS0_; minja::Value::operator=(minja::Value const&)
loc_69989:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnOb; "Value is not an object: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_69A41
loc_699E6:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_69A41:
jmp short loc_69A45
jmp short loc_69A54
loc_69A45:
mov r14, rax
lea rdi, [rsp+68h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_69A5A
loc_69A54:
mov r14, rax
mov bpl, 1
loc_69A5A:
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_69A70
jmp short loc_69A78
jmp short $+2
loc_69A6D:
mov r14, rax
loc_69A70:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_69A78:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::set(minja::Value *this, const minja::Value *a2, const minja::Value *a3)
{
long long v4; // rax
void *exception; // rbx
void *v7; // rbx
_BYTE v8[32]; // [rsp+8h] [rbp-60h] BYREF
_BYTE v9[64]; // [rsp+28h] [rbp-40h] BYREF
if ( !*((_QWORD *)this + 4) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v8, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v9, (long long)"Value is not an object: ", (long long)v8);
std::runtime_error::runtime_error(exception, v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !minja::Value::is_primitive(a2) )
{
v7 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v8, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v9, (long long)"Unashable type: ", (long long)v8);
std::runtime_error::runtime_error(v7, v9);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator[](
*((_QWORD *)this + 4),
(char *)a2 + 64);
return minja::Value::operator=(v4, a3);
}
| set:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
CMP qword ptr [RDI + 0x20],0x0
JZ 0x00169989
MOV RBX,RDX
MOV R15,RSI
MOV RDI,RSI
CALL 0x00162ef0
TEST AL,AL
JZ 0x001699e6
MOV RDI,qword ptr [R14 + 0x20]
ADD R15,0x40
MOV RSI,R15
CALL 0x00169aae
MOV RDI,RAX
MOV RSI,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00169b06
LAB_00169989:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV RBX,RAX
LAB_00169994:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00162f00
LAB_001699a6:
LEA RSI,[0x1b42c5]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00158626
MOV BPL,0x1
LAB_001699bf:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00123e60
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123f30
LAB_001699e6:
PUSH 0x10
POP RDI
CALL 0x00123480
MOV RBX,RAX
LAB_001699f1:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00162f00
LAB_00169a03:
LEA RSI,[0x1b42de]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00158626
MOV BPL,0x1
LAB_00169a1c:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00123e60
XOR EBP,EBP
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123f30
|
/* minja::Value::set(minja::Value const&, minja::Value const&) */
void __thiscall minja::Value::set(Value *this,Value *param_1,Value *param_2)
{
Value *this_00;
runtime_error *prVar1;
char cVar2;
int1 local_60 [32];
string local_40 [32];
if (*(long *)(this + 0x20) == 0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00169994 to 001699a5 has its CatchHandler @ 00169a6d */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 001699a6 to 001699bb has its CatchHandler @ 00169a54 */
std::operator+((char *)local_40,(string *)"Value is not an object: ");
/* try { // try from 001699bf to 001699e3 has its CatchHandler @ 00169a45 */
std::runtime_error::runtime_error(prVar1,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
cVar2 = is_primitive(param_1);
if (cVar2 != '\0') {
this_00 = (Value *)nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::operator[](*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),param_1 + 0x40);
operator=(this_00,param_2);
return;
}
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001699f1 to 00169a02 has its CatchHandler @ 00169a6b */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 00169a03 to 00169a18 has its CatchHandler @ 00169a43 */
std::operator+((char *)local_40,(string *)"Unashable type: ");
/* try { // try from 00169a1c to 00169a40 has its CatchHandler @ 00169a41 */
std::runtime_error::runtime_error(prVar1,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
|
|
1,953 | resolve_collation | eloqsql/mysys/charset.c | my_bool resolve_collation(const char *cl_name,
CHARSET_INFO *default_cl,
CHARSET_INFO **cl,
myf my_flags)
{
*cl= get_charset_by_name(cl_name, my_flags);
if (*cl == NULL)
{
*cl= default_cl;
return TRUE;
}
return FALSE;
} | O3 | c | resolve_collation:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq -0xc8(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0x13af(%rip), %rax # 0x2e24e
movq %rax, 0x80(%rdi)
leaq -0x13ae(%rip), %rax # 0x2e25d
movq %rax, 0x88(%rdi)
leaq -0x13a1(%rip), %rax # 0x2e278
movq %rax, 0x90(%rdi)
leaq -0x38a9(%rip), %rax # 0x2bd7e
movq %rax, 0x98(%rdi)
leaq 0x2c758b(%rip), %rax # 0x2f6bc0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0x13b0(%rip), %rax # 0x2e296
movq %rax, 0xa8(%rdi)
movq %rcx, %rdx
callq 0x2f1c8
movq %rax, %rcx
testq %rax, %rax
sete %al
cmovneq %rcx, %r14
movq %r14, (%rbx)
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x2f680
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24360
| resolve_collation:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 0C0h
mov rbx, rdx
mov r14, rsi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea rdi, [rbp+var_C8]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
mov rdx, rcx
call my_collation_get_by_name
mov rcx, rax
test rax, rax
setz al
cmovnz r14, rcx
mov [rbx], r14
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_2F680
add rsp, 0C0h
pop rbx
pop r14
pop rbp
retn
loc_2F680:
call ___stack_chk_fail
| bool resolve_collation(long long a1, long long a2, long long *a3, long long a4)
{
long long v6; // rcx
bool result; // al
char v8[128]; // [rsp+8h] [rbp-C8h] BYREF
long long ( *v9)(long long); // [rsp+88h] [rbp-48h]
long long ( *v10)(unsigned long long); // [rsp+90h] [rbp-40h]
long long ( *v11)(long long, unsigned long long); // [rsp+98h] [rbp-38h]
long long ( *v12)(long long); // [rsp+A0h] [rbp-30h]
long long ( *v13)(); // [rsp+A8h] [rbp-28h]
long long ( *v14)(unsigned int *); // [rsp+B0h] [rbp-20h]
unsigned long long v15; // [rsp+B8h] [rbp-18h]
v15 = __readfsqword(0x28u);
v8[0] = 0;
v9 = my_once_alloc_c;
v10 = my_malloc_c;
v11 = my_realloc_c;
v12 = my_free;
v13 = my_charset_error_reporter;
v14 = add_collation;
v6 = my_collation_get_by_name((long long)v8, a1, a4);
result = v6 == 0;
if ( v6 )
a2 = v6;
*a3 = a2;
return result;
}
| resolve_collation:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0xc0
MOV RBX,RDX
MOV R14,RSI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[RBP + -0xc8]
MOV byte ptr [RDI],0x0
LEA RAX,[0x12e24e]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x12e25d]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x12e278]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x12bd7e]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x3f6bc0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x12e296]
MOV qword ptr [RDI + 0xa8],RAX
MOV RDX,RCX
CALL 0x0012f1c8
MOV RCX,RAX
TEST RAX,RAX
SETZ AL
CMOVNZ R14,RCX
MOV qword ptr [RBX],R14
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0012f680
ADD RSP,0xc0
POP RBX
POP R14
POP RBP
RET
LAB_0012f680:
CALL 0x00124360
|
bool resolve_collation(int8 param_1,long param_2,long *param_3,int8 param_4)
{
long lVar1;
long in_FS_OFFSET;
int1 local_d0 [128];
code *local_50;
code *local_48;
code *local_40;
code *local_38;
int *local_30;
code *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_d0[0] = 0;
local_50 = my_once_alloc_c;
local_48 = my_malloc_c;
local_40 = my_realloc_c;
local_38 = my_free;
local_30 = my_charset_error_reporter;
local_28 = add_collation;
lVar1 = my_collation_get_by_name(local_d0,param_1,param_4);
if (lVar1 != 0) {
param_2 = lVar1;
}
*param_3 = param_2;
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return lVar1 == 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,954 | close_cached_file | eloqsql/mysys/mf_cache.c | void close_cached_file(IO_CACHE *cache)
{
DBUG_ENTER("close_cached_file");
if (my_b_inited(cache))
{
File file=cache->file;
cache->file= -1; /* Don't flush data */
(void) end_io_cache(cache);
if (file >= 0)
{
(void) my_close(file,MYF(0));
#ifdef CANT_DELETE_OPEN_FILES
if (cache->file_name)
{
(void) my_delete(cache->file_name, MYF(MY_WME));
my_free(cache->file_name);
}
#endif
}
}
DBUG_VOID_RETURN;
} | O3 | c | close_cached_file:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0xab949
movl 0xd4(%rdi), %ebx
movl $0xffffffff, 0xd4(%rdi) # imm = 0xFFFFFFFF
callq 0x991eb
testl %ebx, %ebx
js 0xab949
movl %ebx, %edi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa31fd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| close_cached_file:
push rbp
mov rbp, rsp
push rbx
push rax
cmp qword ptr [rdi+20h], 0
jz short loc_AB949
mov ebx, [rdi+0D4h]
mov dword ptr [rdi+0D4h], 0FFFFFFFFh
call end_io_cache
test ebx, ebx
js short loc_AB949
mov edi, ebx
xor esi, esi
add rsp, 8
pop rbx
pop rbp
jmp my_close
loc_AB949:
add rsp, 8
pop rbx
pop rbp
retn
| long long close_cached_file(long long a1)
{
int v1; // ebx
long long result; // rax
if ( *(_QWORD *)(a1 + 32) )
{
v1 = *(_DWORD *)(a1 + 212);
*(_DWORD *)(a1 + 212) = -1;
result = end_io_cache(a1);
if ( v1 >= 0 )
return my_close((unsigned int)v1, 0);
}
return result;
}
| close_cached_file:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP qword ptr [RDI + 0x20],0x0
JZ 0x001ab949
MOV EBX,dword ptr [RDI + 0xd4]
MOV dword ptr [RDI + 0xd4],0xffffffff
CALL 0x001991eb
TEST EBX,EBX
JS 0x001ab949
MOV EDI,EBX
XOR ESI,ESI
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001a31fd
LAB_001ab949:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void close_cached_file(long param_1)
{
int iVar1;
if (*(long *)(param_1 + 0x20) != 0) {
iVar1 = *(int *)(param_1 + 0xd4);
*(int4 *)(param_1 + 0xd4) = 0xffffffff;
end_io_cache();
if (-1 < iVar1) {
my_close(iVar1,0);
return;
}
}
return;
}
|
|
1,955 | eth_calculate_domain | corpus-core[P]colibri-stateless/src/chains/eth/verifier/verify_blockhash_proof.c | bool eth_calculate_domain(chain_id_t chain_id, uint64_t slot, bytes32_t domain) {
uint8_t buffer[36] = {0};
bytes32_t root = {0};
// compute fork_data root hash to the seconf 32 bytes of bffer
buffer[0] = (uint8_t) c4_chain_fork_id(chain_id, (slot - 1) >> 5);
if (!c4_chain_genesis_validators_root(chain_id, buffer + 4)) false;
ssz_hash_tree_root(ssz_ob(FORK_DATA_CONTAINER, bytes(buffer, 36)), root);
// build domain by replacing the first 4 bytes with the sync committee domain which creates the domain-data in the 2nd 32 bytes of buffer
memset(domain, 0, 4);
memcpy(domain + 4, root, 28);
domain[0] = 7; // Domain-Type SYNC_COMMITTEE
return true;
} | O2 | c | eth_calculate_domain:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movl %edi, %ebp
xorps %xmm0, %xmm0
leaq 0x34(%rsp), %r15
movaps %xmm0, 0xc(%r15)
movaps %xmm0, -0x4(%r15)
andl $0x0, 0x1c(%r15)
leaq 0x60(%rsp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
decq %rsi
shrq $0x5, %rsi
callq 0x504d5
movb %al, -0x4(%r15)
movl %ebp, %edi
movq %r15, %rsi
callq 0x504b4
movl $0x24, 0x18(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x7e9ae(%rip), %rax # 0xa8c50
movq %rax, 0x28(%rsp)
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x4d3f1
movl $0x7, (%rbx)
movaps (%r14), %xmm0
movups %xmm0, 0x4(%rbx)
movups 0xc(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| eth_calculate_domain:
push rbp
push r15
push r14
push rbx
sub rsp, 88h
mov rbx, rdx
mov ebp, edi
xorps xmm0, xmm0
lea r15, [rsp+0A8h+var_74]
movaps xmmword ptr [r15+0Ch], xmm0
movaps xmmword ptr [r15-4], xmm0
and dword ptr [r15+1Ch], 0
lea r14, [rsp+0A8h+var_48]
movaps xmmword ptr [r14+10h], xmm0
movaps xmmword ptr [r14], xmm0
dec rsi
shr rsi, 5
call c4_chain_fork_id
mov [r15-4], al
mov edi, ebp
mov rsi, r15
call c4_chain_genesis_validators_root
mov dword ptr [rsp+0A8h+var_90], 24h ; '$'
lea rax, [rsp+0A8h+var_78]
mov qword ptr [rsp+0A8h+var_90+8], rax
lea rax, FORK_DATA_CONTAINER
mov [rsp+0A8h+var_80], rax
mov [rsp+0A8h+var_98], rax
movups xmm0, [rsp+0A8h+var_90]
movups [rsp+0A8h+var_A8], xmm0
mov rdi, r14
call ssz_hash_tree_root
mov dword ptr [rbx], 7
movaps xmm0, xmmword ptr [r14]
movups xmmword ptr [rbx+4], xmm0
movups xmm0, xmmword ptr [r14+0Ch]
movups xmmword ptr [rbx+10h], xmm0
mov al, 1
add rsp, 88h
pop rbx
pop r14
pop r15
pop rbp
retn
| char eth_calculate_domain(long long a1, long long a2, long long a3)
{
long long v4; // rdx
long long v5; // rcx
long long v6; // r8
long long v7; // r9
_BYTE v9[32]; // [rsp+30h] [rbp-78h] BYREF
int v10; // [rsp+50h] [rbp-58h]
_OWORD v11[4]; // [rsp+60h] [rbp-48h] BYREF
memset(v9, 0, sizeof(v9));
v10 = 0;
memset(v11, 0, 32);
v9[0] = c4_chain_fork_id(a1, (unsigned long long)(a2 - 1) >> 5);
c4_chain_genesis_validators_root((unsigned int)a1, &v9[4]);
ssz_hash_tree_root(v11, &v9[4], v4, v5, v6, v7, 36, v9, &FORK_DATA_CONTAINER);
*(_DWORD *)a3 = 7;
*(_OWORD *)(a3 + 4) = v11[0];
*(_OWORD *)(a3 + 16) = *(_OWORD *)((char *)v11 + 12);
return 1;
}
| eth_calculate_domain:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x88
MOV RBX,RDX
MOV EBP,EDI
XORPS XMM0,XMM0
LEA R15,[RSP + 0x34]
MOVAPS xmmword ptr [R15 + 0xc],XMM0
MOVAPS xmmword ptr [R15 + -0x4],XMM0
AND dword ptr [R15 + 0x1c],0x0
LEA R14,[RSP + 0x60]
MOVAPS xmmword ptr [R14 + 0x10],XMM0
MOVAPS xmmword ptr [R14],XMM0
DEC RSI
SHR RSI,0x5
CALL 0x001504d5
MOV byte ptr [R15 + -0x4],AL
MOV EDI,EBP
MOV RSI,R15
CALL 0x001504b4
MOV dword ptr [RSP + 0x18],0x24
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[0x1a8c50]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x18]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R14
CALL 0x0014d3f1
MOV dword ptr [RBX],0x7
MOVAPS XMM0,xmmword ptr [R14]
MOVUPS xmmword ptr [RBX + 0x4],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0xc]
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOV AL,0x1
ADD RSP,0x88
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 eth_calculate_domain(ulong param_1,long param_2,int4 *param_3)
{
int1 uVar1;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int4 local_58;
int8 local_48;
int4 uStack_40;
int4 uStack_3c;
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
local_68 = 0;
uStack_60 = 0;
local_78 = 0;
uStack_70 = 0;
local_58 = 0;
local_38 = 0;
uStack_34 = 0;
uStack_30 = 0;
uStack_2c = 0;
local_48 = 0;
uStack_40 = 0;
uStack_3c = 0;
uVar1 = c4_chain_fork_id(param_1,param_2 - 1U >> 5);
local_78 = CONCAT71(local_78._1_7_,uVar1);
c4_chain_genesis_validators_root(param_1 & 0xffffffff,(long)&local_78 + 4);
ssz_hash_tree_root(&local_48);
*param_3 = 7;
*(int8 *)(param_3 + 1) = local_48;
*(ulong *)(param_3 + 3) = CONCAT44(uStack_3c,uStack_40);
*(ulong *)(param_3 + 4) = CONCAT44(local_38,uStack_3c);
*(ulong *)(param_3 + 6) = CONCAT44(uStack_30,uStack_34);
return 1;
}
|
|
1,956 | mysql_set_server_option_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_set_server_option_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_set_server_option,
(parms->mysql, parms->option),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_set_server_option_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %rbx
movl 0x8(%rdi), %esi
movq %rax, %rdi
callq 0x1f44c
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_set_server_option_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rcx, [rax+480h]
mov rbx, [rcx+28h]
mov esi, [rdi+8]
mov rdi, rax
call mysql_set_server_option
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_set_server_option_start_internal(long long a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)a1 + 1152LL) + 40LL);
result = mysql_set_server_option(*(_QWORD *)a1, *(_DWORD *)(a1 + 8));
v1[2] = result;
*v1 = 0;
return result;
}
| mysql_set_server_option_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV ESI,dword ptr [RDI + 0x8]
MOV RDI,RAX
CALL 0x0011f44c
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_set_server_option_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_set_server_option(*param_1,(int)param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
1,957 | codegen_type_apply_conversion | tsotchke[P]eshkol/src/backend/codegen/type_conversion.c | char* codegen_type_apply_conversion(CodegenContext* context, const char* expr, Type* from, Type* to) {
assert(context != NULL);
assert(expr != NULL);
assert(from != NULL);
assert(to != NULL);
// Get conversion code
const char* conversion = codegen_type_conversion_code(context, from, to);
// Apply conversion
Arena* arena = codegen_context_get_arena(context);
// Special case for numeric to void* (for mixed type conditionals)
if (to->kind == TYPE_ANY && (from->kind == TYPE_INTEGER || from->kind == TYPE_FLOAT)) {
char* result = arena_alloc(arena, strlen(conversion) + strlen(expr) + 30);
sprintf(result, "%s%s; (void*)&temp; })", conversion, expr);
return result;
}
char* result = arena_alloc(arena, strlen(conversion) + strlen(expr) + 3);
sprintf(result, "%s(%s)", conversion, expr);
return result;
} | O3 | c | codegen_type_apply_conversion:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15145
movq %rsi, %rbx
testq %rsi, %rsi
je 0x15164
movq %rdx, %r12
testq %rdx, %rdx
je 0x15183
movq %rcx, %r13
testq %rcx, %rcx
je 0x151a2
movq %rdi, %r15
movq %r12, %rsi
movq %r13, %rdx
callq 0x14ed7
movq %rax, %r14
movq %r15, %rdi
callq 0xb317
movq %rax, %r15
cmpl $0xc, (%r13)
jne 0x150ec
movl (%r12), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x150ec
leaq 0xc197(%rip), %r12 # 0x2127b
movl $0x1e, %r13d
jmp 0x150f9
leaq 0xc19f(%rip), %r12 # 0x21292
movl $0x3, %r13d
movq %r14, %rdi
callq 0x2100
movq %rax, %rbp
movq %rbx, %rdi
callq 0x2100
addq %rax, %r13
addq %rbp, %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x32d3
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22b0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c13(%rip), %rdi # 0x19d5f
leaq 0xbec1(%rip), %rsi # 0x21014
leaq 0xc0c0(%rip), %rcx # 0x2121a
movl $0xcf, %edx
callq 0x2180
leaq 0xc103(%rip), %rdi # 0x2126e
leaq 0xbea2(%rip), %rsi # 0x21014
leaq 0xc0a1(%rip), %rcx # 0x2121a
movl $0xd0, %edx
callq 0x2180
leaq 0xbfc4(%rip), %rdi # 0x2114e
leaq 0xbe83(%rip), %rsi # 0x21014
leaq 0xc082(%rip), %rcx # 0x2121a
movl $0xd1, %edx
callq 0x2180
leaq 0xbfe1(%rip), %rdi # 0x2118a
leaq 0xbe64(%rip), %rsi # 0x21014
leaq 0xc063(%rip), %rcx # 0x2121a
movl $0xd2, %edx
callq 0x2180
nopl (%rax)
| codegen_type_apply_conversion:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test rdi, rdi
jz loc_15145
mov rbx, rsi
test rsi, rsi
jz loc_15164
mov r12, rdx
test rdx, rdx
jz loc_15183
mov r13, rcx
test rcx, rcx
jz loc_151A2
mov r15, rdi
mov rsi, r12
mov rdx, r13
call codegen_type_conversion_code
mov r14, rax
mov rdi, r15
call codegen_context_get_arena
mov r15, rax
cmp dword ptr [r13+0], 0Ch
jnz short loc_150EC
mov eax, [r12]
and eax, 0FFFFFFFEh
cmp eax, 2
jnz short loc_150EC
lea r12, aSSVoidTemp; "%s%s; (void*)&temp; })"
mov r13d, 1Eh
jmp short loc_150F9
loc_150EC:
lea r12, aSS_0; "%s(%s)"
mov r13d, 3
loc_150F9:
mov rdi, r14
call _strlen
mov rbp, rax
mov rdi, rbx
call _strlen
add r13, rax
add r13, rbp
mov rdi, r15
mov rsi, r13
call arena_alloc
mov r15, rax
mov rdi, rax
mov rsi, r12
mov rdx, r14
mov rcx, rbx
xor eax, eax
call _sprintf
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_15145:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCharCodegenTyp; "char *codegen_type_apply_conversion(Cod"...
mov edx, 0CFh
call ___assert_fail
loc_15164:
lea rdi, aExprNull; "expr != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCharCodegenTyp; "char *codegen_type_apply_conversion(Cod"...
mov edx, 0D0h
call ___assert_fail
loc_15183:
lea rdi, aFromNull; "from != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCharCodegenTyp; "char *codegen_type_apply_conversion(Cod"...
mov edx, 0D1h
call ___assert_fail
loc_151A2:
lea rdi, aToNull; "to != NULL"
lea rsi, aWorkspaceLlm4b_22; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCharCodegenTyp; "char *codegen_type_apply_conversion(Cod"...
mov edx, 0D2h
call ___assert_fail
| long long codegen_type_apply_conversion(long long a1, long long a2, int *a3, int *a4)
{
char *v6; // r14
long long arena; // r15
const char *v8; // r12
long long v9; // r13
long long v10; // rbp
long long v11; // rax
long long v12; // r15
long long v13; // r8
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
207LL,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)");
if ( !a2 )
__assert_fail(
"expr != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
208LL,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)");
if ( !a3 )
__assert_fail(
"from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
209LL,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)");
if ( !a4 )
__assert_fail(
"to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
210LL,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)");
v6 = codegen_type_conversion_code(a1, a3, a4);
arena = codegen_context_get_arena(a1);
if ( *a4 == 12 && (*a3 & 0xFFFFFFFE) == 2 )
{
v8 = "%s%s; (void*)&temp; })";
v9 = 30LL;
}
else
{
v8 = "%s(%s)";
v9 = 3LL;
}
v10 = strlen(v6);
v11 = strlen(a2);
v12 = arena_alloc(arena, v10 + v11 + v9);
sprintf(v12, v8, v6, a2, v13);
return v12;
}
| codegen_type_apply_conversion:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00115145
MOV RBX,RSI
TEST RSI,RSI
JZ 0x00115164
MOV R12,RDX
TEST RDX,RDX
JZ 0x00115183
MOV R13,RCX
TEST RCX,RCX
JZ 0x001151a2
MOV R15,RDI
MOV RSI,R12
MOV RDX,R13
CALL 0x00114ed7
MOV R14,RAX
MOV RDI,R15
CALL 0x0010b317
MOV R15,RAX
CMP dword ptr [R13],0xc
JNZ 0x001150ec
MOV EAX,dword ptr [R12]
AND EAX,0xfffffffe
CMP EAX,0x2
JNZ 0x001150ec
LEA R12,[0x12127b]
MOV R13D,0x1e
JMP 0x001150f9
LAB_001150ec:
LEA R12,[0x121292]
MOV R13D,0x3
LAB_001150f9:
MOV RDI,R14
CALL 0x00102100
MOV RBP,RAX
MOV RDI,RBX
CALL 0x00102100
ADD R13,RAX
ADD R13,RBP
MOV RDI,R15
MOV RSI,R13
CALL 0x001032d3
MOV R15,RAX
MOV RDI,RAX
MOV RSI,R12
MOV RDX,R14
MOV RCX,RBX
XOR EAX,EAX
CALL 0x001022b0
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00115145:
LEA RDI,[0x119d5f]
LEA RSI,[0x121014]
LEA RCX,[0x12121a]
MOV EDX,0xcf
CALL 0x00102180
LAB_00115164:
LEA RDI,[0x12126e]
LEA RSI,[0x121014]
LEA RCX,[0x12121a]
MOV EDX,0xd0
CALL 0x00102180
LAB_00115183:
LEA RDI,[0x12114e]
LEA RSI,[0x121014]
LEA RCX,[0x12121a]
MOV EDX,0xd1
CALL 0x00102180
LAB_001151a2:
LEA RDI,[0x12118a]
LEA RSI,[0x121014]
LEA RCX,[0x12121a]
MOV EDX,0xd2
CALL 0x00102180
|
char * codegen_type_apply_conversion(long param_1,char *param_2,uint *param_3,int *param_4)
{
char *__s;
int8 uVar1;
size_t sVar2;
size_t sVar3;
char *__s_00;
char *__format;
long lVar4;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xcf,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)"
);
}
if (param_2 == (char *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("expr != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xd0,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)"
);
}
if (param_3 == (uint *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xd1,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)"
);
}
if (param_4 != (int *)0x0) {
__s = (char *)codegen_type_conversion_code(param_1,param_3,param_4);
uVar1 = codegen_context_get_arena(param_1);
if ((*param_4 == 0xc) && ((*param_3 & 0xfffffffe) == 2)) {
__format = "%s%s; (void*)&temp; })";
lVar4 = 0x1e;
}
else {
__format = "%s(%s)";
lVar4 = 3;
}
sVar2 = strlen(__s);
sVar3 = strlen(param_2);
__s_00 = (char *)arena_alloc(uVar1,lVar4 + sVar3 + sVar2);
sprintf(__s_00,__format,__s,param_2);
return __s_00;
}
/* WARNING: Subroutine does not return */
__assert_fail("to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xd2,
"char *codegen_type_apply_conversion(CodegenContext *, const char *, Type *, Type *)"
);
}
|
|
1,958 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) | llama.cpp/common/json.hpp | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x8a0f8
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x8a0f8
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x8a073
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
cmpb $0x2, %r14b
jne 0x89f19
movq %rsp, %rdi
callq 0x8a13c
movq (%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
subq %r15, %r13
sarq $0x4, %r13
testq %r13, %r13
jle 0x89f5a
incq %r13
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x89108
addq $0x10, %r15
decq %r13
cmpq $0x1, %r13
ja 0x89eff
jmp 0x89f5a
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x8a13c
movq (%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x89f5a
movq %rsp, %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x89108
addq $0x30, %r12
cmpq %r13, %r12
jne 0x89f44
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
je 0x8a06b
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq -0x10(%r13), %rdi
movups -0x10(%r13), %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %esi, %esi
callq 0x852f2
movb $0x0, -0x10(%r13)
movq $0x0, -0x8(%r13)
movq %r15, %rdi
movl $0x1, %esi
callq 0x852f2
movq 0x8(%rsp), %r13
addq $-0x10, %r13
movq %r13, 0x8(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x852f2
movq %r13, %rdi
callq 0x89a0c
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x8a014
cmpl $0x2, %eax
jne 0x8a04a
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
subq %r13, %rbp
sarq $0x4, %rbp
testq %rbp, %rbp
jle 0x8a00a
incq %rbp
movq %r12, %rdi
movq %r13, %rsi
callq 0x89108
addq $0x10, %r13
decq %rbp
cmpq $0x1, %rbp
jg 0x89fea
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x8a290
jmp 0x8a04a
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
cmpq %rbp, %r13
je 0x8a042
leaq 0x20(%r13), %rsi
movq %r12, %rdi
callq 0x89108
addq $0x30, %r13
cmpq %rbp, %r13
jne 0x8a025
movq 0x28(%rsp), %rdi
movq (%rdi), %r13
movq %r13, %rsi
callq 0x8a2d6
movq %r15, %rdi
xorl %esi, %esi
callq 0x852f2
movq %r15, %rdi
callq 0x89a0c
movq 0x8(%rsp), %r13
cmpq %r13, (%rsp)
jne 0x89f71
movq %rsp, %rdi
callq 0x8a23e
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x8a0f8
leaq 0x88e9b(%rip), %rcx # 0x112f20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x8a390
jmp 0x8a0b5
movq (%rbx), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x8a0b8
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x20180
movq (%rbx), %rdi
movl $0x20, %esi
jmp 0x8a0f3
movq (%rbx), %rdi
callq 0x8a23e
movq (%rbx), %rdi
movl $0x18, %esi
jmp 0x8a0f3
movq (%rbx), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x8a0ee
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x20180
movq (%rbx), %rdi
movl $0x28, %esi
callq 0x20180
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8a10b
jmp 0x8a10b
movq %rax, %rbx
jmp 0x8a12c
jmp 0x8a112
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x852f2
movq %r14, %rdi
callq 0x89a0c
movq %rsp, %rdi
callq 0x8a23e
movq %rbx, %rdi
callq 0x20af0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_8A08C; jumptable 000000000008A08C default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_8A08C; jumptable 000000000008A08C default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_8A073
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
mov [rsp+68h+var_58], 0
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
cmp r14b, 2
jnz short loc_89F19
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r15, [rax]
mov r13, [rax+8]
sub r13, r15
sar r13, 4
test r13, r13
jle short loc_89F5A
inc r13
mov r12, rsp
loc_89EFF:
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r15, 10h
dec r13
cmp r13, 1
ja short loc_89EFF
jmp short loc_89F5A
loc_89F19:
mov rax, 0AAAAAAAAAAAAAAABh
imul rax, rsi
mov rdi, rsp
mov rsi, rax
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov r12, [rax]
mov r13, [rax+8]
cmp r12, r13
jz short loc_89F5A
mov r15, rsp
loc_89F44:
lea rsi, [r12+20h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
add r12, 30h ; '0'
cmp r12, r13
jnz short loc_89F44
loc_89F5A:
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jz loc_8A06B
lea r15, [rsp+68h+var_48]
mov r12, rsp
loc_89F71:
lea rdi, [r13-10h]
movups xmm0, xmmword ptr [r13-10h]
movaps [rsp+68h+var_48], xmm0
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r13-10h], 0
mov qword ptr [r13-8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, qword ptr [rsp+68h+var_68+8]
add r13, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], r13
mov rdi, r13
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r13
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_8A014
cmp eax, 2
jnz short loc_8A04A
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
sub rbp, r13
sar rbp, 4
test rbp, rbp
jle short loc_8A00A
inc rbp
loc_89FEA:
mov rdi, r12
mov rsi, r13
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> &&)
add r13, 10h
dec rbp
cmp rbp, 1
jg short loc_89FEA
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_8A00A:
mov rsi, r13
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE15_M_erase_at_endEPSD_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::_M_erase_at_end(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*)
jmp short loc_8A04A
loc_8A014:
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
mov rbp, [rdi+8]
cmp r13, rbp
jz short loc_8A042
loc_8A025:
lea rsi, [r13+20h]
mov rdi, 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> &&)
add r13, 30h ; '0'
cmp r13, rbp
jnz short loc_8A025
mov rdi, qword ptr [rsp+68h+var_48+8]
mov r13, [rdi]
loc_8A042:
mov rsi, r13
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE15_M_erase_at_endEPSG_; 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>>>::_M_erase_at_end(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>>*)
loc_8A04A:
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r13, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], r13
jnz loc_89F71
loc_8A06B:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_8A073:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja short def_8A08C; jumptable 000000000008A08C default case, cases 4-7
lea rcx, jpt_8A08C
movsxd rax, ds:(jpt_8A08C - 112F20h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_8A08E:
mov rdi, [rbx]; jumptable 000000000008A08C case 1
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EED2Ev; 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>>>::~vector()
jmp short loc_8A0B5
loc_8A098:
mov rdi, [rbx]; jumptable 000000000008A08C case 3
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_8A0B8
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_8A0B5:
mov rdi, [rbx]
loc_8A0B8:
mov esi, 20h ; ' '
jmp short loc_8A0F3
loc_8A0BF:
mov rdi, [rbx]; jumptable 000000000008A08C case 2
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()
mov rdi, [rbx]
mov esi, 18h
jmp short loc_8A0F3
loc_8A0D1:
mov rdi, [rbx]; jumptable 000000000008A08C case 8
mov rax, [rdi]
test rax, rax
jz short loc_8A0EE
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [rbx]; void *
loc_8A0EE:
mov esi, 28h ; '('; unsigned __int64
loc_8A0F3:
call __ZdlPvm; operator delete(void *,ulong)
def_8A08C:
add rsp, 38h; jumptable 000000000008A08C default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_8A10B
jmp short $+2
loc_8A10B:
mov rbx, rax
jmp short loc_8A12C
jmp short $+2
loc_8A112:
mov rbx, rax
lea r14, [rsp+arg_18]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_8A12C:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
long long **a1,
int a2)
{
long long *v2; // rax
char v3; // r14
long long v5; // rsi
long long v6; // r15
long long v7; // r13
long long v8; // r13
bool v9; // cf
long long v10; // r12
long long i; // r13
long long j; // r13
char *v13; // r13
long long v14; // rdi
long long v15; // r13
long long v16; // rbp
long long v17; // rbp
long long v18; // rdi
long long v19; // r13
long long v20; // rbp
void **v21; // rdi
_QWORD *v22; // rcx
unsigned long long v23; // rsi
long long v24; // rax
__int128 v25; // [rsp+0h] [rbp-68h] BYREF
long long v26; // [rsp+10h] [rbp-58h]
_OWORD v27[4]; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( *a1 != 0LL || a2 != 1 )
{
v3 = a2;
if ( v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8 )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v25 = 0LL;
v26 = 0LL;
v5 = (v2[1] - *v2) >> 4;
if ( v3 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
v5);
v6 = **a1;
v7 = ((*a1)[1] - v6) >> 4;
if ( v7 > 0 )
{
v8 = v7 + 1;
do
{
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)&v25,
v6);
v6 += 16LL;
v9 = v8-- == 1;
}
while ( !v9 && v8 != 1 );
}
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v25,
0xAAAAAAAAAAAAAAABLL * v5);
v10 = **a1;
for ( i = (*a1)[1]; v10 != i; v10 += 48LL )
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)&v25,
v10 + 32);
}
for ( j = *((_QWORD *)&v25 + 1); (_QWORD)v25 != *((_QWORD *)&v25 + 1); j = *((_QWORD *)&v25 + 1) )
{
v27[0] = *(_OWORD *)(j - 16);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(j - 16));
*(_BYTE *)(j - 16) = 0;
*(_QWORD *)(j - 8) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
v13 = (char *)(*((_QWORD *)&v25 + 1) - 16LL);
*((_QWORD *)&v25 + 1) = 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>::assert_invariant(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>::data::~data(v13);
if ( LOBYTE(v27[0]) == 1 )
{
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
v20 = *(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL);
if ( **((_QWORD **)&v27[0] + 1) != v20 )
{
do
{
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)&v25,
v19 + 32);
v19 += 48LL;
}
while ( v19 != v20 );
v18 = *((_QWORD *)&v27[0] + 1);
v19 = **((_QWORD **)&v27[0] + 1);
}
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>>>::_M_erase_at_end(
v18,
v19);
}
else if ( LOBYTE(v27[0]) == 2 )
{
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
v16 = (long long)(*(_QWORD *)(*((_QWORD *)&v27[0] + 1) + 8LL) - **((_QWORD **)&v27[0] + 1)) >> 4;
if ( v16 > 0 )
{
v17 = v16 + 1;
do
{
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)&v25,
v15);
v15 += 16LL;
--v17;
}
while ( v17 > 1 );
v14 = *((_QWORD *)&v27[0] + 1);
v15 = **((_QWORD **)&v27[0] + 1);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::_M_erase_at_end(
v14,
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>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v25);
}
switch ( v3 )
{
case 1:
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>>>::~vector(*a1);
goto LABEL_29;
case 2:
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(*a1);
v21 = (void **)*a1;
v23 = 24LL;
goto LABEL_35;
case 3:
v21 = (void **)*a1;
v22 = *a1 + 2;
if ( (_QWORD *)**a1 != v22 )
{
operator delete((void *)**a1, *v22 + 1LL);
LABEL_29:
v21 = (void **)*a1;
}
v23 = 32LL;
goto LABEL_35;
case 8:
v21 = (void **)*a1;
v24 = **a1;
if ( v24 )
{
operator delete((void *)**a1, (unsigned long long)v21[2] - v24);
v21 = (void **)*a1;
}
v23 = 40LL;
LABEL_35:
operator delete(v21, v23);
break;
default:
return;
}
}
}
}
| destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x0018a0f8
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x0018a0f8
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x0018a073
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
CMP R14B,0x2
JNZ 0x00189f19
LAB_00189edb:
MOV RDI,RSP
CALL 0x0018a13c
MOV RAX,qword ptr [RBX]
MOV R15,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
SUB R13,R15
SAR R13,0x4
TEST R13,R13
JLE 0x00189f5a
INC R13
MOV R12,RSP
LAB_00189eff:
MOV RDI,R12
MOV RSI,R15
CALL 0x00189108
ADD R15,0x10
DEC R13
CMP R13,0x1
JA 0x00189eff
JMP 0x00189f5a
LAB_00189f19:
MOV RAX,-0x5555555555555555
IMUL RAX,RSI
LAB_00189f27:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x0018a13c
MOV RAX,qword ptr [RBX]
MOV R12,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R12,R13
JZ 0x00189f5a
MOV R15,RSP
LAB_00189f44:
LEA RSI,[R12 + 0x20]
LAB_00189f49:
MOV RDI,R15
CALL 0x00189108
ADD R12,0x30
CMP R12,R13
JNZ 0x00189f44
LAB_00189f5a:
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JZ 0x0018a06b
LEA R15,[RSP + 0x20]
MOV R12,RSP
LAB_00189f71:
LEA RDI,[R13 + -0x10]
MOVUPS XMM0,xmmword ptr [R13 + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
XOR ESI,ESI
CALL 0x001852f2
MOV byte ptr [R13 + -0x10],0x0
MOV qword ptr [R13 + -0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001852f2
MOV R13,qword ptr [RSP + 0x8]
ADD R13,-0x10
MOV qword ptr [RSP + 0x8],R13
MOV RDI,R13
XOR ESI,ESI
CALL 0x001852f2
MOV RDI,R13
CALL 0x00189a0c
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x0018a014
CMP EAX,0x2
JNZ 0x0018a04a
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
SUB RBP,R13
SAR RBP,0x4
TEST RBP,RBP
JLE 0x0018a00a
INC RBP
LAB_00189fea:
MOV RDI,R12
MOV RSI,R13
CALL 0x00189108
ADD R13,0x10
DEC RBP
CMP RBP,0x1
JG 0x00189fea
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0018a00a:
MOV RSI,R13
CALL 0x0018a290
JMP 0x0018a04a
LAB_0018a014:
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP R13,RBP
JZ 0x0018a042
LAB_0018a025:
LEA RSI,[R13 + 0x20]
LAB_0018a029:
MOV RDI,R12
CALL 0x00189108
LAB_0018a031:
ADD R13,0x30
CMP R13,RBP
JNZ 0x0018a025
MOV RDI,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RDI]
LAB_0018a042:
MOV RSI,R13
CALL 0x0018a2d6
LAB_0018a04a:
MOV RDI,R15
XOR ESI,ESI
CALL 0x001852f2
MOV RDI,R15
CALL 0x00189a0c
MOV R13,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],R13
JNZ 0x00189f71
LAB_0018a06b:
MOV RDI,RSP
CALL 0x0018a23e
LAB_0018a073:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x0018a0f8
LEA RCX,[0x212f20]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x0018a390
JMP 0x0018a0b5
caseD_3:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x0018a0b8
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x00120180
LAB_0018a0b5:
MOV RDI,qword ptr [RBX]
LAB_0018a0b8:
MOV ESI,0x20
JMP 0x0018a0f3
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x0018a23e
MOV RDI,qword ptr [RBX]
MOV ESI,0x18
JMP 0x0018a0f3
caseD_8:
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0018a0ee
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x00120180
MOV RDI,qword ptr [RBX]
LAB_0018a0ee:
MOV ESI,0x28
LAB_0018a0f3:
CALL 0x00120180
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
pair *ppVar3;
void *pvVar4;
byte bVar5;
ulong uVar6;
bool bVar7;
int8 *puVar8;
long lVar9;
data *pdVar10;
pair *ppVar11;
basic_json *pbVar12;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
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>>>
*pvStack_40;
plVar1 = *(long **)this;
if (param_2 == 1 && plVar1 == (long *)0x0) {
return;
}
bVar5 = (byte)param_2;
if ((bVar5 == 8 || (bVar5 & 0xfe) == 2) && plVar1 == (long *)0x0) {
return;
}
if ((byte)(bVar5 - 1) < 2) {
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
local_58 = 0;
uVar6 = plVar1[1] - *plVar1 >> 4;
if (bVar5 == 2) {
/* try { // try from 00189edb to 00189ee2 has its CatchHandler @ 0018a107 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((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_68,uVar6);
pbVar12 = (basic_json *)**(long **)this;
lVar9 = (*(long **)this)[1] - (long)pbVar12 >> 4;
if (0 < lVar9) {
uVar6 = lVar9 + 1;
do {
/* try { // try from 00189eff to 00189f09 has its CatchHandler @ 0018a10b */
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_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
uVar6 = uVar6 - 1;
} while (1 < uVar6);
}
}
else {
/* try { // try from 00189f27 to 00189f31 has its CatchHandler @ 0018a107 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((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_68,uVar6 * -0x5555555555555555);
lVar2 = (*(long **)this)[1];
for (lVar9 = **(long **)this; lVar9 != lVar2; lVar9 = lVar9 + 0x30) {
/* try { // try from 00189f49 to 00189f50 has its CatchHandler @ 0018a109 */
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_68,(basic_json *)(lVar9 + 0x20));
}
}
if (local_68 != pdStack_60) {
do {
pdVar10 = pdStack_60;
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pdStack_60 + -8);
assert_invariant((bool)((char)pdStack_60 + -0x10));
pdVar10[-0x10] = (data)0x0;
*(int8 *)(pdVar10 + -8) = 0;
bVar7 = SUB81((data *)&local_48,0);
assert_invariant(bVar7);
pdVar10 = pdStack_60 + -0x10;
pdStack_60 = pdVar10;
assert_invariant(SUB81(pdVar10,0));
data::~data(pdVar10);
if (local_48._0_1_ == (data)0x1) {
ppVar11 = *(pair **)pvStack_40;
ppVar3 = *(pair **)(pvStack_40 + 8);
if (ppVar11 != ppVar3) {
do {
/* try { // try from 0018a029 to 0018a030 has its CatchHandler @ 0018a112 */
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_68,(basic_json *)(ppVar11 + 0x20));
ppVar11 = ppVar11 + 0x30;
} while (ppVar11 != ppVar3);
ppVar11 = *(pair **)pvStack_40;
}
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>>>>
::_M_erase_at_end((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>>>>
*)pvStack_40,ppVar11);
}
else if (local_48._0_1_ == (data)0x2) {
pbVar12 = *(basic_json **)pvStack_40;
lVar9 = *(long *)(pvStack_40 + 8) - (long)pbVar12 >> 4;
if (0 < lVar9) {
lVar9 = lVar9 + 1;
do {
/* try { // try from 00189fea to 00189ff4 has its CatchHandler @ 0018a110 */
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_68,pbVar12);
pbVar12 = pbVar12 + 0x10;
lVar9 = lVar9 + -1;
} while (1 < lVar9);
pbVar12 = *(basic_json **)pvStack_40;
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::_M_erase_at_end(pvStack_40,pbVar12);
}
assert_invariant(bVar7);
data::~data((data *)&local_48);
} while (local_68 != pdStack_60);
}
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_68);
}
switch(param_2 & 0xff) {
case 1:
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>>>>
::~vector(*(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);
LAB_0018a0b5:
puVar8 = *(int8 **)this;
goto LAB_0018a0b8;
case 2:
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>>>
**)this);
puVar8 = *(int8 **)this;
uVar6 = 0x18;
break;
case 3:
puVar8 = *(int8 **)this;
if ((long *)*puVar8 != puVar8 + 2) {
operator_delete((long *)*puVar8,puVar8[2] + 1);
goto LAB_0018a0b5;
}
LAB_0018a0b8:
uVar6 = 0x20;
break;
default:
goto switchD_0018a08c_caseD_4;
case 8:
puVar8 = *(int8 **)this;
pvVar4 = (void *)*puVar8;
if (pvVar4 != (void *)0x0) {
operator_delete(pvVar4,puVar8[2] - (long)pvVar4);
puVar8 = *(int8 **)this;
}
uVar6 = 0x28;
}
operator_delete(puVar8,uVar6);
switchD_0018a08c_caseD_4:
return;
}
|
|
1,959 | func_gb2312_uni_onechar | eloqsql/strings/ctype-gb2312.c | static int func_gb2312_uni_onechar(int code){
if ((code>=0x2121)&&(code<=0x2658))
return(tab_gb2312_uni0[code-0x2121]);
if ((code>=0x2721)&&(code<=0x296F))
return(tab_gb2312_uni1[code-0x2721]);
if ((code>=0x3021)&&(code<=0x777E))
return(tab_gb2312_uni2[code-0x3021]);
return(0);
} | O0 | c | func_gb2312_uni_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2121, -0x8(%rbp) # imm = 0x2121
jl 0xe0a44
cmpl $0x2658, -0x8(%rbp) # imm = 0x2658
jg 0xe0a44
movl -0x8(%rbp), %eax
subl $0x2121, %eax # imm = 0x2121
movslq %eax, %rcx
leaq 0xcba15(%rip), %rax # 0x1ac450
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe0aa5
cmpl $0x2721, -0x8(%rbp) # imm = 0x2721
jl 0xe0a71
cmpl $0x296f, -0x8(%rbp) # imm = 0x296F
jg 0xe0a71
movl -0x8(%rbp), %eax
subl $0x2721, %eax # imm = 0x2721
movslq %eax, %rcx
leaq 0xcc458(%rip), %rax # 0x1acec0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe0aa5
cmpl $0x3021, -0x8(%rbp) # imm = 0x3021
jl 0xe0a9e
cmpl $0x777e, -0x8(%rbp) # imm = 0x777E
jg 0xe0a9e
movl -0x8(%rbp), %eax
subl $0x3021, %eax # imm = 0x3021
movslq %eax, %rcx
leaq 0xcc8cb(%rip), %rax # 0x1ad360
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xe0aa5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_gb2312_uni_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 2121h
jl short loc_E0A44
cmp [rbp+var_8], 2658h
jg short loc_E0A44
mov eax, [rbp+var_8]
sub eax, 2121h
movsxd rcx, eax
lea rax, tab_gb2312_uni0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_E0AA5
loc_E0A44:
cmp [rbp+var_8], 2721h
jl short loc_E0A71
cmp [rbp+var_8], 296Fh
jg short loc_E0A71
mov eax, [rbp+var_8]
sub eax, 2721h
movsxd rcx, eax
lea rax, tab_gb2312_uni1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_E0AA5
loc_E0A71:
cmp [rbp+var_8], 3021h
jl short loc_E0A9E
cmp [rbp+var_8], 777Eh
jg short loc_E0A9E
mov eax, [rbp+var_8]
sub eax, 3021h
movsxd rcx, eax
lea rax, tab_gb2312_uni2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_E0AA5
loc_E0A9E:
mov [rbp+var_4], 0
loc_E0AA5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_gb2312_uni_onechar(int a1)
{
if ( a1 < 8481 || a1 > 9816 )
{
if ( a1 < 10017 || a1 > 10607 )
{
if ( a1 < 12321 || a1 > 30590 )
return 0;
else
return tab_gb2312_uni2[a1 - 12321];
}
else
{
return tab_gb2312_uni1[a1 - 10017];
}
}
else
{
return tab_gb2312_uni0[a1 - 8481];
}
}
| func_gb2312_uni_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0x2121
JL 0x001e0a44
CMP dword ptr [RBP + -0x8],0x2658
JG 0x001e0a44
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2121
MOVSXD RCX,EAX
LEA RAX,[0x2ac450]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e0aa5
LAB_001e0a44:
CMP dword ptr [RBP + -0x8],0x2721
JL 0x001e0a71
CMP dword ptr [RBP + -0x8],0x296f
JG 0x001e0a71
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2721
MOVSXD RCX,EAX
LEA RAX,[0x2acec0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e0aa5
LAB_001e0a71:
CMP dword ptr [RBP + -0x8],0x3021
JL 0x001e0a9e
CMP dword ptr [RBP + -0x8],0x777e
JG 0x001e0a9e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3021
MOVSXD RCX,EAX
LEA RAX,[0x2ad360]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001e0aa5
LAB_001e0a9e:
MOV dword ptr [RBP + -0x4],0x0
LAB_001e0aa5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_gb2312_uni_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0x2121) || (0x2658 < param_1)) {
if ((param_1 < 0x2721) || (0x296f < param_1)) {
if ((param_1 < 0x3021) || (0x777e < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni2 + (long)(param_1 + -0x3021) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni1 + (long)(param_1 + -0x2721) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni0 + (long)(param_1 + -0x2121) * 2);
}
return uVar1;
}
|
|
1,960 | evmone::(anonymous namespace)::validate_types(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>, evmone::EOF1Header const&) | corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/eof.cpp | EOFValidationError validate_types(bytes_view container, const EOF1Header& header) noexcept
{
for (size_t i = 0; i < header.get_type_count(); ++i)
{
const auto [inputs, outputs, max_stack_increase] = header.get_type(container, i);
// First type should be (0, 0x80)
if (i == 0 && (inputs != 0 || outputs != NON_RETURNING_FUNCTION))
return EOFValidationError::invalid_first_section_type;
if ((outputs > OUTPUTS_INPUTS_NUMBER_LIMIT && outputs != NON_RETURNING_FUNCTION) ||
inputs > OUTPUTS_INPUTS_NUMBER_LIMIT)
return EOFValidationError::inputs_outputs_num_above_limit;
if (max_stack_increase > MAX_STACK_INCREASE_LIMIT)
return EOFValidationError::max_stack_increase_above_limit;
}
return EOFValidationError::success;
} | O0 | cpp | evmone::(anonymous namespace)::validate_types(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>, evmone::EOF1Header const&):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7c550
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x741c6
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x70020
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x74179
movzbl -0x2c(%rbp), %eax
cmpl $0x0, %eax
jne 0x74170
movzbl -0x2b(%rbp), %eax
cmpl $0x80, %eax
je 0x74179
movl $0x12, -0x4(%rbp)
jmp 0x741cd
movzbl -0x2b(%rbp), %eax
cmpl $0x7f, %eax
jle 0x7418d
movzbl -0x2b(%rbp), %eax
cmpl $0x80, %eax
jne 0x74196
movzbl -0x2c(%rbp), %eax
cmpl $0x7f, %eax
jle 0x7419f
movl $0x18, -0x4(%rbp)
jmp 0x741cd
movzwl -0x2a(%rbp), %eax
cmpl $0x3ff, %eax # imm = 0x3FF
jle 0x741b3
movl $0x17, -0x4(%rbp)
jmp 0x741cd
jmp 0x741b5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7410c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN6evmone12_GLOBAL__N_114validate_typesESt17basic_string_viewIhN4evmc11byte_traitsIhEEERKNS_10EOF1HeaderE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_18], rdi
mov [rbp+var_10], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 0
loc_7410C:
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rdi, [rbp+var_20]; this
call _ZNK6evmone10EOF1Header14get_type_countEv; evmone::EOF1Header::get_type_count(void)
mov rcx, rax
mov rax, [rbp+var_48]
cmp rax, rcx
jnb loc_741C6
mov rdi, [rbp+var_20]
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rcx, [rbp+var_28]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
call _ZNK6evmone10EOF1Header8get_typeESt17basic_string_viewIhN4evmc11byte_traitsIhEEEm; evmone::EOF1Header::get_type(std::basic_string_view<uchar,evmc::byte_traits<uchar>>,ulong)
mov [rbp+var_2C], eax
cmp [rbp+var_28], 0
jnz short loc_74179
movzx eax, byte ptr [rbp+var_2C]
cmp eax, 0
jnz short loc_74170
movzx eax, byte ptr [rbp+var_2C+1]
cmp eax, 80h
jz short loc_74179
loc_74170:
mov [rbp+var_4], 12h
jmp short loc_741CD
loc_74179:
movzx eax, byte ptr [rbp+var_2C+1]
cmp eax, 7Fh
jle short loc_7418D
movzx eax, byte ptr [rbp+var_2C+1]
cmp eax, 80h
jnz short loc_74196
loc_7418D:
movzx eax, byte ptr [rbp+var_2C]
cmp eax, 7Fh
jle short loc_7419F
loc_74196:
mov [rbp+var_4], 18h
jmp short loc_741CD
loc_7419F:
movzx eax, word ptr [rbp+var_2C+2]
cmp eax, 3FFh
jle short loc_741B3
mov [rbp+var_4], 17h
jmp short loc_741CD
loc_741B3:
jmp short $+2
loc_741B5:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp loc_7410C
loc_741C6:
mov [rbp+var_4], 0
loc_741CD:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long evmone::`anonymous namespace'::validate_types(long long a1, long long a2, evmone::EOF1Header *a3)
{
int type; // [rsp+24h] [rbp-2Ch]
unsigned long long i; // [rsp+28h] [rbp-28h]
for ( i = 0LL; i < evmone::EOF1Header::get_type_count(a3); ++i )
{
type = evmone::EOF1Header::get_type((long long)a3, a1, a2, i);
if ( !i && ((_BYTE)type || BYTE1(type) != 128) )
return 18;
if ( BYTE1(type) > 0x80u || (unsigned __int8)type > 0x7Fu )
return 24;
if ( HIWORD(type) > 0x3FFu )
return 23;
}
return 0;
}
| validate_types:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],0x0
LAB_0017410c:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0017c550
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,RCX
JNC 0x001741c6
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00170020
MOV dword ptr [RBP + -0x2c],EAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x00174179
MOVZX EAX,byte ptr [RBP + -0x2c]
CMP EAX,0x0
JNZ 0x00174170
MOVZX EAX,byte ptr [RBP + -0x2b]
CMP EAX,0x80
JZ 0x00174179
LAB_00174170:
MOV dword ptr [RBP + -0x4],0x12
JMP 0x001741cd
LAB_00174179:
MOVZX EAX,byte ptr [RBP + -0x2b]
CMP EAX,0x7f
JLE 0x0017418d
MOVZX EAX,byte ptr [RBP + -0x2b]
CMP EAX,0x80
JNZ 0x00174196
LAB_0017418d:
MOVZX EAX,byte ptr [RBP + -0x2c]
CMP EAX,0x7f
JLE 0x0017419f
LAB_00174196:
MOV dword ptr [RBP + -0x4],0x18
JMP 0x001741cd
LAB_0017419f:
MOVZX EAX,word ptr [RBP + -0x2a]
CMP EAX,0x3ff
JLE 0x001741b3
MOV dword ptr [RBP + -0x4],0x17
JMP 0x001741cd
LAB_001741b3:
JMP 0x001741b5
LAB_001741b5:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0017410c
LAB_001741c6:
MOV dword ptr [RBP + -0x4],0x0
LAB_001741cd:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
/* evmone::(anonymous namespace)::validate_types(std::basic_string_view<unsigned char,
evmc::byte_traits<unsigned char> >, evmone::EOF1Header const&) */
int4 __thiscall
evmone::(anonymous_namespace)::validate_types
(_anonymous_namespace_ *this,int8 param_2,EOF1Header *param_3)
{
int4 uVar1;
ulong uVar2;
byte local_34;
byte bStack_33;
ushort uStack_32;
ulong local_30;
local_30 = 0;
while( true ) {
uVar2 = EOF1Header::get_type_count(param_3);
if (uVar2 <= local_30) {
return 0;
}
uVar1 = EOF1Header::get_type(param_3,this,param_2,local_30);
local_34 = (byte)uVar1;
bStack_33 = (byte)((uint)uVar1 >> 8);
if ((local_30 == 0) && ((local_34 != 0 || (bStack_33 != 0x80)))) break;
if (((0x7f < bStack_33) && (bStack_33 != 0x80)) || (0x7f < local_34)) {
return 0x18;
}
uStack_32 = (ushort)((uint)uVar1 >> 0x10);
if (0x3ff < uStack_32) {
return 0x17;
}
local_30 = local_30 + 1;
}
return 0x12;
}
|
|
1,961 | ma_read_rnd_mempack_record | eloqsql/storage/maria/ma_packrec.c | static int _ma_read_rnd_mempack_record(MARIA_HA *info,
uchar *buf,
register MARIA_RECORD_POS filepos,
my_bool skip_deleted_blocks
__attribute__((unused)))
{
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share= info->s;
uchar *pos,*start;
DBUG_ENTER("_ma_read_rnd_mempack_record");
if (filepos >= share->state.state.data_file_length)
{
my_errno=HA_ERR_END_OF_FILE;
goto err;
}
if (!(pos= (uchar*) _ma_mempack_get_block_info(info, &info->bit_buff,
&block_info,
&info->rec_buff,
&info->rec_buff_size,
(uchar*)
(start= share->file_map +
filepos))))
goto err;
#ifndef DBUG_OFF
if (block_info.rec_len > info->s->max_pack_length)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
#endif
info->packed_length=block_info.rec_len;
info->cur_row.lastpos= filepos;
info->cur_row.nextpos= filepos+(uint) (pos-start)+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
DBUG_RETURN (_ma_pack_rec_unpack(info, &info->bit_buff, buf,
pos, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O3 | c | ma_read_rnd_mempack_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rdi
cmpq %rdx, 0x40(%rdi)
jbe 0x47f8d
movq %rdx, %r15
movq %rsi, %rbx
leaq 0x290(%r14), %r12
leaq 0x3a0(%r14), %rcx
leaq 0x460(%r14), %r8
movq 0x5f0(%rdi), %r13
addq %rdx, %r13
leaq -0x88(%rbp), %rdx
movq %r12, %rsi
movq %r13, %r9
callq 0x4989d
testq %rax, %rax
je 0x47f98
movq -0x70(%rbp), %r8
movq %r8, 0x450(%r14)
movq %r15, 0x98(%r14)
movl %eax, %ecx
subl %r13d, %ecx
addq %r8, %r15
addq %rcx, %r15
movq %r15, 0xa0(%r14)
orb $-0x7e, 0x624(%r14)
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x47fbd
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x479fd
callq 0xa8156
movl $0x89, (%rax)
callq 0xa8156
movl (%rax), %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x47fbd
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a270
| _ma_read_rnd_mempack_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rdi, [rdi]
cmp [rdi+40h], rdx
jbe loc_47F8D
mov r15, rdx
mov rbx, rsi
lea r12, [r14+290h]
lea rcx, [r14+3A0h]
lea r8, [r14+460h]
mov r13, [rdi+5F0h]
add r13, rdx
lea rdx, [rbp+var_88]
mov rsi, r12
mov r9, r13
call _ma_mempack_get_block_info
test rax, rax
jz short loc_47F98
mov r8, [rbp+var_70]
mov [r14+450h], r8
mov [r14+98h], r15
mov ecx, eax
sub ecx, r13d
add r15, r8
add r15, rcx
mov [r14+0A0h], r15
or byte ptr [r14+624h], 82h
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_47FBD
mov rdi, r14
mov rsi, r12
mov rdx, rbx
mov rcx, rax
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ma_pack_rec_unpack
loc_47F8D:
call _my_thread_var
mov dword ptr [rax], 89h
loc_47F98:
call _my_thread_var
mov eax, [rax]
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_47FBD
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_47FBD:
call ___stack_chk_fail
| long long ma_read_rnd_mempack_record(long long *a1, long long a2, unsigned long long a3)
{
long long v4; // rdi
unsigned long long v6; // r13
long long block_info; // rax
int v8; // r9d
long long v9; // r8
_BYTE v11[24]; // [rsp+8h] [rbp-88h] BYREF
long long v12; // [rsp+20h] [rbp-70h]
unsigned long long v13; // [rsp+60h] [rbp-30h]
v13 = __readfsqword(0x28u);
v4 = *a1;
if ( *(_QWORD *)(v4 + 64) <= a3 )
{
*(_DWORD *)my_thread_var(v4) = 137;
}
else
{
v6 = a3 + *(_QWORD *)(v4 + 1520);
block_info = ma_mempack_get_block_info(v4, a1 + 82, v11, a1 + 116, a1 + 140, v6);
if ( block_info )
{
v9 = v12;
a1[138] = v12;
a1[19] = a3;
a1[20] = (unsigned int)(block_info - v6) + v9 + a3;
*((_BYTE *)a1 + 1572) |= 0x82u;
return ma_pack_rec_unpack(a1, (long long)(a1 + 82), a2, block_info, v9, v8);
}
}
return *(unsigned int *)my_thread_var(v4);
}
| _ma_read_rnd_mempack_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RDI]
CMP qword ptr [RDI + 0x40],RDX
JBE 0x00147f8d
MOV R15,RDX
MOV RBX,RSI
LEA R12,[R14 + 0x290]
LEA RCX,[R14 + 0x3a0]
LEA R8,[R14 + 0x460]
MOV R13,qword ptr [RDI + 0x5f0]
ADD R13,RDX
LEA RDX,[RBP + -0x88]
MOV RSI,R12
MOV R9,R13
CALL 0x0014989d
TEST RAX,RAX
JZ 0x00147f98
MOV R8,qword ptr [RBP + -0x70]
MOV qword ptr [R14 + 0x450],R8
MOV qword ptr [R14 + 0x98],R15
MOV ECX,EAX
SUB ECX,R13D
ADD R15,R8
ADD R15,RCX
MOV qword ptr [R14 + 0xa0],R15
OR byte ptr [R14 + 0x624],0x82
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00147fbd
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
MOV RCX,RAX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001479fd
LAB_00147f8d:
CALL 0x001a8156
MOV dword ptr [RAX],0x89
LAB_00147f98:
CALL 0x001a8156
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00147fbd
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00147fbd:
CALL 0x0012a270
|
ulong _ma_read_rnd_mempack_record(long *param_1,int8 param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
int4 *puVar3;
uint *puVar4;
long lVar5;
long in_FS_OFFSET;
int1 local_90 [24];
long local_78;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *param_1;
if (param_3 < *(ulong *)(lVar1 + 0x40)) {
lVar5 = *(long *)(lVar1 + 0x5f0) + param_3;
lVar1 = _ma_mempack_get_block_info
(lVar1,param_1 + 0x52,local_90,param_1 + 0x74,param_1 + 0x8c,lVar5);
if (lVar1 != 0) {
param_1[0x8a] = local_78;
param_1[0x13] = param_3;
param_1[0x14] = param_3 + local_78 + (ulong)(uint)((int)lVar1 - (int)lVar5);
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 0x82;
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar2 = _ma_pack_rec_unpack(param_1,param_1 + 0x52,param_2,lVar1);
return uVar2;
}
goto LAB_00147fbd;
}
}
else {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
}
puVar4 = (uint *)_my_thread_var();
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return (ulong)*puVar4;
}
LAB_00147fbd:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
1,962 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O3 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x346b5
imull $0xcccccccd, %esi, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x346fc
jmp 0x346d9
movq %rdi, %rbx
callq 0x3193e
movl (%rax), %ecx
movl $0x844, %esi # imm = 0x844
movl $0x14, %edi
movq %rbx, %rdx
movl $0x3c, %r8d
xorl %eax, %eax
callq 0x2cce7
leaq 0x317e8(%rip), %rsi # 0x65ec8
movl $0x844, %edx # imm = 0x844
movl $0x14, %edi
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
xorl %eax, %eax
callq 0x2ce01
movl $0x3c, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24250
| wait_for_free_space:
push rbp
mov rbp, rsp
push rbx
push rax
test esi, esi
jz short loc_346B5
imul eax, esi, 0CCCCCCCDh
mov ecx, 19999998h
add eax, ecx
ror eax, 1
cmp eax, ecx
ja short loc_346FC
jmp short loc_346D9
loc_346B5:
mov rbx, rdi
call _my_thread_var
mov ecx, [rax]
mov esi, 844h
mov edi, 14h
mov rdx, rbx
mov r8d, 3Ch ; '<'
xor eax, eax
call my_error
loc_346D9:
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov edi, 14h
mov ecx, 3Ch ; '<'
mov r8d, 258h
xor eax, eax
call my_printf_error
loc_346FC:
mov edi, 3Ch ; '<'
add rsp, 8
pop rbx
pop rbp
jmp _sleep
| long long wait_for_free_space(
long long a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
unsigned int *v15; // rax
char v17; // [rsp-8h] [rbp-10h]
v17 = v14;
if ( !a2 )
{
v15 = (unsigned int *)my_thread_var();
my_error(0x14u, 2116LL, a1, *v15, 60LL);
LABEL_5:
my_printf_error(
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
20LL,
(long long)"Retry in %d secs. Message reprinted in %d secs",
2116LL,
60LL,
600LL,
a14,
v17);
return sleep(60LL);
}
if ( __ROR4__(-858993459 * a2 + 429496728, 1) <= 0x19999998u )
goto LABEL_5;
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST ESI,ESI
JZ 0x001346b5
IMUL EAX,ESI,-0x33333333
MOV ECX,0x19999998
ADD EAX,ECX
ROR EAX,0x1
CMP EAX,ECX
JA 0x001346fc
JMP 0x001346d9
LAB_001346b5:
MOV RBX,RDI
CALL 0x0013193e
MOV ECX,dword ptr [RAX]
MOV ESI,0x844
MOV EDI,0x14
MOV RDX,RBX
MOV R8D,0x3c
XOR EAX,EAX
CALL 0x0012cce7
LAB_001346d9:
LEA RSI,[0x165ec8]
MOV EDX,0x844
MOV EDI,0x14
MOV ECX,0x3c
MOV R8D,0x258
XOR EAX,EAX
CALL 0x0012ce01
LAB_001346fc:
MOV EDI,0x3c
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00124250
|
void wait_for_free_space(int8 param_1,int param_2)
{
uint uVar1;
int4 *puVar2;
if (param_2 == 0) {
puVar2 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar2,0x3c);
}
else {
uVar1 = param_2 * -0x33333333 + 0x19999998;
if (0x19999998 < (uVar1 >> 1 | (uint)((uVar1 & 1) != 0) << 0x1f)) goto LAB_001346fc;
}
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
LAB_001346fc:
sleep(0x3c);
return;
}
|
|
1,963 | psi_mutex_trylock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_mutex_trylock(mysql_mutex_t *that,
const char *file, uint line)
{
PSI_mutex_locker_state state;
PSI_mutex_locker *locker= PSI_MUTEX_CALL(start_mutex_wait)
(&state, that->m_psi, PSI_MUTEX_TRYLOCK, file, line);
# ifdef SAFE_MUTEX
int result= safe_mutex_lock(&that->m_mutex, TRUE, file, line);
# else
int result= pthread_mutex_trylock(&that->m_mutex);
# endif
if (locker)
PSI_MUTEX_CALL(end_mutex_wait)(locker, result);
return result;
} | O3 | c | psi_mutex_trylock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x2cc0b1(%rip), %r15 # 0x2f0848
movq (%r15), %rax
movq 0x40(%rdi), %rsi
leaq -0x48(%rbp), %rdi
pushq $0x1
popq %rdx
callq *0x190(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0x24090
movl %eax, %r14d
testq %rbx, %rbx
je 0x247cd
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x198(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_mutex_trylock:
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+40h]
lea rdi, [rbp+var_48]
push 1
pop rdx
call qword ptr [rax+190h]
mov rbx, rax
mov rdi, r14
call _pthread_mutex_trylock
mov r14d, eax
test rbx, rbx
jz short loc_247CD
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+198h]
loc_247CD:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_mutex_trylock(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[0] + 50))(
v6,
*(_QWORD *)(a1 + 64),
1LL,
a2,
a3);
v4 = pthread_mutex_trylock(a1);
if ( v3 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 51))(v3, v4);
return v4;
}
| psi_mutex_trylock:
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,[0x3f0848]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x40]
LEA RDI,[RBP + -0x48]
PUSH 0x1
POP RDX
CALL qword ptr [RAX + 0x190]
MOV RBX,RAX
MOV RDI,R14
CALL 0x00124090
MOV R14D,EAX
TEST RBX,RBX
JZ 0x001247cd
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x198]
LAB_001247cd:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int psi_mutex_trylock(pthread_mutex_t *param_1,int8 param_2,int4 param_3)
{
int iVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 400))
(local_50,*(int8 *)((long)param_1 + 0x40),1,param_2,param_3);
iVar1 = pthread_mutex_trylock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x198))(lVar2,iVar1);
}
return iVar1;
}
|
|
1,964 | google::protobuf::internal::ExtensionSet::RegisterExtension(google::protobuf::MessageLite const*, int, unsigned char, bool, bool, char const* (*)(char const*, google::protobuf::internal::ParseContext*)) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc | void ExtensionSet::RegisterExtension(const MessageLite* extendee, int number,
FieldType type, bool is_repeated,
bool is_packed,
LazyEagerVerifyFnType verify_func) {
GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_ENUM);
GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_MESSAGE);
GOOGLE_CHECK_NE(type, WireFormatLite::TYPE_GROUP);
ExtensionInfo info(extendee, number, type, is_repeated, is_packed,
verify_func);
Register(info);
} | O3 | cpp | google::protobuf::internal::ExtensionSet::RegisterExtension(google::protobuf::MessageLite const*, int, unsigned char, bool, bool, char const* (*)(char const*, google::protobuf::internal::ParseContext*)):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbp
movl %r8d, %r14d
movl %ecx, %r12d
movl %edx, %r15d
movq %rdi, %r13
cmpl $0xe, %edx
jne 0x9374b
movq %r13, 0x8(%rsp)
movl %esi, %r13d
leaq 0x29d97(%rip), %rdx # 0xbd498
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x8a, %ecx
callq 0x169ca
leaq 0x29de3(%rip), %rsi # 0xbd502
movq %rbx, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x10(%rsp), %rdi
callq 0x169e8
movl %r13d, %esi
movq 0x8(%rsp), %r13
jmp 0x937ec
cmpb $0xb, %r15b
jne 0x9379f
movl %esi, 0x8(%rsp)
leaq 0x29d3c(%rip), %rdx # 0xbd498
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x8b, %ecx
callq 0x169ca
leaq 0x29dbe(%rip), %rsi # 0xbd538
movq %rbx, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x10(%rsp), %rdi
callq 0x169e8
movl 0x8(%rsp), %esi
jmp 0x937ec
cmpb $0xa, %r15b
jne 0x937ec
movq %r13, 0x8(%rsp)
movl %esi, %r13d
leaq 0x29ce4(%rip), %rdx # 0xbd498
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x3, %esi
movl $0x8c, %ecx
callq 0x169ca
leaq 0x29d9f(%rip), %rsi # 0xbd571
movq %rbx, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
jmp 0x93734
leaq 0x10(%rsp), %rdi
movq %r13, (%rdi)
movl %esi, 0x8(%rdi)
movb %r15b, 0xc(%rdi)
movb %r12b, 0xd(%rdi)
movb %r14b, 0xe(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq %rbp, 0x28(%rdi)
callq 0x93849
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x93834
jmp 0x93834
jmp 0x93834
jmp 0x93834
jmp 0x93834
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x169e8
movq %rbx, %rdi
callq 0xf570
| _ZN6google8protobuf8internal12ExtensionSet17RegisterExtensionEPKNS0_11MessageLiteEihbbPFPKcS7_PNS1_12ParseContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbp, r9
mov r14d, r8d
mov r12d, ecx
mov r15d, edx
mov r13, rdi
cmp edx, 0Eh
jnz short loc_9374B
mov [rsp+78h+var_70], r13
mov r13d, esi
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/aimrt_"...
lea rbx, [rsp+78h+var_68]
mov rdi, rbx
mov esi, 3
mov ecx, 8Ah
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedTyp; "CHECK failed: (type) != (WireFormatLite"...
mov rdi, rbx
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_71]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
loc_93734:
lea rdi, [rsp+78h+var_68]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov esi, r13d
mov r13, [rsp+78h+var_70]
jmp loc_937EC
loc_9374B:
cmp r15b, 0Bh
jnz short loc_9379F
mov dword ptr [rsp+78h+var_70], esi
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/aimrt_"...
lea rbx, [rsp+78h+var_68]
mov rdi, rbx
mov esi, 3
mov ecx, 8Bh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedTyp_0; "CHECK failed: (type) != (WireFormatLite"...
mov rdi, rbx
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_71]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+78h+var_68]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov esi, dword ptr [rsp+78h+var_70]
jmp short loc_937EC
loc_9379F:
cmp r15b, 0Ah
jnz short loc_937EC
mov [rsp+78h+var_70], r13
mov r13d, esi
lea rdx, aWorkspaceLlm4b_22; "/workspace/llm4binary/github2025/aimrt_"...
lea rbx, [rsp+78h+var_68]
mov rdi, rbx
mov esi, 3
mov ecx, 8Ch
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedTyp_1; "CHECK failed: (type) != (WireFormatLite"...
mov rdi, rbx
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_71]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp loc_93734
loc_937EC:
lea rdi, [rsp+78h+var_68]
mov [rdi], r13
mov [rdi+8], esi
mov [rdi+0Ch], r15b
mov [rdi+0Dh], r12b
mov [rdi+0Eh], r14b
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
mov qword ptr [rdi+20h], 0
mov [rdi+28h], rbp
call _ZN6google8protobuf8internal12_GLOBAL__N_18RegisterERKNS1_13ExtensionInfoE; google::protobuf::internal::`anonymous namespace'::Register(google::protobuf::internal::ExtensionInfo const&)
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_93834
jmp short loc_93834
jmp short loc_93834
jmp short loc_93834
jmp short $+2
loc_93834:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::internal::ExtensionSet::RegisterExtension(
google::protobuf::internal::ExtensionSet *this,
const google::protobuf::MessageLite *a2,
int a3,
char a4,
char a5,
long long a6)
{
char v9; // r15
google::protobuf::internal::ExtensionSet *v10; // r13
int v11; // r13d
google::protobuf::internal::LogMessage *v12; // rax
google::protobuf::internal::LogMessage *v13; // rax
google::protobuf::internal::LogMessage *v14; // rax
char v16; // [rsp+7h] [rbp-71h] BYREF
google::protobuf::internal::ExtensionSet *v17; // [rsp+8h] [rbp-70h]
google::protobuf::internal::ExtensionSet *v18; // [rsp+10h] [rbp-68h] BYREF
int v19; // [rsp+18h] [rbp-60h]
char v20; // [rsp+1Ch] [rbp-5Ch]
char v21; // [rsp+1Dh] [rbp-5Bh]
char v22; // [rsp+1Eh] [rbp-5Ah]
__int128 v23; // [rsp+20h] [rbp-58h]
long long v24; // [rsp+30h] [rbp-48h]
long long v25; // [rsp+38h] [rbp-40h]
v9 = a3;
v10 = this;
if ( a3 == 14 )
{
v17 = this;
v11 = (int)a2;
google::protobuf::internal::LogMessage::LogMessage(
(long long)&v18,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc",
138);
v12 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)&v18,
(long long)"CHECK failed: (type) != (WireFormatLite::TYPE_ENUM): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v16, v12);
}
else
{
if ( (_BYTE)a3 == 11 )
{
LODWORD(v17) = (_DWORD)a2;
google::protobuf::internal::LogMessage::LogMessage(
(long long)&v18,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc",
139);
v13 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)&v18,
(long long)"CHECK failed: (type) != (WireFormatLite::TYPE_MESSAGE): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v16, v13);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)&v18);
LODWORD(a2) = (_DWORD)v17;
goto LABEL_8;
}
if ( (_BYTE)a3 != 10 )
goto LABEL_8;
v17 = this;
v11 = (int)a2;
google::protobuf::internal::LogMessage::LogMessage(
(long long)&v18,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc",
140);
v14 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)&v18,
(long long)"CHECK failed: (type) != (WireFormatLite::TYPE_GROUP): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v16, v14);
}
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)&v18);
LODWORD(a2) = v11;
v10 = v17;
LABEL_8:
v18 = v10;
v19 = (int)a2;
v20 = v9;
v21 = a4;
v22 = a5;
v23 = 0LL;
v24 = 0LL;
v25 = a6;
return google::protobuf::internal::`anonymous namespace'::Register();
}
| RegisterExtension:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBP,R9
MOV R14D,R8D
MOV R12D,ECX
MOV R15D,EDX
MOV R13,RDI
CMP EDX,0xe
JNZ 0x0019374b
MOV qword ptr [RSP + 0x8],R13
MOV R13D,ESI
LEA RDX,[0x1bd498]
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x3
MOV ECX,0x8a
CALL 0x001169ca
LAB_00193718:
LEA RSI,[0x1bd502]
MOV RDI,RBX
CALL 0x001164c8
LAB_00193727:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_00193734:
LEA RDI,[RSP + 0x10]
CALL 0x001169e8
MOV ESI,R13D
MOV R13,qword ptr [RSP + 0x8]
JMP 0x001937ec
LAB_0019374b:
CMP R15B,0xb
JNZ 0x0019379f
MOV dword ptr [RSP + 0x8],ESI
LEA RDX,[0x1bd498]
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x3
MOV ECX,0x8b
CALL 0x001169ca
LAB_00193773:
LEA RSI,[0x1bd538]
MOV RDI,RBX
CALL 0x001164c8
LAB_00193782:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_0019378f:
LEA RDI,[RSP + 0x10]
CALL 0x001169e8
MOV ESI,dword ptr [RSP + 0x8]
JMP 0x001937ec
LAB_0019379f:
CMP R15B,0xa
JNZ 0x001937ec
MOV qword ptr [RSP + 0x8],R13
MOV R13D,ESI
LEA RDX,[0x1bd498]
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x3
MOV ECX,0x8c
CALL 0x001169ca
LAB_001937cb:
LEA RSI,[0x1bd571]
MOV RDI,RBX
CALL 0x001164c8
LAB_001937da:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_001937e7:
JMP 0x00193734
LAB_001937ec:
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],R13
MOV dword ptr [RDI + 0x8],ESI
MOV byte ptr [RDI + 0xc],R15B
MOV byte ptr [RDI + 0xd],R12B
MOV byte ptr [RDI + 0xe],R14B
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RDI + 0x20],0x0
MOV qword ptr [RDI + 0x28],RBP
CALL 0x00193849
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::internal::ExtensionSet::RegisterExtension(google::protobuf::MessageLite const*,
int, unsigned char, bool, bool, char const* (*)(char const*,
google::protobuf::internal::ParseContext*)) */
void google::protobuf::internal::ExtensionSet::RegisterExtension
(MessageLite *param_1,int param_2,uchar param_3,bool param_4,bool param_5,
_func_char_ptr_char_ptr_ParseContext_ptr *param_6)
{
LogMessage *pLVar1;
int7 in_register_00000011;
LogFinisher local_71;
MessageLite *local_70;
MessageLite *local_68;
int local_60;
uchar local_5c;
int1 local_5b;
int1 local_5a;
int8 local_58;
int8 uStack_50;
int8 local_48;
_func_char_ptr_char_ptr_ParseContext_ptr *local_40;
if ((int)CONCAT71(in_register_00000011,param_3) == 0xe) {
local_70 = param_1;
LogMessage::LogMessage
((LogMessage *)&local_68,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc"
,0x8a);
/* try { // try from 00193718 to 00193726 has its CatchHandler @ 00193834 */
pLVar1 = (LogMessage *)
LogMessage::operator<<
((LogMessage *)&local_68,
"CHECK failed: (type) != (WireFormatLite::TYPE_ENUM): ");
/* try { // try from 00193727 to 00193733 has its CatchHandler @ 00193832 */
LogFinisher::operator=(&local_71,pLVar1);
}
else {
local_68 = param_1;
if (param_3 == '\v') {
local_70 = (MessageLite *)CONCAT44(local_70._4_4_,param_2);
LogMessage::LogMessage
((LogMessage *)&local_68,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc"
,0x8b);
/* try { // try from 00193773 to 00193781 has its CatchHandler @ 00193830 */
pLVar1 = (LogMessage *)
LogMessage::operator<<
((LogMessage *)&local_68,
"CHECK failed: (type) != (WireFormatLite::TYPE_MESSAGE): ");
/* try { // try from 00193782 to 0019378e has its CatchHandler @ 0019382e */
LogFinisher::operator=(&local_71,pLVar1);
LogMessage::~LogMessage((LogMessage *)&local_68);
param_2 = (int)local_70;
goto LAB_001937ec;
}
if (param_3 != '\n') goto LAB_001937ec;
local_70 = param_1;
LogMessage::LogMessage
((LogMessage *)&local_68,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/extension_set.cc"
,0x8c);
/* try { // try from 001937cb to 001937d9 has its CatchHandler @ 0019382c */
pLVar1 = (LogMessage *)
LogMessage::operator<<
((LogMessage *)&local_68,
"CHECK failed: (type) != (WireFormatLite::TYPE_GROUP): ");
/* try { // try from 001937da to 001937e6 has its CatchHandler @ 0019382a */
LogFinisher::operator=(&local_71,pLVar1);
}
LogMessage::~LogMessage((LogMessage *)&local_68);
local_68 = local_70;
LAB_001937ec:
local_58 = 0;
uStack_50 = 0;
local_48 = 0;
local_60 = param_2;
local_5c = param_3;
local_5b = param_4;
local_5a = param_5;
local_40 = param_6;
(anonymous_namespace)::Register((ExtensionInfo *)&local_68);
return;
}
|
|
1,965 | ma_calc_total_blob_length | eloqsql/storage/maria/ma_dynrec.c | ulong _ma_calc_total_blob_length(MARIA_HA *info, const uchar *record)
{
ulong length;
MARIA_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length= _ma_calc_blob_length(blob->pack_length,
record + blob->offset);
length+=blob->length;
}
return length;
} | O0 | c | ma_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x288(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x3f0(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x3cbed
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
addq (%rax), %rsi
callq 0x3f540
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x3cba3
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_calc_total_blob_length:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
mov rax, [rbp+var_8]
mov rax, [rax+288h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov ecx, [rcx+3F0h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_28], rax
loc_3CBA3:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jz short loc_3CBED
mov rax, [rbp+var_20]
mov edi, [rax+8]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_20]
add rsi, [rax]
call _ma_calc_blob_length
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
mov rax, [rax+10h]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
jmp short loc_3CBA3
loc_3CBED:
mov rax, [rbp+var_18]
add rsp, 30h
pop rbp
retn
| long long ma_calc_total_blob_length(_QWORD *a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
long long v6; // [rsp+18h] [rbp-18h]
v6 = 0LL;
v5 = a1[81];
v4 = 24LL * *(unsigned int *)(*a1 + 1008LL) + v5;
while ( v5 != v4 )
{
*(_QWORD *)(v5 + 16) = ma_calc_blob_length(*(unsigned int *)(v5 + 8), *(_QWORD *)v5 + a2, a3);
v6 += *(_QWORD *)(v5 + 16);
v5 += 24LL;
}
return v6;
}
| _ma_calc_total_blob_length:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x288]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x3f0]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
LAB_0013cba3:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x0013cbed
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
ADD RSI,qword ptr [RAX]
CALL 0x0013f540
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0013cba3
LAB_0013cbed:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x30
POP RBP
RET
|
long _ma_calc_total_blob_length(long *param_1,long param_2)
{
long *plVar1;
long lVar2;
long *local_28;
long local_20;
local_20 = 0;
local_28 = (long *)param_1[0x51];
plVar1 = local_28 + (ulong)*(uint *)(*param_1 + 0x3f0) * 3;
for (; local_28 != plVar1; local_28 = local_28 + 3) {
lVar2 = _ma_calc_blob_length((int)local_28[1],param_2 + *local_28);
local_28[2] = lVar2;
local_20 = local_28[2] + local_20;
}
return local_20;
}
|
|
1,966 | LefDefParser::lefwVersion(int, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwVersion(int vers1,
int vers2)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_INIT && lefwState < LEFW_END)
return LEFW_BAD_ORDER; // not of the ENDs
if (lefwSynArray[LEFW_VERSION])
return LEFW_ALREADY_DEFINED;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "VERSION %d.%d ;\n", vers1, vers2);
else
fprintf(lefwFile, "VERSION %d.%d ;\n", vers1, vers2);
if (vers2 >= 10)
versionNum = vers1 + (vers2 / 100.0);
else
versionNum = vers1 + (vers2 / 10.0);
lefwSynArray[LEFW_VERSION] = 1;
lefwLines++;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwVersion(int, int):
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
leaq 0x7d1d5(%rip), %rax # 0x8d0f0
movq (%rax), %rdi
testq %rdi, %rdi
je 0xff82
leaq 0x7d41a(%rip), %rcx # 0x8d344
movl $0x2, %eax
cmpl $0x0, (%rcx)
je 0xff87
leaq 0x7d405(%rip), %rcx # 0x8d340
movl (%rcx), %ecx
cmpl $0x1, %ecx
setne %dl
cmpl $0x4f, %ecx
setl %cl
testb %cl, %dl
jne 0xff87
leaq 0x7d1ac(%rip), %r14 # 0x8d100
movl $0x4, %eax
cmpl $0x0, 0x11c(%r14)
jne 0xff87
movl %esi, %ebx
cmpb $0x1, 0x7d470(%rip) # 0x8d3dc
jne 0xff8c
leaq 0x4a7f0(%rip), %rsi # 0x5a765
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x55afd
jmp 0xff9e
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4a7d2(%rip), %rsi # 0x5a765
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x22e0
xorl %eax, %eax
cmpl $0xa, %ebx
cvtsi2sd %ebp, %xmm0
cvtsi2sd %ebx, %xmm1
setge %al
leaq 0x5abbb(%rip), %rcx # 0x6ab70
divsd (%rcx,%rax,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x7ceea(%rip) # 0x8ceb0
movl $0x1, 0x11c(%r14)
leaq 0x7d364(%rip), %rax # 0x8d33c
incl (%rax)
xorl %eax, %eax
jmp 0xff87
| _ZN12LefDefParser11lefwVersionEii:
push rbp
push r14
push rbx
mov ebp, edi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_FF82
lea rcx, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
mov eax, 2
cmp dword ptr [rcx], 0
jz short loc_FF87
lea rcx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rcx]
cmp ecx, 1
setnz dl
cmp ecx, 4Fh ; 'O'
setl cl
test dl, cl
jnz short loc_FF87
lea r14, _ZN12LefDefParser12lefwSynArrayE; LefDefParser::lefwSynArray
mov eax, 4
cmp dword ptr [r14+11Ch], 0
jnz short loc_FF87
mov ebx, esi
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_FF8C
lea rsi, aVersionDD; "VERSION %d.%d ;\n"
mov edx, ebp
mov ecx, ebx
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_FF9E
loc_FF82:
mov eax, 1
loc_FF87:
pop rbx
pop r14
pop rbp
retn
loc_FF8C:
lea rsi, aVersionDD; "VERSION %d.%d ;\n"
mov edx, ebp
mov ecx, ebx
xor eax, eax
call _fprintf
loc_FF9E:
xor eax, eax
cmp ebx, 0Ah
cvtsi2sd xmm0, ebp
cvtsi2sd xmm1, ebx
setnl al
lea rcx, unk_6AB70
divsd xmm1, qword ptr [rcx+rax*8]
addsd xmm1, xmm0
movsd cs:_ZN12LefDefParserL10versionNumE, xmm1; LefDefParser::versionNum
mov dword ptr [r14+11Ch], 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
jmp short loc_FF87
| long long LefDefParser::lefwVersion(LefDefParser *this, int a2, int a3, long long a4, int a5, int a6)
{
long long result; // rax
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwState >= 79 || LefDefParser::lefwState == 1 )
{
result = 4LL;
if ( !LefDefParser::lefwSynArray[71] )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"VERSION %d.%d ;\n", (_DWORD)this, a2, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "VERSION %d.%d ;\n", (_DWORD)this, a2);
*(double *)&LefDefParser::versionNum = (double)a2 / dbl_6AB70[a2 >= 10] + (double)(int)this;
LefDefParser::lefwSynArray[71] = 1;
++LefDefParser::lefwLines;
return 0LL;
}
}
}
return result;
}
| lefwVersion:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDI
LEA RAX,[0x18d0f0]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x0010ff82
LEA RCX,[0x18d344]
MOV EAX,0x2
CMP dword ptr [RCX],0x0
JZ 0x0010ff87
LEA RCX,[0x18d340]
MOV ECX,dword ptr [RCX]
CMP ECX,0x1
SETNZ DL
CMP ECX,0x4f
SETL CL
TEST DL,CL
JNZ 0x0010ff87
LEA R14,[0x18d100]
MOV EAX,0x4
CMP dword ptr [R14 + 0x11c],0x0
JNZ 0x0010ff87
MOV EBX,ESI
CMP byte ptr [0x0018d3dc],0x1
JNZ 0x0010ff8c
LEA RSI,[0x15a765]
MOV EDX,EBP
MOV ECX,EBX
XOR EAX,EAX
CALL 0x00155afd
JMP 0x0010ff9e
LAB_0010ff82:
MOV EAX,0x1
LAB_0010ff87:
POP RBX
POP R14
POP RBP
RET
LAB_0010ff8c:
LEA RSI,[0x15a765]
MOV EDX,EBP
MOV ECX,EBX
XOR EAX,EAX
CALL 0x001022e0
LAB_0010ff9e:
XOR EAX,EAX
CMP EBX,0xa
CVTSI2SD XMM0,EBP
CVTSI2SD XMM1,EBX
SETGE AL
LEA RCX,[0x16ab70]
DIVSD XMM1,qword ptr [RCX + RAX*0x8]
ADDSD XMM1,XMM0
MOVSD qword ptr [0x0018ceb0],XMM1
MOV dword ptr [R14 + 0x11c],0x1
LEA RAX,[0x18d33c]
INC dword ptr [RAX]
XOR EAX,EAX
JMP 0x0010ff87
|
/* LefDefParser::lefwVersion(int, int) */
int8 LefDefParser::lefwVersion(int param_1,int param_2)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if (((lefwDidInit != 0) && (lefwState == 1 || 0x4e < lefwState)) &&
(uVar1 = 4, lefwSynArray._284_4_ == 0)) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,"VERSION %d.%d ;\n",param_1,param_2);
}
else {
fprintf(lefwFile,"VERSION %d.%d ;\n",param_1,param_2);
}
versionNum = (double)param_2 / *(double *)(&DAT_0016ab70 + (ulong)(9 < param_2) * 8) +
(double)param_1;
lefwSynArray._284_4_ = 1;
lefwLines = lefwLines + 1;
uVar1 = 0;
}
}
return uVar1;
}
|
|
1,967 | JS_GetModuleNamespace | bluesky950520[P]quickjs/quickjs.c | JSValue JS_GetModuleNamespace(JSContext *ctx, JSModuleDef *m)
{
if (JS_IsUndefined(m->module_ns)) {
JSValue val;
val = js_build_module_ns(ctx, m);
if (JS_IsException(val))
return JS_EXCEPTION;
m->module_ns = val;
}
return js_dup(m->module_ns);
} | O1 | c | JS_GetModuleNamespace:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
cmpl $0x3, 0x60(%rsi)
jne 0x30bbc
movq %rdi, %r15
movq 0x40(%rdi), %rax
movq 0xb0(%rax), %rsi
movq 0xb8(%rax), %rdx
movl $0xb, %ecx
callq 0x20f05
movq %rdx, %r14
movq %rax, 0x10(%rsp)
cmpl $0x6, %r14d
jne 0x30b44
movq %rax, %r12
jmp 0x30ba5
movq 0x10(%rsp), %r13
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, (%r12)
movaps %xmm0, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x4359c
movl %eax, %ebp
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1cb99
testl %ebp, %ebp
je 0x30be4
movq 0x50(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x10(%rsp), %rsi
movq 0x18(%r15), %rdi
movq %r14, %rdx
callq 0x1d8c6
movl $0x6, %r14d
xorl %r12d, %r12d
cmpl $0x6, %r14d
jne 0x30bb4
movl $0x6, %edx
xorl %eax, %eax
jmp 0x30bd5
movq %r12, 0x58(%rbx)
movq %r14, 0x60(%rbx)
movq 0x58(%rbx), %rax
movq 0x60(%rbx), %rdx
movq %rax, 0x40(%rsp)
cmpl $-0x9, %edx
jb 0x30bd5
movq 0x40(%rsp), %rcx
incl (%rcx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x20(%rsp)
movslq 0x5c(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
jle 0x30cbf
movq 0x50(%rsp), %r12
movq 0x8(%rsp), %r13
shlq $0x4, %r13
xorl %ebp, %ebp
movq 0x8(%r12,%rbp), %rax
testq %rax, %rax
je 0x30c24
movq %rax, 0x28(%rsp)
movq %rbx, 0x18(%rsp)
xorl %eax, %eax
jmp 0x30c3d
movl (%r12,%rbp), %r8d
movq %r15, %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rcx
callq 0x4377e
testl %eax, %eax
je 0x30c55
cmpl $0x3, %eax
jne 0x30e44
movl $0x0, 0x4(%r12,%rbp)
jmp 0x30cb2
movq 0x28(%rsp), %rax
cmpl $0x7e, 0x14(%rax)
jne 0x30c80
movl $0x2, 0x4(%r12,%rbp)
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq (%rax), %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
jmp 0x30cad
movl $0x1, 0x4(%r12,%rbp)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x30c99
movq %rcx, 0x8(%r12,%rbp)
jmp 0x30cb2
movq 0x18(%rsp), %rcx
movq 0x68(%rcx), %rcx
movq 0x38(%rcx), %rcx
movslq (%rax), %rax
movq (%rcx,%rax,8), %rax
movq %rax, 0x8(%r12,%rbp)
addq $0x10, %rbp
cmpq %rbp, %r13
jne 0x30c0c
movq 0x50(%rsp), %rbp
leaq 0x12b9f(%rip), %rcx # 0x4386a
movl $0x10, %edx
movq %rbp, %rdi
movq 0x8(%rsp), %r12
movq %r12, %rsi
movq %r15, %r8
callq 0x1c031
testl %r12d, %r12d
jle 0x30dc3
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
shlq $0x4, 0x8(%rsp)
xorl %r12d, %r12d
movq %r14, 0x38(%rsp)
movl 0x4(%rbp,%r12), %eax
cmpl $0x2, %eax
je 0x30d4c
cmpl $0x1, %eax
jne 0x30da8
movq 0x8(%rbp,%r12), %r14
movl (%rbp,%r12), %ecx
testq %r14, %r14
je 0x30d7f
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movl %ecx, %edx
movl $0x26, %ecx
callq 0x3bf45
xorl %r13d, %r13d
testq %rax, %rax
je 0x30d97
incl (%r14)
movq %r14, (%rax)
movb $0x1, %al
jmp 0x30d9f
movl (%rbp,%r12), %ecx
movq 0x8(%rbp,%r12), %r9
movl $0x6, (%rsp)
movq %r15, %rdi
movq 0x30(%rsp), %rsi
movq %r14, %rdx
movl $0x1, %r8d
callq 0x41517
testl %eax, %eax
jns 0x30da8
movl $0x2, %r13d
jmp 0x30dab
movl $0x2, %r13d
movq %r15, %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq 0x437e9
jmp 0x30d9d
movl $0x2, %r13d
xorl %eax, %eax
testb %al, %al
movq 0x38(%rsp), %r14
je 0x30dab
xorl %r13d, %r13d
testl %r13d, %r13d
jne 0x30e35
addq $0x10, %r12
cmpq %r12, 0x8(%rsp)
jne 0x30d04
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1cb99
movq 0x18(%r15), %rax
movq 0x68(%rax), %rax
movq 0x3f8(%rax), %r8
movq 0x4(%r8), %rcx
movq %rcx, %rdx
shrq $0x3e, %rdx
cmpl $0x1, %edx
sete %dl
negl %ecx
setno %cl
orb %dl, %cl
jne 0x30dfe
movq 0x178(%rax), %r8
incl (%r8)
movq 0x10(%rsp), %r12
movl $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0xda, %ecx
movq $-0x7, %r9
callq 0x26abb
movq 0x20(%rsp), %rax
andb $-0x2, 0x5(%rax)
jmp 0x30ba5
cmpl $0x2, %r13d
je 0x30b7e
jmp 0x30ba5
movl (%r12,%rbp), %ecx
movq %r15, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x437e9
jmp 0x30b7e
| JS_GetModuleNamespace:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rsi
cmp dword ptr [rsi+60h], 3
jnz loc_30BBC
mov r15, rdi
mov rax, [rdi+40h]
mov rsi, [rax+0B0h]
mov rdx, [rax+0B8h]
mov ecx, 0Bh
call JS_NewObjectProtoClass
mov r14, rdx
mov [rsp+98h+var_88], rax
cmp r14d, 6
jnz short loc_30B44
mov r12, rax
jmp short loc_30BA5
loc_30B44:
mov r13, [rsp+98h+var_88]
xorps xmm0, xmm0
lea r12, [rsp+98h+var_58]
movaps xmmword ptr [r12], xmm0
movaps xmmword ptr [r12+10h], xmm0
mov rdi, r15
mov rsi, r12
mov rdx, rbx
xor ecx, ecx
call get_exported_names
mov ebp, eax
mov rsi, [r12]
mov rdi, r15
call js_free
test ebp, ebp
jz short loc_30BE4
loc_30B7E:
mov rsi, [rsp+98h+var_48]
mov rdi, r15
call js_free
mov rsi, [rsp+98h+var_88]
mov rdi, [r15+18h]
mov rdx, r14
call JS_FreeValueRT
mov r14d, 6
xor r12d, r12d
loc_30BA5:
cmp r14d, 6
jnz short loc_30BB4
mov edx, 6
xor eax, eax
jmp short loc_30BD5
loc_30BB4:
mov [rbx+58h], r12
mov [rbx+60h], r14
loc_30BBC:
mov rax, [rbx+58h]
mov rdx, [rbx+60h]
mov [rsp+98h+var_58], rax
cmp edx, 0FFFFFFF7h
jb short loc_30BD5
mov rcx, [rsp+98h+var_58]
inc dword ptr [rcx]
loc_30BD5:
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_30BE4:
mov [rsp+98h+var_78], r13
movsxd rax, [rsp+98h+var_3C]
mov [rsp+98h+var_90], rax
test rax, rax
jle loc_30CBF
mov r12, [rsp+98h+var_48]
mov r13, [rsp+98h+var_90]
shl r13, 4
xor ebp, ebp
loc_30C0C:
mov rax, [r12+rbp+8]
test rax, rax
jz short loc_30C24
mov [rsp+98h+var_70], rax
mov [rsp+98h+var_80], rbx
xor eax, eax
jmp short loc_30C3D
loc_30C24:
mov r8d, [r12+rbp]
mov rdi, r15
lea rsi, [rsp+98h+var_80]
lea rdx, [rsp+98h+var_70]
mov rcx, rbx
call js_resolve_export
loc_30C3D:
test eax, eax
jz short loc_30C55
cmp eax, 3
jnz loc_30E44
mov dword ptr [r12+rbp+4], 0
jmp short loc_30CB2
loc_30C55:
mov rax, [rsp+98h+var_70]
cmp dword ptr [rax+14h], 7Eh ; '~'
jnz short loc_30C80
mov dword ptr [r12+rbp+4], 2
mov rcx, [rsp+98h+var_80]
mov rcx, [rcx+18h]
movsxd rax, dword ptr [rax]
shl rax, 4
mov rax, [rcx+rax+8]
jmp short loc_30CAD
loc_30C80:
mov dword ptr [r12+rbp+4], 1
mov rcx, [rax+8]
test rcx, rcx
jz short loc_30C99
mov [r12+rbp+8], rcx
jmp short loc_30CB2
loc_30C99:
mov rcx, [rsp+98h+var_80]
mov rcx, [rcx+68h]
mov rcx, [rcx+38h]
movsxd rax, dword ptr [rax]
mov rax, [rcx+rax*8]
loc_30CAD:
mov [r12+rbp+8], rax
loc_30CB2:
add rbp, 10h
cmp r13, rbp
jnz loc_30C0C
loc_30CBF:
mov rbp, [rsp+98h+var_48]
lea rcx, exported_names_cmp
mov edx, 10h
mov rdi, rbp
mov r12, [rsp+98h+var_90]
mov rsi, r12
mov r8, r15
call rqsort
test r12d, r12d
jle loc_30DC3
mov rax, [rsp+98h+var_88]
mov [rsp+98h+var_68], rax
shl [rsp+98h+var_90], 4
xor r12d, r12d
mov [rsp+98h+var_60], r14
loc_30D04:
mov eax, [rbp+r12+4]
cmp eax, 2
jz short loc_30D4C
cmp eax, 1
jnz loc_30DA8
mov r14, [rbp+r12+8]
mov ecx, [rbp+r12+0]
test r14, r14
jz short loc_30D7F
mov rdi, r15
mov rsi, [rsp+98h+var_78]
mov edx, ecx
mov ecx, 26h ; '&'
call add_property
xor r13d, r13d
test rax, rax
jz short loc_30D97
inc dword ptr [r14]
mov [rax], r14
mov al, 1
jmp short loc_30D9F
loc_30D4C:
mov ecx, [rbp+r12+0]
mov r9, [rbp+r12+8]
mov [rsp+98h+var_98], 6
mov rdi, r15
mov rsi, [rsp+98h+var_68]
mov rdx, r14
mov r8d, 1
call JS_DefineAutoInitProperty
test eax, eax
jns short loc_30DA8
mov r13d, 2
jmp short loc_30DAB
loc_30D7F:
mov r13d, 2
mov rdi, r15
mov esi, 2
mov rdx, rbx
call js_resolve_export_throw_error
jmp short loc_30D9D
loc_30D97:
mov r13d, 2
loc_30D9D:
xor eax, eax
loc_30D9F:
test al, al
mov r14, [rsp+98h+var_60]
jz short loc_30DAB
loc_30DA8:
xor r13d, r13d
loc_30DAB:
test r13d, r13d
jnz loc_30E35
add r12, 10h
cmp [rsp+98h+var_90], r12
jnz loc_30D04
loc_30DC3:
mov rdi, r15
mov rsi, rbp
call js_free
mov rax, [r15+18h]
mov rax, [rax+68h]
mov r8, [rax+3F8h]
mov rcx, [r8+4]
mov rdx, rcx
shr rdx, 3Eh
cmp edx, 1
setz dl
neg ecx
setno cl
or cl, dl
jnz short loc_30DFE
mov r8, [rax+178h]
loc_30DFE:
inc dword ptr [r8]
mov r12, [rsp+98h+var_88]
mov [rsp+98h+var_98], 0
mov rdi, r15
mov rsi, r12
mov rdx, r14
mov ecx, 0DAh
mov r9, 0FFFFFFFFFFFFFFF9h
call JS_DefinePropertyValue
mov rax, [rsp+98h+var_78]
and byte ptr [rax+5], 0FEh
jmp loc_30BA5
loc_30E35:
cmp r13d, 2
jz loc_30B7E
jmp loc_30BA5
loc_30E44:
mov ecx, [r12+rbp]
mov rdi, r15
mov esi, eax
mov rdx, rbx
call js_resolve_export_throw_error
jmp loc_30B7E
| long long JS_GetModuleNamespace(
long long a1,
long long a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rax
long long v11; // rdx
long long v12; // r14
_DWORD *v13; // r12
int exported_names; // ebp
long long result; // rax
long long v16; // rdx
long long v17; // r12
long long v18; // r13
long long v19; // rbp
unsigned int v20; // eax
int *v21; // rax
long long v22; // rax
long long v23; // rcx
long long v24; // rbp
long long v25; // r12
int v26; // eax
_DWORD *v27; // r14
long long v28; // rcx
_QWORD *v29; // rax
int v30; // r13d
char v31; // al
__m128 v32; // xmm4
__m128 v33; // xmm5
long long v34; // rax
long long v35; // r8
unsigned long long v36; // [rsp+8h] [rbp-90h]
long long v37; // [rsp+8h] [rbp-90h]
_DWORD *v38; // [rsp+10h] [rbp-88h]
long long v39; // [rsp+18h] [rbp-80h] BYREF
_DWORD *v40; // [rsp+20h] [rbp-78h]
int *v41; // [rsp+28h] [rbp-70h] BYREF
_DWORD *v42; // [rsp+30h] [rbp-68h]
long long v43; // [rsp+38h] [rbp-60h]
__int128 v44; // [rsp+40h] [rbp-58h] BYREF
__int128 v45; // [rsp+50h] [rbp-48h]
if ( *(_DWORD *)(a2 + 96) != 3 )
goto LABEL_9;
v10 = JS_NewObjectProtoClass(
a1,
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 176LL),
*(_QWORD *)(*(_QWORD *)(a1 + 64) + 184LL),
0xBu);
v12 = v11;
v38 = (_DWORD *)v10;
if ( (_DWORD)v11 == 6 )
{
v13 = (_DWORD *)v10;
goto LABEL_6;
}
v44 = 0LL;
v45 = 0LL;
exported_names = get_exported_names(a1, &v44, a2, 0LL);
js_free(a1, v44);
if ( exported_names )
goto LABEL_5;
v40 = v38;
v36 = SHIDWORD(v45);
if ( SHIDWORD(v45) <= 0 )
{
LABEL_27:
v24 = v45;
rqsort(v45, v36, 16LL, (long long ( *)(unsigned long long, unsigned long long, long long))exported_names_cmp, a1);
if ( (int)v36 <= 0 )
{
LABEL_43:
js_free(a1, v24);
v34 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL);
v35 = *(_QWORD *)(v34 + 1016);
if ( !((*(_QWORD *)(v35 + 4) >> 62 == 1) | !__OFSUB__(-(int)*(_QWORD *)(v35 + 4), 1)) )
v35 = *(_QWORD *)(v34 + 376);
++*(_DWORD *)v35;
v13 = v38;
JS_DefinePropertyValue(
a1,
(unsigned long long)v38,
v12,
218LL,
(_DWORD *)v35,
-7LL,
0.0,
a4,
a5,
a6,
v32,
v33,
a9,
a10,
0);
*((_BYTE *)v40 + 5) &= ~1u;
goto LABEL_6;
}
v42 = v38;
v37 = 16 * v36;
v25 = 0LL;
v43 = v12;
while ( 1 )
{
v26 = *(_DWORD *)(v24 + v25 + 4);
if ( v26 != 2 )
break;
if ( (int)JS_DefineAutoInitProperty(
a1,
(_DWORD)v42,
v12,
*(_DWORD *)(v24 + v25),
1,
*(_QWORD *)(v24 + v25 + 8),
6) >= 0 )
goto LABEL_40;
v30 = 2;
LABEL_41:
if ( v30 )
goto LABEL_5;
v25 += 16LL;
if ( v37 == v25 )
goto LABEL_43;
}
if ( v26 != 1 )
goto LABEL_40;
v27 = *(_DWORD **)(v24 + v25 + 8);
v28 = *(unsigned int *)(v24 + v25);
if ( v27 )
{
v29 = (_QWORD *)add_property(a1, v40, (unsigned int)v28, 38LL);
v30 = 0;
if ( v29 )
{
++*v27;
*v29 = v27;
v31 = 1;
goto LABEL_39;
}
v30 = 2;
}
else
{
v30 = 2;
js_resolve_export_throw_error(a1, 2LL, a2, v28);
}
v31 = 0;
LABEL_39:
v12 = v43;
if ( v31 )
{
LABEL_40:
v30 = 0;
goto LABEL_41;
}
goto LABEL_41;
}
v17 = v45;
v18 = 16LL * SHIDWORD(v45);
v19 = 0LL;
while ( 1 )
{
if ( *(_QWORD *)(v17 + v19 + 8) )
{
v41 = *(int **)(v17 + v19 + 8);
v39 = a2;
v20 = 0;
}
else
{
v20 = js_resolve_export(a1, &v39, &v41, a2, *(unsigned int *)(v17 + v19));
}
if ( v20 )
break;
v21 = v41;
if ( v41[5] == 126 )
{
*(_DWORD *)(v17 + v19 + 4) = 2;
v22 = *(_QWORD *)(*(_QWORD *)(v39 + 24) + 16LL * *v21 + 8);
LABEL_25:
*(_QWORD *)(v17 + v19 + 8) = v22;
goto LABEL_26;
}
*(_DWORD *)(v17 + v19 + 4) = 1;
v23 = *((_QWORD *)v21 + 1);
if ( !v23 )
{
v22 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v39 + 104) + 56LL) + 8LL * *v21);
goto LABEL_25;
}
*(_QWORD *)(v17 + v19 + 8) = v23;
LABEL_26:
v19 += 16LL;
if ( v18 == v19 )
goto LABEL_27;
}
if ( v20 == 3 )
{
*(_DWORD *)(v17 + v19 + 4) = 0;
goto LABEL_26;
}
js_resolve_export_throw_error(a1, v20, a2, *(unsigned int *)(v17 + v19));
LABEL_5:
js_free(a1, v45);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v38, v12);
v12 = 6LL;
v13 = 0LL;
LABEL_6:
if ( (_DWORD)v12 == 6 )
return 0LL;
*(_QWORD *)(a2 + 88) = v13;
*(_QWORD *)(a2 + 96) = v12;
LABEL_9:
result = *(_QWORD *)(a2 + 88);
v16 = *(_QWORD *)(a2 + 96);
*(_QWORD *)&v44 = result;
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
++*(_DWORD *)v44;
return result;
}
| JS_GetModuleNamespace:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RSI
CMP dword ptr [RSI + 0x60],0x3
JNZ 0x00130bbc
MOV R15,RDI
MOV RAX,qword ptr [RDI + 0x40]
MOV RSI,qword ptr [RAX + 0xb0]
MOV RDX,qword ptr [RAX + 0xb8]
MOV ECX,0xb
CALL 0x00120f05
MOV R14,RDX
MOV qword ptr [RSP + 0x10],RAX
CMP R14D,0x6
JNZ 0x00130b44
MOV R12,RAX
JMP 0x00130ba5
LAB_00130b44:
MOV R13,qword ptr [RSP + 0x10]
XORPS XMM0,XMM0
LEA R12,[RSP + 0x40]
MOVAPS xmmword ptr [R12],XMM0
MOVAPS xmmword ptr [R12 + 0x10],XMM0
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBX
XOR ECX,ECX
CALL 0x0014359c
MOV EBP,EAX
MOV RSI,qword ptr [R12]
MOV RDI,R15
CALL 0x0011cb99
TEST EBP,EBP
JZ 0x00130be4
LAB_00130b7e:
MOV RSI,qword ptr [RSP + 0x50]
MOV RDI,R15
CALL 0x0011cb99
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [R15 + 0x18]
MOV RDX,R14
CALL 0x0011d8c6
MOV R14D,0x6
XOR R12D,R12D
LAB_00130ba5:
CMP R14D,0x6
JNZ 0x00130bb4
MOV EDX,0x6
XOR EAX,EAX
JMP 0x00130bd5
LAB_00130bb4:
MOV qword ptr [RBX + 0x58],R12
MOV qword ptr [RBX + 0x60],R14
LAB_00130bbc:
MOV RAX,qword ptr [RBX + 0x58]
MOV RDX,qword ptr [RBX + 0x60]
MOV qword ptr [RSP + 0x40],RAX
CMP EDX,-0x9
JC 0x00130bd5
MOV RCX,qword ptr [RSP + 0x40]
INC dword ptr [RCX]
LAB_00130bd5:
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00130be4:
MOV qword ptr [RSP + 0x20],R13
MOVSXD RAX,dword ptr [RSP + 0x5c]
MOV qword ptr [RSP + 0x8],RAX
TEST RAX,RAX
JLE 0x00130cbf
MOV R12,qword ptr [RSP + 0x50]
MOV R13,qword ptr [RSP + 0x8]
SHL R13,0x4
XOR EBP,EBP
LAB_00130c0c:
MOV RAX,qword ptr [R12 + RBP*0x1 + 0x8]
TEST RAX,RAX
JZ 0x00130c24
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x18],RBX
XOR EAX,EAX
JMP 0x00130c3d
LAB_00130c24:
MOV R8D,dword ptr [R12 + RBP*0x1]
MOV RDI,R15
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x28]
MOV RCX,RBX
CALL 0x0014377e
LAB_00130c3d:
TEST EAX,EAX
JZ 0x00130c55
CMP EAX,0x3
JNZ 0x00130e44
MOV dword ptr [R12 + RBP*0x1 + 0x4],0x0
JMP 0x00130cb2
LAB_00130c55:
MOV RAX,qword ptr [RSP + 0x28]
CMP dword ptr [RAX + 0x14],0x7e
JNZ 0x00130c80
MOV dword ptr [R12 + RBP*0x1 + 0x4],0x2
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x18]
MOVSXD RAX,dword ptr [RAX]
SHL RAX,0x4
MOV RAX,qword ptr [RCX + RAX*0x1 + 0x8]
JMP 0x00130cad
LAB_00130c80:
MOV dword ptr [R12 + RBP*0x1 + 0x4],0x1
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x00130c99
MOV qword ptr [R12 + RBP*0x1 + 0x8],RCX
JMP 0x00130cb2
LAB_00130c99:
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RCX + 0x38]
MOVSXD RAX,dword ptr [RAX]
MOV RAX,qword ptr [RCX + RAX*0x8]
LAB_00130cad:
MOV qword ptr [R12 + RBP*0x1 + 0x8],RAX
LAB_00130cb2:
ADD RBP,0x10
CMP R13,RBP
JNZ 0x00130c0c
LAB_00130cbf:
MOV RBP,qword ptr [RSP + 0x50]
LEA RCX,[0x14386a]
MOV EDX,0x10
MOV RDI,RBP
MOV R12,qword ptr [RSP + 0x8]
MOV RSI,R12
MOV R8,R15
CALL 0x0011c031
TEST R12D,R12D
JLE 0x00130dc3
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
SHL qword ptr [RSP + 0x8],0x4
XOR R12D,R12D
MOV qword ptr [RSP + 0x38],R14
LAB_00130d04:
MOV EAX,dword ptr [RBP + R12*0x1 + 0x4]
CMP EAX,0x2
JZ 0x00130d4c
CMP EAX,0x1
JNZ 0x00130da8
MOV R14,qword ptr [RBP + R12*0x1 + 0x8]
MOV ECX,dword ptr [RBP + R12*0x1]
TEST R14,R14
JZ 0x00130d7f
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,ECX
MOV ECX,0x26
CALL 0x0013bf45
XOR R13D,R13D
TEST RAX,RAX
JZ 0x00130d97
INC dword ptr [R14]
MOV qword ptr [RAX],R14
MOV AL,0x1
JMP 0x00130d9f
LAB_00130d4c:
MOV ECX,dword ptr [RBP + R12*0x1]
MOV R9,qword ptr [RBP + R12*0x1 + 0x8]
MOV dword ptr [RSP],0x6
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,R14
MOV R8D,0x1
CALL 0x00141517
TEST EAX,EAX
JNS 0x00130da8
MOV R13D,0x2
JMP 0x00130dab
LAB_00130d7f:
MOV R13D,0x2
MOV RDI,R15
MOV ESI,0x2
MOV RDX,RBX
CALL 0x001437e9
JMP 0x00130d9d
LAB_00130d97:
MOV R13D,0x2
LAB_00130d9d:
XOR EAX,EAX
LAB_00130d9f:
TEST AL,AL
MOV R14,qword ptr [RSP + 0x38]
JZ 0x00130dab
LAB_00130da8:
XOR R13D,R13D
LAB_00130dab:
TEST R13D,R13D
JNZ 0x00130e35
ADD R12,0x10
CMP qword ptr [RSP + 0x8],R12
JNZ 0x00130d04
LAB_00130dc3:
MOV RDI,R15
MOV RSI,RBP
CALL 0x0011cb99
MOV RAX,qword ptr [R15 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV R8,qword ptr [RAX + 0x3f8]
MOV RCX,qword ptr [R8 + 0x4]
MOV RDX,RCX
SHR RDX,0x3e
CMP EDX,0x1
SETZ DL
NEG ECX
SETNO CL
OR CL,DL
JNZ 0x00130dfe
MOV R8,qword ptr [RAX + 0x178]
LAB_00130dfe:
INC dword ptr [R8]
MOV R12,qword ptr [RSP + 0x10]
MOV dword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
MOV ECX,0xda
MOV R9,-0x7
CALL 0x00126abb
MOV RAX,qword ptr [RSP + 0x20]
AND byte ptr [RAX + 0x5],0xfe
JMP 0x00130ba5
LAB_00130e35:
CMP R13D,0x2
JZ 0x00130b7e
JMP 0x00130ba5
LAB_00130e44:
MOV ECX,dword ptr [R12 + RBP*0x1]
MOV RDI,R15
MOV ESI,EAX
MOV RDX,RBX
CALL 0x001437e9
JMP 0x00130b7e
|
/* WARNING: Removing unreachable block (ram,0x00130df7) */
int1 [16] JS_GetModuleNamespace(long param_1,long param_2)
{
bool bVar1;
bool bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int1 auVar5 [16];
long lVar6;
int iVar7;
int iVar8;
int *piVar10;
long lVar11;
int8 uVar12;
int8 *puVar13;
int8 uVar14;
long lVar15;
int1 auVar16 [16];
int1 auVar17 [16];
long local_80;
long local_78;
int *local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 uStack_50;
long local_48;
int8 uStack_40;
long lVar9;
if (*(int *)(param_2 + 0x60) == 3) {
auVar16 = JS_NewObjectProtoClass
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0xb0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0xb8),0xb);
uVar14 = auVar16._8_8_;
lVar9 = auVar16._0_8_;
if (auVar16._8_4_ != 6) {
local_58 = 0;
uStack_50 = 0;
local_48 = 0;
uStack_40 = 0;
iVar7 = get_exported_names(param_1,&local_58,param_2,0);
js_free(param_1,local_58);
lVar6 = local_48;
auVar3._8_8_ = uVar14;
auVar3._0_8_ = local_68;
if (iVar7 == 0) {
iVar7 = uStack_40._4_4_;
lVar11 = (long)uStack_40._4_4_;
local_78 = lVar9;
if (0 < lVar11) {
lVar15 = 0;
do {
piVar10 = *(int **)(lVar6 + 8 + lVar15);
if (piVar10 == (int *)0x0) {
iVar8 = js_resolve_export(param_1,&local_80,&local_70,param_2,
*(int4 *)(lVar6 + lVar15));
}
else {
iVar8 = 0;
local_80 = param_2;
local_70 = piVar10;
}
if (iVar8 == 0) {
if (local_70[5] == 0x7e) {
*(int4 *)(lVar6 + 4 + lVar15) = 2;
uVar12 = *(int8 *)(*(long *)(local_80 + 0x18) + 8 + (long)*local_70 * 0x10);
}
else {
*(int4 *)(lVar6 + 4 + lVar15) = 1;
if (*(long *)(local_70 + 2) != 0) {
*(long *)(lVar6 + 8 + lVar15) = *(long *)(local_70 + 2);
goto LAB_00130cb2;
}
uVar12 = *(int8 *)
(*(long *)(*(long *)(local_80 + 0x68) + 0x38) + (long)*local_70 * 8);
}
*(int8 *)(lVar6 + 8 + lVar15) = uVar12;
}
else {
if (iVar8 != 3) {
js_resolve_export_throw_error(param_1,iVar8,param_2,*(int4 *)(lVar6 + lVar15))
;
auVar3._0_8_ = local_68;
goto LAB_00130b7e;
}
*(int4 *)(lVar6 + 4 + lVar15) = 0;
}
LAB_00130cb2:
lVar15 = lVar15 + 0x10;
} while (lVar11 << 4 != lVar15);
}
lVar6 = local_48;
rqsort(local_48,lVar11,0x10,exported_names_cmp,param_1);
auVar5._8_8_ = uVar14;
auVar5._0_8_ = local_68;
if (0 < iVar7) {
lVar15 = 0;
local_60 = uVar14;
do {
local_68 = auVar16._0_8_;
iVar7 = *(int *)(lVar6 + 4 + lVar15);
if (iVar7 == 2) {
iVar7 = JS_DefineAutoInitProperty
(param_1,local_68,auVar16._8_8_,*(int4 *)(lVar6 + lVar15),1,
*(int8 *)(lVar6 + 8 + lVar15),6);
auVar16._8_8_ = auVar16._8_8_;
auVar16._0_8_ = local_68;
if (-1 < iVar7) goto LAB_00130da8;
bVar2 = true;
}
else {
if (iVar7 == 1) {
piVar10 = *(int **)(lVar6 + 8 + lVar15);
if (piVar10 == (int *)0x0) {
js_resolve_export_throw_error(param_1,2,param_2);
LAB_00130d9d:
bVar2 = true;
bVar1 = false;
}
else {
puVar13 = (int8 *)
add_property(param_1,local_78,*(int4 *)(lVar6 + lVar15),0x26);
bVar2 = false;
if (puVar13 == (int8 *)0x0) goto LAB_00130d9d;
*piVar10 = *piVar10 + 1;
*puVar13 = piVar10;
bVar1 = true;
}
auVar16._8_8_ = local_60;
auVar16._0_8_ = local_68;
if (!bVar1) goto LAB_00130dab;
}
LAB_00130da8:
bVar2 = false;
}
LAB_00130dab:
auVar4._8_8_ = auVar16._8_8_;
auVar4._0_8_ = lVar15;
if (bVar2) {
auVar3 = auVar16;
auVar16 = auVar4;
if (!bVar2) goto LAB_00130ba5;
goto LAB_00130b7e;
}
lVar15 = lVar15 + 0x10;
auVar5 = auVar16;
} while (lVar11 << 4 != lVar15);
}
local_68 = auVar5._0_8_;
auVar16._8_8_ = auVar5._8_8_;
auVar16._0_8_ = lVar9;
js_free(param_1,lVar6);
piVar10 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x3f8);
*piVar10 = *piVar10 + 1;
JS_DefinePropertyValue(param_1,lVar9,auVar5._8_8_,0xda,piVar10,0xfffffffffffffff9,0);
*(byte *)(local_78 + 5) = *(byte *)(local_78 + 5) & 0xfe;
}
else {
LAB_00130b7e:
local_68 = auVar3._0_8_;
js_free(param_1,local_48);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar9,auVar3._8_8_);
auVar16 = ZEXT816(6) << 0x40;
}
}
LAB_00130ba5:
if (auVar16._8_4_ == 6) {
uVar14 = 6;
piVar10 = (int *)0x0;
goto LAB_00130bd5;
}
*(int1 (*) [16])(param_2 + 0x58) = auVar16;
}
piVar10 = *(int **)(param_2 + 0x58);
uVar14 = *(int8 *)(param_2 + 0x60);
if (0xfffffff6 < (uint)uVar14) {
*piVar10 = *piVar10 + 1;
}
LAB_00130bd5:
auVar17._8_8_ = uVar14;
auVar17._0_8_ = piVar10;
return auVar17;
}
|
|
1,968 | JS_GetModuleNamespace | bluesky950520[P]quickjs/quickjs.c | JSValue JS_GetModuleNamespace(JSContext *ctx, JSModuleDef *m)
{
if (JS_IsUndefined(m->module_ns)) {
JSValue val;
val = js_build_module_ns(ctx, m);
if (JS_IsException(val))
return JS_EXCEPTION;
m->module_ns = val;
}
return js_dup(m->module_ns);
} | O2 | c | JS_GetModuleNamespace:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbp
movq 0x60(%rsi), %rbx
cmpl $0x3, %ebx
jne 0x29192
movq %rdi, %r12
pushq $0xb
popq %rsi
callq 0x1b297
movq %rax, %r15
movq %rdx, %rbx
cmpl $0x6, %ebx
jne 0x291a0
cmpl $0x6, %ebx
je 0x291fa
movq %r15, 0x58(%rbp)
movq %rbx, 0x60(%rbp)
jmp 0x29196
movq 0x58(%rbp), %r15
cmpl $-0x9, %ebx
jb 0x29200
incl (%r15)
jmp 0x29200
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r13
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
xorl %r14d, %r14d
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x3b198
movq %rbp, 0x30(%rsp)
movl %eax, %ebp
movq (%r13), %rsi
movq %r12, %rdi
callq 0x1726e
testl %ebp, %ebp
je 0x29215
movq 0x50(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1726e
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1801e
pushq $0x6
popq %rbx
xorl %r15d, %r15d
movq %r15, %rax
movq %rbx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x5c(%rsp), %rax
testl %eax, %eax
movl $0x0, %edx
movq %rax, 0x28(%rsp)
cmovgl %eax, %edx
movq 0x50(%rsp), %r13
shlq $0x4, %rdx
movq 0x30(%rsp), %rbp
movq %rdx, 0x10(%rsp)
cmpq %r14, %rdx
je 0x292f5
movq 0x8(%r13,%r14), %rax
testq %rax, %rax
je 0x29256
movq %rbp, 0x20(%rsp)
jmp 0x29287
movl (%r13,%r14), %r8d
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbp, %rcx
callq 0x3b33a
cmpl $0x3, %eax
je 0x292c6
testl %eax, %eax
jne 0x293ee
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %rdx
cmpl $0x7e, 0x14(%rax)
jne 0x292ad
movl $0x2, 0x4(%r13,%r14)
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq (%rax), %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
jmp 0x292e7
movl $0x1, 0x4(%r13,%r14)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x292d3
movq %rcx, 0x8(%r13,%r14)
jmp 0x292ec
andl $0x0, 0x4(%r13,%r14)
movq 0x10(%rsp), %rdx
jmp 0x292ec
movq 0x20(%rsp), %rcx
movq 0x68(%rcx), %rcx
movq 0x38(%rcx), %rcx
movslq (%rax), %rax
movq (%rcx,%rax,8), %rax
movq %rax, 0x8(%r13,%r14)
addq $0x10, %r14
jmp 0x2923c
leaq 0x12126(%rip), %rcx # 0x3b422
pushq $0x10
popq %rdx
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movq %r12, %r8
callq 0x1683c
movq 0x10(%rsp), %rcx
xorl %r14d, %r14d
movq %rbx, 0x18(%rsp)
cmpq %r14, %rcx
je 0x293b1
movl 0x4(%r13,%r14), %eax
cmpl $0x2, %eax
je 0x29378
cmpl $0x1, %eax
jne 0x293a8
movq %r15, %rbx
movq 0x8(%r13,%r14), %r15
movl (%r13,%r14), %ecx
testq %r15, %r15
je 0x29405
movq %r12, %rdi
movq %rbx, %rsi
movl %ecx, %edx
pushq $0x26
popq %rcx
callq 0x34d1a
testq %rax, %rax
je 0x29413
incl (%r15)
movq %r15, (%rax)
movq %rbx, %r15
movq 0x18(%rsp), %rbx
movq 0x10(%rsp), %rcx
jmp 0x293a8
movl (%r13,%r14), %ecx
movq 0x8(%r13,%r14), %r9
movl $0x6, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
pushq $0x1
popq %r8
callq 0x393f2
movq 0x10(%rsp), %rcx
testl %eax, %eax
js 0x291e1
addq $0x10, %r14
jmp 0x2931c
movq %r12, %rdi
movq %r13, %rsi
callq 0x1726e
pushq $0x7f
popq %rsi
movq %r12, %rdi
callq 0x1a990
movq %rdx, %r9
andl $0x0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movl $0xda, %ecx
movq %rax, %r8
callq 0x20872
andb $-0x2, 0x5(%r15)
jmp 0x29183
movl (%r13,%r14), %ecx
movq %r12, %rdi
movl %eax, %esi
movq %rbp, %rdx
callq 0x3b3a3
jmp 0x291e1
pushq $0x2
popq %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x3b3a3
movq %rbx, %r15
movq 0x18(%rsp), %rbx
jmp 0x291e1
| JS_GetModuleNamespace:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbp, rsi
mov rbx, [rsi+60h]
cmp ebx, 3
jnz short loc_29192
mov r12, rdi
push 0Bh
pop rsi
call JS_NewObjectClass
mov r15, rax
mov rbx, rdx
cmp ebx, 6
jnz short loc_291A0
loc_29183:
cmp ebx, 6
jz short loc_291FA
mov [rbp+58h], r15
mov [rbp+60h], rbx
jmp short loc_29196
loc_29192:
mov r15, [rbp+58h]
loc_29196:
cmp ebx, 0FFFFFFF7h
jb short loc_29200
inc dword ptr [r15]
jmp short loc_29200
loc_291A0:
xorps xmm0, xmm0
lea r13, [rsp+98h+var_58]
movaps xmmword ptr [r13+10h], xmm0
movaps xmmword ptr [r13+0], xmm0
xor r14d, r14d
mov rdi, r12
mov rsi, r13
mov rdx, rbp
xor ecx, ecx
call get_exported_names
mov [rsp+98h+var_68], rbp
mov ebp, eax
mov rsi, [r13+0]
mov rdi, r12
call js_free
test ebp, ebp
jz short loc_29215
mov r13, [rsp+98h+var_48]
loc_291E1:
mov rdi, r12
mov rsi, r13
call js_free
mov rdi, r12
mov rsi, r15
mov rdx, rbx
call JS_FreeValue
loc_291FA:
push 6
pop rbx
xor r15d, r15d
loc_29200:
mov rax, r15
mov rdx, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_29215:
movsxd rax, [rsp+98h+var_3C]
test eax, eax
mov edx, 0
mov [rsp+98h+var_70], rax
cmovg edx, eax
mov r13, [rsp+98h+var_48]
shl rdx, 4
mov rbp, [rsp+98h+var_68]
mov [rsp+98h+var_88], rdx
loc_2923C:
cmp rdx, r14
jz loc_292F5
mov rax, [r13+r14+8]
test rax, rax
jz short loc_29256
mov [rsp+98h+var_78], rbp
jmp short loc_29287
loc_29256:
mov r8d, [r13+r14+0]
mov rdi, r12
lea rsi, [rsp+98h+var_78]
lea rdx, [rsp+98h+var_60]
mov rcx, rbp
call js_resolve_export
cmp eax, 3
jz short loc_292C6
test eax, eax
jnz loc_293EE
mov rax, [rsp+98h+var_60]
mov rdx, [rsp+98h+var_88]
loc_29287:
cmp dword ptr [rax+14h], 7Eh ; '~'
jnz short loc_292AD
mov dword ptr [r13+r14+4], 2
mov rcx, [rsp+98h+var_78]
mov rcx, [rcx+18h]
movsxd rax, dword ptr [rax]
shl rax, 4
mov rax, [rcx+rax+8]
jmp short loc_292E7
loc_292AD:
mov dword ptr [r13+r14+4], 1
mov rcx, [rax+8]
test rcx, rcx
jz short loc_292D3
mov [r13+r14+8], rcx
jmp short loc_292EC
loc_292C6:
and dword ptr [r13+r14+4], 0
mov rdx, [rsp+98h+var_88]
jmp short loc_292EC
loc_292D3:
mov rcx, [rsp+98h+var_78]
mov rcx, [rcx+68h]
mov rcx, [rcx+38h]
movsxd rax, dword ptr [rax]
mov rax, [rcx+rax*8]
loc_292E7:
mov [r13+r14+8], rax
loc_292EC:
add r14, 10h
jmp loc_2923C
loc_292F5:
lea rcx, exported_names_cmp
push 10h
pop rdx
mov rdi, r13
mov rsi, [rsp+98h+var_70]
mov r8, r12
call rqsort
mov rcx, [rsp+98h+var_88]
xor r14d, r14d
mov [rsp+98h+var_80], rbx
loc_2931C:
cmp rcx, r14
jz loc_293B1
mov eax, [r13+r14+4]
cmp eax, 2
jz short loc_29378
cmp eax, 1
jnz short loc_293A8
mov rbx, r15
mov r15, [r13+r14+8]
mov ecx, [r13+r14+0]
test r15, r15
jz loc_29405
mov rdi, r12
mov rsi, rbx
mov edx, ecx
push 26h ; '&'
pop rcx
call add_property
test rax, rax
jz loc_29413
inc dword ptr [r15]
mov [rax], r15
mov r15, rbx
mov rbx, [rsp+98h+var_80]
mov rcx, [rsp+98h+var_88]
jmp short loc_293A8
loc_29378:
mov ecx, [r13+r14+0]
mov r9, [r13+r14+8]
mov [rsp+98h+var_98], 6
mov rdi, r12
mov rsi, r15
mov rdx, rbx
push 1
pop r8
call JS_DefineAutoInitProperty
mov rcx, [rsp+98h+var_88]
test eax, eax
js loc_291E1
loc_293A8:
add r14, 10h
jmp loc_2931C
loc_293B1:
mov rdi, r12
mov rsi, r13
call js_free
push 7Fh
pop rsi
mov rdi, r12
call JS_AtomToString
mov r9, rdx
and [rsp+98h+var_98], 0
mov rdi, r12
mov rsi, r15
mov rdx, rbx
mov ecx, 0DAh
mov r8, rax
call JS_DefinePropertyValue
and byte ptr [r15+5], 0FEh
jmp loc_29183
loc_293EE:
mov ecx, [r13+r14+0]
mov rdi, r12
mov esi, eax
mov rdx, rbp
call js_resolve_export_throw_error
jmp loc_291E1
loc_29405:
push 2
pop rsi
mov rdi, r12
mov rdx, rbp
call js_resolve_export_throw_error
loc_29413:
mov r15, rbx
mov rbx, [rsp+98h+var_80]
jmp loc_291E1
| long long JS_GetModuleNamespace(
long long a1,
long long a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rbp
long long v11; // rbx
long long v12; // r15
long long v13; // rdx
long long v14; // r14
int exported_names; // ebp
long long v16; // r13
long long v18; // rdx
long long v19; // rdx
int *v20; // rax
unsigned int v21; // eax
long long v22; // rax
long long v23; // rcx
long long v24; // rcx
long long v25; // r14
int v26; // eax
long long v27; // rbx
_DWORD *v28; // r15
long long v29; // rcx
_QWORD *v30; // rax
int inited; // eax
_DWORD *v32; // rax
long long v33; // rdx
__m128 v34; // xmm4
__m128 v35; // xmm5
long long v36; // [rsp+10h] [rbp-88h]
long long v37; // [rsp+18h] [rbp-80h]
long long v38; // [rsp+20h] [rbp-78h] BYREF
unsigned long long v39; // [rsp+28h] [rbp-70h]
long long v40; // [rsp+30h] [rbp-68h]
int *v41; // [rsp+38h] [rbp-60h] BYREF
__int128 v42; // [rsp+40h] [rbp-58h] BYREF
__int128 v43; // [rsp+50h] [rbp-48h]
v10 = a2;
v11 = *(_QWORD *)(a2 + 96);
if ( (_DWORD)v11 != 3 )
{
v12 = *(_QWORD *)(a2 + 88);
LABEL_6:
if ( (unsigned int)v11 >= 0xFFFFFFF7 )
++*(_DWORD *)v12;
return v12;
}
v12 = JS_NewObjectClass(a1, 11);
v11 = v13;
if ( (_DWORD)v13 == 6 )
{
LABEL_3:
if ( (_DWORD)v11 == 6 )
return 0LL;
*(_QWORD *)(v10 + 88) = v12;
*(_QWORD *)(v10 + 96) = v11;
goto LABEL_6;
}
v43 = 0LL;
v42 = 0LL;
v14 = 0LL;
v40 = a2;
exported_names = get_exported_names(a1, &v42, a2, 0LL);
js_free(a1, v42);
if ( exported_names )
{
v16 = v43;
goto LABEL_10;
}
v18 = 0LL;
v39 = SHIDWORD(v43);
if ( SHIDWORD(v43) > 0 )
v18 = HIDWORD(v43);
v16 = v43;
v19 = 16 * v18;
v10 = v40;
v36 = v19;
while ( v19 != v14 )
{
v20 = *(int **)(v16 + v14 + 8);
if ( v20 )
{
v38 = v10;
}
else
{
v21 = js_resolve_export(a1, &v38, &v41, v10, *(unsigned int *)(v16 + v14));
if ( v21 == 3 )
{
*(_DWORD *)(v16 + v14 + 4) = 0;
v19 = v36;
goto LABEL_29;
}
if ( v21 )
{
js_resolve_export_throw_error(a1, v21, v10, *(unsigned int *)(v16 + v14));
goto LABEL_10;
}
v20 = v41;
v19 = v36;
}
if ( v20[5] == 126 )
{
*(_DWORD *)(v16 + v14 + 4) = 2;
v22 = *(_QWORD *)(*(_QWORD *)(v38 + 24) + 16LL * *v20 + 8);
}
else
{
*(_DWORD *)(v16 + v14 + 4) = 1;
v23 = *((_QWORD *)v20 + 1);
if ( v23 )
{
*(_QWORD *)(v16 + v14 + 8) = v23;
goto LABEL_29;
}
v22 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v38 + 104) + 56LL) + 8LL * *v20);
}
*(_QWORD *)(v16 + v14 + 8) = v22;
LABEL_29:
v14 += 16LL;
}
rqsort(v16, v39, 16LL, (long long ( *)(unsigned long long, unsigned long long, long long))exported_names_cmp, a1);
v24 = v36;
v25 = 0LL;
v37 = v11;
while ( 1 )
{
if ( v24 == v25 )
{
js_free(a1, v16);
v32 = (_DWORD *)JS_AtomToString(a1, 127);
JS_DefinePropertyValue(a1, v12, v11, 218LL, v32, v33, 0.0, a4, a5, a6, v34, v35, a9, a10, 0);
*(_BYTE *)(v12 + 5) &= ~1u;
goto LABEL_3;
}
v26 = *(_DWORD *)(v16 + v25 + 4);
if ( v26 == 2 )
{
inited = JS_DefineAutoInitProperty(a1, v12, v11, *(_DWORD *)(v16 + v25), 1, *(_QWORD *)(v16 + v25 + 8), 6);
v24 = v36;
if ( inited < 0 )
goto LABEL_10;
goto LABEL_38;
}
if ( v26 != 1 )
goto LABEL_38;
v27 = v12;
v28 = *(_DWORD **)(v16 + v25 + 8);
v29 = *(unsigned int *)(v16 + v25);
if ( !v28 )
break;
v30 = (_QWORD *)add_property(a1, v27, (unsigned int)v29, 38LL);
if ( !v30 )
goto LABEL_42;
++*v28;
*v30 = v28;
v12 = v27;
v11 = v37;
v24 = v36;
LABEL_38:
v25 += 16LL;
}
js_resolve_export_throw_error(a1, 2LL, v10, v29);
LABEL_42:
v12 = v27;
v11 = v37;
LABEL_10:
js_free(a1, v16);
JS_FreeValue(a1, v12, v11);
return 0LL;
}
| JS_GetModuleNamespace:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBP,RSI
MOV RBX,qword ptr [RSI + 0x60]
CMP EBX,0x3
JNZ 0x00129192
MOV R12,RDI
PUSH 0xb
POP RSI
CALL 0x0011b297
MOV R15,RAX
MOV RBX,RDX
CMP EBX,0x6
JNZ 0x001291a0
LAB_00129183:
CMP EBX,0x6
JZ 0x001291fa
MOV qword ptr [RBP + 0x58],R15
MOV qword ptr [RBP + 0x60],RBX
JMP 0x00129196
LAB_00129192:
MOV R15,qword ptr [RBP + 0x58]
LAB_00129196:
CMP EBX,-0x9
JC 0x00129200
INC dword ptr [R15]
JMP 0x00129200
LAB_001291a0:
XORPS XMM0,XMM0
LEA R13,[RSP + 0x40]
MOVAPS xmmword ptr [R13 + 0x10],XMM0
MOVAPS xmmword ptr [R13],XMM0
XOR R14D,R14D
MOV RDI,R12
MOV RSI,R13
MOV RDX,RBP
XOR ECX,ECX
CALL 0x0013b198
MOV qword ptr [RSP + 0x30],RBP
MOV EBP,EAX
MOV RSI,qword ptr [R13]
MOV RDI,R12
CALL 0x0011726e
TEST EBP,EBP
JZ 0x00129215
MOV R13,qword ptr [RSP + 0x50]
LAB_001291e1:
MOV RDI,R12
MOV RSI,R13
CALL 0x0011726e
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
CALL 0x0011801e
LAB_001291fa:
PUSH 0x6
POP RBX
XOR R15D,R15D
LAB_00129200:
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00129215:
MOVSXD RAX,dword ptr [RSP + 0x5c]
TEST EAX,EAX
MOV EDX,0x0
MOV qword ptr [RSP + 0x28],RAX
CMOVG EDX,EAX
MOV R13,qword ptr [RSP + 0x50]
SHL RDX,0x4
MOV RBP,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDX
LAB_0012923c:
CMP RDX,R14
JZ 0x001292f5
MOV RAX,qword ptr [R13 + R14*0x1 + 0x8]
TEST RAX,RAX
JZ 0x00129256
MOV qword ptr [RSP + 0x20],RBP
JMP 0x00129287
LAB_00129256:
MOV R8D,dword ptr [R13 + R14*0x1]
MOV RDI,R12
LEA RSI,[RSP + 0x20]
LEA RDX,[RSP + 0x38]
MOV RCX,RBP
CALL 0x0013b33a
CMP EAX,0x3
JZ 0x001292c6
TEST EAX,EAX
JNZ 0x001293ee
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00129287:
CMP dword ptr [RAX + 0x14],0x7e
JNZ 0x001292ad
MOV dword ptr [R13 + R14*0x1 + 0x4],0x2
MOV RCX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RCX + 0x18]
MOVSXD RAX,dword ptr [RAX]
SHL RAX,0x4
MOV RAX,qword ptr [RCX + RAX*0x1 + 0x8]
JMP 0x001292e7
LAB_001292ad:
MOV dword ptr [R13 + R14*0x1 + 0x4],0x1
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x001292d3
MOV qword ptr [R13 + R14*0x1 + 0x8],RCX
JMP 0x001292ec
LAB_001292c6:
AND dword ptr [R13 + R14*0x1 + 0x4],0x0
MOV RDX,qword ptr [RSP + 0x10]
JMP 0x001292ec
LAB_001292d3:
MOV RCX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RCX + 0x68]
MOV RCX,qword ptr [RCX + 0x38]
MOVSXD RAX,dword ptr [RAX]
MOV RAX,qword ptr [RCX + RAX*0x8]
LAB_001292e7:
MOV qword ptr [R13 + R14*0x1 + 0x8],RAX
LAB_001292ec:
ADD R14,0x10
JMP 0x0012923c
LAB_001292f5:
LEA RCX,[0x13b422]
PUSH 0x10
POP RDX
MOV RDI,R13
MOV RSI,qword ptr [RSP + 0x28]
MOV R8,R12
CALL 0x0011683c
MOV RCX,qword ptr [RSP + 0x10]
XOR R14D,R14D
MOV qword ptr [RSP + 0x18],RBX
LAB_0012931c:
CMP RCX,R14
JZ 0x001293b1
MOV EAX,dword ptr [R13 + R14*0x1 + 0x4]
CMP EAX,0x2
JZ 0x00129378
CMP EAX,0x1
JNZ 0x001293a8
MOV RBX,R15
MOV R15,qword ptr [R13 + R14*0x1 + 0x8]
MOV ECX,dword ptr [R13 + R14*0x1]
TEST R15,R15
JZ 0x00129405
MOV RDI,R12
MOV RSI,RBX
MOV EDX,ECX
PUSH 0x26
POP RCX
CALL 0x00134d1a
TEST RAX,RAX
JZ 0x00129413
INC dword ptr [R15]
MOV qword ptr [RAX],R15
MOV R15,RBX
MOV RBX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
JMP 0x001293a8
LAB_00129378:
MOV ECX,dword ptr [R13 + R14*0x1]
MOV R9,qword ptr [R13 + R14*0x1 + 0x8]
MOV dword ptr [RSP],0x6
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
PUSH 0x1
POP R8
CALL 0x001393f2
MOV RCX,qword ptr [RSP + 0x10]
TEST EAX,EAX
JS 0x001291e1
LAB_001293a8:
ADD R14,0x10
JMP 0x0012931c
LAB_001293b1:
MOV RDI,R12
MOV RSI,R13
CALL 0x0011726e
PUSH 0x7f
POP RSI
MOV RDI,R12
CALL 0x0011a990
MOV R9,RDX
AND dword ptr [RSP],0x0
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
MOV ECX,0xda
MOV R8,RAX
CALL 0x00120872
AND byte ptr [R15 + 0x5],0xfe
JMP 0x00129183
LAB_001293ee:
MOV ECX,dword ptr [R13 + R14*0x1]
MOV RDI,R12
MOV ESI,EAX
MOV RDX,RBP
CALL 0x0013b3a3
JMP 0x001291e1
LAB_00129405:
PUSH 0x2
POP RSI
MOV RDI,R12
MOV RDX,RBP
CALL 0x0013b3a3
LAB_00129413:
MOV R15,RBX
MOV RBX,qword ptr [RSP + 0x18]
JMP 0x001291e1
|
int1 [16] JS_GetModuleNamespace(int8 param_1,long param_2)
{
long lVar1;
int iVar2;
int *piVar4;
int8 uVar5;
int8 *puVar6;
ulong uVar8;
long lVar9;
int1 auVar10 [16];
int1 auVar11 [16];
long local_78;
long local_70;
long local_68;
int *local_60;
int8 local_58;
int8 uStack_50;
long local_48;
int8 uStack_40;
long lVar3;
int8 uVar7;
if ((int)*(int8 *)(param_2 + 0x60) == 3) {
auVar10 = JS_NewObjectClass(param_1,0xb);
uVar7 = auVar10._8_8_;
lVar3 = auVar10._0_8_;
if (auVar10._8_4_ == 6) {
LAB_00129183:
if (auVar10._8_4_ != 6) {
*(int1 (*) [16])(param_2 + 0x58) = auVar10;
goto LAB_00129196;
}
}
else {
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
lVar9 = 0;
iVar2 = get_exported_names(param_1,&local_58,param_2,0);
local_68 = param_2;
js_free(param_1,local_58);
lVar1 = local_48;
param_2 = local_68;
if (iVar2 == 0) {
local_70 = (long)(int)uStack_40._4_4_;
uVar8 = 0;
if (0 < (int)uStack_40._4_4_) {
uVar8 = (ulong)uStack_40._4_4_;
}
for (; uVar8 << 4 != lVar9; lVar9 = lVar9 + 0x10) {
piVar4 = *(int **)(lVar1 + 8 + lVar9);
if (piVar4 == (int *)0x0) {
iVar2 = js_resolve_export(param_1,&local_78,&local_60,param_2,
*(int4 *)(lVar1 + lVar9));
if (iVar2 != 3) {
piVar4 = local_60;
if (iVar2 == 0) goto LAB_00129287;
js_resolve_export_throw_error(param_1,iVar2,param_2,*(int4 *)(lVar1 + lVar9));
goto LAB_001291e1;
}
*(int4 *)(lVar1 + 4 + lVar9) = 0;
}
else {
local_78 = param_2;
LAB_00129287:
if (piVar4[5] == 0x7e) {
*(int4 *)(lVar1 + 4 + lVar9) = 2;
uVar5 = *(int8 *)(*(long *)(local_78 + 0x18) + 8 + (long)*piVar4 * 0x10);
}
else {
*(int4 *)(lVar1 + 4 + lVar9) = 1;
if (*(long *)(piVar4 + 2) != 0) {
*(long *)(lVar1 + 8 + lVar9) = *(long *)(piVar4 + 2);
goto LAB_001292ec;
}
uVar5 = *(int8 *)
(*(long *)(*(long *)(local_78 + 0x68) + 0x38) + (long)*piVar4 * 8);
}
*(int8 *)(lVar1 + 8 + lVar9) = uVar5;
}
LAB_001292ec:
}
rqsort(lVar1,local_70,0x10,exported_names_cmp,param_1);
for (lVar9 = 0; uVar8 << 4 != lVar9; lVar9 = lVar9 + 0x10) {
iVar2 = *(int *)(lVar1 + 4 + lVar9);
if (iVar2 == 2) {
iVar2 = JS_DefineAutoInitProperty
(param_1,lVar3,uVar7,*(int4 *)(lVar1 + lVar9),1,
*(int8 *)(lVar1 + 8 + lVar9),6);
if (iVar2 < 0) goto LAB_001291e1;
}
else if (iVar2 == 1) {
piVar4 = *(int **)(lVar1 + 8 + lVar9);
if (piVar4 == (int *)0x0) {
js_resolve_export_throw_error(param_1,2,param_2);
goto LAB_001291e1;
}
puVar6 = (int8 *)add_property(param_1,lVar3,*(int4 *)(lVar1 + lVar9),0x26);
if (puVar6 == (int8 *)0x0) goto LAB_001291e1;
*piVar4 = *piVar4 + 1;
*puVar6 = piVar4;
}
}
js_free(param_1,lVar1);
auVar11 = JS_AtomToString(param_1,0x7f);
JS_DefinePropertyValue(param_1,lVar3,uVar7,0xda,auVar11._0_8_,auVar11._8_8_,0);
*(byte *)(lVar3 + 5) = *(byte *)(lVar3 + 5) & 0xfe;
goto LAB_00129183;
}
LAB_001291e1:
js_free(param_1,lVar1);
JS_FreeValue(param_1,lVar3,uVar7);
}
auVar10 = ZEXT816(6) << 0x40;
}
else {
auVar10._8_8_ = *(int8 *)(param_2 + 0x60);
auVar10._0_8_ = *(int8 *)(param_2 + 0x58);
LAB_00129196:
if (0xfffffff6 < auVar10._8_4_) {
*auVar10._0_8_ = *auVar10._0_8_ + 1;
}
}
return auVar10;
}
|
|
1,969 | ph_parse_headers | xtate/src/proto/proto-http-parser.c | int ph_parse_headers(const char *buf_start, size_t len,
struct ph_header *headers, size_t *num_headers,
size_t last_len) {
const char *buf = buf_start, *buf_end = buf + len;
size_t max_headers = *num_headers;
int r;
*num_headers = 0;
/* if last_len != 0, check if the response is complete (a fast
countermeasure against slowloris */
if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
return r;
}
if ((buf = parse_headers(buf, buf_end, headers, num_headers, max_headers,
&r)) == NULL) {
return r;
}
return (int)(buf - buf_start);
} | O3 | c | ph_parse_headers:
pushq %rbp
pushq %rbx
pushq %rax
movq %r8, %rax
movq %rdi, %rbx
addq %rdi, %rsi
movq (%rcx), %r8
movq $0x0, (%rcx)
testq %rax, %rax
je 0x33e5d
cmpq $0x3, %rax
leaq -0x3(%rbx,%rax), %r9
cmovbq %rbx, %r9
xorl %edi, %edi
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpq %rsi, %r9
je 0x33e7e
movzbl (%r9), %ebp
leaq 0x1(%r9), %r10
cmpl $0xa, %ebp
je 0x33e4c
xorl %r11d, %r11d
cmpl $0xd, %ebp
jne 0x33e51
cmpq %rsi, %r10
je 0x33e7e
cmpb $0xa, (%r10)
jne 0x33e79
addq $0x2, %r9
incl %edi
movq %r9, %r10
jmp 0x33e4e
incl %edi
movl %edi, %r11d
movq %r10, %r9
movl %r11d, %edi
cmpl $0x2, %r11d
jne 0x33e17
leaq 0x4(%rsp), %r9
movq %rbx, %rdi
callq 0x33e85
testq %rax, %rax
je 0x33e73
subl %ebx, %eax
jmp 0x33e7e
movl 0x4(%rsp), %eax
jmp 0x33e7e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| ph_parse_headers:
push rbp
push rbx
push rax
mov rax, r8
mov rbx, rdi
add rsi, rdi
mov r8, [rcx]
mov qword ptr [rcx], 0
test rax, rax
jz short loc_33E5D
cmp rax, 3
lea r9, [rbx+rax-3]
cmovb r9, rbx
xor edi, edi
loc_33E17:
mov eax, 0FFFFFFFEh
cmp r9, rsi
jz short loc_33E7E
movzx ebp, byte ptr [r9]
lea r10, [r9+1]
cmp ebp, 0Ah
jz short loc_33E4C
xor r11d, r11d
cmp ebp, 0Dh
jnz short loc_33E51
cmp r10, rsi
jz short loc_33E7E
cmp byte ptr [r10], 0Ah
jnz short loc_33E79
add r9, 2
inc edi
mov r10, r9
jmp short loc_33E4E
loc_33E4C:
inc edi
loc_33E4E:
mov r11d, edi
loc_33E51:
mov r9, r10
mov edi, r11d
cmp r11d, 2
jnz short loc_33E17
loc_33E5D:
lea r9, [rsp+18h+var_14]
mov rdi, rbx
call parse_headers
test rax, rax
jz short loc_33E73
sub eax, ebx
jmp short loc_33E7E
loc_33E73:
mov eax, [rsp+18h+var_14]
jmp short loc_33E7E
loc_33E79:
mov eax, 0FFFFFFFFh
loc_33E7E:
add rsp, 8
pop rbx
pop rbp
retn
| long long ph_parse_headers(unsigned __int8 *a1, long long a2, long long a3, long long *a4, unsigned long long a5)
{
long long v5; // rax
unsigned __int8 *v8; // rsi
long long v9; // r8
unsigned __int8 *v10; // r9
int v11; // edi
long long result; // rax
int v13; // ebp
unsigned __int8 *v14; // r10
int v15; // r11d
int v16; // edi
long long v17; // rax
unsigned int v18[5]; // [rsp+0h] [rbp-14h] BYREF
v18[0] = HIDWORD(v5);
v8 = &a1[a2];
v9 = *a4;
*a4 = 0LL;
if ( a5 )
{
v10 = &a1[a5 - 3];
if ( a5 < 3 )
v10 = a1;
v11 = 0;
while ( 1 )
{
result = 4294967294LL;
if ( v10 == v8 )
return result;
v13 = *v10;
v14 = v10 + 1;
if ( v13 == 10 )
break;
v15 = 0;
if ( v13 == 13 )
{
if ( v14 == v8 )
return result;
if ( *v14 != 10 )
return 0xFFFFFFFFLL;
v16 = v11 + 1;
v14 = v10 + 2;
goto LABEL_12;
}
LABEL_13:
v10 = v14;
v11 = v15;
if ( v15 == 2 )
goto LABEL_14;
}
v16 = v11 + 1;
LABEL_12:
v15 = v16;
goto LABEL_13;
}
LABEL_14:
v17 = parse_headers(a1, v8, a3, a4, v9, v18);
if ( v17 )
return (unsigned int)(v17 - (_DWORD)a1);
else
return v18[0];
}
| ph_parse_headers:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RAX,R8
MOV RBX,RDI
ADD RSI,RDI
MOV R8,qword ptr [RCX]
MOV qword ptr [RCX],0x0
TEST RAX,RAX
JZ 0x00133e5d
CMP RAX,0x3
LEA R9,[RBX + RAX*0x1 + -0x3]
CMOVC R9,RBX
XOR EDI,EDI
LAB_00133e17:
MOV EAX,0xfffffffe
CMP R9,RSI
JZ 0x00133e7e
MOVZX EBP,byte ptr [R9]
LEA R10,[R9 + 0x1]
CMP EBP,0xa
JZ 0x00133e4c
XOR R11D,R11D
CMP EBP,0xd
JNZ 0x00133e51
CMP R10,RSI
JZ 0x00133e7e
CMP byte ptr [R10],0xa
JNZ 0x00133e79
ADD R9,0x2
INC EDI
MOV R10,R9
JMP 0x00133e4e
LAB_00133e4c:
INC EDI
LAB_00133e4e:
MOV R11D,EDI
LAB_00133e51:
MOV R9,R10
MOV EDI,R11D
CMP R11D,0x2
JNZ 0x00133e17
LAB_00133e5d:
LEA R9,[RSP + 0x4]
MOV RDI,RBX
CALL 0x00133e85
TEST RAX,RAX
JZ 0x00133e73
SUB EAX,EBX
JMP 0x00133e7e
LAB_00133e73:
MOV EAX,dword ptr [RSP + 0x4]
JMP 0x00133e7e
LAB_00133e79:
MOV EAX,0xffffffff
LAB_00133e7e:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int ph_parse_headers(char *param_1,long param_2,int8 param_3,int8 *param_4,ulong param_5
)
{
int iVar1;
int8 in_RAX;
long lVar2;
int iVar3;
char *pcVar4;
char *pcVar5;
int local_14;
*param_4 = 0;
if (param_5 != 0) {
pcVar4 = param_1 + (param_5 - 3);
if (param_5 < 3) {
pcVar4 = param_1;
}
iVar3 = 0;
do {
if (pcVar4 == param_1 + param_2) {
return -2;
}
pcVar5 = pcVar4 + 1;
if (*pcVar4 == '\n') {
LAB_00133e4e:
iVar1 = iVar3 + 1;
}
else {
iVar1 = 0;
if (*pcVar4 == '\r') {
if (pcVar5 == param_1 + param_2) {
return -2;
}
if (*pcVar5 != '\n') {
return -1;
}
pcVar5 = pcVar4 + 2;
goto LAB_00133e4e;
}
}
iVar3 = iVar1;
pcVar4 = pcVar5;
} while (iVar3 != 2);
}
lVar2 = parse_headers(param_1);
if (lVar2 == 0) {
local_14 = (int)((ulong)in_RAX >> 0x20);
}
else {
local_14 = (int)lVar2 - (int)param_1;
}
return local_14;
}
|
|
1,970 | my_thread_global_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_global_init(void)
{
int pth_ret;
/* Normally this should never be called twice */
DBUG_ASSERT(my_thread_global_init_done == 0);
if (my_thread_global_init_done)
return 0;
my_thread_global_init_done= 1;
/*
THR_KEY_mysys is deleted in my_end() as DBUG libraries are using it even
after my_thread_global_end() is called.
my_thr_key_mysys_exist is used to protect against application like QT
that calls my_thread_global_init() + my_thread_global_end() multiple times
without calling my_init() + my_end().
*/
if (!my_thr_key_mysys_exists &&
(pth_ret= pthread_key_create(&THR_KEY_mysys, NULL)) != 0)
{
fprintf(stderr, "Can't initialize threads: error %d\n", pth_ret);
return 1;
}
my_thr_key_mysys_exists= 1;
/* Mutex used by my_thread_init() and after my_thread_destroy_mutex() */
my_thread_init_internal_mutex();
if (my_thread_init())
return 1;
my_thread_init_common_mutex();
return 0;
} | O3 | c | my_thread_global_init:
cmpb $0x0, 0x3441ed(%rip) # 0x36e488
je 0x2a2a0
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movb $0x1, 0x3441db(%rip) # 0x36e488
leaq 0x343f10(%rip), %rbx # 0x36e1c4
cmpb $0x0, (%rbx)
je 0x2a2d7
movb $0x1, (%rbx)
callq 0x2a0ef
callq 0x2a311
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2a30a
callq 0x29f62
xorl %eax, %eax
jmp 0x2a30a
leaq 0x3441ae(%rip), %rdi # 0x36e48c
xorl %esi, %esi
callq 0x245a0
testl %eax, %eax
je 0x2a2b9
movq 0x2cbce0(%rip), %rcx # 0x2f5fd0
movq (%rcx), %rdi
leaq 0x37dfa(%rip), %rdx # 0x620f4
movl $0x1, %esi
movl %eax, %ecx
xorl %eax, %eax
callq 0x245f0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| my_thread_global_init:
cmp cs:my_thread_global_init_done, 0
jz short loc_2A2A0
xor eax, eax
retn
loc_2A2A0:
push rbp
mov rbp, rsp
push rbx
push rax
mov cs:my_thread_global_init_done, 1
lea rbx, my_thr_key_mysys_exists
cmp byte ptr [rbx], 0
jz short loc_2A2D7
loc_2A2B9:
mov byte ptr [rbx], 1
call my_thread_init_internal_mutex
call my_thread_init
mov ecx, eax
mov al, 1
test cl, cl
jnz short loc_2A30A
call my_thread_init_common_mutex
xor eax, eax
jmp short loc_2A30A
loc_2A2D7:
lea rdi, THR_KEY_mysys
xor esi, esi
call _pthread_key_create
test eax, eax
jz short loc_2A2B9
mov rcx, cs:stderr_ptr
mov rdi, [rcx]
lea rdx, aCanTInitialize; "Can't initialize threads: error %d\n"
mov esi, 1
mov ecx, eax
xor eax, eax
call ___fprintf_chk
mov al, 1
loc_2A30A:
add rsp, 8
pop rbx
pop rbp
retn
| char my_thread_global_init(void *a1)
{
char result; // al
char v2; // cl
int v3; // eax
if ( my_thread_global_init_done )
return 0;
my_thread_global_init_done = 1;
if ( my_thr_key_mysys_exists || (a1 = &THR_KEY_mysys, (v3 = pthread_key_create(&THR_KEY_mysys, 0LL)) == 0) )
{
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
v2 = my_thread_init(a1);
result = 1;
if ( !v2 )
{
my_thread_init_common_mutex();
return 0;
}
}
else
{
__fprintf_chk(stderr, 1LL, "Can't initialize threads: error %d\n", v3);
return 1;
}
return result;
}
| my_thread_global_init:
CMP byte ptr [0x0046e488],0x0
JZ 0x0012a2a0
XOR EAX,EAX
RET
LAB_0012a2a0:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV byte ptr [0x0046e488],0x1
LEA RBX,[0x46e1c4]
CMP byte ptr [RBX],0x0
JZ 0x0012a2d7
LAB_0012a2b9:
MOV byte ptr [RBX],0x1
CALL 0x0012a0ef
CALL 0x0012a311
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x0012a30a
CALL 0x00129f62
XOR EAX,EAX
JMP 0x0012a30a
LAB_0012a2d7:
LEA RDI,[0x46e48c]
XOR ESI,ESI
CALL 0x001245a0
TEST EAX,EAX
JZ 0x0012a2b9
MOV RCX,qword ptr [0x003f5fd0]
MOV RDI,qword ptr [RCX]
LEA RDX,[0x1620f4]
MOV ESI,0x1
MOV ECX,EAX
XOR EAX,EAX
CALL 0x001245f0
MOV AL,0x1
LAB_0012a30a:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
bool my_thread_global_init(void)
{
char cVar1;
int iVar2;
if (my_thread_global_init_done != '\0') {
return false;
}
my_thread_global_init_done = 1;
if ((my_thr_key_mysys_exists == '\0') &&
(iVar2 = pthread_key_create(&THR_KEY_mysys,(__destr_function *)0x0), iVar2 != 0)) {
__fprintf_chk(*(int8 *)PTR_stderr_003f5fd0,1,"Can\'t initialize threads: error %d\n",iVar2
);
return true;
}
my_thr_key_mysys_exists = 1;
my_thread_init_internal_mutex();
cVar1 = my_thread_init();
if (cVar1 == '\0') {
my_thread_init_common_mutex();
}
return cVar1 != '\0';
}
|
|
1,971 | mysql_next_result_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_next_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_next_result,
(parms->mysql),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_next_result_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 0x1d120
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mysql_next_result_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_next_result
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_next_result_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
v2[2] = mysql_next_result(*a1);
result = v2;
*v2 = 0;
return result;
}
| mysql_next_result_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 0x0011d120
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_next_result_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_next_result(*param_1);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
1,972 | mysql_next_result_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_next_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_next_result,
(parms->mysql),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_next_result_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1985d
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_next_result_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_next_result
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_next_result_start_internal(long long *a1)
{
long long v1; // rdi
_DWORD *v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_DWORD **)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_next_result(v1);
v2[2] = result;
*v2 = 0;
return result;
}
| mysql_next_result_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011985d
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_next_result_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_next_result();
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
1,973 | std::hash<minja::Value>::operator()(minja::Value const&) const | monkey531[P]llama/common/minja.hpp | size_t operator()(const minja::Value & v) const {
if (!v.is_hashable())
throw std::runtime_error("Unsupported type for hashing: " + v.dump());
return std::hash<json>()(v.get<json>());
} | O3 | cpp | std::hash<minja::Value>::operator()(minja::Value const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0xb1dca
cmpq $0x0, 0x20(%r14)
jne 0xb1dca
cmpq $0x0, 0x30(%r14)
jne 0xb1dca
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1eb2
movq %rbx, %rdi
callq 0xb23cf
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x591c0
movq %r14, %rdi
callq 0x5e6ae
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1a440
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x86eb0
leaq 0x3fb03(%rip), %rsi # 0xf18f5
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x79645
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ae40
xorl %ebp, %ebp
movq 0x7a1da(%rip), %rsi # 0x12bff0
movq 0x7a143(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af30
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1e43
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a900
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1e5e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a900
testb %bpl, %bpl
jne 0xb1e88
jmp 0xb1eaa
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1e88
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a900
jmp 0xb1e88
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a680
jmp 0xb1eaa
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x591c0
movq %rbx, %rdi
callq 0x5e6ae
movq %r14, %rdi
callq 0x1afc0
| _ZNKSt4hashIN5minja5ValueEEclERKS1_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
cmp qword ptr [rsi+10h], 0
jnz short loc_B1DCA
cmp qword ptr [r14+20h], 0
jnz short loc_B1DCA
cmp qword ptr [r14+30h], 0
jnz short loc_B1DCA
mov rbx, rsp
mov rdi, rbx
mov rsi, r14
call _ZNK5minja5Value3getIN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEEEET_v; minja::Value::get<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(void)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail4hashINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEmRKT_; nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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> const&)
mov rbx, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_B1DCA:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnsupportedTyp; "Unsupported type for hashing: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1E43
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1E43:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1E5E
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1E5E:
test bpl, bpl
jnz short loc_B1E88
jmp short loc_B1EAA
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1E88
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B1E88
mov r14, rax
loc_B1E88:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_B1EAA
mov r14, rax
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_B1EAA:
mov rdi, r14
call __Unwind_Resume
| long long std::hash<minja::Value>::operator()(long long a1, _QWORD *a2)
{
long long v2; // rbx
void *exception; // rbx
char v5[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v6[16]; // [rsp+20h] [rbp-38h] BYREF
if ( a2[2] || a2[4] || a2[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"Unsupported type for hashing: ", (long long)v6);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(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>>(
v5,
a2);
v2 = nlohmann::json_abi_v3_11_3::detail::hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(v5);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v5);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v5);
return v2;
}
| operator():
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001b1dca
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001b1dca
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001b1dca
MOV RBX,RSP
MOV RDI,RBX
MOV RSI,R14
CALL 0x001b1eb2
LAB_001b1d9e:
MOV RDI,RBX
CALL 0x001b23cf
LAB_001b1da6:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x001591c0
MOV RDI,R14
CALL 0x0015e6ae
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001b1dca:
MOV EDI,0x10
CALL 0x0011a440
MOV RBX,RAX
LAB_001b1dd7:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00186eb0
LAB_001b1deb:
LEA RSI,[0x1f18f5]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00179645
MOV BPL,0x1
LAB_001b1e02:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011ae40
XOR EBP,EBP
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af30
|
/* std::hash<minja::Value>::TEMPNAMEPLACEHOLDERVALUE(minja::Value const&) const */
ulong __thiscall std::hash<minja::Value>::operator()(hash<minja::Value> *this,Value *param_1)
{
ulong uVar1;
runtime_error *this_00;
basic_json abStack_58 [32];
int1 local_38 [32];
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
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>>
();
/* try { // try from 001b1d9e to 001b1da5 has its CatchHandler @ 001b1e92 */
uVar1 = nlohmann::json_abi_v3_11_3::detail::
hash<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(abStack_58);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(abStack_58,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)abStack_58);
return uVar1;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001b1dd7 to 001b1dea has its CatchHandler @ 001b1e85 */
minja::Value::dump_abi_cxx11_((int)local_38,SUB81(param_1,0));
/* try { // try from 001b1deb to 001b1dfe has its CatchHandler @ 001b1e65 */
operator+((char *)abStack_58,(string *)"Unsupported type for hashing: ");
/* try { // try from 001b1e02 to 001b1e24 has its CatchHandler @ 001b1e25 */
std::runtime_error::runtime_error(this_00,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
|
|
1,974 | PycFloat::~PycFloat() | Pyarmor-Static-Unpack-1shot/pyc_numeric.h | PycFloat(int type = TYPE_FLOAT)
: PycObject(type) { } | O3 | c | PycFloat::~PycFloat():
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x182da(%rip), %rax # 0x4aa90
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x327cb
callq 0x71f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x71f0
nop
| _ZN8PycFloatD0Ev:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
lea rax, off_4AA90
mov [rdi], rax
mov rdi, [rdi+10h]; void *
lea rax, [rbx+20h]
cmp rdi, rax
jz short loc_327CB
call __ZdlPv; operator delete(void *)
loc_327CB:
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop rbp
jmp __ZdlPv; operator delete(void *)
| void PycFloat::~PycFloat(PycFloat *this)
{
char *v2; // rdi
*(_QWORD *)this = off_4AA90;
v2 = (char *)*((_QWORD *)this + 2);
if ( v2 != (char *)this + 32 )
operator delete(v2);
operator delete(this);
}
| ~PycFloat:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x14aa90]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x10]
LEA RAX,[RBX + 0x20]
CMP RDI,RAX
JZ 0x001327cb
CALL 0x001071f0
LAB_001327cb:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001071f0
|
/* PycFloat::~PycFloat() */
void __thiscall PycFloat::~PycFloat(PycFloat *this)
{
*(int ***)this = &PTR__PycFloat_0014aa90;
if (*(PycFloat **)(this + 0x10) != this + 0x20) {
operator_delete(*(PycFloat **)(this + 0x10));
}
operator_delete(this);
return;
}
|
|
1,975 | os_event_signal | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal-src/src/os_posix.c | void
os_event_signal (p_event_t* event, uint32_t mask)
{
if (event && *event) {
os_event_t* pevent = (os_event_t*)(*event);
pthread_mutex_lock(&pevent->mutex);
pevent->flags |= mask;
pthread_cond_broadcast(&pevent->cond); // Signal all waiting threads
pthread_mutex_unlock(&pevent->mutex);
}
} | O3 | c | os_event_signal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15431
movq (%rdi), %r14
testq %r14, %r14
je 0x15431
movl %esi, %ebx
leaq 0x30(%r14), %r15
movq %r15, %rdi
callq 0x65a0
orl %ebx, 0x58(%r14)
movq %r14, %rdi
callq 0x60d0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x63a0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| os_event_signal:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
test rdi, rdi
jz short loc_15431
mov r14, [rdi]
test r14, r14
jz short loc_15431
mov ebx, esi
lea r15, [r14+30h]
mov rdi, r15
call _pthread_mutex_lock
or [r14+58h], ebx
mov rdi, r14
call _pthread_cond_broadcast
mov rdi, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_15431:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long os_event_signal(long long *a1, int a2)
{
long long v2; // r14
long long result; // rax
if ( a1 )
{
v2 = *a1;
if ( *a1 )
{
pthread_mutex_lock(v2 + 48);
*(_DWORD *)(v2 + 88) |= a2;
pthread_cond_broadcast(v2);
return pthread_mutex_unlock(v2 + 48);
}
}
return result;
}
| os_event_signal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00115431
MOV R14,qword ptr [RDI]
TEST R14,R14
JZ 0x00115431
MOV EBX,ESI
LEA R15,[R14 + 0x30]
MOV RDI,R15
CALL 0x001065a0
OR dword ptr [R14 + 0x58],EBX
MOV RDI,R14
CALL 0x001060d0
MOV RDI,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001063a0
LAB_00115431:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void os_event_signal(int8 *param_1,uint param_2)
{
pthread_cond_t *__cond;
if ((param_1 != (int8 *)0x0) &&
(__cond = (pthread_cond_t *)*param_1, __cond != (pthread_cond_t *)0x0)) {
pthread_mutex_lock((pthread_mutex_t *)(__cond + 1));
*(uint *)((long)__cond + 0x58) = *(uint *)((long)__cond + 0x58) | param_2;
pthread_cond_broadcast(__cond);
pthread_mutex_unlock((pthread_mutex_t *)(__cond + 1));
return;
}
return;
}
|
|
1,976 | dynstr_realloc | eloqsql/mysys/string.c | my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size)
{
DBUG_ENTER("dynstr_realloc");
if (!additional_size) DBUG_RETURN(FALSE);
if (str->length + additional_size > str->max_length)
{
str->max_length=((str->length + additional_size+str->alloc_increment-1)/
str->alloc_increment)*str->alloc_increment;
if (!(str->str=(char*) my_realloc(key_memory_DYNAMIC_STRING, str->str,
str->max_length, MYF(MY_WME))))
DBUG_RETURN(TRUE);
}
DBUG_RETURN(FALSE);
} | O3 | c | dynstr_realloc:
testq %rsi, %rsi
je 0x9ece6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jbe 0x9ecdd
movq (%rbx), %r8
movq 0x18(%rbx), %rcx
leaq (%rcx,%rsi), %r9
decq %r9
movq %r9, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r9
movq %r9, 0x10(%rbx)
leaq 0x3ca3cd(%rip), %rax # 0x469090
movl (%rax), %edi
movl $0x10, %ecx
movq %r8, %rsi
movq %r9, %rdx
callq 0x9c820
movq %rax, (%rbx)
testq %rax, %rax
je 0x9ece9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
jmp 0x9ecdf
| dynstr_realloc:
test rsi, rsi
jz short loc_9ECE6
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
add rsi, [rdi+8]
cmp rsi, [rdi+10h]
jbe short loc_9ECDD
mov r8, [rbx]
mov rcx, [rbx+18h]
lea r9, [rcx+rsi]
dec r9
mov rax, r9
xor edx, edx
div rcx
sub r9, rdx
mov [rbx+10h], r9
lea rax, key_memory_DYNAMIC_STRING
mov edi, [rax]
mov ecx, 10h
mov rsi, r8
mov rdx, r9
call my_realloc
mov [rbx], rax
test rax, rax
jz short loc_9ECE9
loc_9ECDD:
xor eax, eax
loc_9ECDF:
add rsp, 8
pop rbx
pop rbp
retn
loc_9ECE6:
xor eax, eax
retn
loc_9ECE9:
mov al, 1
jmp short loc_9ECDF
| _BOOL8 dynstr_realloc(long long *a1, long long a2)
{
unsigned long long v2; // rsi
long long v3; // r8
unsigned long long v4; // rcx
unsigned long long v5; // rtt
long long v6; // rax
_BOOL8 result; // rax
if ( !a2 )
return 0LL;
v2 = a1[1] + a2;
result = 0;
if ( v2 > a1[2] )
{
v3 = *a1;
v4 = a1[3];
v5 = v4 + v2 - 1;
a1[2] = v5 - v5 % v4;
v6 = my_realloc(key_memory_DYNAMIC_STRING, v3, v5 - v5 % v4, 16);
*a1 = v6;
if ( !v6 )
return 1;
}
return result;
}
| dynstr_realloc:
TEST RSI,RSI
JZ 0x0019ece6
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
ADD RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JBE 0x0019ecdd
MOV R8,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x18]
LEA R9,[RCX + RSI*0x1]
DEC R9
MOV RAX,R9
XOR EDX,EDX
DIV RCX
SUB R9,RDX
MOV qword ptr [RBX + 0x10],R9
LEA RAX,[0x569090]
MOV EDI,dword ptr [RAX]
MOV ECX,0x10
MOV RSI,R8
MOV RDX,R9
CALL 0x0019c820
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JZ 0x0019ece9
LAB_0019ecdd:
XOR EAX,EAX
LAB_0019ecdf:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0019ece6:
XOR EAX,EAX
RET
LAB_0019ece9:
MOV AL,0x1
JMP 0x0019ecdf
|
int8 dynstr_realloc(long *param_1,long param_2)
{
ulong uVar1;
long lVar2;
if (param_2 == 0) {
return 0;
}
if ((ulong)param_1[2] < (ulong)(param_2 + param_1[1])) {
uVar1 = (param_1[3] + param_2 + param_1[1]) - 1;
lVar2 = uVar1 - uVar1 % (ulong)param_1[3];
param_1[2] = lVar2;
lVar2 = my_realloc(key_memory_DYNAMIC_STRING,*param_1,lVar2,0x10);
*param_1 = lVar2;
if (lVar2 == 0) {
return 1;
}
}
return 0;
}
|
|
1,977 | Annotate_rows_log_event::~Annotate_rows_log_event() | eloqsql/sql/log_event.cc | Annotate_rows_log_event::~Annotate_rows_log_event()
{
DBUG_ENTER("Annotate_rows_log_event::~Annotate_rows_log_event");
#ifndef MYSQL_CLIENT
if (m_saved_thd_query)
thd->set_query(m_save_thd_query_txt, m_save_thd_query_len);
else if (m_used_query_txt)
thd->reset_query();
#endif
DBUG_VOID_RETURN;
} | O0 | cpp | Annotate_rows_log_event::~Annotate_rows_log_event():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xd4d9c0
movq -0x10(%rbp), %rdi
movl $0x90, %esi
callq 0x812780
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN23Annotate_rows_log_eventD0Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
mov [rbp+var_10], rdi
call _ZN23Annotate_rows_log_eventD2Ev; Annotate_rows_log_event::~Annotate_rows_log_event()
mov rdi, [rbp+var_10]; void *
mov esi, 90h; unsigned __int64
call _ZN9Log_eventdlEPvm; Log_event::operator delete(void *,ulong)
add rsp, 10h
pop rbp
retn
| void Annotate_rows_log_event::~Annotate_rows_log_event(Annotate_rows_log_event *this)
{
Annotate_rows_log_event::~Annotate_rows_log_event(this);
Log_event::operator delete(this);
}
| create_literal_item:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x8
CALL 0x008e7810
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x8
CALL 0x008e7830
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x008ec910
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8,RAX
MOV R9B,byte ptr [RBP + -0x19]
MOV RAX,qword ptr [RDI]
AND R9B,0x1
MOVZX R9D,R9B
CALL qword ptr [RAX + 0x370]
ADD RSP,0x40
POP RBP
RET
|
/* Type_handler::create_literal_item(THD*, String const*, bool) const */
void __thiscall
Type_handler::create_literal_item(Type_handler *this,THD *param_1,String *param_2,bool param_3)
{
int4 uVar1;
int8 uVar2;
int8 uVar3;
uVar2 = Binary_string::ptr((Binary_string *)(param_2 + 8));
uVar1 = Binary_string::length((Binary_string *)(param_2 + 8));
uVar3 = Charset::charset((Charset *)param_2);
(**(code **)(*(long *)this + 0x370))(this,param_1,uVar2,uVar1,uVar3,param_3);
return;
}
|
|
1,978 | Annotate_rows_log_event::~Annotate_rows_log_event() | eloqsql/sql/log_event.cc | Annotate_rows_log_event::~Annotate_rows_log_event()
{
DBUG_ENTER("Annotate_rows_log_event::~Annotate_rows_log_event");
#ifndef MYSQL_CLIENT
if (m_saved_thd_query)
thd->set_query(m_save_thd_query_txt, m_save_thd_query_len);
else if (m_used_query_txt)
thd->reset_query();
#endif
DBUG_VOID_RETURN;
} | O3 | cpp | Annotate_rows_log_event::~Annotate_rows_log_event():
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xaa4b81(%rip), %rax # 0x146bab8
movq %rax, (%rdi)
cmpb $0x1, 0x8c(%rdi)
jne 0x9c6f71
movq 0x60(%rbx), %rdi
movq 0x80(%rbx), %rax
movl 0x88(%rbx), %ecx
movq 0xb50(%rdi), %rdx
leaq -0x20(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
callq 0x6e2a06
jmp 0x9c6f98
cmpb $0x1, 0x8d(%rbx)
jne 0x9c6f98
movq 0x60(%rbx), %rdi
leaq 0xb1951b(%rip), %rax # 0x14e04a0
leaq -0x20(%rbp), %rsi
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
callq 0x6e2a06
movq %rbx, %rdi
callq 0x6e2c3a
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x6c7e0c
nop
| _ZN23Annotate_rows_log_eventD2Ev:
push rbp; Alternative name is 'Annotate_rows_log_event::~Annotate_rows_log_event()'
mov rbp, rsp
push rbx
sub rsp, 18h
mov rbx, rdi
lea rax, off_146BAB8
mov [rdi], rax
cmp byte ptr [rdi+8Ch], 1
jnz short loc_9C6F71
mov rdi, [rbx+60h]
mov rax, [rbx+80h]
mov ecx, [rbx+88h]
mov rdx, [rdi+0B50h]
lea rsi, [rbp+var_20]
mov [rsi+10h], rdx
mov [rsi], rax
mov [rsi+8], rcx
call _ZN3THD9set_queryERK11CSET_STRING; THD::set_query(CSET_STRING const&)
jmp short loc_9C6F98
loc_9C6F71:
cmp byte ptr [rbx+8Dh], 1
jnz short loc_9C6F98
mov rdi, [rbx+60h]
lea rax, my_charset_bin
lea rsi, [rbp+var_20]
mov [rsi+10h], rax
xorps xmm0, xmm0
movaps xmmword ptr [rsi], xmm0
call _ZN3THD9set_queryERK11CSET_STRING; THD::set_query(CSET_STRING const&)
loc_9C6F98:
mov rdi, rbx; this
call _ZN9Log_eventD2Ev; Log_event::~Log_event()
add rsp, 18h
pop rbx
pop rbp
retn
mov rdi, rax
call __clang_call_terminate
| void Annotate_rows_log_event::~Annotate_rows_log_event(Annotate_rows_log_event *this)
{
long long v2; // rdi
long long v3; // rax
long long v4; // rcx
long long v5; // rdi
__int128 v6; // [rsp+0h] [rbp-20h] BYREF
signed __int32 *v7; // [rsp+10h] [rbp-10h]
*(_QWORD *)this = &off_146BAB8;
if ( *((_BYTE *)this + 140) == 1 )
{
v2 = *((_QWORD *)this + 12);
v3 = *((_QWORD *)this + 16);
v4 = *((unsigned int *)this + 34);
v7 = *(signed __int32 **)(v2 + 2896);
*(_QWORD *)&v6 = v3;
*((_QWORD *)&v6 + 1) = v4;
THD::set_query(v2, (long long)&v6);
}
else if ( *((_BYTE *)this + 141) == 1 )
{
v5 = *((_QWORD *)this + 12);
v7 = my_charset_bin;
v6 = 0LL;
THD::set_query(v5, (long long)&v6);
}
Log_event::~Log_event(this);
}
| |||
1,979 | aggregate_all_stages(PFS_stage_stat*, PFS_stage_stat*) | eloqsql/storage/perfschema/pfs_instr.cc | void aggregate_all_stages(PFS_stage_stat *from_array,
PFS_stage_stat *to_array)
{
PFS_stage_stat *from;
PFS_stage_stat *from_last;
PFS_stage_stat *to;
from= from_array;
from_last= from_array + stage_class_max;
to= to_array;
for ( ; from < from_last ; from++, to++)
{
if (from->m_timer1_stat.m_count > 0)
{
to->aggregate(from);
from->reset();
}
}
} | O0 | cpp | aggregate_all_stages(PFS_stage_stat*, PFS_stage_stat*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
leaq 0x3d908d(%rip), %rcx # 0x40a090
movq (%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3105f
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x31043
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36080
movq -0x18(%rbp), %rdi
callq 0x2d9d0
jmp 0x31045
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
jmp 0x31019
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _Z20aggregate_all_stagesP14PFS_stage_statS0_:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
lea rcx, stage_class_max
mov rcx, [rcx]
shl rcx, 5
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_31019:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_3105F
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jbe short loc_31043
mov rdi, [rbp+var_28]; this
mov rsi, [rbp+var_18]; PFS_stage_stat *
call _ZN14PFS_stage_stat9aggregateEPKS_; PFS_stage_stat::aggregate(PFS_stage_stat const*)
mov rdi, [rbp+var_18]; this
call _ZN14PFS_stage_stat5resetEv; PFS_stage_stat::reset(void)
loc_31043:
jmp short $+2
loc_31045:
mov rax, [rbp+var_18]
add rax, 20h ; ' '
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, 20h ; ' '
mov [rbp+var_28], rax
jmp short loc_31019
loc_3105F:
add rsp, 30h
pop rbp
retn
| PFS_stage_stat * aggregate_all_stages(PFS_stage_stat *a1, PFS_stage_stat *a2)
{
PFS_stage_stat *result; // rax
PFS_stage_stat *v4; // [rsp+10h] [rbp-20h]
PFS_stage_stat *v5; // [rsp+18h] [rbp-18h]
v5 = a1;
v4 = (PFS_stage_stat *)((char *)a1 + 32 * stage_class_max);
while ( 1 )
{
result = v5;
if ( v5 >= v4 )
break;
if ( *(_QWORD *)v5 )
{
PFS_stage_stat::aggregate(a2, v5);
PFS_stage_stat::reset(v5);
}
v5 = (PFS_stage_stat *)((char *)v5 + 32);
a2 = (PFS_stage_stat *)((char *)a2 + 32);
}
return result;
}
| aggregate_all_stages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x50a090]
MOV RCX,qword ptr [RCX]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_00131019:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0013105f
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JBE 0x00131043
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00136080
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012d9d0
LAB_00131043:
JMP 0x00131045
LAB_00131045:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x20
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x20
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00131019
LAB_0013105f:
ADD RSP,0x30
POP RBP
RET
|
/* aggregate_all_stages(PFS_stage_stat*, PFS_stage_stat*) */
void aggregate_all_stages(PFS_stage_stat *param_1,PFS_stage_stat *param_2)
{
long lVar1;
PFS_stage_stat *local_30;
PFS_stage_stat *local_20;
lVar1 = stage_class_max * 0x20;
local_30 = param_2;
for (local_20 = param_1; local_20 < param_1 + lVar1; local_20 = local_20 + 0x20) {
if (*(long *)local_20 != 0) {
PFS_stage_stat::aggregate(local_30,local_20);
PFS_stage_stat::reset(local_20);
}
local_30 = local_30 + 0x20;
}
return;
}
|
|
1,980 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const | llama.cpp/common/json.hpp | pointer operator->() const
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
return &(m_it.object_iterator->second);
}
case value_t::array:
{
JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
return &*m_it.array_iterator;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
{
return m_object;
}
JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
}
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0xeae40
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0xeada3
cmpl $0x1, %ecx
jne 0xeadd0
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%r14), %rax
cmpq %rcx, %rax
je 0xeae5c
addq $0x40, %rax
jmp 0xeadd7
movq 0x8(%rax), %rcx
movq 0x10(%r14), %rax
cmpq 0x8(%rcx), %rax
jne 0xeadd7
leaq 0x9748c(%rip), %rdi # 0x182244
leaq 0x88053(%rip), %rdx # 0x172e12
leaq 0x8a634(%rip), %rcx # 0x1753fa
movl $0x3397, %esi # imm = 0x3397
jmp 0xeae76
cmpq $0x0, 0x18(%r14)
jne 0xeade2
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x25790
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8a638(%rip), %rsi # 0x175437
leaq 0x8a641(%rip), %rdx # 0x175447
leaq 0x8(%rsp), %rdi
callq 0x52736
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0xebd32
xorl %ebp, %ebp
leaq 0xefc17(%rip), %rsi # 0x1daa48
leaq -0x66bd6(%rip), %rdx # 0x84262
movq %rbx, %rdi
callq 0x25c00
leaq 0x973fd(%rip), %rdi # 0x182244
leaq 0x87fc4(%rip), %rdx # 0x172e12
leaq 0x8a528(%rip), %rcx # 0x17537d
movl $0x338b, %esi # imm = 0x338B
jmp 0xeae76
leaq 0x973e1(%rip), %rdi # 0x182244
leaq 0x87fa8(%rip), %rdx # 0x172e12
leaq 0x8a54a(%rip), %rcx # 0x1753bb
movl $0x3391, %esi # imm = 0x3391
xorl %eax, %eax
callq 0x26090
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xeae97
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0xeaea1
jmp 0xeaea9
movq %rax, %r14
movq %rbx, %rdi
callq 0x26150
movq %r14, %rdi
callq 0x25ca0
nop
| _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz loc_EAE40
mov r14, rdi
movzx ecx, byte ptr [rax]
cmp ecx, 2
jz short loc_EADA3
cmp ecx, 1
jnz short loc_EADD0
mov rcx, [rax+8]
add rcx, 8
mov rax, [r14+8]
cmp rax, rcx
jz loc_EAE5C
add rax, 40h ; '@'
jmp short loc_EADD7
loc_EADA3:
mov rcx, [rax+8]
mov rax, [r14+10h]
cmp rax, [rcx+8]
jnz short loc_EADD7
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItArrayIterat; "m_it.array_iterator != m_object->m_data"...
mov esi, 3397h
jmp loc_EAE76
loc_EADD0:
cmp qword ptr [r14+18h], 0
jnz short loc_EADE2
loc_EADD7:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_EADE2:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotGetValue; "cannot get value"
lea rdx, aCannotGetValue+10h; ""
lea rdi, [rsp+48h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0D6h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_EAE40:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 338Bh
jmp short loc_EAE76
loc_EAE5C:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItObjectItera; "m_it.object_iterator != m_object->m_dat"...
mov esi, 3391h
loc_EAE76:
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_EAE97
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_EAE97:
test bpl, bpl
jnz short loc_EAEA1
jmp short loc_EAEA9
mov r14, rax
loc_EAEA1:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_EAEA9:
mov rdi, r14
call __Unwind_Resume
| operator->:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001eae40
MOV R14,RDI
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x2
JZ 0x001eada3
CMP ECX,0x1
JNZ 0x001eadd0
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,0x8
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,RCX
JZ 0x001eae5c
ADD RAX,0x40
JMP 0x001eadd7
LAB_001eada3:
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RCX + 0x8]
JNZ 0x001eadd7
LEA RDI,[0x282244]
LEA RDX,[0x272e12]
LEA RCX,[0x2753fa]
MOV ESI,0x3397
JMP 0x001eae76
LAB_001eadd0:
CMP qword ptr [R14 + 0x18],0x0
JNZ 0x001eade2
LAB_001eadd7:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001eade2:
MOV EDI,0x20
CALL 0x00125790
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001eadf8:
LEA RSI,[0x275437]
LEA RDX,[0x275447]
LEA RDI,[RSP + 0x8]
CALL 0x00152736
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_001eae16:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xd6
CALL 0x001ebd32
XOR EBP,EBP
LEA RSI,[0x2daa48]
LEA RDX,[0x184262]
MOV RDI,RBX
CALL 0x00125c00
LAB_001eae40:
LEA RDI,[0x282244]
LEA RDX,[0x272e12]
LEA RCX,[0x27537d]
MOV ESI,0x338b
JMP 0x001eae76
LAB_001eae5c:
LEA RDI,[0x282244]
LEA RDX,[0x272e12]
LEA RCX,[0x2753bb]
MOV ESI,0x3391
LAB_001eae76:
XOR EAX,EAX
CALL 0x00126090
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() const */
char * __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long *plVar1;
char *pcVar2;
int8 uVar3;
int1 *local_40 [2];
int1 local_30 [16];
pcVar2 = *(char **)this;
if (pcVar2 == (char *)0x0) {
pcVar2 = "m_object != nullptr";
uVar3 = 0x338b;
LAB_001eae76:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
if (*pcVar2 == '\x02') {
plVar1 = (long *)(pcVar2 + 8);
pcVar2 = *(char **)(this + 0x10);
if (pcVar2 == *(char **)(*plVar1 + 8)) {
pcVar2 = "m_it.array_iterator != m_object->m_data.m_value.array->end()";
uVar3 = 0x3397;
goto LAB_001eae76;
}
}
else if (*pcVar2 == '\x01') {
if (*(long *)(this + 8) == *(long *)(pcVar2 + 8) + 8) {
pcVar2 = "m_it.object_iterator != m_object->m_data.m_value.object->end()";
uVar3 = 0x3391;
goto LAB_001eae76;
}
pcVar2 = (char *)(*(long *)(this + 8) + 0x40);
}
else if (*(long *)(this + 0x18) != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 001eadf8 to 001eae0f has its CatchHandler @ 001eae9e */
std::__cxx11::string::_M_construct<char_const*>(local_40,"cannot get value","");
/* try { // try from 001eae16 to 001eae3f has its CatchHandler @ 001eae7d */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd6,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&invalid_iterator::typeinfo,exception::~exception);
}
return pcVar2;
}
|
||
1,981 | my_8bit_charset_flags_from_data | eloqsql/strings/ctype-simple.c | uint my_8bit_charset_flags_from_data(CHARSET_INFO *cs)
{
uint flags= 0;
if (my_charset_is_8bit_pure_ascii(cs))
flags|= MY_CS_PUREASCII;
if (!my_charset_is_ascii_compatible(cs))
flags|= MY_CS_NONASCII;
return flags;
} | O0 | c | my_8bit_charset_flags_from_data:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x127fe0
cmpb $0x0, %al
je 0x127fbb
movl -0xc(%rbp), %eax
orl $0x1000, %eax # imm = 0x1000
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x128040
cmpb $0x0, %al
jne 0x127fd3
movl -0xc(%rbp), %eax
orl $0x2000, %eax # imm = 0x2000
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| my_8bit_charset_flags_from_data:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rdi, [rbp+var_8]
call my_charset_is_8bit_pure_ascii
cmp al, 0
jz short loc_127FBB
mov eax, [rbp+var_C]
or eax, 1000h
mov [rbp+var_C], eax
loc_127FBB:
mov rdi, [rbp+var_8]
call my_charset_is_ascii_compatible
cmp al, 0
jnz short loc_127FD3
mov eax, [rbp+var_C]
or eax, 2000h
mov [rbp+var_C], eax
loc_127FD3:
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
| long long my_8bit_charset_flags_from_data(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-Ch]
v2 = 0;
if ( (unsigned __int8)my_charset_is_8bit_pure_ascii(a1) )
v2 = 4096;
if ( !(unsigned __int8)my_charset_is_ascii_compatible(a1) )
v2 |= 0x2000u;
return v2;
}
| |||
1,982 | my_8bit_charset_flags_from_data | eloqsql/strings/ctype-simple.c | uint my_8bit_charset_flags_from_data(CHARSET_INFO *cs)
{
uint flags= 0;
if (my_charset_is_8bit_pure_ascii(cs))
flags|= MY_CS_PUREASCII;
if (!my_charset_is_ascii_compatible(cs))
flags|= MY_CS_NONASCII;
return flags;
} | O3 | c | my_8bit_charset_flags_from_data:
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0xbeb8c
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
xorl %edx, %edx
cmpw $0x80, (%rcx,%rdx,2)
jae 0xbeb73
incq %rdx
cmpq $0x100, %rdx # imm = 0x100
jne 0xbeb5a
movl $0x1000, %eax # imm = 0x1000
xorl %edx, %edx
movzwl (%rcx,%rdx,2), %esi
cmpq %rsi, %rdx
jne 0xbeb8f
incq %rdx
cmpq $0x80, %rdx
jne 0xbeb75
jmp 0xbeb94
xorl %eax, %eax
retq
orl $0x2000, %eax # imm = 0x2000
popq %rbp
retq
| my_8bit_charset_flags_from_data:
mov rcx, [rdi+68h]
test rcx, rcx
jz short loc_BEB8C
push rbp
mov rbp, rsp
xor eax, eax
xor edx, edx
loc_BEB5A:
cmp word ptr [rcx+rdx*2], 80h
jnb short loc_BEB73
inc rdx
cmp rdx, 100h
jnz short loc_BEB5A
mov eax, 1000h
loc_BEB73:
xor edx, edx
loc_BEB75:
movzx esi, word ptr [rcx+rdx*2]
cmp rdx, rsi
jnz short loc_BEB8F
inc rdx
cmp rdx, 80h
jnz short loc_BEB75
jmp short loc_BEB94
loc_BEB8C:
xor eax, eax
retn
loc_BEB8F:
or eax, 2000h
loc_BEB94:
pop rbp
retn
| long long my_8bit_charset_flags_from_data(long long a1)
{
long long v1; // rcx
long long result; // rax
long long v3; // rdx
long long v4; // rdx
v1 = *(_QWORD *)(a1 + 104);
if ( !v1 )
return 0LL;
result = 0LL;
v3 = 0LL;
while ( *(_WORD *)(v1 + 2 * v3) < 0x80u )
{
if ( ++v3 == 256 )
{
result = 4096LL;
break;
}
}
v4 = 0LL;
while ( v4 == *(unsigned __int16 *)(v1 + 2 * v4) )
{
if ( ++v4 == 128 )
return result;
}
return (unsigned int)result | 0x2000;
}
| my_8bit_charset_flags_from_data:
MOV RCX,qword ptr [RDI + 0x68]
TEST RCX,RCX
JZ 0x001beb8c
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
XOR EDX,EDX
LAB_001beb5a:
CMP word ptr [RCX + RDX*0x2],0x80
JNC 0x001beb73
INC RDX
CMP RDX,0x100
JNZ 0x001beb5a
MOV EAX,0x1000
LAB_001beb73:
XOR EDX,EDX
LAB_001beb75:
MOVZX ESI,word ptr [RCX + RDX*0x2]
CMP RDX,RSI
JNZ 0x001beb8f
INC RDX
CMP RDX,0x80
JNZ 0x001beb75
JMP 0x001beb94
LAB_001beb8c:
XOR EAX,EAX
RET
LAB_001beb8f:
OR EAX,0x2000
LAB_001beb94:
POP RBP
RET
|
uint my_8bit_charset_flags_from_data(long param_1)
{
long lVar1;
uint uVar2;
long lVar3;
ulong uVar4;
lVar1 = *(long *)(param_1 + 0x68);
if (lVar1 == 0) {
return 0;
}
uVar2 = 0;
lVar3 = 0;
do {
if (0x7f < *(ushort *)(lVar1 + lVar3 * 2)) goto LAB_001beb73;
lVar3 = lVar3 + 1;
} while (lVar3 != 0x100);
uVar2 = 0x1000;
LAB_001beb73:
uVar4 = 0;
do {
if (uVar4 != *(ushort *)(lVar1 + uVar4 * 2)) {
return uVar2 | 0x2000;
}
uVar4 = uVar4 + 1;
} while (uVar4 != 0x80);
return uVar2;
}
|
|
1,983 | stbi__high_bit(unsigned int) | SDL3Lite/dependencies/stb_image.h | static int stbi__high_bit(unsigned int z)
{
int n=0;
if (z == 0) return -1;
if (z >= 0x10000) { n += 16; z >>= 16; }
if (z >= 0x00100) { n += 8; z >>= 8; }
if (z >= 0x00010) { n += 4; z >>= 4; }
if (z >= 0x00004) { n += 2; z >>= 2; }
if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
return n;
} | O0 | c | stbi__high_bit(unsigned int):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x3214d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x321c8
cmpl $0x10000, -0x8(%rbp) # imm = 0x10000
jb 0x32168
movl -0xc(%rbp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp) # imm = 0x100
jb 0x32183
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jb 0x3219b
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rbp)
cmpl $0x4, -0x8(%rbp)
jb 0x321b3
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rbp)
cmpl $0x2, -0x8(%rbp)
jb 0x321c2
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| _ZL14stbi__high_bitj:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
mov [rbp+var_C], 0
cmp [rbp+var_8], 0
jnz short loc_3214D
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_321C8
loc_3214D:
cmp [rbp+var_8], 10000h
jb short loc_32168
mov eax, [rbp+var_C]
add eax, 10h
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shr eax, 10h
mov [rbp+var_8], eax
loc_32168:
cmp [rbp+var_8], 100h
jb short loc_32183
mov eax, [rbp+var_C]
add eax, 8
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shr eax, 8
mov [rbp+var_8], eax
loc_32183:
cmp [rbp+var_8], 10h
jb short loc_3219B
mov eax, [rbp+var_C]
add eax, 4
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shr eax, 4
mov [rbp+var_8], eax
loc_3219B:
cmp [rbp+var_8], 4
jb short loc_321B3
mov eax, [rbp+var_C]
add eax, 2
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
shr eax, 2
mov [rbp+var_8], eax
loc_321B3:
cmp [rbp+var_8], 2
jb short loc_321C2
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_C], eax
loc_321C2:
mov eax, [rbp+var_C]
mov [rbp+var_4], eax
loc_321C8:
mov eax, [rbp+var_4]
pop rbp
retn
| long long stbi__high_bit(unsigned int a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
unsigned int v3; // [rsp+4h] [rbp-8h]
v3 = a1;
v2 = 0;
if ( a1 )
{
if ( a1 >= 0x10000 )
{
v2 = 16;
v3 = HIWORD(a1);
}
if ( v3 >= 0x100 )
{
v2 += 8;
v3 >>= 8;
}
if ( v3 >= 0x10 )
{
v2 += 4;
v3 >>= 4;
}
if ( v3 >= 4 )
{
v2 += 2;
v3 >>= 2;
}
if ( v3 >= 2 )
++v2;
return v2;
}
else
{
return (unsigned int)-1;
}
}
| stbi__high_bit:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],0x0
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x0013214d
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001321c8
LAB_0013214d:
CMP dword ptr [RBP + -0x8],0x10000
JC 0x00132168
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x10
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x10
MOV dword ptr [RBP + -0x8],EAX
LAB_00132168:
CMP dword ptr [RBP + -0x8],0x100
JC 0x00132183
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x8
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x8
MOV dword ptr [RBP + -0x8],EAX
LAB_00132183:
CMP dword ptr [RBP + -0x8],0x10
JC 0x0013219b
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x4
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x4
MOV dword ptr [RBP + -0x8],EAX
LAB_0013219b:
CMP dword ptr [RBP + -0x8],0x4
JC 0x001321b3
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x2
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x2
MOV dword ptr [RBP + -0x8],EAX
LAB_001321b3:
CMP dword ptr [RBP + -0x8],0x2
JC 0x001321c2
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
LAB_001321c2:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
LAB_001321c8:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
/* stbi__high_bit(unsigned int) */
int stbi__high_bit(uint param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
if (param_1 == 0) {
local_c = -1;
}
else {
local_10 = param_1;
if (0xffff < param_1) {
local_14 = 0x10;
local_10 = param_1 >> 0x10;
}
if (0xff < local_10) {
local_14 = local_14 + 8;
local_10 = local_10 >> 8;
}
if (0xf < local_10) {
local_14 = local_14 + 4;
local_10 = local_10 >> 4;
}
if (3 < local_10) {
local_14 = local_14 + 2;
local_10 = local_10 >> 2;
}
if (1 < local_10) {
local_14 = local_14 + 1;
}
local_c = local_14;
}
return local_c;
}
|
|
1,984 | stbi__high_bit(unsigned int) | SDL3Lite/dependencies/stb_image.h | static int stbi__high_bit(unsigned int z)
{
int n=0;
if (z == 0) return -1;
if (z >= 0x10000) { n += 16; z >>= 16; }
if (z >= 0x00100) { n += 8; z >>= 8; }
if (z >= 0x00010) { n += 4; z >>= 4; }
if (z >= 0x00004) { n += 2; z >>= 2; }
if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
return n;
} | O3 | c | stbi__high_bit(unsigned int):
movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x32880
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x32914
cmpl $0x10000, -0x8(%rsp) # imm = 0x10000
jb 0x328a0
movl -0xc(%rsp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rsp)
cmpl $0x100, -0x8(%rsp) # imm = 0x100
jb 0x328c0
movl -0xc(%rsp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rsp)
cmpl $0x10, -0x8(%rsp)
jb 0x328dd
movl -0xc(%rsp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rsp)
cmpl $0x4, -0x8(%rsp)
jb 0x328fa
movl -0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rsp)
cmpl $0x2, -0x8(%rsp)
jb 0x3290c
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
| _ZL14stbi__high_bitj:
mov [rsp+var_8], edi
mov [rsp+var_C], 0
cmp [rsp+var_8], 0
jnz short loc_32880
mov [rsp+var_4], 0FFFFFFFFh
jmp loc_32914
loc_32880:
cmp [rsp+var_8], 10000h
jb short loc_328A0
mov eax, [rsp+var_C]
add eax, 10h
mov [rsp+var_C], eax
mov eax, [rsp+var_8]
shr eax, 10h
mov [rsp+var_8], eax
loc_328A0:
cmp [rsp+var_8], 100h
jb short loc_328C0
mov eax, [rsp+var_C]
add eax, 8
mov [rsp+var_C], eax
mov eax, [rsp+var_8]
shr eax, 8
mov [rsp+var_8], eax
loc_328C0:
cmp [rsp+var_8], 10h
jb short loc_328DD
mov eax, [rsp+var_C]
add eax, 4
mov [rsp+var_C], eax
mov eax, [rsp+var_8]
shr eax, 4
mov [rsp+var_8], eax
loc_328DD:
cmp [rsp+var_8], 4
jb short loc_328FA
mov eax, [rsp+var_C]
add eax, 2
mov [rsp+var_C], eax
mov eax, [rsp+var_8]
shr eax, 2
mov [rsp+var_8], eax
loc_328FA:
cmp [rsp+var_8], 2
jb short loc_3290C
mov eax, [rsp+var_C]
add eax, 1
mov [rsp+var_C], eax
loc_3290C:
mov eax, [rsp+var_C]
mov [rsp+var_4], eax
loc_32914:
mov eax, [rsp+var_4]
retn
| long long stbi__high_bit(unsigned int a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
unsigned int v3; // [rsp+4h] [rbp-8h]
v3 = a1;
v2 = 0;
if ( a1 )
{
if ( a1 >= 0x10000 )
{
v2 = 16;
v3 = HIWORD(a1);
}
if ( v3 >= 0x100 )
{
v2 += 8;
v3 >>= 8;
}
if ( v3 >= 0x10 )
{
v2 += 4;
v3 >>= 4;
}
if ( v3 >= 4 )
{
v2 += 2;
v3 >>= 2;
}
if ( v3 >= 2 )
++v2;
return v2;
}
else
{
return (unsigned int)-1;
}
}
| stbi__high_bit:
MOV dword ptr [RSP + -0x8],EDI
MOV dword ptr [RSP + -0xc],0x0
CMP dword ptr [RSP + -0x8],0x0
JNZ 0x00132880
MOV dword ptr [RSP + -0x4],0xffffffff
JMP 0x00132914
LAB_00132880:
CMP dword ptr [RSP + -0x8],0x10000
JC 0x001328a0
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x10
MOV dword ptr [RSP + -0xc],EAX
MOV EAX,dword ptr [RSP + -0x8]
SHR EAX,0x10
MOV dword ptr [RSP + -0x8],EAX
LAB_001328a0:
CMP dword ptr [RSP + -0x8],0x100
JC 0x001328c0
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x8
MOV dword ptr [RSP + -0xc],EAX
MOV EAX,dword ptr [RSP + -0x8]
SHR EAX,0x8
MOV dword ptr [RSP + -0x8],EAX
LAB_001328c0:
CMP dword ptr [RSP + -0x8],0x10
JC 0x001328dd
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x4
MOV dword ptr [RSP + -0xc],EAX
MOV EAX,dword ptr [RSP + -0x8]
SHR EAX,0x4
MOV dword ptr [RSP + -0x8],EAX
LAB_001328dd:
CMP dword ptr [RSP + -0x8],0x4
JC 0x001328fa
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x2
MOV dword ptr [RSP + -0xc],EAX
MOV EAX,dword ptr [RSP + -0x8]
SHR EAX,0x2
MOV dword ptr [RSP + -0x8],EAX
LAB_001328fa:
CMP dword ptr [RSP + -0x8],0x2
JC 0x0013290c
MOV EAX,dword ptr [RSP + -0xc]
ADD EAX,0x1
MOV dword ptr [RSP + -0xc],EAX
LAB_0013290c:
MOV EAX,dword ptr [RSP + -0xc]
MOV dword ptr [RSP + -0x4],EAX
LAB_00132914:
MOV EAX,dword ptr [RSP + -0x4]
RET
|
/* stbi__high_bit(unsigned int) */
int stbi__high_bit(uint param_1)
{
int4 local_c;
int4 local_8;
int4 local_4;
local_c = 0;
if (param_1 == 0) {
local_4 = -1;
}
else {
local_8 = param_1;
if (0xffff < param_1) {
local_c = 0x10;
local_8 = param_1 >> 0x10;
}
if (0xff < local_8) {
local_c = local_c + 8;
local_8 = local_8 >> 8;
}
if (0xf < local_8) {
local_c = local_c + 4;
local_8 = local_8 >> 4;
}
if (3 < local_8) {
local_c = local_c + 2;
local_8 = local_8 >> 2;
}
if (1 < local_8) {
local_c = local_c + 1;
}
local_4 = local_c;
}
return local_4;
}
|
|
1,985 | test_if_hard_path | eloqsql/mysys/my_getwd.c | int test_if_hard_path(register const char *dir_name)
{
if (dir_name[0] == FN_HOMELIB && dir_name[1] == FN_LIBCHAR)
return (home_dir != NullS && test_if_hard_path(home_dir));
if (dir_name[0] == FN_LIBCHAR)
return (TRUE);
#ifdef FN_DEVCHAR
return (strchr(dir_name,FN_DEVCHAR) != 0);
#else
return FALSE;
#endif
} | O0 | c | test_if_hard_path:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jne 0xefdec
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0xefdec
xorl %eax, %eax
leaq 0xb91bda(%rip), %rcx # 0xc81998
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0xefddf
leaq 0xb91bca(%rip), %rax # 0xc81998
movq (%rax), %rdi
callq 0xefd90
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xefe08
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xefe01
movl $0x1, -0x4(%rbp)
jmp 0xefe08
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| test_if_hard_path:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 7Eh ; '~'
jnz short loc_EFDEC
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax+1]
cmp eax, 2Fh ; '/'
jnz short loc_EFDEC
xor eax, eax
lea rcx, home_dir
cmp qword ptr [rcx], 0
mov [rbp+var_11], al
jz short loc_EFDDF
lea rax, home_dir
mov rdi, [rax]
call test_if_hard_path
cmp eax, 0
setnz al
mov [rbp+var_11], al
loc_EFDDF:
mov al, [rbp+var_11]
and al, 1
movzx eax, al
mov [rbp+var_4], eax
jmp short loc_EFE08
loc_EFDEC:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_EFE01
mov [rbp+var_4], 1
jmp short loc_EFE08
loc_EFE01:
mov [rbp+var_4], 0
loc_EFE08:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| _BOOL8 test_if_hard_path(char *a1)
{
bool v2; // [rsp+Fh] [rbp-11h]
if ( *a1 == 126 && a1[1] == 47 )
{
v2 = 0;
if ( home_dir )
return (unsigned int)test_if_hard_path(home_dir) != 0;
return v2;
}
else
{
return *a1 == 47;
}
}
| test_if_hard_path:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7e
JNZ 0x001efdec
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX + 0x1]
CMP EAX,0x2f
JNZ 0x001efdec
XOR EAX,EAX
LEA RCX,[0xd81998]
CMP qword ptr [RCX],0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x001efddf
LEA RAX,[0xd81998]
MOV RDI,qword ptr [RAX]
CALL 0x001efd90
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x11],AL
LAB_001efddf:
MOV AL,byte ptr [RBP + -0x11]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001efe08
LAB_001efdec:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001efe01
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001efe08
LAB_001efe01:
MOV dword ptr [RBP + -0x4],0x0
LAB_001efe08:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
bool test_if_hard_path(char *param_1)
{
int iVar1;
bool local_19;
if ((*param_1 == '~') && (param_1[1] == '/')) {
local_19 = false;
if (home_dir != 0) {
iVar1 = test_if_hard_path(home_dir);
local_19 = iVar1 != 0;
}
}
else if (*param_1 == '/') {
local_19 = true;
}
else {
local_19 = false;
}
return local_19;
}
|
|
1,986 | my_xml_leave | eloqsql/strings/xml.c | static int my_xml_leave(MY_XML_PARSER *p, const char *str, size_t slen)
{
char *e, *tag;
size_t glen;
char s[32];
char g[32];
int rc;
/* Find previous '/' or beginning */
for (e= p->attr.end; (e > p->attr.start) && (e[0] != '/') ; e--);
glen= (size_t) ((e[0] == '/') ? (p->attr.end - e - 1) : p->attr.end - e);
tag= e[0] == '/' ? e + 1 : e;
if (str && (slen != glen || memcmp(str, tag, slen)))
{
mstr(s,str,sizeof(s)-1,slen);
if (glen)
{
mstr(g, tag, sizeof(g)-1, glen);
sprintf(p->errstr,"'</%s>' unexpected ('</%s>' wanted)",s,g);
}
else
sprintf(p->errstr,"'</%s>' unexpected (END-OF-INPUT wanted)", s);
return MY_XML_ERROR;
}
if (p->flags & MY_XML_FLAG_RELATIVE_NAMES)
rc= p->leave_xml ? p->leave_xml(p, str, slen) : MY_XML_OK;
else
rc= (p->leave_xml ?
p->leave_xml(p, p->attr.start, p->attr.end - p->attr.start) :
MY_XML_OK);
*e='\0';
p->attr.end= e;
return rc;
} | O3 | c | my_xml_leave:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x118(%rdi), %r13
movq 0x120(%rdi), %rax
movq %rax, %rdx
movq %rax, %r12
subq %r13, %rdx
movq %rdi, -0x78(%rbp)
jbe 0x5a2e8
movq %rax, %r12
cmpb $0x2f, (%r12)
je 0x5a2ef
decq %r12
cmpq %r13, %r12
ja 0x5a2d6
movq %r13, %r12
cmpb $0x2f, (%r12)
jne 0x5a300
movq %r12, %rbx
notq %rbx
addq %rax, %rbx
movl $0x1, %r15d
jmp 0x5a309
subq %r12, %rax
xorl %r15d, %r15d
movq %rax, %rbx
testq %rsi, %rsi
je 0x5a3c8
addq %r12, %r15
cmpq %r14, %rbx
jne 0x5a346
movq %rsi, %rdi
movq %rsi, -0x88(%rbp)
movq %r15, %rsi
movq %rdx, -0x80(%rbp)
movq %r14, %rdx
callq 0x242d0
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
testl %eax, %eax
je 0x5a3c8
cmpq $0x1f, %r14
movl $0x1f, %r12d
cmovaeq %r12, %r14
leaq -0x50(%rbp), %rdi
movl $0x20, %ecx
movq %r14, %rdx
callq 0x245a0
movb $0x0, -0x50(%rbp,%r14)
testq %rbx, %rbx
je 0x5a3f7
cmpq $0x1f, %rbx
cmovbq %rbx, %r12
leaq -0x70(%rbp), %r13
movl $0x20, %ecx
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x245a0
movb $0x0, -0x70(%rbp,%r12)
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
leaq 0x55e7(%rip), %rcx # 0x5f98f
movl $0x1, %r14d
leaq -0x50(%rbp), %r8
movl $0x80, %edx
movl $0x1, %esi
movq %r13, %r9
xorl %eax, %eax
callq 0x241b0
jmp 0x5a432
movq -0x78(%rbp), %rbx
testb $0x1, (%rbx)
movq 0x158(%rbx), %rax
jne 0x5a3e5
testq %rax, %rax
je 0x5a423
movq %rbx, %rdi
movq %r13, %rsi
jmp 0x5a3f0
testq %rax, %rax
je 0x5a423
movq %rbx, %rdi
movq %r14, %rdx
callq *%rax
movl %eax, %r14d
jmp 0x5a426
movq -0x78(%rbp), %rdi
addq $0x8, %rdi
leaq 0x55ad(%rip), %rcx # 0x5f9b3
movl $0x1, %r14d
leaq -0x50(%rbp), %r8
movl $0x80, %edx
movl $0x1, %esi
xorl %eax, %eax
callq 0x241b0
jmp 0x5a432
xorl %r14d, %r14d
movb $0x0, (%r12)
movq %r12, 0x120(%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x5a453
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24340
| my_xml_leave:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, rdx
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13, [rdi+118h]
mov rax, [rdi+120h]
mov rdx, rax
mov r12, rax
sub rdx, r13
mov [rbp+var_78], rdi
jbe short loc_5A2E8
mov r12, rax
loc_5A2D6:
cmp byte ptr [r12], 2Fh ; '/'
jz short loc_5A2EF
dec r12
cmp r12, r13
ja short loc_5A2D6
mov r12, r13
loc_5A2E8:
cmp byte ptr [r12], 2Fh ; '/'
jnz short loc_5A300
loc_5A2EF:
mov rbx, r12
not rbx
add rbx, rax
mov r15d, 1
jmp short loc_5A309
loc_5A300:
sub rax, r12
xor r15d, r15d
mov rbx, rax
loc_5A309:
test rsi, rsi
jz loc_5A3C8
add r15, r12
cmp rbx, r14
jnz short loc_5A346
mov rdi, rsi
mov [rbp+var_88], rsi
mov rsi, r15
mov [rbp+var_80], rdx
mov rdx, r14
call _bcmp
mov rdx, [rbp+var_80]
mov rsi, [rbp+var_88]
test eax, eax
jz loc_5A3C8
loc_5A346:
cmp r14, 1Fh
mov r12d, 1Fh
cmovnb r14, r12
lea rdi, [rbp+var_50]
mov ecx, 20h ; ' '
mov rdx, r14
call ___memcpy_chk
mov [rbp+r14+var_50], 0
test rbx, rbx
jz loc_5A3F7
cmp rbx, 1Fh
cmovb r12, rbx
lea r13, [rbp+var_70]
mov ecx, 20h ; ' '
mov rdi, r13
mov rsi, r15
mov rdx, r12
call ___memcpy_chk
mov [rbp+r12+var_70], 0
mov rdi, [rbp+var_78]
add rdi, 8
lea rcx, aSUnexpectedSWa; "'</%s>' unexpected ('</%s>' wanted)"
mov r14d, 1
lea r8, [rbp+var_50]
mov edx, 80h
mov esi, 1
mov r9, r13
xor eax, eax
call ___sprintf_chk
jmp short loc_5A432
loc_5A3C8:
mov rbx, [rbp+var_78]
test byte ptr [rbx], 1
mov rax, [rbx+158h]
jnz short loc_5A3E5
test rax, rax
jz short loc_5A423
mov rdi, rbx
mov rsi, r13
jmp short loc_5A3F0
loc_5A3E5:
test rax, rax
jz short loc_5A423
mov rdi, rbx
mov rdx, r14
loc_5A3F0:
call rax
mov r14d, eax
jmp short loc_5A426
loc_5A3F7:
mov rdi, [rbp+var_78]
add rdi, 8
lea rcx, aSUnexpectedEnd; "'</%s>' unexpected (END-OF-INPUT wanted"...
mov r14d, 1
lea r8, [rbp+var_50]
mov edx, 80h
mov esi, 1
xor eax, eax
call ___sprintf_chk
jmp short loc_5A432
loc_5A423:
xor r14d, r14d
loc_5A426:
mov byte ptr [r12], 0
mov [rbx+120h], r12
loc_5A432:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_5A453
mov eax, r14d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5A453:
call ___stack_chk_fail
| long long my_xml_leave(long long a1, unsigned long long a2, unsigned long long a3)
{
unsigned long long v4; // r13
_BYTE *v5; // rax
unsigned long long v6; // r12
unsigned long long v7; // rdx
unsigned long long v8; // rbx
long long v9; // r15
_BYTE *v10; // r15
int v11; // eax
long long v12; // r12
unsigned int v13; // r14d
long long ( *v14)(long long, unsigned long long, unsigned long long); // rax
_BYTE *v16; // [rsp+10h] [rbp-80h]
char v17[32]; // [rsp+20h] [rbp-70h] BYREF
char v18[32]; // [rsp+40h] [rbp-50h] BYREF
unsigned long long v19; // [rsp+60h] [rbp-30h]
v19 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a1 + 280);
v5 = *(_BYTE **)(a1 + 288);
v6 = (unsigned long long)v5;
v7 = (unsigned long long)&v5[-v4];
if ( (unsigned long long)v5 <= v4 )
{
LABEL_6:
if ( *(_BYTE *)v6 != 47 )
{
v9 = 0LL;
v8 = (unsigned long long)&v5[-v6];
goto LABEL_9;
}
}
else
{
v6 = *(_QWORD *)(a1 + 288);
while ( *(_BYTE *)v6 != 47 )
{
if ( --v6 <= v4 )
{
v6 = *(_QWORD *)(a1 + 280);
goto LABEL_6;
}
}
}
v8 = (unsigned long long)&v5[~v6];
v9 = 1LL;
LABEL_9:
if ( !a2
|| (v10 = (_BYTE *)(v6 + v9), v8 == a3)
&& (v16 = &v5[-v4], v11 = bcmp(a2, v10, a3), v7 = (unsigned long long)v16, !v11) )
{
v14 = *(long long ( **)(long long, unsigned long long, unsigned long long))(a1 + 344);
if ( (*(_BYTE *)a1 & 1) != 0 )
{
if ( v14 )
{
v7 = a3;
goto LABEL_23;
}
}
else if ( v14 )
{
a2 = v4;
LABEL_23:
v13 = v14(a1, a2, v7);
LABEL_26:
*(_BYTE *)v6 = 0;
*(_QWORD *)(a1 + 288) = v6;
return v13;
}
v13 = 0;
goto LABEL_26;
}
v12 = 31LL;
if ( a3 >= 0x1F )
a3 = 31LL;
__memcpy_chk(v18, a2, a3, 32LL);
v18[a3] = 0;
if ( v8 )
{
if ( v8 < 0x1F )
v12 = v8;
__memcpy_chk(v17, v10, v12, 32LL);
v17[v12] = 0;
v13 = 1;
__sprintf_chk(a1 + 8, 1LL, 128LL, "'</%s>' unexpected ('</%s>' wanted)", v18, v17);
}
else
{
v13 = 1;
__sprintf_chk(a1 + 8, 1LL, 128LL, "'</%s>' unexpected (END-OF-INPUT wanted)", v18);
}
return v13;
}
| my_xml_leave:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13,qword ptr [RDI + 0x118]
MOV RAX,qword ptr [RDI + 0x120]
MOV RDX,RAX
MOV R12,RAX
SUB RDX,R13
MOV qword ptr [RBP + -0x78],RDI
JBE 0x0015a2e8
MOV R12,RAX
LAB_0015a2d6:
CMP byte ptr [R12],0x2f
JZ 0x0015a2ef
DEC R12
CMP R12,R13
JA 0x0015a2d6
MOV R12,R13
LAB_0015a2e8:
CMP byte ptr [R12],0x2f
JNZ 0x0015a300
LAB_0015a2ef:
MOV RBX,R12
NOT RBX
ADD RBX,RAX
MOV R15D,0x1
JMP 0x0015a309
LAB_0015a300:
SUB RAX,R12
XOR R15D,R15D
MOV RBX,RAX
LAB_0015a309:
TEST RSI,RSI
JZ 0x0015a3c8
ADD R15,R12
CMP RBX,R14
JNZ 0x0015a346
MOV RDI,RSI
MOV qword ptr [RBP + -0x88],RSI
MOV RSI,R15
MOV qword ptr [RBP + -0x80],RDX
MOV RDX,R14
CALL 0x001242d0
MOV RDX,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x88]
TEST EAX,EAX
JZ 0x0015a3c8
LAB_0015a346:
CMP R14,0x1f
MOV R12D,0x1f
CMOVNC R14,R12
LEA RDI,[RBP + -0x50]
MOV ECX,0x20
MOV RDX,R14
CALL 0x001245a0
MOV byte ptr [RBP + R14*0x1 + -0x50],0x0
TEST RBX,RBX
JZ 0x0015a3f7
CMP RBX,0x1f
CMOVC R12,RBX
LEA R13,[RBP + -0x70]
MOV ECX,0x20
MOV RDI,R13
MOV RSI,R15
MOV RDX,R12
CALL 0x001245a0
MOV byte ptr [RBP + R12*0x1 + -0x70],0x0
MOV RDI,qword ptr [RBP + -0x78]
ADD RDI,0x8
LEA RCX,[0x15f98f]
MOV R14D,0x1
LEA R8,[RBP + -0x50]
MOV EDX,0x80
MOV ESI,0x1
MOV R9,R13
XOR EAX,EAX
CALL 0x001241b0
JMP 0x0015a432
LAB_0015a3c8:
MOV RBX,qword ptr [RBP + -0x78]
TEST byte ptr [RBX],0x1
MOV RAX,qword ptr [RBX + 0x158]
JNZ 0x0015a3e5
TEST RAX,RAX
JZ 0x0015a423
MOV RDI,RBX
MOV RSI,R13
JMP 0x0015a3f0
LAB_0015a3e5:
TEST RAX,RAX
JZ 0x0015a423
MOV RDI,RBX
MOV RDX,R14
LAB_0015a3f0:
CALL RAX
MOV R14D,EAX
JMP 0x0015a426
LAB_0015a3f7:
MOV RDI,qword ptr [RBP + -0x78]
ADD RDI,0x8
LEA RCX,[0x15f9b3]
MOV R14D,0x1
LEA R8,[RBP + -0x50]
MOV EDX,0x80
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001241b0
JMP 0x0015a432
LAB_0015a423:
XOR R14D,R14D
LAB_0015a426:
MOV byte ptr [R12],0x0
MOV qword ptr [RBX + 0x120],R12
LAB_0015a432:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0015a453
MOV EAX,R14D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015a453:
CALL 0x00124340
|
int4 my_xml_leave(byte *param_1,char *param_2,char *param_3)
{
code *pcVar1;
int iVar2;
int4 uVar3;
char *pcVar4;
ulong uVar5;
char *pcVar6;
char *pcVar7;
char *pcVar8;
char *pcVar9;
long lVar10;
long in_FS_OFFSET;
char local_78 [32];
char local_58 [32];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar7 = *(char **)(param_1 + 0x118);
pcVar6 = *(char **)(param_1 + 0x120);
pcVar4 = pcVar6 + -(long)pcVar7;
pcVar9 = pcVar6;
pcVar8 = pcVar6;
if (pcVar7 <= pcVar6 && pcVar4 != (char *)0x0) {
do {
pcVar9 = pcVar8;
if (*pcVar8 == '/') goto LAB_0015a2ef;
pcVar8 = pcVar8 + -1;
pcVar9 = pcVar7;
} while (pcVar7 < pcVar8);
}
if (*pcVar9 == '/') {
LAB_0015a2ef:
uVar5 = ~(ulong)pcVar9;
lVar10 = 1;
}
else {
uVar5 = -(long)pcVar9;
lVar10 = 0;
}
pcVar6 = pcVar6 + uVar5;
if ((param_2 != (char *)0x0) &&
((pcVar6 != param_3 || (iVar2 = bcmp(param_2,pcVar9 + lVar10,(size_t)param_3), iVar2 != 0)))) {
if ((char *)0x1e < param_3) {
param_3 = (char *)0x1f;
}
__memcpy_chk(local_58,param_2,param_3,0x20);
local_58[(long)param_3] = '\0';
if (pcVar6 == (char *)0x0) {
uVar3 = 1;
__sprintf_chk(param_1 + 8,1,0x80,"\'</%s>\' unexpected (END-OF-INPUT wanted)",local_58);
}
else {
pcVar7 = (char *)0x1f;
if (pcVar6 < (char *)0x1f) {
pcVar7 = pcVar6;
}
__memcpy_chk(local_78,pcVar9 + lVar10,pcVar7,0x20);
local_78[(long)pcVar7] = '\0';
uVar3 = 1;
__sprintf_chk(param_1 + 8,1,0x80,"\'</%s>\' unexpected (\'</%s>\' wanted)",local_58,local_78);
}
goto LAB_0015a432;
}
pcVar1 = *(code **)(param_1 + 0x158);
if ((*param_1 & 1) == 0) {
if (pcVar1 == (code *)0x0) goto LAB_0015a423;
LAB_0015a3f0:
uVar3 = (*pcVar1)(param_1,pcVar7,pcVar4);
}
else {
pcVar4 = param_3;
pcVar7 = param_2;
if (pcVar1 != (code *)0x0) goto LAB_0015a3f0;
LAB_0015a423:
uVar3 = 0;
}
*pcVar9 = '\0';
*(char **)(param_1 + 0x120) = pcVar9;
LAB_0015a432:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
|
|
1,987 | mysql_stmt_reset_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_stmt_reset_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_reset,
(parms->stmt),
parms->stmt->mysql,
my_bool,
r_my_bool)
} | O0 | c | mysql_stmt_reset_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 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2c1f0
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 (%rax,%rax)
| mysql_stmt_reset_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+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
call mysql_stmt_reset
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_stmt_reset_start_internal(long long *a1)
{
long long result; // rax
long long v2; // [rsp+0h] [rbp-20h]
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
*(_BYTE *)(v2 + 8) = mysql_stmt_reset(*a1);
result = v2;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_stmt_reset_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 + 0x38]
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 0x0012c1f0
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_stmt_reset_start_internal(long *param_1)
{
int4 *puVar1;
int1 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_reset(*param_1);
*(int1 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
1,988 | wait_for_free_space | eloqsql/mysys/errors.c | void wait_for_free_space(const char *filename, int errors)
{
if (errors == 0)
my_error(EE_DISK_FULL,MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
filename,my_errno,MY_WAIT_FOR_USER_TO_FIX_PANIC);
if (!(errors % MY_WAIT_GIVE_USER_A_MESSAGE))
my_printf_error(EE_DISK_FULL,
"Retry in %d secs. Message reprinted in %d secs",
MYF(ME_BELL | ME_ERROR_LOG | ME_WARNING),
MY_WAIT_FOR_USER_TO_FIX_PANIC,
MY_WAIT_GIVE_USER_A_MESSAGE * MY_WAIT_FOR_USER_TO_FIX_PANIC );
(void) sleep(MY_WAIT_FOR_USER_TO_FIX_PANIC);
} | O3 | c | wait_for_free_space:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
je 0x4bc75
imull $0xcccccccd, %esi, %eax # imm = 0xCCCCCCCD
movl $0x19999998, %ecx # imm = 0x19999998
addl %ecx, %eax
rorl %eax
cmpl %ecx, %eax
ja 0x4bcbc
jmp 0x4bc99
movq %rdi, %rbx
callq 0x488b6
movl (%rax), %ecx
movl $0x844, %esi # imm = 0x844
movl $0x14, %edi
movq %rbx, %rdx
movl $0x3c, %r8d
xorl %eax, %eax
callq 0x4954b
leaq 0x14e18(%rip), %rsi # 0x60ab8
movl $0x844, %edx # imm = 0x844
movl $0x14, %edi
movl $0x3c, %ecx
movl $0x258, %r8d # imm = 0x258
xorl %eax, %eax
callq 0x49665
movl $0x3c, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x241f0
| wait_for_free_space:
push rbp
mov rbp, rsp
push rbx
push rax
test esi, esi
jz short loc_4BC75
imul eax, esi, 0CCCCCCCDh
mov ecx, 19999998h
add eax, ecx
ror eax, 1
cmp eax, ecx
ja short loc_4BCBC
jmp short loc_4BC99
loc_4BC75:
mov rbx, rdi
call _my_thread_var
mov ecx, [rax]
mov esi, 844h
mov edi, 14h
mov rdx, rbx
mov r8d, 3Ch ; '<'
xor eax, eax
call my_error
loc_4BC99:
lea rsi, aRetryInDSecsMe; "Retry in %d secs. Message reprinted in "...
mov edx, 844h
mov edi, 14h
mov ecx, 3Ch ; '<'
mov r8d, 258h
xor eax, eax
call my_printf_error
loc_4BCBC:
mov edi, 3Ch ; '<'
add rsp, 8
pop rbx
pop rbp
jmp _sleep
| long long wait_for_free_space(
long long a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
unsigned int *v15; // rax
char v17; // [rsp-8h] [rbp-10h]
v17 = v14;
if ( !a2 )
{
v15 = (unsigned int *)my_thread_var();
my_error(0x14u, 2116LL, a1, *v15, 60LL);
LABEL_5:
my_printf_error(
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
20LL,
"Retry in %d secs. Message reprinted in %d secs",
2116LL,
60LL,
600LL,
a14,
v17);
return sleep(60LL);
}
if ( __ROR4__(-858993459 * a2 + 429496728, 1) <= 0x19999998u )
goto LABEL_5;
return sleep(60LL);
}
| wait_for_free_space:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
TEST ESI,ESI
JZ 0x0014bc75
IMUL EAX,ESI,-0x33333333
MOV ECX,0x19999998
ADD EAX,ECX
ROR EAX,0x1
CMP EAX,ECX
JA 0x0014bcbc
JMP 0x0014bc99
LAB_0014bc75:
MOV RBX,RDI
CALL 0x001488b6
MOV ECX,dword ptr [RAX]
MOV ESI,0x844
MOV EDI,0x14
MOV RDX,RBX
MOV R8D,0x3c
XOR EAX,EAX
CALL 0x0014954b
LAB_0014bc99:
LEA RSI,[0x160ab8]
MOV EDX,0x844
MOV EDI,0x14
MOV ECX,0x3c
MOV R8D,0x258
XOR EAX,EAX
CALL 0x00149665
LAB_0014bcbc:
MOV EDI,0x3c
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001241f0
|
void wait_for_free_space(int8 param_1,int param_2)
{
uint uVar1;
int4 *puVar2;
if (param_2 == 0) {
puVar2 = (int4 *)_my_thread_var();
my_error(0x14,0x844,param_1,*puVar2,0x3c);
}
else {
uVar1 = param_2 * -0x33333333 + 0x19999998;
if (0x19999998 < (uVar1 >> 1 | (uint)((uVar1 & 1) != 0) << 0x1f)) goto LAB_0014bcbc;
}
my_printf_error(0x14,"Retry in %d secs. Message reprinted in %d secs",0x844,0x3c,600);
LAB_0014bcbc:
sleep(0x3c);
return;
}
|
|
1,989 | my_cset_init_8bit | eloqsql/strings/ctype-simple.c | static my_bool
my_cset_init_8bit(struct charset_info_st *cs, MY_CHARSET_LOADER *loader)
{
cs->state|= my_8bit_charset_flags_from_data(cs);
cs->caseup_multiply= 1;
cs->casedn_multiply= 1;
cs->pad_char= ' ';
if (!cs->to_lower || !cs->to_upper || !cs->m_ctype || !cs->tab_to_uni)
return TRUE;
return create_fromuni(cs, loader);
} | O0 | c | my_cset_init_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7c1d0
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x94(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x95(%rax)
movq -0x10(%rbp), %rax
movb $0x20, 0xb0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x7cf92
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x7cf92
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x7cf92
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x7cf98
movb $0x1, -0x1(%rbp)
jmp 0x7cfa8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7d080
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_cset_init_8bit:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
call my_8bit_charset_flags_from_data
mov ecx, eax
mov rax, [rbp+var_10]
or ecx, [rax+0Ch]
mov [rax+0Ch], ecx
mov rax, [rbp+var_10]
mov byte ptr [rax+94h], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+95h], 1
mov rax, [rbp+var_10]
mov byte ptr [rax+0B0h], 20h ; ' '
mov rax, [rbp+var_10]
cmp qword ptr [rax+48h], 0
jz short loc_7CF92
mov rax, [rbp+var_10]
cmp qword ptr [rax+50h], 0
jz short loc_7CF92
mov rax, [rbp+var_10]
cmp qword ptr [rax+40h], 0
jz short loc_7CF92
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_7CF98
loc_7CF92:
mov [rbp+var_1], 1
jmp short loc_7CFA8
loc_7CF98:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call create_fromuni
mov [rbp+var_1], al
loc_7CFA8:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_cset_init_8bit(long long a1, long long a2)
{
*(_DWORD *)(a1 + 12) |= my_8bit_charset_flags_from_data(a1);
*(_BYTE *)(a1 + 148) = 1;
*(_BYTE *)(a1 + 149) = 1;
*(_BYTE *)(a1 + 176) = 32;
if ( *(_QWORD *)(a1 + 72) && *(_QWORD *)(a1 + 80) && *(_QWORD *)(a1 + 64) && *(_QWORD *)(a1 + 104) )
return create_fromuni(a1, a2);
else
return 1;
}
| my_cset_init_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0017c1d0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
OR ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x94],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x95],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xb0],0x20
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x0017cf92
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x0017cf92
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x0017cf92
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x0017cf98
LAB_0017cf92:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017cfa8
LAB_0017cf98:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0017d080
MOV byte ptr [RBP + -0x1],AL
LAB_0017cfa8:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_cset_init_8bit(long param_1,int8 param_2)
{
uint uVar1;
int1 local_9;
uVar1 = my_8bit_charset_flags_from_data(param_1);
*(uint *)(param_1 + 0xc) = uVar1 | *(uint *)(param_1 + 0xc);
*(int1 *)(param_1 + 0x94) = 1;
*(int1 *)(param_1 + 0x95) = 1;
*(int1 *)(param_1 + 0xb0) = 0x20;
if ((((*(long *)(param_1 + 0x48) == 0) || (*(long *)(param_1 + 0x50) == 0)) ||
(*(long *)(param_1 + 0x40) == 0)) || (*(long *)(param_1 + 0x68) == 0)) {
local_9 = 1;
}
else {
local_9 = create_fromuni(param_1,param_2);
}
return local_9;
}
|
|
1,990 | chess::Bitboard chess::movegen::seenSquares<(chess::Color::underlying)1>(chess::Board const&, chess::Bitboard) | Razamindset[P]pawnstar-chess-engine/src/engine/../chess-library/include/chess.hpp | constexpr Bitboard operator&(const Bitboard& rhs) const noexcept { return Bitboard(bits & rhs.bits); } | O3 | cpp | chess::Bitboard chess::movegen::seenSquares<(chess::Color::underlying)1>(chess::Board const&, chess::Bitboard):
movdqu 0x20(%rsi), %xmm1
movdqu 0x28(%rsi), %xmm0
movdqu 0x38(%rsi), %xmm5
movdqu 0x50(%rsi), %xmm8
pshufd $0x44, %xmm1, %xmm3 # xmm3 = xmm1[0,1,0,1]
pand %xmm8, %xmm3
movdqa %xmm3, %xmm1
psrlw $0x1, %xmm1
movdqa 0x4528(%rip), %xmm4 # 0xf660
pand %xmm4, %xmm1
psubb %xmm1, %xmm3
movdqa 0x4528(%rip), %xmm2 # 0xf670
movdqa %xmm3, %xmm1
pand %xmm2, %xmm1
psrlw $0x2, %xmm3
pand %xmm2, %xmm3
paddb %xmm1, %xmm3
movdqa %xmm3, %xmm1
psrlw $0x4, %xmm1
paddb %xmm3, %xmm1
movdqa 0x450e(%rip), %xmm6 # 0xf680
pand %xmm6, %xmm1
pxor %xmm7, %xmm7
psadbw %xmm7, %xmm1
pshufd $0xee, %xmm1, %xmm3 # xmm3 = xmm1[2,3,2,3]
pshufd $0x44, %xmm8, %xmm9 # xmm9 = xmm8[0,1,0,1]
movdqa %xmm0, %xmm10
pand %xmm9, %xmm10
pand %xmm5, %xmm9
movdqa %xmm9, %xmm11
psrlw $0x1, %xmm11
pand %xmm4, %xmm11
psubb %xmm11, %xmm9
movdqa %xmm9, %xmm11
pand %xmm2, %xmm11
psrlw $0x2, %xmm9
pand %xmm2, %xmm9
paddb %xmm11, %xmm9
movdqa %xmm9, %xmm11
psrlw $0x4, %xmm11
paddb %xmm9, %xmm11
pand %xmm6, %xmm11
psadbw %xmm7, %xmm11
movdqa %xmm10, %xmm9
psrlw $0x1, %xmm9
pand %xmm4, %xmm9
psubb %xmm9, %xmm10
movdqa %xmm10, %xmm9
pand %xmm2, %xmm9
psrlw $0x2, %xmm10
pand %xmm2, %xmm10
paddb %xmm9, %xmm10
movdqa %xmm10, %xmm9
psrlw $0x4, %xmm9
paddb %xmm10, %xmm9
pand %xmm6, %xmm9
psadbw %xmm7, %xmm9
packuswb %xmm11, %xmm9
pshufd $0xee, %xmm8, %xmm10 # xmm10 = xmm8[2,3,2,3]
movsd %xmm0, %xmm8 # xmm8 = xmm0[0],xmm8[1]
movsd %xmm10, %xmm0 # xmm0 = xmm10[0],xmm0[1]
andpd %xmm8, %xmm0
pand %xmm10, %xmm5
movdqa %xmm5, %xmm8
psrlw $0x1, %xmm8
pand %xmm4, %xmm8
psubb %xmm8, %xmm5
movdqa %xmm5, %xmm8
pand %xmm2, %xmm8
psrlw $0x2, %xmm5
pand %xmm2, %xmm5
paddb %xmm8, %xmm5
movdqa %xmm5, %xmm8
psrlw $0x4, %xmm8
paddb %xmm5, %xmm8
pand %xmm6, %xmm8
psadbw %xmm7, %xmm8
movapd %xmm0, %xmm5
psrlw $0x1, %xmm5
pand %xmm4, %xmm5
psubb %xmm5, %xmm0
movdqa %xmm0, %xmm4
pand %xmm2, %xmm4
psrlw $0x2, %xmm0
pand %xmm2, %xmm0
paddb %xmm4, %xmm0
movdqa %xmm0, %xmm2
psrlw $0x4, %xmm2
paddb %xmm0, %xmm2
pand %xmm6, %xmm2
psadbw %xmm7, %xmm2
packuswb %xmm8, %xmm2
psubd %xmm2, %xmm9
pmaddwd 0x43b2(%rip), %xmm9 # 0xf690
psubd %xmm3, %xmm1
movd %xmm1, %eax
imull $0x64, %eax, %ecx
pshufd $0xee, %xmm9, %xmm0 # xmm0 = xmm9[2,3,2,3]
paddd %xmm9, %xmm0
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
paddd %xmm0, %xmm1
movd %xmm1, %eax
addl %ecx, %eax
retq
| _ZN6Engine16evaluateMaterialERKN5chess5BoardE:
movdqu xmm1, xmmword ptr [rsi+20h]
movdqu xmm0, xmmword ptr [rsi+28h]
movdqu xmm5, xmmword ptr [rsi+38h]
movdqu xmm8, xmmword ptr [rsi+50h]
pshufd xmm3, xmm1, 44h ; 'D'
pand xmm3, xmm8
movdqa xmm1, xmm3
psrlw xmm1, 1
movdqa xmm4, cs:xmmword_F660
pand xmm1, xmm4
psubb xmm3, xmm1
movdqa xmm2, cs:xmmword_F670
movdqa xmm1, xmm3
pand xmm1, xmm2
psrlw xmm3, 2
pand xmm3, xmm2
paddb xmm3, xmm1
movdqa xmm1, xmm3
psrlw xmm1, 4
paddb xmm1, xmm3
movdqa xmm6, cs:xmmword_F680
pand xmm1, xmm6
pxor xmm7, xmm7
psadbw xmm1, xmm7
pshufd xmm3, xmm1, 0EEh
pshufd xmm9, xmm8, 44h ; 'D'
movdqa xmm10, xmm0
pand xmm10, xmm9
pand xmm9, xmm5
movdqa xmm11, xmm9
psrlw xmm11, 1
pand xmm11, xmm4
psubb xmm9, xmm11
movdqa xmm11, xmm9
pand xmm11, xmm2
psrlw xmm9, 2
pand xmm9, xmm2
paddb xmm9, xmm11
movdqa xmm11, xmm9
psrlw xmm11, 4
paddb xmm11, xmm9
pand xmm11, xmm6
psadbw xmm11, xmm7
movdqa xmm9, xmm10
psrlw xmm9, 1
pand xmm9, xmm4
psubb xmm10, xmm9
movdqa xmm9, xmm10
pand xmm9, xmm2
psrlw xmm10, 2
pand xmm10, xmm2
paddb xmm10, xmm9
movdqa xmm9, xmm10
psrlw xmm9, 4
paddb xmm9, xmm10
pand xmm9, xmm6
psadbw xmm9, xmm7
packuswb xmm9, xmm11
pshufd xmm10, xmm8, 0EEh
movsd xmm8, xmm0
movsd xmm0, xmm10
andpd xmm0, xmm8
pand xmm5, xmm10
movdqa xmm8, xmm5
psrlw xmm8, 1
pand xmm8, xmm4
psubb xmm5, xmm8
movdqa xmm8, xmm5
pand xmm8, xmm2
psrlw xmm5, 2
pand xmm5, xmm2
paddb xmm5, xmm8
movdqa xmm8, xmm5
psrlw xmm8, 4
paddb xmm8, xmm5
pand xmm8, xmm6
psadbw xmm8, xmm7
movapd xmm5, xmm0
psrlw xmm5, 1
pand xmm5, xmm4
psubb xmm0, xmm5
movdqa xmm4, xmm0
pand xmm4, xmm2
psrlw xmm0, 2
pand xmm0, xmm2
paddb xmm0, xmm4
movdqa xmm2, xmm0
psrlw xmm2, 4
paddb xmm2, xmm0
pand xmm2, xmm6
psadbw xmm2, xmm7
packuswb xmm2, xmm8
psubd xmm9, xmm2
pmaddwd xmm9, cs:xmmword_F690
psubd xmm1, xmm3
movd eax, xmm1
imul ecx, eax, 64h ; 'd'
pshufd xmm0, xmm9, 0EEh
paddd xmm0, xmm9
pshufd xmm1, xmm0, 55h ; 'U'
paddd xmm1, xmm0
movd eax, xmm1
add eax, ecx
retn
| long long Engine::evaluateMaterial(Engine *this, const chess::Board *a2)
{
__m128d v2; // xmm0
__m128i v3; // xmm5
__m128d v4; // xmm8
__m128i v5; // xmm3
__m128i si128; // xmm4
__m128i v7; // xmm3
__m128i v8; // xmm2
__m128i v9; // xmm3
__m128i v10; // xmm6
__m128i v11; // xmm1
__m128i v12; // xmm9
__m128i v13; // xmm10
__m128i v14; // xmm9
__m128i v15; // xmm9
__m128i v16; // xmm9
__m128i v17; // xmm10
__m128i v18; // xmm10
__m128i v19; // xmm9
__m128i v20; // xmm10
__m128i v21; // xmm0
__m128i v22; // xmm5
__m128i v23; // xmm5
__m128i v24; // xmm5
__m128i v25; // xmm0
__m128i v26; // xmm0
__m128i v27; // xmm9
__m128i v28; // xmm0
v2 = (__m128d)_mm_loadu_si128((const __m128i *)((char *)a2 + 40));
v3 = _mm_loadu_si128((const __m128i *)((char *)a2 + 56));
v4 = (__m128d)_mm_loadu_si128((const __m128i *)a2 + 5);
v5 = _mm_and_si128(_mm_shuffle_epi32(_mm_loadu_si128((const __m128i *)a2 + 2), 68), (__m128i)v4);
si128 = _mm_load_si128((const __m128i *)&xmmword_F660);
v7 = _mm_sub_epi8(v5, _mm_and_si128(_mm_srli_epi16(v5, 1u), si128));
v8 = _mm_load_si128((const __m128i *)&xmmword_F670);
v9 = _mm_add_epi8(_mm_and_si128(_mm_srli_epi16(v7, 2u), v8), _mm_and_si128(v7, v8));
v10 = _mm_load_si128((const __m128i *)&xmmword_F680);
v11 = _mm_sad_epu8(_mm_and_si128(_mm_add_epi8(_mm_srli_epi16(v9, 4u), v9), v10), (__m128i)0LL);
v12 = _mm_shuffle_epi32((__m128i)v4, 68);
v13 = _mm_and_si128((__m128i)v2, v12);
v14 = _mm_and_si128(v12, v3);
v15 = _mm_sub_epi8(v14, _mm_and_si128(_mm_srli_epi16(v14, 1u), si128));
v16 = _mm_add_epi8(_mm_and_si128(_mm_srli_epi16(v15, 2u), v8), _mm_and_si128(v15, v8));
v17 = _mm_sub_epi8(v13, _mm_and_si128(_mm_srli_epi16(v13, 1u), si128));
v18 = _mm_add_epi8(_mm_and_si128(_mm_srli_epi16(v17, 2u), v8), _mm_and_si128(v17, v8));
v19 = _mm_packus_epi16(
_mm_sad_epu8(_mm_and_si128(_mm_add_epi8(_mm_srli_epi16(v18, 4u), v18), v10), (__m128i)0LL),
_mm_sad_epu8(_mm_and_si128(_mm_add_epi8(_mm_srli_epi16(v16, 4u), v16), v10), (__m128i)0LL));
v20 = _mm_shuffle_epi32((__m128i)v4, 238);
v4.m128d_f64[0] = v2.m128d_f64[0];
v2.m128d_f64[0] = *(double *)v20.m128i_i64;
v21 = (__m128i)_mm_and_pd(v2, v4);
v22 = _mm_and_si128(v3, v20);
v23 = _mm_sub_epi8(v22, _mm_and_si128(_mm_srli_epi16(v22, 1u), si128));
v24 = _mm_add_epi8(_mm_and_si128(_mm_srli_epi16(v23, 2u), v8), _mm_and_si128(v23, v8));
v25 = _mm_sub_epi8(v21, _mm_and_si128(_mm_srli_epi16(v21, 1u), si128));
v26 = _mm_add_epi8(_mm_and_si128(_mm_srli_epi16(v25, 2u), v8), _mm_and_si128(v25, v8));
v27 = _mm_madd_epi16(
_mm_sub_epi32(
v19,
_mm_packus_epi16(
_mm_sad_epu8(_mm_and_si128(_mm_add_epi8(_mm_srli_epi16(v26, 4u), v26), v10), (__m128i)0LL),
_mm_sad_epu8(_mm_and_si128(_mm_add_epi8(_mm_srli_epi16(v24, 4u), v24), v10), (__m128i)0LL))),
(__m128i)xmmword_F690);
v28 = _mm_add_epi32(_mm_shuffle_epi32(v27, 238), v27);
return (unsigned int)(100 * _mm_cvtsi128_si32(_mm_sub_epi32(v11, _mm_shuffle_epi32(v11, 238)))
+ _mm_cvtsi128_si32(_mm_add_epi32(_mm_shuffle_epi32(v28, 85), v28)));
}
| evaluateMaterial:
MOVDQU XMM1,xmmword ptr [RSI + 0x20]
MOVDQU XMM0,xmmword ptr [RSI + 0x28]
MOVDQU XMM5,xmmword ptr [RSI + 0x38]
MOVDQU XMM8,xmmword ptr [RSI + 0x50]
PSHUFD XMM3,XMM1,0x44
PAND XMM3,XMM8
MOVDQA XMM1,XMM3
PSRLW XMM1,0x1
MOVDQA XMM4,xmmword ptr [0x0010f660]
PAND XMM1,XMM4
PSUBB XMM3,XMM1
MOVDQA XMM2,xmmword ptr [0x0010f670]
MOVDQA XMM1,XMM3
PAND XMM1,XMM2
PSRLW XMM3,0x2
PAND XMM3,XMM2
PADDB XMM3,XMM1
MOVDQA XMM1,XMM3
PSRLW XMM1,0x4
PADDB XMM1,XMM3
MOVDQA XMM6,xmmword ptr [0x0010f680]
PAND XMM1,XMM6
PXOR XMM7,XMM7
PSADBW XMM1,XMM7
PSHUFD XMM3,XMM1,0xee
PSHUFD XMM9,XMM8,0x44
MOVDQA XMM10,XMM0
PAND XMM10,XMM9
PAND XMM9,XMM5
MOVDQA XMM11,XMM9
PSRLW XMM11,0x1
PAND XMM11,XMM4
PSUBB XMM9,XMM11
MOVDQA XMM11,XMM9
PAND XMM11,XMM2
PSRLW XMM9,0x2
PAND XMM9,XMM2
PADDB XMM9,XMM11
MOVDQA XMM11,XMM9
PSRLW XMM11,0x4
PADDB XMM11,XMM9
PAND XMM11,XMM6
PSADBW XMM11,XMM7
MOVDQA XMM9,XMM10
PSRLW XMM9,0x1
PAND XMM9,XMM4
PSUBB XMM10,XMM9
MOVDQA XMM9,XMM10
PAND XMM9,XMM2
PSRLW XMM10,0x2
PAND XMM10,XMM2
PADDB XMM10,XMM9
MOVDQA XMM9,XMM10
PSRLW XMM9,0x4
PADDB XMM9,XMM10
PAND XMM9,XMM6
PSADBW XMM9,XMM7
PACKUSWB XMM9,XMM11
PSHUFD XMM10,XMM8,0xee
MOVSD XMM8,XMM0
MOVSD XMM0,XMM10
ANDPD XMM0,XMM8
PAND XMM5,XMM10
MOVDQA XMM8,XMM5
PSRLW XMM8,0x1
PAND XMM8,XMM4
PSUBB XMM5,XMM8
MOVDQA XMM8,XMM5
PAND XMM8,XMM2
PSRLW XMM5,0x2
PAND XMM5,XMM2
PADDB XMM5,XMM8
MOVDQA XMM8,XMM5
PSRLW XMM8,0x4
PADDB XMM8,XMM5
PAND XMM8,XMM6
PSADBW XMM8,XMM7
MOVAPD XMM5,XMM0
PSRLW XMM5,0x1
PAND XMM5,XMM4
PSUBB XMM0,XMM5
MOVDQA XMM4,XMM0
PAND XMM4,XMM2
PSRLW XMM0,0x2
PAND XMM0,XMM2
PADDB XMM0,XMM4
MOVDQA XMM2,XMM0
PSRLW XMM2,0x4
PADDB XMM2,XMM0
PAND XMM2,XMM6
PSADBW XMM2,XMM7
PACKUSWB XMM2,XMM8
PSUBD XMM9,XMM2
PMADDWD XMM9,xmmword ptr [0x0010f690]
PSUBD XMM1,XMM3
MOVD EAX,XMM1
IMUL ECX,EAX,0x64
PSHUFD XMM0,XMM9,0xee
PADDD XMM0,XMM9
PSHUFD XMM1,XMM0,0x55
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD EAX,ECX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* Engine::evaluateMaterial(chess::Board const&) */
int __thiscall Engine::evaluateMaterial(Engine *this,Board *param_1)
{
short sVar1;
short sVar2;
short sVar3;
short sVar4;
ushort uVar5;
ulong uVar8;
int1 auVar11 [12];
ulong uVar16;
int1 auVar14 [16];
int1 auVar17 [16];
int1 auVar18 [16];
int iVar19;
int1 auVar21 [16];
char cVar23;
int1 auVar24 [12];
byte bVar32;
char cVar33;
byte bVar34;
char cVar35;
byte bVar36;
char cVar37;
byte bVar38;
char cVar39;
byte bVar40;
int1 auVar28 [16];
int1 auVar30 [16];
int1 auVar41 [12];
int1 auVar45 [16];
int1 auVar47 [16];
int1 auVar42 [12];
int1 auVar49 [16];
int1 auVar50 [16];
int1 auVar51 [16];
int iVar52;
int1 auVar53 [12];
int1 auVar58 [16];
int1 auVar60 [16];
int1 auVar54 [12];
int1 auVar62 [16];
int1 auVar63 [16];
int1 auVar65 [16];
int1 auVar66 [12];
int1 auVar67 [12];
int1 auVar71 [16];
int1 auVar73 [16];
int1 auVar74 [16];
int1 auVar75 [16];
int4 uVar6;
int6 uVar7;
int8 uVar9;
int1 auVar10 [12];
int1 auVar12 [14];
int1 auVar13 [14];
int1 auVar15 [16];
int1 auVar20 [12];
int1 auVar22 [16];
int1 auVar25 [12];
int1 auVar26 [14];
int1 auVar27 [14];
int1 auVar29 [16];
int1 auVar31 [16];
int1 auVar43 [14];
int1 auVar44 [14];
int1 auVar46 [16];
int1 auVar48 [16];
int1 auVar55 [12];
int1 auVar56 [14];
int1 auVar57 [14];
int1 auVar64 [16];
int1 auVar59 [16];
int1 auVar61 [16];
int1 auVar68 [14];
int1 auVar69 [14];
int1 auVar70 [16];
int1 auVar72 [16];
auVar18 = *(int1 (*) [16])(param_1 + 0x20);
auVar14 = *(int1 (*) [16])(param_1 + 0x28);
auVar15 = *(int1 (*) [16])(param_1 + 0x50);
auVar28._0_8_ = auVar18._0_8_;
auVar28._8_4_ = auVar18._0_4_;
auVar28._12_4_ = auVar18._4_4_;
auVar28 = auVar28 & auVar15;
auVar17._0_2_ = auVar28._0_2_ >> 1;
auVar17._2_2_ = auVar28._2_2_ >> 1;
auVar17._4_2_ = auVar28._4_2_ >> 1;
auVar17._6_2_ = auVar28._6_2_ >> 1;
auVar17._8_2_ = auVar28._8_2_ >> 1;
auVar17._10_2_ = auVar28._10_2_ >> 1;
auVar17._12_2_ = auVar28._12_2_ >> 1;
auVar17._14_2_ = auVar28._14_2_ >> 1;
auVar17 = auVar17 & _DAT_0010f660;
uVar5 = CONCAT11(auVar28[1] - auVar17[1],auVar28[0] - auVar17[0]);
uVar6 = CONCAT13(auVar28[3] - auVar17[3],CONCAT12(auVar28[2] - auVar17[2],uVar5));
uVar7 = CONCAT15(auVar28[5] - auVar17[5],CONCAT14(auVar28[4] - auVar17[4],uVar6));
uVar9 = CONCAT17(auVar28[7] - auVar17[7],CONCAT16(auVar28[6] - auVar17[6],uVar7));
auVar24._0_10_ = CONCAT19(auVar28[9] - auVar17[9],CONCAT18(auVar28[8] - auVar17[8],uVar9));
auVar24[10] = auVar28[10] - auVar17[10];
auVar24[0xb] = auVar28[0xb] - auVar17[0xb];
auVar26[0xc] = auVar28[0xc] - auVar17[0xc];
auVar26._0_12_ = auVar24;
auVar26[0xd] = auVar28[0xd] - auVar17[0xd];
auVar29[0xe] = auVar28[0xe] - auVar17[0xe];
auVar29._0_14_ = auVar26;
auVar29[0xf] = auVar28[0xf] - auVar17[0xf];
auVar18 = auVar29 & _DAT_0010f670;
auVar30._0_2_ = uVar5 >> 2;
auVar30._2_2_ = (ushort)((uint)uVar6 >> 0x12);
auVar30._4_2_ = (ushort)((uint6)uVar7 >> 0x22);
auVar30._6_2_ = (ushort)((ulong)uVar9 >> 0x32);
auVar30._8_2_ = (ushort)((unkuint10)auVar24._0_10_ >> 0x42);
auVar30._10_2_ = auVar24._10_2_ >> 2;
auVar30._12_2_ = auVar26._12_2_ >> 2;
auVar30._14_2_ = auVar29._14_2_ >> 2;
auVar30 = auVar30 & _DAT_0010f670;
cVar23 = auVar30[0] + auVar18[0];
bVar32 = auVar30[1] + auVar18[1];
uVar5 = CONCAT11(bVar32,cVar23);
cVar33 = auVar30[2] + auVar18[2];
bVar34 = auVar30[3] + auVar18[3];
uVar6 = CONCAT13(bVar34,CONCAT12(cVar33,uVar5));
cVar35 = auVar30[4] + auVar18[4];
bVar36 = auVar30[5] + auVar18[5];
uVar7 = CONCAT15(bVar36,CONCAT14(cVar35,uVar6));
cVar37 = auVar30[6] + auVar18[6];
bVar38 = auVar30[7] + auVar18[7];
uVar9 = CONCAT17(bVar38,CONCAT16(cVar37,uVar7));
cVar39 = auVar30[8] + auVar18[8];
bVar40 = auVar30[9] + auVar18[9];
auVar25._0_10_ = CONCAT19(bVar40,CONCAT18(cVar39,uVar9));
auVar25[10] = auVar30[10] + auVar18[10];
auVar25[0xb] = auVar30[0xb] + auVar18[0xb];
auVar27[0xc] = auVar30[0xc] + auVar18[0xc];
auVar27._0_12_ = auVar25;
auVar27[0xd] = auVar30[0xd] + auVar18[0xd];
auVar31[0xe] = auVar30[0xe] + auVar18[0xe];
auVar31._0_14_ = auVar27;
auVar31[0xf] = auVar30[0xf] + auVar18[0xf];
auVar74[0] = (char)(uVar5 >> 4) + cVar23;
auVar74[1] = (bVar32 >> 4) + bVar32;
auVar74[2] = (char)(ushort)((uint)uVar6 >> 0x14) + cVar33;
auVar74[3] = (bVar34 >> 4) + bVar34;
auVar74[4] = (char)(ushort)((uint6)uVar7 >> 0x24) + cVar35;
auVar74[5] = (bVar36 >> 4) + bVar36;
auVar74[6] = (char)(ushort)((ulong)uVar9 >> 0x34) + cVar37;
auVar74[7] = (bVar38 >> 4) + bVar38;
auVar74[8] = (char)(ushort)((unkuint10)auVar25._0_10_ >> 0x44) + cVar39;
auVar74[9] = (bVar40 >> 4) + bVar40;
auVar74[10] = (char)(auVar25._10_2_ >> 4) + auVar25[10];
auVar74[0xb] = (auVar25[0xb] >> 4) + auVar25[0xb];
auVar74[0xc] = (char)(auVar27._12_2_ >> 4) + auVar27[0xc];
auVar74[0xd] = (auVar27[0xd] >> 4) + auVar27[0xd];
auVar74[0xe] = (char)(auVar31._14_2_ >> 4) + auVar31[0xe];
auVar74[0xf] = (auVar31[0xf] >> 4) + auVar31[0xf];
auVar17 = psadbw(auVar74 & _DAT_0010f680,(int1 [16])0x0);
auVar58._0_8_ = auVar15._0_8_;
auVar58._8_4_ = auVar15._0_4_;
auVar58._12_4_ = auVar15._4_4_;
auVar18 = auVar14 & auVar58;
auVar58 = auVar58 & *(int1 (*) [16])(param_1 + 0x38);
auVar73._0_2_ = auVar58._0_2_ >> 1;
auVar73._2_2_ = auVar58._2_2_ >> 1;
auVar73._4_2_ = auVar58._4_2_ >> 1;
auVar73._6_2_ = auVar58._6_2_ >> 1;
auVar73._8_2_ = auVar58._8_2_ >> 1;
auVar73._10_2_ = auVar58._10_2_ >> 1;
auVar73._12_2_ = auVar58._12_2_ >> 1;
auVar73._14_2_ = auVar58._14_2_ >> 1;
auVar73 = auVar73 & _DAT_0010f660;
uVar5 = CONCAT11(auVar58[1] - auVar73[1],auVar58[0] - auVar73[0]);
uVar6 = CONCAT13(auVar58[3] - auVar73[3],CONCAT12(auVar58[2] - auVar73[2],uVar5));
uVar7 = CONCAT15(auVar58[5] - auVar73[5],CONCAT14(auVar58[4] - auVar73[4],uVar6));
uVar9 = CONCAT17(auVar58[7] - auVar73[7],CONCAT16(auVar58[6] - auVar73[6],uVar7));
auVar53._0_10_ = CONCAT19(auVar58[9] - auVar73[9],CONCAT18(auVar58[8] - auVar73[8],uVar9));
auVar53[10] = auVar58[10] - auVar73[10];
auVar53[0xb] = auVar58[0xb] - auVar73[0xb];
auVar56[0xc] = auVar58[0xc] - auVar73[0xc];
auVar56._0_12_ = auVar53;
auVar56[0xd] = auVar58[0xd] - auVar73[0xd];
auVar59[0xe] = auVar58[0xe] - auVar73[0xe];
auVar59._0_14_ = auVar56;
auVar59[0xf] = auVar58[0xf] - auVar73[0xf];
auVar74 = auVar59 & _DAT_0010f670;
auVar60._0_2_ = uVar5 >> 2;
auVar60._2_2_ = (ushort)((uint)uVar6 >> 0x12);
auVar60._4_2_ = (ushort)((uint6)uVar7 >> 0x22);
auVar60._6_2_ = (ushort)((ulong)uVar9 >> 0x32);
auVar60._8_2_ = (ushort)((unkuint10)auVar53._0_10_ >> 0x42);
auVar60._10_2_ = auVar53._10_2_ >> 2;
auVar60._12_2_ = auVar56._12_2_ >> 2;
auVar60._14_2_ = auVar59._14_2_ >> 2;
auVar60 = auVar60 & _DAT_0010f670;
cVar23 = auVar60[0] + auVar74[0];
bVar32 = auVar60[1] + auVar74[1];
uVar5 = CONCAT11(bVar32,cVar23);
cVar33 = auVar60[2] + auVar74[2];
bVar34 = auVar60[3] + auVar74[3];
uVar6 = CONCAT13(bVar34,CONCAT12(cVar33,uVar5));
cVar35 = auVar60[4] + auVar74[4];
bVar36 = auVar60[5] + auVar74[5];
uVar7 = CONCAT15(bVar36,CONCAT14(cVar35,uVar6));
cVar37 = auVar60[6] + auVar74[6];
bVar38 = auVar60[7] + auVar74[7];
uVar9 = CONCAT17(bVar38,CONCAT16(cVar37,uVar7));
cVar39 = auVar60[8] + auVar74[8];
bVar40 = auVar60[9] + auVar74[9];
auVar54._0_10_ = CONCAT19(bVar40,CONCAT18(cVar39,uVar9));
auVar54[10] = auVar60[10] + auVar74[10];
auVar54[0xb] = auVar60[0xb] + auVar74[0xb];
auVar57[0xc] = auVar60[0xc] + auVar74[0xc];
auVar57._0_12_ = auVar54;
auVar57[0xd] = auVar60[0xd] + auVar74[0xd];
auVar61[0xe] = auVar60[0xe] + auVar74[0xe];
auVar61._0_14_ = auVar57;
auVar61[0xf] = auVar60[0xf] + auVar74[0xf];
auVar75[0] = (char)(uVar5 >> 4) + cVar23;
auVar75[1] = (bVar32 >> 4) + bVar32;
auVar75[2] = (char)(ushort)((uint)uVar6 >> 0x14) + cVar33;
auVar75[3] = (bVar34 >> 4) + bVar34;
auVar75[4] = (char)(ushort)((uint6)uVar7 >> 0x24) + cVar35;
auVar75[5] = (bVar36 >> 4) + bVar36;
auVar75[6] = (char)(ushort)((ulong)uVar9 >> 0x34) + cVar37;
auVar75[7] = (bVar38 >> 4) + bVar38;
auVar75[8] = (char)(ushort)((unkuint10)auVar54._0_10_ >> 0x44) + cVar39;
auVar75[9] = (bVar40 >> 4) + bVar40;
auVar75[10] = (char)(auVar54._10_2_ >> 4) + auVar54[10];
auVar75[0xb] = (auVar54[0xb] >> 4) + auVar54[0xb];
auVar75[0xc] = (char)(auVar57._12_2_ >> 4) + auVar57[0xc];
auVar75[0xd] = (auVar57[0xd] >> 4) + auVar57[0xd];
auVar75[0xe] = (char)(auVar61._14_2_ >> 4) + auVar61[0xe];
auVar75[0xf] = (auVar61[0xf] >> 4) + auVar61[0xf];
auVar74 = psadbw(auVar75 & _DAT_0010f680,(int1 [16])0x0);
auVar62._0_2_ = auVar18._0_2_ >> 1;
auVar62._2_2_ = auVar18._2_2_ >> 1;
auVar62._4_2_ = auVar18._4_2_ >> 1;
auVar62._6_2_ = auVar18._6_2_ >> 1;
auVar62._8_2_ = auVar18._8_2_ >> 1;
auVar62._10_2_ = auVar18._10_2_ >> 1;
auVar62._12_2_ = auVar18._12_2_ >> 1;
auVar62._14_2_ = auVar18._14_2_ >> 1;
auVar62 = auVar62 & _DAT_0010f660;
uVar5 = CONCAT11(auVar18[1] - auVar62[1],auVar18[0] - auVar62[0]);
uVar6 = CONCAT13(auVar18[3] - auVar62[3],CONCAT12(auVar18[2] - auVar62[2],uVar5));
uVar7 = CONCAT15(auVar18[5] - auVar62[5],CONCAT14(auVar18[4] - auVar62[4],uVar6));
uVar9 = CONCAT17(auVar18[7] - auVar62[7],CONCAT16(auVar18[6] - auVar62[6],uVar7));
auVar66._0_10_ = CONCAT19(auVar18[9] - auVar62[9],CONCAT18(auVar18[8] - auVar62[8],uVar9));
auVar66[10] = auVar18[10] - auVar62[10];
auVar66[0xb] = auVar18[0xb] - auVar62[0xb];
auVar68[0xc] = auVar18[0xc] - auVar62[0xc];
auVar68._0_12_ = auVar66;
auVar68[0xd] = auVar18[0xd] - auVar62[0xd];
auVar70[0xe] = auVar18[0xe] - auVar62[0xe];
auVar70._0_14_ = auVar68;
auVar70[0xf] = auVar18[0xf] - auVar62[0xf];
auVar18 = auVar70 & _DAT_0010f670;
auVar71._0_2_ = uVar5 >> 2;
auVar71._2_2_ = (ushort)((uint)uVar6 >> 0x12);
auVar71._4_2_ = (ushort)((uint6)uVar7 >> 0x22);
auVar71._6_2_ = (ushort)((ulong)uVar9 >> 0x32);
auVar71._8_2_ = (ushort)((unkuint10)auVar66._0_10_ >> 0x42);
auVar71._10_2_ = auVar66._10_2_ >> 2;
auVar71._12_2_ = auVar68._12_2_ >> 2;
auVar71._14_2_ = auVar70._14_2_ >> 2;
auVar71 = auVar71 & _DAT_0010f670;
cVar23 = auVar71[0] + auVar18[0];
bVar32 = auVar71[1] + auVar18[1];
uVar5 = CONCAT11(bVar32,cVar23);
cVar33 = auVar71[2] + auVar18[2];
bVar34 = auVar71[3] + auVar18[3];
uVar6 = CONCAT13(bVar34,CONCAT12(cVar33,uVar5));
cVar35 = auVar71[4] + auVar18[4];
bVar36 = auVar71[5] + auVar18[5];
uVar7 = CONCAT15(bVar36,CONCAT14(cVar35,uVar6));
cVar37 = auVar71[6] + auVar18[6];
bVar38 = auVar71[7] + auVar18[7];
uVar9 = CONCAT17(bVar38,CONCAT16(cVar37,uVar7));
cVar39 = auVar71[8] + auVar18[8];
bVar40 = auVar71[9] + auVar18[9];
auVar67._0_10_ = CONCAT19(bVar40,CONCAT18(cVar39,uVar9));
auVar67[10] = auVar71[10] + auVar18[10];
auVar67[0xb] = auVar71[0xb] + auVar18[0xb];
auVar69[0xc] = auVar71[0xc] + auVar18[0xc];
auVar69._0_12_ = auVar67;
auVar69[0xd] = auVar71[0xd] + auVar18[0xd];
auVar72[0xe] = auVar71[0xe] + auVar18[0xe];
auVar72._0_14_ = auVar69;
auVar72[0xf] = auVar71[0xf] + auVar18[0xf];
auVar63[0] = (char)(uVar5 >> 4) + cVar23;
auVar63[1] = (bVar32 >> 4) + bVar32;
auVar63[2] = (char)(ushort)((uint)uVar6 >> 0x14) + cVar33;
auVar63[3] = (bVar34 >> 4) + bVar34;
auVar63[4] = (char)(ushort)((uint6)uVar7 >> 0x24) + cVar35;
auVar63[5] = (bVar36 >> 4) + bVar36;
auVar63[6] = (char)(ushort)((ulong)uVar9 >> 0x34) + cVar37;
auVar63[7] = (bVar38 >> 4) + bVar38;
auVar63[8] = (char)(ushort)((unkuint10)auVar67._0_10_ >> 0x44) + cVar39;
auVar63[9] = (bVar40 >> 4) + bVar40;
auVar63[10] = (char)(auVar67._10_2_ >> 4) + auVar67[10];
auVar63[0xb] = (auVar67[0xb] >> 4) + auVar67[0xb];
auVar63[0xc] = (char)(auVar69._12_2_ >> 4) + auVar69[0xc];
auVar63[0xd] = (auVar69[0xd] >> 4) + auVar69[0xd];
auVar63[0xe] = (char)(auVar72._14_2_ >> 4) + auVar72[0xe];
auVar63[0xf] = (auVar72[0xf] >> 4) + auVar72[0xf];
auVar18 = psadbw(auVar63 & _DAT_0010f680,(int1 [16])0x0);
sVar1 = auVar18._0_2_;
sVar2 = auVar18._2_2_;
sVar3 = auVar18._4_2_;
sVar4 = auVar18._6_2_;
iVar52 = CONCAT13((0 < sVar4) * (sVar4 < 0x100) * auVar18[6] - (0xff < sVar4),
CONCAT12((0 < sVar3) * (sVar3 < 0x100) * auVar18[4] - (0xff < sVar3),
CONCAT11((0 < sVar2) * (sVar2 < 0x100) * auVar18[2] - (0xff < sVar2),
(0 < sVar1) * (sVar1 < 0x100) * auVar18[0] - (0xff < sVar1))))
;
sVar1 = auVar18._8_2_;
sVar2 = auVar18._10_2_;
sVar3 = auVar18._12_2_;
sVar4 = auVar18._14_2_;
auVar55._0_8_ =
CONCAT17((0 < sVar4) * (sVar4 < 0x100) * auVar18[0xe] - (0xff < sVar4),
CONCAT16((0 < sVar3) * (sVar3 < 0x100) * auVar18[0xc] - (0xff < sVar3),
CONCAT15((0 < sVar2) * (sVar2 < 0x100) * auVar18[10] - (0xff < sVar2),
CONCAT14((0 < sVar1) * (sVar1 < 0x100) * auVar18[8] -
(0xff < sVar1),iVar52))));
sVar1 = auVar74._0_2_;
auVar55[8] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[0] - (0xff < sVar1);
sVar1 = auVar74._2_2_;
auVar55[9] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[2] - (0xff < sVar1);
sVar1 = auVar74._4_2_;
auVar55[10] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[4] - (0xff < sVar1);
sVar1 = auVar74._6_2_;
auVar55[0xb] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[6] - (0xff < sVar1);
sVar1 = auVar74._8_2_;
auVar64[0xc] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[8] - (0xff < sVar1);
auVar64._0_12_ = auVar55;
sVar1 = auVar74._10_2_;
auVar64[0xd] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[10] - (0xff < sVar1);
sVar1 = auVar74._12_2_;
auVar64[0xe] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[0xc] - (0xff < sVar1);
sVar1 = auVar74._14_2_;
auVar64[0xf] = (0 < sVar1) * (sVar1 < 0x100) * auVar74[0xe] - (0xff < sVar1);
auVar45._0_8_ = auVar15._8_8_;
auVar45._8_4_ = auVar15._8_4_;
auVar45._12_4_ = auVar15._12_4_;
uVar8 = auVar45._0_8_ & auVar14._0_8_;
uVar16 = auVar14._8_8_ & auVar45._0_8_;
auVar45 = *(int1 (*) [16])(param_1 + 0x38) & auVar45;
auVar50._0_2_ = auVar45._0_2_ >> 1;
auVar50._2_2_ = auVar45._2_2_ >> 1;
auVar50._4_2_ = auVar45._4_2_ >> 1;
auVar50._6_2_ = auVar45._6_2_ >> 1;
auVar50._8_2_ = auVar45._8_2_ >> 1;
auVar50._10_2_ = auVar45._10_2_ >> 1;
auVar50._12_2_ = auVar45._12_2_ >> 1;
auVar50._14_2_ = auVar45._14_2_ >> 1;
auVar50 = auVar50 & _DAT_0010f660;
uVar5 = CONCAT11(auVar45[1] - auVar50[1],auVar45[0] - auVar50[0]);
uVar6 = CONCAT13(auVar45[3] - auVar50[3],CONCAT12(auVar45[2] - auVar50[2],uVar5));
uVar7 = CONCAT15(auVar45[5] - auVar50[5],CONCAT14(auVar45[4] - auVar50[4],uVar6));
uVar9 = CONCAT17(auVar45[7] - auVar50[7],CONCAT16(auVar45[6] - auVar50[6],uVar7));
auVar41._0_10_ = CONCAT19(auVar45[9] - auVar50[9],CONCAT18(auVar45[8] - auVar50[8],uVar9));
auVar41[10] = auVar45[10] - auVar50[10];
auVar41[0xb] = auVar45[0xb] - auVar50[0xb];
auVar43[0xc] = auVar45[0xc] - auVar50[0xc];
auVar43._0_12_ = auVar41;
auVar43[0xd] = auVar45[0xd] - auVar50[0xd];
auVar46[0xe] = auVar45[0xe] - auVar50[0xe];
auVar46._0_14_ = auVar43;
auVar46[0xf] = auVar45[0xf] - auVar50[0xf];
auVar18 = auVar46 & _DAT_0010f670;
auVar47._0_2_ = uVar5 >> 2;
auVar47._2_2_ = (ushort)((uint)uVar6 >> 0x12);
auVar47._4_2_ = (ushort)((uint6)uVar7 >> 0x22);
auVar47._6_2_ = (ushort)((ulong)uVar9 >> 0x32);
auVar47._8_2_ = (ushort)((unkuint10)auVar41._0_10_ >> 0x42);
auVar47._10_2_ = auVar41._10_2_ >> 2;
auVar47._12_2_ = auVar43._12_2_ >> 2;
auVar47._14_2_ = auVar46._14_2_ >> 2;
auVar47 = auVar47 & _DAT_0010f670;
cVar23 = auVar47[0] + auVar18[0];
bVar32 = auVar47[1] + auVar18[1];
uVar5 = CONCAT11(bVar32,cVar23);
cVar33 = auVar47[2] + auVar18[2];
bVar34 = auVar47[3] + auVar18[3];
uVar6 = CONCAT13(bVar34,CONCAT12(cVar33,uVar5));
cVar35 = auVar47[4] + auVar18[4];
bVar36 = auVar47[5] + auVar18[5];
uVar7 = CONCAT15(bVar36,CONCAT14(cVar35,uVar6));
cVar37 = auVar47[6] + auVar18[6];
bVar38 = auVar47[7] + auVar18[7];
uVar9 = CONCAT17(bVar38,CONCAT16(cVar37,uVar7));
cVar39 = auVar47[8] + auVar18[8];
bVar40 = auVar47[9] + auVar18[9];
auVar42._0_10_ = CONCAT19(bVar40,CONCAT18(cVar39,uVar9));
auVar42[10] = auVar47[10] + auVar18[10];
auVar42[0xb] = auVar47[0xb] + auVar18[0xb];
auVar44[0xc] = auVar47[0xc] + auVar18[0xc];
auVar44._0_12_ = auVar42;
auVar44[0xd] = auVar47[0xd] + auVar18[0xd];
auVar48[0xe] = auVar47[0xe] + auVar18[0xe];
auVar48._0_14_ = auVar44;
auVar48[0xf] = auVar47[0xf] + auVar18[0xf];
auVar51[0] = (char)(uVar5 >> 4) + cVar23;
auVar51[1] = (bVar32 >> 4) + bVar32;
auVar51[2] = (char)(ushort)((uint)uVar6 >> 0x14) + cVar33;
auVar51[3] = (bVar34 >> 4) + bVar34;
auVar51[4] = (char)(ushort)((uint6)uVar7 >> 0x24) + cVar35;
auVar51[5] = (bVar36 >> 4) + bVar36;
auVar51[6] = (char)(ushort)((ulong)uVar9 >> 0x34) + cVar37;
auVar51[7] = (bVar38 >> 4) + bVar38;
auVar51[8] = (char)(ushort)((unkuint10)auVar42._0_10_ >> 0x44) + cVar39;
auVar51[9] = (bVar40 >> 4) + bVar40;
auVar51[10] = (char)(auVar42._10_2_ >> 4) + auVar42[10];
auVar51[0xb] = (auVar42[0xb] >> 4) + auVar42[0xb];
auVar51[0xc] = (char)(auVar44._12_2_ >> 4) + auVar44[0xc];
auVar51[0xd] = (auVar44[0xd] >> 4) + auVar44[0xd];
auVar51[0xe] = (char)(auVar48._14_2_ >> 4) + auVar48[0xe];
auVar51[0xf] = (auVar48[0xf] >> 4) + auVar48[0xf];
auVar28 = psadbw(auVar51 & _DAT_0010f680,(int1 [16])0x0);
auVar49._0_2_ = (ushort)uVar8 >> 1;
auVar49._2_2_ = (ushort)(uVar8 >> 0x10) >> 1;
auVar49._4_2_ = (ushort)(uVar8 >> 0x20) >> 1;
auVar49._6_2_ = (ushort)(uVar8 >> 0x31);
auVar49._8_2_ = (ushort)uVar16 >> 1;
auVar49._10_2_ = (ushort)(uVar16 >> 0x10) >> 1;
auVar49._12_2_ = (ushort)(uVar16 >> 0x20) >> 1;
auVar49._14_2_ = (ushort)(uVar16 >> 0x31);
auVar49 = auVar49 & _DAT_0010f660;
uVar5 = CONCAT11((char)(uVar8 >> 8) - auVar49[1],(char)uVar8 - auVar49[0]);
uVar6 = CONCAT13((char)(uVar8 >> 0x18) - auVar49[3],
CONCAT12((char)(uVar8 >> 0x10) - auVar49[2],uVar5));
uVar7 = CONCAT15((char)(uVar8 >> 0x28) - auVar49[5],
CONCAT14((char)(uVar8 >> 0x20) - auVar49[4],uVar6));
uVar9 = CONCAT17((char)(uVar8 >> 0x38) - auVar49[7],
CONCAT16((char)(uVar8 >> 0x30) - auVar49[6],uVar7));
auVar10._0_10_ =
CONCAT19((char)(uVar16 >> 8) - auVar49[9],CONCAT18((char)uVar16 - auVar49[8],uVar9));
auVar10[10] = (char)(uVar16 >> 0x10) - auVar49[10];
auVar10[0xb] = (char)(uVar16 >> 0x18) - auVar49[0xb];
auVar12[0xc] = (char)(uVar16 >> 0x20) - auVar49[0xc];
auVar12._0_12_ = auVar10;
auVar12[0xd] = (char)(uVar16 >> 0x28) - auVar49[0xd];
auVar18[0xe] = (char)(uVar16 >> 0x30) - auVar49[0xe];
auVar18._0_14_ = auVar12;
auVar18[0xf] = (char)(uVar16 >> 0x38) - auVar49[0xf];
auVar74 = auVar18 & _DAT_0010f670;
auVar14._0_2_ = uVar5 >> 2;
auVar14._2_2_ = (ushort)((uint)uVar6 >> 0x12);
auVar14._4_2_ = (ushort)((uint6)uVar7 >> 0x22);
auVar14._6_2_ = (ushort)((ulong)uVar9 >> 0x32);
auVar14._8_2_ = (ushort)((unkuint10)auVar10._0_10_ >> 0x42);
auVar14._10_2_ = auVar10._10_2_ >> 2;
auVar14._12_2_ = auVar12._12_2_ >> 2;
auVar14._14_2_ = auVar18._14_2_ >> 2;
auVar14 = auVar14 & _DAT_0010f670;
cVar23 = auVar14[0] + auVar74[0];
bVar32 = auVar14[1] + auVar74[1];
uVar5 = CONCAT11(bVar32,cVar23);
cVar33 = auVar14[2] + auVar74[2];
bVar34 = auVar14[3] + auVar74[3];
uVar6 = CONCAT13(bVar34,CONCAT12(cVar33,uVar5));
cVar35 = auVar14[4] + auVar74[4];
bVar36 = auVar14[5] + auVar74[5];
uVar7 = CONCAT15(bVar36,CONCAT14(cVar35,uVar6));
cVar37 = auVar14[6] + auVar74[6];
bVar38 = auVar14[7] + auVar74[7];
uVar9 = CONCAT17(bVar38,CONCAT16(cVar37,uVar7));
cVar39 = auVar14[8] + auVar74[8];
bVar40 = auVar14[9] + auVar74[9];
auVar11._0_10_ = CONCAT19(bVar40,CONCAT18(cVar39,uVar9));
auVar11[10] = auVar14[10] + auVar74[10];
auVar11[0xb] = auVar14[0xb] + auVar74[0xb];
auVar13[0xc] = auVar14[0xc] + auVar74[0xc];
auVar13._0_12_ = auVar11;
auVar13[0xd] = auVar14[0xd] + auVar74[0xd];
auVar15[0xe] = auVar14[0xe] + auVar74[0xe];
auVar15._0_14_ = auVar13;
auVar15[0xf] = auVar14[0xf] + auVar74[0xf];
auVar21[0] = (char)(uVar5 >> 4) + cVar23;
auVar21[1] = (bVar32 >> 4) + bVar32;
auVar21[2] = (char)(ushort)((uint)uVar6 >> 0x14) + cVar33;
auVar21[3] = (bVar34 >> 4) + bVar34;
auVar21[4] = (char)(ushort)((uint6)uVar7 >> 0x24) + cVar35;
auVar21[5] = (bVar36 >> 4) + bVar36;
auVar21[6] = (char)(ushort)((ulong)uVar9 >> 0x34) + cVar37;
auVar21[7] = (bVar38 >> 4) + bVar38;
auVar21[8] = (char)(ushort)((unkuint10)auVar11._0_10_ >> 0x44) + cVar39;
auVar21[9] = (bVar40 >> 4) + bVar40;
auVar21[10] = (char)(auVar11._10_2_ >> 4) + auVar11[10];
auVar21[0xb] = (auVar11[0xb] >> 4) + auVar11[0xb];
auVar21[0xc] = (char)(auVar13._12_2_ >> 4) + auVar13[0xc];
auVar21[0xd] = (auVar13[0xd] >> 4) + auVar13[0xd];
auVar21[0xe] = (char)(auVar15._14_2_ >> 4) + auVar15[0xe];
auVar21[0xf] = (auVar15[0xf] >> 4) + auVar15[0xf];
auVar18 = psadbw(auVar21 & _DAT_0010f680,(int1 [16])0x0);
sVar1 = auVar18._0_2_;
sVar2 = auVar18._2_2_;
sVar3 = auVar18._4_2_;
sVar4 = auVar18._6_2_;
iVar19 = CONCAT13((0 < sVar4) * (sVar4 < 0x100) * auVar18[6] - (0xff < sVar4),
CONCAT12((0 < sVar3) * (sVar3 < 0x100) * auVar18[4] - (0xff < sVar3),
CONCAT11((0 < sVar2) * (sVar2 < 0x100) * auVar18[2] - (0xff < sVar2),
(0 < sVar1) * (sVar1 < 0x100) * auVar18[0] - (0xff < sVar1))))
;
sVar1 = auVar18._8_2_;
sVar2 = auVar18._10_2_;
sVar3 = auVar18._12_2_;
sVar4 = auVar18._14_2_;
auVar20._0_8_ =
CONCAT17((0 < sVar4) * (sVar4 < 0x100) * auVar18[0xe] - (0xff < sVar4),
CONCAT16((0 < sVar3) * (sVar3 < 0x100) * auVar18[0xc] - (0xff < sVar3),
CONCAT15((0 < sVar2) * (sVar2 < 0x100) * auVar18[10] - (0xff < sVar2),
CONCAT14((0 < sVar1) * (sVar1 < 0x100) * auVar18[8] -
(0xff < sVar1),iVar19))));
sVar1 = auVar28._0_2_;
auVar20[8] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[0] - (0xff < sVar1);
sVar1 = auVar28._2_2_;
auVar20[9] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[2] - (0xff < sVar1);
sVar1 = auVar28._4_2_;
auVar20[10] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[4] - (0xff < sVar1);
sVar1 = auVar28._6_2_;
auVar20[0xb] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[6] - (0xff < sVar1);
sVar1 = auVar28._8_2_;
auVar22[0xc] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[8] - (0xff < sVar1);
auVar22._0_12_ = auVar20;
sVar1 = auVar28._10_2_;
auVar22[0xd] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[10] - (0xff < sVar1);
sVar1 = auVar28._12_2_;
auVar22[0xe] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[0xc] - (0xff < sVar1);
sVar1 = auVar28._14_2_;
auVar22[0xf] = (0 < sVar1) * (sVar1 < 0x100) * auVar28[0xe] - (0xff < sVar1);
auVar65._0_4_ = iVar52 - iVar19;
auVar65._4_4_ = (int)((ulong)auVar55._0_8_ >> 0x20) - (int)((ulong)auVar20._0_8_ >> 0x20);
auVar65._8_4_ = auVar55._8_4_ - auVar20._8_4_;
auVar65._12_4_ = auVar64._12_4_ - auVar22._12_4_;
auVar18 = pmaddwd(auVar65,_DAT_0010f690);
return auVar18._12_4_ + auVar18._4_4_ + auVar18._8_4_ + auVar18._0_4_ +
(auVar17._0_4_ - auVar17._8_4_) * 100;
}
|
|
1,991 | ma_pvio_cache_read | eloqsql/libmariadb/libmariadb/ma_pvio.c | ssize_t ma_pvio_cache_read(MARIADB_PVIO *pvio, uchar *buffer, size_t length)
{
ssize_t r;
if (!pvio)
return -1;
if (!pvio->cache)
return ma_pvio_read(pvio, buffer, length);
if (pvio->cache + pvio->cache_size > pvio->cache_pos)
{
ssize_t remaining = pvio->cache + pvio->cache_size - pvio->cache_pos;
assert(remaining > 0);
r= MIN((ssize_t)length, remaining);
memcpy(buffer, pvio->cache_pos, r);
pvio->cache_pos+= r;
}
else if (length >= PVIO_READ_AHEAD_CACHE_MIN_SIZE)
{
r= ma_pvio_read(pvio, buffer, length);
}
else
{
r= ma_pvio_read(pvio, pvio->cache, PVIO_READ_AHEAD_CACHE_SIZE);
if (r > 0)
{
if (length < (size_t)r)
{
pvio->cache_size= r;
pvio->cache_pos= pvio->cache + length;
r= length;
}
memcpy(buffer, pvio->cache, r);
}
}
return r;
} | O3 | c | ma_pvio_cache_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4c24d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x4c269
movq 0x18(%r15), %rcx
addq %rsi, %rcx
movq 0x10(%r15), %rax
subq %rax, %rcx
jbe 0x4c260
cmpq %rbx, %rcx
cmovlq %rcx, %rbx
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x370a0
addq %rbx, 0x10(%r15)
movq %rbx, %r12
jmp 0x4c254
movq $-0x1, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x800, %rbx # imm = 0x800
jb 0x4c27f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4bfe0
movl $0x4000, %edx # imm = 0x4000
movq %r15, %rdi
callq 0x4bfe0
movq %rax, %r12
testq %rax, %rax
jle 0x4c254
movq 0x8(%r15), %rsi
cmpq %rbx, %r12
jbe 0x4c2ae
movq %r12, 0x18(%r15)
leaq (%rsi,%rbx), %rax
movq %rax, 0x10(%r15)
movq %rbx, %r12
jmp 0x4c2b1
movq %r12, %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x370a0
jmp 0x4c254
| ma_pvio_cache_read:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
test rdi, rdi
jz short loc_4C24D
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rsi, [rdi+8]
test rsi, rsi
jz short loc_4C269
mov rcx, [r15+18h]
add rcx, rsi
mov rax, [r15+10h]
sub rcx, rax
jbe short loc_4C260
cmp rcx, rbx
cmovl rbx, rcx
mov rdi, r14
mov rsi, rax
mov rdx, rbx
call _memcpy
add [r15+10h], rbx
mov r12, rbx
jmp short loc_4C254
loc_4C24D:
mov r12, 0FFFFFFFFFFFFFFFFh
loc_4C254:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_4C260:
cmp rbx, 800h
jb short loc_4C27F
loc_4C269:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp ma_pvio_read
loc_4C27F:
mov edx, 4000h
mov rdi, r15
call ma_pvio_read
mov r12, rax
test rax, rax
jle short loc_4C254
mov rsi, [r15+8]
cmp r12, rbx
jbe short loc_4C2AE
mov [r15+18h], r12
lea rax, [rsi+rbx]
mov [r15+10h], rax
mov r12, rbx
jmp short loc_4C2B1
loc_4C2AE:
mov rbx, r12
loc_4C2B1:
mov rdi, r14
mov rdx, rbx
call _memcpy
jmp short loc_4C254
| long long ma_pvio_cache_read(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v3; // rbx
long long v5; // rsi
unsigned long long v6; // rcx
unsigned long long v7; // rax
bool v8; // cc
long long v9; // rcx
long long v10; // r12
long long v12; // rax
long long v13; // rsi
if ( !a1 )
return -1LL;
v3 = a3;
v5 = a1[1];
if ( v5 )
{
v6 = v5 + a1[3];
v7 = a1[2];
v8 = v6 <= v7;
v9 = v6 - v7;
if ( !v8 )
{
if ( v9 < a3 )
v3 = v9;
memcpy(a2, a1[2], v3);
a1[2] += v3;
return v3;
}
if ( (unsigned long long)a3 < 0x800 )
{
v12 = ma_pvio_read((long long)a1, v5, 0x4000LL);
v10 = v12;
if ( v12 > 0 )
{
v13 = a1[1];
if ( v12 <= v3 )
{
v3 = v12;
}
else
{
a1[3] = v12;
a1[2] = v13 + v3;
v10 = v3;
}
memcpy(a2, v13, v3);
}
return v10;
}
}
return ma_pvio_read((long long)a1, a2, a3);
}
| ma_pvio_cache_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
TEST RDI,RDI
JZ 0x0014c24d
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RSI,qword ptr [RDI + 0x8]
TEST RSI,RSI
JZ 0x0014c269
MOV RCX,qword ptr [R15 + 0x18]
ADD RCX,RSI
MOV RAX,qword ptr [R15 + 0x10]
SUB RCX,RAX
JBE 0x0014c260
CMP RCX,RBX
CMOVL RBX,RCX
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
CALL 0x001370a0
ADD qword ptr [R15 + 0x10],RBX
MOV R12,RBX
JMP 0x0014c254
LAB_0014c24d:
MOV R12,-0x1
LAB_0014c254:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0014c260:
CMP RBX,0x800
JC 0x0014c27f
LAB_0014c269:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0014bfe0
LAB_0014c27f:
MOV EDX,0x4000
MOV RDI,R15
CALL 0x0014bfe0
MOV R12,RAX
TEST RAX,RAX
JLE 0x0014c254
MOV RSI,qword ptr [R15 + 0x8]
CMP R12,RBX
JBE 0x0014c2ae
MOV qword ptr [R15 + 0x18],R12
LEA RAX,[RSI + RBX*0x1]
MOV qword ptr [R15 + 0x10],RAX
MOV R12,RBX
JMP 0x0014c2b1
LAB_0014c2ae:
MOV RBX,R12
LAB_0014c2b1:
MOV RDI,R14
MOV RDX,RBX
CALL 0x001370a0
JMP 0x0014c254
|
ulong ma_pvio_cache_read(long param_1,void *param_2,ulong param_3)
{
long lVar1;
void *__src;
ulong uVar2;
void *pvVar3;
size_t sVar4;
if (param_1 == 0) {
uVar2 = 0xffffffffffffffff;
}
else {
lVar1 = *(long *)(param_1 + 8);
if (lVar1 == 0) {
LAB_0014c269:
uVar2 = ma_pvio_read(param_1,param_2,param_3);
return uVar2;
}
pvVar3 = (void *)(*(long *)(param_1 + 0x18) + lVar1);
__src = *(void **)(param_1 + 0x10);
sVar4 = (long)pvVar3 - (long)__src;
if (pvVar3 < __src || sVar4 == 0) {
if (0x7ff < param_3) goto LAB_0014c269;
uVar2 = ma_pvio_read(param_1,lVar1,0x4000);
if (0 < (long)uVar2) {
if (param_3 < uVar2) {
*(ulong *)(param_1 + 0x18) = uVar2;
*(ulong *)(param_1 + 0x10) = (long)*(void **)(param_1 + 8) + param_3;
uVar2 = param_3;
}
memcpy(param_2,*(void **)(param_1 + 8),uVar2);
}
}
else {
uVar2 = param_3;
if ((long)sVar4 < (long)param_3) {
uVar2 = sVar4;
}
memcpy(param_2,__src,uVar2);
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + uVar2;
}
}
return uVar2;
}
|
|
1,992 | my_multi_malloc_large | eloqsql/mysys/mulalloc.c | void *my_multi_malloc_large(PSI_memory_key key, myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
ulonglong tot_length,length;
DBUG_ENTER("my_multi_malloc");
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args,ulonglong);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *) my_malloc(key, (size_t) tot_length, myFlags)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,ulonglong);
res+=ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
} | O0 | c | my_multi_malloc_large:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0xeceb1
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)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%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 $0x10, (%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 0xecf3b
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 0xecf58
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 0xecff3
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0xecfab
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 0xecfc8
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0xecf00
leaq -0x30(%rbp), %rax
movl -0xc(%rbp), %edi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xf3830
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xed020
jmp 0xed013
movq $0x0, -0x8(%rbp)
jmp 0xed156
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 $0x10, (%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 0xed087
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 0xed0a4
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 0xed14a
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 0xed102
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 0xed11f
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
movq (%rax), %rax
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 0xed04c
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)
nopl (%rax)
| my_multi_malloc_large:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_ECEB1
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_ECEB1:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
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], 10h
mov [rbp+var_50], 0
loc_ECF00:
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_ECF3B
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_ECF58
loc_ECF3B:
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_ECF58:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_ECFF3
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_ECFAB
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_ECFC8
loc_ECFAB:
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_ECFC8:
mov rax, [rbp+var_140]
mov rax, [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_ECF00
loc_ECFF3:
lea rax, [rbp+var_30]
mov edi, [rbp+var_C]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_18]
call my_malloc
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_ED020
jmp short $+2
loc_ED013:
mov [rbp+var_8], 0
jmp loc_ED156
loc_ED020:
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], 10h
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_ED04C:
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_ED087
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_ED0A4
loc_ED087:
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_ED0A4:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_ED14A
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_ED102
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_ED11F
loc_ED102:
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_ED11F:
mov rax, [rbp+var_170]
mov rax, [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_ED04C
loc_ED14A:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_ED156:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
| long long my_multi_malloc_large(unsigned int a1, long long a2, ...)
{
_QWORD *overflow_arg_area; // rax
_QWORD *v3; // rax
_QWORD *v4; // rax
_QWORD *v5; // rax
long long i; // [rsp+120h] [rbp-50h]
long long j; // [rsp+128h] [rbp-48h]
long long v9; // [rsp+130h] [rbp-40h]
va_list va; // [rsp+140h] [rbp-30h] BYREF
long long v11; // [rsp+158h] [rbp-18h]
unsigned int v12; // [rsp+164h] [rbp-Ch]
va_start(va, a2);
v12 = a1;
v11 = a2;
for ( i = 0LL; ; i += (*v3 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*overflow_arg_area )
break;
if ( va[0].gp_offset > 0x28 )
{
v3 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v3 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
v9 = my_malloc(v12, i, v11);
if ( !v9 )
return 0LL;
va_end(va);
va_start(va, a2);
for ( j = v9; ; j += (*v5 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
v4 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*v4 )
break;
*(_QWORD *)*v4 = j;
if ( va[0].gp_offset > 0x28 )
{
v5 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v5 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
return v9;
}
| my_multi_malloc_large:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x001eceb1
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_001eceb1:
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 dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
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],0x10
MOV qword ptr [RBP + -0x50],0x0
LAB_001ecf00:
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 0x001ecf3b
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 0x001ecf58
LAB_001ecf3b:
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_001ecf58:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ecff3
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 0x001ecfab
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 0x001ecfc8
LAB_001ecfab:
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_001ecfc8:
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword 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 0x001ecf00
LAB_001ecff3:
LEA RAX,[RBP + -0x30]
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001f3830
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001ed020
JMP 0x001ed013
LAB_001ed013:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001ed156
LAB_001ed020:
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],0x10
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ed04c:
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 0x001ed087
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 0x001ed0a4
LAB_001ed087:
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_001ed0a4:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001ed14a
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 0x001ed102
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 0x001ed11f
LAB_001ed102:
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_001ed11f:
MOV RAX,qword ptr [RBP + -0x170]
MOV RAX,qword 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 0x001ed04c
LAB_001ed14a:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001ed156:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long my_multi_malloc_large
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long *local_178;
long *local_160;
long *local_148;
long *local_130;
long local_118 [4];
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;
long local_60;
long local_58;
long local_50;
long local_40;
uint local_38;
int4 local_34;
long *local_30;
long *local_28;
int8 local_20;
int4 local_14;
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 = (long *)&stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 1;
}
local_40 = *local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 1;
}
local_60 = *local_148;
local_58 = (local_60 + 7U & 0xfffffffffffffff8) + local_58;
}
local_118[2] = param_11;
local_118[3] = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_20 = param_10;
local_14 = param_9;
local_10 = my_malloc(param_9,local_58,param_10);
if (local_10 == 0) {
local_10 = 0;
}
else {
local_30 = (long *)&stack0x00000008;
local_38 = 0x10;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 1;
}
if ((long *)*local_160 == (long *)0x0) break;
*(long *)*local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 1;
}
local_50 = (*local_178 + 7U & 0xfffffffffffffff8) + local_50;
}
}
return local_10;
}
|
|
1,993 | treeFirst | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_island.c | static int treeFirst(const mjModel* m, const mjData* d, int tree[2], int i) {
int efc_type = d->efc_type[i];
int efc_id = d->efc_id[i];
// clear outputs
tree[0] = -1;
tree[1] = -1;
// ==== fast handling of special cases
// joint friction
if (efc_type == mjCNSTR_FRICTION_DOF) {
tree[0] = m->dof_treeid[efc_id];
return -1;
}
// joint limit
if (efc_type == mjCNSTR_LIMIT_JOINT) {
tree[0] = m->dof_treeid[m->jnt_dofadr[efc_id]];
return -1;
}
// contact
if (efc_type == mjCNSTR_CONTACT_FRICTIONLESS ||
efc_type == mjCNSTR_CONTACT_PYRAMIDAL ||
efc_type == mjCNSTR_CONTACT_ELLIPTIC) {
tree[0] = m->body_treeid[m->geom_bodyid[d->contact[efc_id].geom[0]]];
tree[1] = m->body_treeid[m->geom_bodyid[d->contact[efc_id].geom[1]]];
// handle static bodies
if (tree[0] < 0) {
if (tree[1] < 0) {
mjERROR("contact %d is between two static bodies", efc_id); // SHOULD NOT OCCUR
} else {
int tmp = tree[0];
tree[0] = tree[1];
tree[1] = tmp;
}
}
return -1;
}
// connect or weld constraints
if (efc_type == mjCNSTR_EQUALITY) {
mjtEq eq_type = m->eq_type[efc_id];
if (eq_type == mjEQ_CONNECT || eq_type == mjEQ_WELD) {
tree[0] = m->body_treeid[m->eq_obj1id[efc_id]];
tree[1] = m->body_treeid[m->eq_obj2id[efc_id]];
// handle static bodies
if (tree[0] < 0) {
if (tree[1] < 0) {
mjERROR("equality %d is between two static bodies", efc_id); // SHOULD NOT OCCUR
} else {
int tmp = tree[0];
tree[0] = tree[1];
tree[1] = tmp;
}
}
return -1;
}
}
// ==== generic case: scan Jacobian
int index = 0;
tree[0] = treeNext(m, d, -1, i, &index);
if (tree[0] < 0) {
mjERROR("no tree found for constraint %d", i); // SHOULD NOT OCCUR
}
return index;
} | O3 | c | treeFirst:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp # imm = 0x410
movl %ecx, %ebp
movq %rdx, %r14
movslq %ecx, %rcx
movq 0x27a60(%rsi), %rax
movq 0x27a68(%rsi), %rdx
movl (%rax,%rcx,4), %eax
movslq (%rdx,%rcx,4), %rbx
movq $-0x1, (%r14)
cmpl $0x3, %eax
je 0x575aa
cmpl $0x1, %eax
jne 0x575d5
movq 0x6d8(%rdi), %rax
movl (%rax,%rbx,4), %eax
jmp 0x575bf
movq 0x648(%rdi), %rax
movq 0x6d8(%rdi), %rcx
movslq (%rax,%rbx,4), %rax
movl (%rcx,%rax,4), %eax
movl %eax, (%r14)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x410, %rsp # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
leal -0x5(%rax), %ecx
cmpl $0x2, %ecx
ja 0x57639
movq 0x570(%rdi), %rcx
movq 0x748(%rdi), %rdx
movq 0x27a58(%rsi), %rsi
leaq (%rbx,%rbx,8), %rdi
shlq $0x6, %rdi
movslq 0x214(%rsi,%rdi), %rax
movslq (%rdx,%rax,4), %rax
movl (%rcx,%rax,4), %eax
movl %eax, (%r14)
movslq 0x218(%rsi,%rdi), %rsi
movslq (%rdx,%rsi,4), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x4(%r14)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax
jns 0x575c7
testl %ecx, %ecx
js 0x57713
movl %ecx, (%r14)
movl %eax, 0x4(%r14)
jmp 0x575c7
testl %eax, %eax
jne 0x5764a
movq 0xd38(%rdi), %rax
cmpl $0x1, (%rax,%rbx,4)
jbe 0x576ad
leaq 0xc(%rsp), %r8
movl $0x0, (%r8)
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movl %ebp, %ecx
callq 0x57895
movl %eax, (%r14)
testl %eax, %eax
jns 0x576a4
leaq 0x166f47(%rip), %rsi # 0x1be5b7
leaq 0x10(%rsp), %rbx
movl $0x400, %edx # imm = 0x400
movq %rbx, %rdi
callq 0x2d240
leaq 0x19(%rsp), %rdi
leaq 0x166f88(%rip), %rdx # 0x1be616
movl $0x3f7, %esi # imm = 0x3F7
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2d250
movq %rbx, %rdi
callq 0x2d260
movl 0xc(%rsp), %ebp
jmp 0x575c7
movq 0x570(%rdi), %rcx
movq 0xd40(%rdi), %rax
movslq (%rax,%rbx,4), %rax
movl (%rcx,%rax,4), %eax
movl %eax, (%r14)
movq 0xd48(%rdi), %rdx
movslq (%rdx,%rbx,4), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x4(%r14)
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testl %eax, %eax
jns 0x575c7
testl %ecx, %ecx
jns 0x57630
leaq 0x166ec4(%rip), %rsi # 0x1be5b7
leaq 0x10(%rsp), %r14
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
callq 0x2d240
leaq 0x19(%rsp), %rdi
leaq 0x166eda(%rip), %rdx # 0x1be5eb
jmp 0x57738
leaq 0x166e9d(%rip), %rsi # 0x1be5b7
leaq 0x10(%rsp), %r14
movl $0x400, %edx # imm = 0x400
movq %r14, %rdi
callq 0x2d240
leaq 0x19(%rsp), %rdi
leaq 0x166e89(%rip), %rdx # 0x1be5c1
movl $0x3f7, %esi # imm = 0x3F7
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2d250
movq %r14, %rdi
callq 0x2d260
jmp 0x575c7
| treeFirst:
push rbp
push r14
push rbx
sub rsp, 410h
mov ebp, ecx
mov r14, rdx
movsxd rcx, ecx
mov rax, [rsi+27A60h]
mov rdx, qword ptr ds:stru_27A68.r_offset[rsi]
mov eax, [rax+rcx*4]
movsxd rbx, dword ptr [rdx+rcx*4]
mov qword ptr [r14], 0FFFFFFFFFFFFFFFFh
cmp eax, 3
jz short loc_575AA
cmp eax, 1
jnz short loc_575D5
mov rax, [rdi+6D8h]
mov eax, [rax+rbx*4]
jmp short loc_575BF
loc_575AA:
mov rax, [rdi+648h]
mov rcx, [rdi+6D8h]
movsxd rax, dword ptr [rax+rbx*4]
mov eax, [rcx+rax*4]
loc_575BF:
mov [r14], eax
mov ebp, 0FFFFFFFFh
loc_575C7:
mov eax, ebp
add rsp, 410h
pop rbx
pop r14
pop rbp
retn
loc_575D5:
lea ecx, [rax-5]
cmp ecx, 2
ja short loc_57639
mov rcx, [rdi+570h]
mov rdx, [rdi+748h]
mov rsi, [rsi+27A58h]
lea rdi, [rbx+rbx*8]
shl rdi, 6
movsxd rax, dword ptr [rsi+rdi+214h]
movsxd rax, dword ptr [rdx+rax*4]
mov eax, [rcx+rax*4]
mov [r14], eax
movsxd rsi, dword ptr [rsi+rdi+218h]
movsxd rdx, dword ptr [rdx+rsi*4]
mov ecx, [rcx+rdx*4]
mov [r14+4], ecx
mov ebp, 0FFFFFFFFh
test eax, eax
jns short loc_575C7
test ecx, ecx
js loc_57713
loc_57630:
mov [r14], ecx
mov [r14+4], eax
jmp short loc_575C7
loc_57639:
test eax, eax
jnz short loc_5764A
mov rax, [rdi+0D38h]
cmp dword ptr [rax+rbx*4], 1
jbe short loc_576AD
loc_5764A:
lea r8, [rsp+428h+var_41C]
mov dword ptr [r8], 0
mov edx, 0FFFFFFFFh
mov ecx, ebp
call treeNext
mov [r14], eax
test eax, eax
jns short loc_576A4
lea rsi, aTreefirst; "treeFirst"
lea rbx, [rsp+428h+var_418]
mov edx, 400h
mov rdi, rbx
call _strncpy
lea rdi, [rsp+428h+var_40F]
lea rdx, aNoTreeFoundFor; ": no tree found for constraint %d"
mov esi, 3F7h
mov ecx, ebp
xor eax, eax
call _snprintf
mov rdi, rbx
call _mju_error_raw
loc_576A4:
mov ebp, [rsp+428h+var_41C]
jmp loc_575C7
loc_576AD:
mov rcx, [rdi+570h]
mov rax, [rdi+0D40h]
movsxd rax, dword ptr [rax+rbx*4]
mov eax, [rcx+rax*4]
mov [r14], eax
mov rdx, [rdi+0D48h]
movsxd rdx, dword ptr [rdx+rbx*4]
mov ecx, [rcx+rdx*4]
mov [r14+4], ecx
mov ebp, 0FFFFFFFFh
test eax, eax
jns loc_575C7
test ecx, ecx
jns loc_57630
lea rsi, aTreefirst; "treeFirst"
lea r14, [rsp+428h+var_418]
mov edx, 400h
mov rdi, r14
call _strncpy
lea rdi, [rsp+428h+var_40F]
lea rdx, aEqualityDIsBet; ": equality %d is between two static bod"...
jmp short loc_57738
loc_57713:
lea rsi, aTreefirst; "treeFirst"
lea r14, [rsp+428h+var_418]
mov edx, 400h
mov rdi, r14
call _strncpy
lea rdi, [rsp+428h+var_40F]
lea rdx, aContactDIsBetw; ": contact %d is between two static bodi"...
loc_57738:
mov esi, 3F7h
mov ecx, ebx
xor eax, eax
call _snprintf
mov rdi, r14
call _mju_error_raw
jmp loc_575C7
| long long treeFirst(_QWORD *a1, long long a2, long long a3, unsigned int a4)
{
int v6; // eax
long long v7; // rbx
int v8; // eax
unsigned int v9; // ebp
long long v11; // rcx
long long v12; // rdx
long long v13; // rsi
int v14; // eax
int v15; // ecx
int v16; // eax
long long v17; // rcx
unsigned int v18; // [rsp+Ch] [rbp-41Ch] BYREF
_BYTE v19[9]; // [rsp+10h] [rbp-418h] BYREF
_BYTE v20[1039]; // [rsp+19h] [rbp-40Fh] BYREF
v6 = *(_DWORD *)(*(_QWORD *)(a2 + 162400) + 4LL * (int)a4);
v7 = *(int *)(*(unsigned long long *)((char *)&stru_27A68.r_offset + a2) + 4LL * (int)a4);
*(_QWORD *)a3 = -1LL;
if ( v6 == 3 )
{
v8 = *(_DWORD *)(a1[219] + 4LL * *(int *)(a1[201] + 4 * v7));
goto LABEL_5;
}
if ( v6 == 1 )
{
v8 = *(_DWORD *)(a1[219] + 4 * v7);
LABEL_5:
*(_DWORD *)a3 = v8;
return (unsigned int)-1;
}
if ( (unsigned int)(v6 - 5) <= 2 )
{
v11 = a1[174];
v12 = a1[233];
v13 = *(_QWORD *)(a2 + 162392);
v14 = *(_DWORD *)(v11 + 4LL * *(int *)(v12 + 4LL * *(int *)(v13 + 576 * v7 + 532)));
*(_DWORD *)a3 = v14;
v15 = *(_DWORD *)(v11 + 4LL * *(int *)(v12 + 4LL * *(int *)(v13 + 576 * v7 + 536)));
*(_DWORD *)(a3 + 4) = v15;
v9 = -1;
if ( v14 >= 0 )
return v9;
if ( v15 >= 0 )
{
LABEL_10:
*(_DWORD *)a3 = v15;
*(_DWORD *)(a3 + 4) = v14;
return v9;
}
strncpy(v19, "treeFirst", 1024LL);
snprintf(v20, 1015LL, ": contact %d is between two static bodies", (unsigned int)v7);
LABEL_20:
mju_error_raw(v19);
return v9;
}
if ( !v6 && *(_DWORD *)(a1[423] + 4 * v7) <= 1u )
{
v17 = a1[174];
v14 = *(_DWORD *)(v17 + 4LL * *(int *)(a1[424] + 4 * v7));
*(_DWORD *)a3 = v14;
v15 = *(_DWORD *)(v17 + 4LL * *(int *)(a1[425] + 4 * v7));
*(_DWORD *)(a3 + 4) = v15;
v9 = -1;
if ( v14 >= 0 )
return v9;
if ( v15 >= 0 )
goto LABEL_10;
strncpy(v19, "treeFirst", 1024LL);
snprintf(v20, 1015LL, ": equality %d is between two static bodies", (unsigned int)v7);
goto LABEL_20;
}
v18 = 0;
v16 = treeNext(a1, a2, 0xFFFFFFFFLL, a4, &v18);
*(_DWORD *)a3 = v16;
if ( v16 < 0 )
{
strncpy(v19, "treeFirst", 1024LL);
snprintf(v20, 1015LL, ": no tree found for constraint %d", a4);
mju_error_raw(v19);
}
return v18;
}
| treeFirst:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x410
MOV EBP,ECX
MOV R14,RDX
MOVSXD RCX,ECX
MOV RAX,qword ptr [RSI + 0x27a60]
MOV RDX,qword ptr [RSI + 0x27a68]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOVSXD RBX,dword ptr [RDX + RCX*0x4]
MOV qword ptr [R14],-0x1
CMP EAX,0x3
JZ 0x001575aa
CMP EAX,0x1
JNZ 0x001575d5
MOV RAX,qword ptr [RDI + 0x6d8]
MOV EAX,dword ptr [RAX + RBX*0x4]
JMP 0x001575bf
LAB_001575aa:
MOV RAX,qword ptr [RDI + 0x648]
MOV RCX,qword ptr [RDI + 0x6d8]
MOVSXD RAX,dword ptr [RAX + RBX*0x4]
MOV EAX,dword ptr [RCX + RAX*0x4]
LAB_001575bf:
MOV dword ptr [R14],EAX
MOV EBP,0xffffffff
LAB_001575c7:
MOV EAX,EBP
ADD RSP,0x410
POP RBX
POP R14
POP RBP
RET
LAB_001575d5:
LEA ECX,[RAX + -0x5]
CMP ECX,0x2
JA 0x00157639
MOV RCX,qword ptr [RDI + 0x570]
MOV RDX,qword ptr [RDI + 0x748]
MOV RSI,qword ptr [RSI + 0x27a58]
LEA RDI,[RBX + RBX*0x8]
SHL RDI,0x6
MOVSXD RAX,dword ptr [RSI + RDI*0x1 + 0x214]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [R14],EAX
MOVSXD RSI,dword ptr [RSI + RDI*0x1 + 0x218]
MOVSXD RDX,dword ptr [RDX + RSI*0x4]
MOV ECX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [R14 + 0x4],ECX
MOV EBP,0xffffffff
TEST EAX,EAX
JNS 0x001575c7
TEST ECX,ECX
JS 0x00157713
LAB_00157630:
MOV dword ptr [R14],ECX
MOV dword ptr [R14 + 0x4],EAX
JMP 0x001575c7
LAB_00157639:
TEST EAX,EAX
JNZ 0x0015764a
MOV RAX,qword ptr [RDI + 0xd38]
CMP dword ptr [RAX + RBX*0x4],0x1
JBE 0x001576ad
LAB_0015764a:
LEA R8,[RSP + 0xc]
MOV dword ptr [R8],0x0
MOV EDX,0xffffffff
MOV ECX,EBP
CALL 0x00157895
MOV dword ptr [R14],EAX
TEST EAX,EAX
JNS 0x001576a4
LEA RSI,[0x2be5b7]
LEA RBX,[RSP + 0x10]
MOV EDX,0x400
MOV RDI,RBX
CALL 0x0012d240
LEA RDI,[RSP + 0x19]
LEA RDX,[0x2be616]
MOV ESI,0x3f7
MOV ECX,EBP
XOR EAX,EAX
CALL 0x0012d250
MOV RDI,RBX
CALL 0x0012d260
LAB_001576a4:
MOV EBP,dword ptr [RSP + 0xc]
JMP 0x001575c7
LAB_001576ad:
MOV RCX,qword ptr [RDI + 0x570]
MOV RAX,qword ptr [RDI + 0xd40]
MOVSXD RAX,dword ptr [RAX + RBX*0x4]
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV dword ptr [R14],EAX
MOV RDX,qword ptr [RDI + 0xd48]
MOVSXD RDX,dword ptr [RDX + RBX*0x4]
MOV ECX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [R14 + 0x4],ECX
MOV EBP,0xffffffff
TEST EAX,EAX
JNS 0x001575c7
TEST ECX,ECX
JNS 0x00157630
LEA RSI,[0x2be5b7]
LEA R14,[RSP + 0x10]
MOV EDX,0x400
MOV RDI,R14
CALL 0x0012d240
LEA RDI,[RSP + 0x19]
LEA RDX,[0x2be5eb]
JMP 0x00157738
LAB_00157713:
LEA RSI,[0x2be5b7]
LEA R14,[RSP + 0x10]
MOV EDX,0x400
MOV RDI,R14
CALL 0x0012d240
LEA RDI,[RSP + 0x19]
LEA RDX,[0x2be5c1]
LAB_00157738:
MOV ESI,0x3f7
MOV ECX,EBX
XOR EAX,EAX
CALL 0x0012d250
MOV RDI,R14
CALL 0x0012d260
JMP 0x001575c7
|
int4 treeFirst(long param_1,long param_2,int *param_3,uint param_4)
{
uint uVar1;
long lVar2;
long lVar3;
long lVar4;
int iVar5;
int iVar6;
char *__format;
long lVar7;
char local_418 [9];
char local_40f [1015];
iVar5 = *(int *)(*(long *)(param_2 + 0x27a60) + (long)(int)param_4 * 4);
uVar1 = *(uint *)(*(long *)(param_2 + 0x27a68) + (long)(int)param_4 * 4);
lVar7 = (long)(int)uVar1;
param_3[0] = -1;
param_3[1] = -1;
if (iVar5 == 3) {
iVar5 = *(int *)(*(long *)(param_1 + 0x6d8) +
(long)*(int *)(*(long *)(param_1 + 0x648) + lVar7 * 4) * 4);
}
else {
if (iVar5 != 1) {
if (iVar5 - 5U < 3) {
lVar2 = *(long *)(param_1 + 0x570);
lVar3 = *(long *)(param_1 + 0x748);
lVar4 = *(long *)(param_2 + 0x27a58);
iVar5 = *(int *)(lVar2 + (long)*(int *)(lVar3 + (long)*(int *)(lVar4 + 0x214 + lVar7 * 0x240
) * 4) * 4);
*param_3 = iVar5;
iVar6 = *(int *)(lVar2 + (long)*(int *)(lVar3 + (long)*(int *)(lVar4 + 0x218 + lVar7 * 0x240
) * 4) * 4);
param_3[1] = iVar6;
if (-1 < iVar5) {
return 0xffffffff;
}
if (iVar6 < 0) {
strncpy(local_418,"treeFirst",0x400);
__format = ": contact %d is between two static bodies";
LAB_00157738:
snprintf(local_40f,0x3f7,__format,(ulong)uVar1);
mju_error_raw(local_418);
return 0xffffffff;
}
}
else {
if ((iVar5 != 0) || (1 < *(uint *)(*(long *)(param_1 + 0xd38) + lVar7 * 4))) {
iVar5 = treeNext(param_1,param_2,0xffffffff,param_4);
*param_3 = iVar5;
if (iVar5 < 0) {
strncpy(local_418,"treeFirst",0x400);
snprintf(local_40f,0x3f7,": no tree found for constraint %d",(ulong)param_4);
mju_error_raw(local_418);
}
return 0;
}
lVar2 = *(long *)(param_1 + 0x570);
iVar5 = *(int *)(lVar2 + (long)*(int *)(*(long *)(param_1 + 0xd40) + lVar7 * 4) * 4);
*param_3 = iVar5;
iVar6 = *(int *)(lVar2 + (long)*(int *)(*(long *)(param_1 + 0xd48) + lVar7 * 4) * 4);
param_3[1] = iVar6;
if (-1 < iVar5) {
return 0xffffffff;
}
if (iVar6 < 0) {
strncpy(local_418,"treeFirst",0x400);
__format = ": equality %d is between two static bodies";
goto LAB_00157738;
}
}
*param_3 = iVar6;
param_3[1] = iVar5;
return 0xffffffff;
}
iVar5 = *(int *)(*(long *)(param_1 + 0x6d8) + lVar7 * 4);
}
*param_3 = iVar5;
return 0xffffffff;
}
|
|
1,994 | Settings::setLastResult(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | void Settings::setLastResult(const std::string& res) {
std::lock_guard<std::mutex> lock(settings_mutex);
lastResult = res;
} | O1 | cpp | Settings::setLastResult(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5520
testl %eax, %eax
jne 0x6ef5
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x74ce
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52f0
movl %eax, %edi
callq 0x5260
movq %rax, %r14
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rdi
callq 0x5600
nop
| _ZN8Settings13setLastResultERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_6EF5
lea rdi, [rbx+0D8h]
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _pthread_mutex_unlock
loc_6EF5:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long Settings::setLastResult(long long a1, long long a2)
{
int v2; // eax
v2 = pthread_mutex_lock(a1);
if ( v2 )
std::__throw_system_error(v2);
std::string::_M_assign(a1 + 216, a2);
return pthread_mutex_unlock(a1);
}
| setLastResult:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x00105520
TEST EAX,EAX
JNZ 0x00106ef5
LEA RDI,[RBX + 0xd8]
LAB_00106ede:
MOV RSI,R14
CALL 0x001074ce
LAB_00106ee6:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001052f0
LAB_00106ef5:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::setLastResult(std::__cxx11::string const&) */
void __thiscall Settings::setLastResult(Settings *this,string *param_1)
{
int iVar1;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar1 == 0) {
/* try { // try from 00106ede to 00106ee5 has its CatchHandler @ 00106efc */
std::__cxx11::string::_M_assign((string *)(this + 0xd8),param_1);
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
|
|
1,995 | Settings::setLastResult(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 666mxvbee[P]BattleShip/lib/Settings/Settings.cpp | void Settings::setLastResult(const std::string& res) {
std::lock_guard<std::mutex> lock(settings_mutex);
lastResult = res;
} | O3 | cpp | Settings::setLastResult(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5520
testl %eax, %eax
jne 0x6e99
leaq 0xd8(%rbx), %rdi
movq %r14, %rsi
callq 0x7478
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x52f0
movl %eax, %edi
callq 0x5260
movq %rax, %r14
movq %rbx, %rdi
callq 0x52f0
movq %r14, %rdi
callq 0x5600
nop
| _ZN8Settings13setLastResultERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_6E99
lea rdi, [rbx+0D8h]
mov rsi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _pthread_mutex_unlock
loc_6E99:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long Settings::setLastResult(long long a1, long long a2)
{
int v2; // eax
v2 = pthread_mutex_lock(a1);
if ( v2 )
std::__throw_system_error(v2);
std::string::_M_assign(a1 + 216, a2);
return pthread_mutex_unlock(a1);
}
| setLastResult:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x00105520
TEST EAX,EAX
JNZ 0x00106e99
LEA RDI,[RBX + 0xd8]
LAB_00106e82:
MOV RSI,R14
CALL 0x00107478
LAB_00106e8a:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001052f0
LAB_00106e99:
MOV EDI,EAX
CALL 0x00105260
|
/* Settings::setLastResult(std::__cxx11::string const&) */
void __thiscall Settings::setLastResult(Settings *this,string *param_1)
{
int iVar1;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar1 == 0) {
/* try { // try from 00106e82 to 00106e89 has its CatchHandler @ 00106ea0 */
std::__cxx11::string::_M_assign((string *)(this + 0xd8),param_1);
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
|
|
1,996 | nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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&, 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 | constexpr value_t type() const noexcept
{
return m_data.m_type;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__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&, 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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movzbl (%rdi), %eax
movb (%rsi), %cl
cmpb %cl, %al
jne 0x8fed8
cmpl $0x8, %eax
ja 0x900a0
movb $0x1, %bl
movl %eax, %eax
leaq 0x60c4a(%rip), %rcx # 0xf0b0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0x90029
movl %eax, %edx
xorb $0x5, %dl
movl %ecx, %r8d
xorb $0x7, %r8b
orb %r8b, %dl
jne 0x8fefa
cvtsi2sdq 0x8(%rdi), %xmm0
cmpeqsd 0x8(%rsi), %xmm0
jmp 0x8ffa0
movl %eax, %r9d
xorb $0x7, %r9b
movl %ecx, %edx
xorb $0x5, %dl
orb %dl, %r9b
jne 0x8ff16
cvtsi2sdq 0x8(%rsi), %xmm0
jmp 0x8ff9a
movl %eax, %r9d
xorb $0x6, %r9b
orb %r8b, %r9b
jne 0x8ff4a
movsd 0x8(%rdi), %xmm0
unpcklps 0x60b42(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x60b4a(%rip), %xmm0 # 0xf0a80
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cmpeqsd 0x8(%rsi), %xmm1
jmp 0x8ff83
movl %eax, %r8d
xorb $0x7, %r8b
xorb $0x6, %cl
orb %cl, %r8b
jne 0x900f1
movsd 0x8(%rsi), %xmm0
unpcklps 0x60b07(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x60b0f(%rip), %xmm0 # 0xf0a80
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
cmpeqsd 0x8(%rdi), %xmm1
movq %xmm1, %rbx
jmp 0x8ffa5
movb 0x8(%rdi), %al
cmpb 0x8(%rsi), %al
jmp 0x90029
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0x900e3
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %r14
movq 0x8(%rax), %r12
movq %r12, %rax
subq %r14, %rax
movq (%rcx), %r15
movq 0x8(%rcx), %rcx
subq %r15, %rcx
cmpq %rcx, %rax
jne 0x900a0
cmpq %r12, %r14
je 0x900e3
movq %r14, %rdi
movq %r15, %rsi
callq 0x8fe9a
movl %eax, %ebx
testb %al, %al
je 0x900e3
addq $0x10, %r14
addq $0x10, %r15
jmp 0x8ffd5
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq 0x8(%rax), %rdx
cmpq 0x8(%rcx), %rdx
jne 0x900a0
testq %rdx, %rdx
je 0x900e3
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x1ba70
testl %eax, %eax
sete %bl
jmp 0x900e3
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %r12, %rax
subq %r15, %rax
movq (%rcx), %r14
movq 0x8(%rcx), %rcx
subq %r14, %rcx
cmpq %rcx, %rax
jne 0x900a0
cmpq %r12, %r15
je 0x900e3
addq $0x20, %r14
movq 0x8(%r15), %rdx
cmpq -0x18(%r14), %rdx
jne 0x900a0
testq %rdx, %rdx
je 0x90081
movq -0x20(%r14), %rsi
movq (%r15), %rdi
callq 0x1ba70
testl %eax, %eax
jne 0x900a0
leaq 0x20(%r15), %rdi
movq %r14, %rsi
callq 0x8fe9a
testb %al, %al
je 0x900a0
addq $0x30, %r15
addq $0x30, %r14
cmpq %r12, %r15
jne 0x90062
jmp 0x900e3
xorl %ebx, %ebx
jmp 0x900e3
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %rcx
leaq 0x18(%rax), %rdx
leaq 0x20(%rax), %rsi
leaq 0x20(%rsp), %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x18(%rcx), %rax
leaq 0x20(%rcx), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
callq 0x9017a
movl %eax, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl %eax, %r8d
xorb $0x6, %r8b
orb %dl, %r8b
je 0x8fecb
xorb $0x5, %al
orb %cl, %al
je 0x8fecb
xorl %ebx, %ebx
xorl %edx, %edx
callq 0x9011e
jmp 0x900e3
movq %rax, %rdi
callq 0x2290d
| _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_:
push r15
push r14
push r12
push rbx
sub rsp, 38h
movzx eax, byte ptr [rdi]
mov cl, [rsi]
cmp al, cl
jnz short loc_8FED8
cmp eax, 8; switch 9 cases
ja def_8FEC9; jumptable 000000000008FEC9 default case
mov bl, 1
mov eax, eax
lea rcx, jpt_8FEC9
movsxd rax, ds:(jpt_8FEC9 - 0F0B0Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_8FECB:
mov rax, [rdi+8]; jumptable 000000000008FEC9 cases 5,6
cmp rax, [rsi+8]
jmp loc_90029
loc_8FED8:
mov edx, eax
xor dl, 5
mov r8d, ecx
xor r8b, 7
or dl, r8b
jnz short loc_8FEFA
cvtsi2sd xmm0, qword ptr [rdi+8]
cmpeqsd xmm0, qword ptr [rsi+8]
jmp loc_8FFA0
loc_8FEFA:
mov r9d, eax
xor r9b, 7
mov edx, ecx
xor dl, 5
or r9b, dl
jnz short loc_8FF16
cvtsi2sd xmm0, qword ptr [rsi+8]
jmp loc_8FF9A
loc_8FF16:
mov r9d, eax
xor r9b, 6
or r9b, r8b
jnz short loc_8FF4A
movsd xmm0, qword ptr [rdi+8]
unpcklps xmm0, cs:xmmword_F0A70
subpd xmm0, cs:xmmword_F0A80
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
cmpeqsd xmm1, qword ptr [rsi+8]
jmp short loc_8FF83
loc_8FF4A:
mov r8d, eax
xor r8b, 7
xor cl, 6
or r8b, cl
jnz loc_900F1
movsd xmm0, qword ptr [rsi+8]
unpcklps xmm0, cs:xmmword_F0A70
subpd xmm0, cs:xmmword_F0A80
movapd xmm1, xmm0
unpckhpd xmm1, xmm0
addsd xmm1, xmm0
cmpeqsd xmm1, qword ptr [rdi+8]
loc_8FF83:
movq rbx, xmm1
jmp short loc_8FFA5
loc_8FF8A:
mov al, [rdi+8]; jumptable 000000000008FEC9 case 4
cmp al, [rsi+8]
jmp loc_90029
loc_8FF95:
movsd xmm0, qword ptr [rsi+8]; jumptable 000000000008FEC9 case 7
loc_8FF9A:
cmpeqsd xmm0, qword ptr [rdi+8]
loc_8FFA0:
movq rbx, xmm0
loc_8FFA5:
and ebx, 1
jmp loc_900E3; jumptable 000000000008FEC9 case 0
loc_8FFAD:
mov rax, [rdi+8]; jumptable 000000000008FEC9 case 2
mov rcx, [rsi+8]
mov r14, [rax]
mov r12, [rax+8]
mov rax, r12
sub rax, r14
mov r15, [rcx]
mov rcx, [rcx+8]
sub rcx, r15
cmp rax, rcx
jnz def_8FEC9; jumptable 000000000008FEC9 default case
loc_8FFD5:
cmp r14, r12
jz loc_900E3; jumptable 000000000008FEC9 case 0
mov rdi, r14
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov ebx, eax
test al, al
jz loc_900E3; jumptable 000000000008FEC9 case 0
add r14, 10h
add r15, 10h
jmp short loc_8FFD5
loc_8FFFD:
mov rax, [rdi+8]; jumptable 000000000008FEC9 case 3
mov rcx, [rsi+8]
mov rdx, [rax+8]
cmp rdx, [rcx+8]
jnz def_8FEC9; jumptable 000000000008FEC9 default case
test rdx, rdx
jz loc_900E3; jumptable 000000000008FEC9 case 0
mov rsi, [rcx]
mov rdi, [rax]
call _bcmp
test eax, eax
loc_90029:
setz bl
jmp loc_900E3; jumptable 000000000008FEC9 case 0
loc_90031:
mov rax, [rdi+8]; jumptable 000000000008FEC9 case 1
mov rcx, [rsi+8]
mov r15, [rax]
mov r12, [rax+8]
mov rax, r12
sub rax, r15
mov r14, [rcx]
mov rcx, [rcx+8]
sub rcx, r14
cmp rax, rcx
jnz short def_8FEC9; jumptable 000000000008FEC9 default case
cmp r15, r12
jz loc_900E3; jumptable 000000000008FEC9 case 0
add r14, 20h ; ' '
loc_90062:
mov rdx, [r15+8]
cmp rdx, [r14-18h]
jnz short def_8FEC9; jumptable 000000000008FEC9 default case
test rdx, rdx
jz short loc_90081
mov rsi, [r14-20h]
mov rdi, [r15]
call _bcmp
test eax, eax
jnz short def_8FEC9; jumptable 000000000008FEC9 default case
loc_90081:
lea rdi, [r15+20h]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
test al, al
jz short def_8FEC9; jumptable 000000000008FEC9 default case
add r15, 30h ; '0'
add r14, 30h ; '0'
cmp r15, r12
jnz short loc_90062
jmp short loc_900E3; jumptable 000000000008FEC9 case 0
def_8FEC9:
xor ebx, ebx; jumptable 000000000008FEC9 default case
jmp short loc_900E3; jumptable 000000000008FEC9 case 0
loc_900A4:
mov rax, [rdi+8]; jumptable 000000000008FEC9 case 8
mov rcx, [rsi+8]
lea rdx, [rax+18h]
lea rsi, [rax+20h]
lea rdi, [rsp+58h+var_38]
mov [rdi], rsi
mov [rdi+8], rdx
mov [rdi+10h], rax
lea rax, [rcx+18h]
lea rdx, [rcx+20h]
lea rsi, [rsp+58h+var_50]
mov [rsi], rdx
mov [rsi+8], rax
mov [rsi+10h], rcx
call _ZNSt15__tuple_compareISt5tupleIJRKSt6vectorIhSaIhEERKmRKbEESA_Lm0ELm3EE4__eqERKSA_SD_; std::__tuple_compare<std::tuple<std::vector<uchar> const&,ulong const&,bool const&>,std::tuple<std::vector<uchar> const&,ulong const&,bool const&>,0ul,3ul>::__eq(std::tuple<std::vector<uchar> const&,ulong const&,bool const&> const&,std::tuple<std::vector<uchar> const&,ulong const&,bool const&> const&)
mov ebx, eax
loc_900E3:
mov eax, ebx; jumptable 000000000008FEC9 case 0
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
loc_900F1:
mov r8d, eax
xor r8b, 6
or r8b, dl
jz loc_8FECB; jumptable 000000000008FEC9 cases 5,6
xor al, 5
or al, cl
jz loc_8FECB; jumptable 000000000008FEC9 cases 5,6
xor ebx, ebx
xor edx, edx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE18compares_unorderedERKSD_SF_b; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::compares_unordered(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
jmp short loc_900E3; jumptable 000000000008FEC9 case 0
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::operator==(unsigned __int8 *a1, unsigned __int8 *a2, __m128d a3)
{
unsigned int v3; // ebx
unsigned __int8 v4; // al
unsigned __int8 v5; // cl
bool v6; // zf
__m128d v7; // rt1
unsigned __int8 v8; // dl
__m128d v9; // xmm0
__m128d v10; // xmm1
__m128d v11; // rt1
__int8 v12; // xmm1_1
unsigned __int8 v13; // cl
__m128d v14; // xmm0
__m128d v15; // xmm1
__m128d v16; // rt1
__int8 v17; // bl
__m128d v18; // rt1
long long *v19; // rax
long long *v20; // rcx
long long v21; // r14
long long v22; // r12
long long v23; // r15
_QWORD *v24; // rax
_QWORD *v25; // rcx
long long v26; // rdx
_QWORD *v27; // rax
_QWORD *v28; // rcx
_QWORD *v29; // r15
_QWORD *v30; // r12
long long v31; // r14
long long v32; // rdx
v4 = *a1;
v5 = *a2;
if ( *a1 != *a2 )
{
if ( v5 ^ 7 | v4 ^ 5 )
{
v8 = v5 ^ 5;
if ( v5 ^ 5 | v4 ^ 7 )
{
if ( v5 ^ 7 | v4 ^ 6 )
{
v13 = v5 ^ 6;
if ( v13 | v4 ^ 7 )
{
if ( v8 | v4 ^ 6 && v13 | v4 ^ 5 )
{
v3 = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::compares_unordered(
a1,
a2,
0LL);
}
else
{
LABEL_3:
v6 = *((_QWORD *)a1 + 1) == *((_QWORD *)a2 + 1);
LABEL_25:
LOBYTE(v3) = v6;
}
return v3;
}
v14 = _mm_sub_pd(
(__m128d)_mm_unpacklo_ps((__m128)*((unsigned long long *)a2 + 1), (__m128)xmmword_F0A70),
(__m128d)xmmword_F0A80);
v15 = _mm_unpackhi_pd(v14, v14);
v15.m128d_f64[0] = v15.m128d_f64[0] + v14.m128d_f64[0];
v16.m128d_f64[0] = *((double *)a1 + 1);
v12 = *(_OWORD *)&_mm_cmpeq_sd(v15, v16);
}
else
{
v9 = _mm_sub_pd(
(__m128d)_mm_unpacklo_ps((__m128)*((unsigned long long *)a1 + 1), (__m128)xmmword_F0A70),
(__m128d)xmmword_F0A80);
v10 = _mm_unpackhi_pd(v9, v9);
v10.m128d_f64[0] = v10.m128d_f64[0] + v9.m128d_f64[0];
v11.m128d_f64[0] = *((double *)a2 + 1);
v12 = *(_OWORD *)&_mm_cmpeq_sd(v10, v11);
}
v17 = v12;
return v17 & 1;
}
a3.m128d_f64[0] = (double)(int)*((_QWORD *)a2 + 1);
LABEL_15:
v18.m128d_f64[0] = *((double *)a1 + 1);
LOBYTE(a3.m128d_f64[0]) = *(_OWORD *)&_mm_cmpeq_sd(a3, v18);
}
else
{
a3.m128d_f64[0] = (double)(int)*((_QWORD *)a1 + 1);
v7.m128d_f64[0] = *((double *)a2 + 1);
LOBYTE(a3.m128d_f64[0]) = *(_OWORD *)&_mm_cmpeq_sd(a3, v7);
}
v17 = LOBYTE(a3.m128d_f64[0]);
return v17 & 1;
}
LOBYTE(v3) = 1;
switch ( *a1 )
{
case 0u:
return v3;
case 1u:
v27 = (_QWORD *)*((_QWORD *)a1 + 1);
v28 = (_QWORD *)*((_QWORD *)a2 + 1);
v29 = (_QWORD *)*v27;
v30 = (_QWORD *)v27[1];
if ( (_QWORD *)((char *)v30 - *v27) != (_QWORD *)(v28[1] - *v28) )
return 0;
if ( v29 == v30 )
return v3;
v31 = *v28 + 32LL;
break;
case 2u:
v19 = (long long *)*((_QWORD *)a1 + 1);
v20 = (long long *)*((_QWORD *)a2 + 1);
v21 = *v19;
v22 = v19[1];
v23 = *v20;
if ( v22 - *v19 != v20[1] - *v20 )
return 0;
while ( v21 != v22 )
{
v3 = nlohmann::json_abi_v3_11_3::operator==(v21, v23);
if ( !(_BYTE)v3 )
break;
v21 += 16LL;
v23 += 16LL;
}
return v3;
case 3u:
v24 = (_QWORD *)*((_QWORD *)a1 + 1);
v25 = (_QWORD *)*((_QWORD *)a2 + 1);
v26 = v24[1];
if ( v26 != v25[1] )
return 0;
if ( !v26 )
return v3;
v6 = (unsigned int)bcmp(*v24, *v25) == 0;
goto LABEL_25;
case 4u:
v6 = a1[8] == a2[8];
goto LABEL_25;
case 5u:
case 6u:
goto LABEL_3;
case 7u:
a3 = (__m128d)*((unsigned long long *)a2 + 1);
goto LABEL_15;
case 8u:
return (unsigned int)std::__tuple_compare<std::tuple<std::vector<unsigned char> const&,unsigned long const&,bool const&>,std::tuple<std::vector<unsigned char> const&,unsigned long const&,bool const&>,0ul,3ul>::__eq();
default:
return 0;
}
while ( 1 )
{
v32 = v29[1];
if ( v32 != *(_QWORD *)(v31 - 24) || v32 && (unsigned int)bcmp(*v29, *(_QWORD *)(v31 - 32)) )
break;
if ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v29 + 4, v31) )
break;
v29 += 6;
v31 += 48LL;
if ( v29 == v30 )
return v3;
}
return 0;
}
| operator==:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOVZX EAX,byte ptr [RDI]
MOV CL,byte ptr [RSI]
CMP AL,CL
JNZ 0x0018fed8
CMP EAX,0x8
JA 0x001900a0
MOV BL,0x1
MOV EAX,EAX
LEA RCX,[0x1f0b0c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV RAX,qword ptr [RDI + 0x8]
CMP RAX,qword ptr [RSI + 0x8]
JMP 0x00190029
LAB_0018fed8:
MOV EDX,EAX
XOR DL,0x5
MOV R8D,ECX
XOR R8B,0x7
OR DL,R8B
JNZ 0x0018fefa
CVTSI2SD XMM0,qword ptr [RDI + 0x8]
CMPEQSD XMM0,qword ptr [RSI + 0x8]
JMP 0x0018ffa0
LAB_0018fefa:
MOV R9D,EAX
XOR R9B,0x7
MOV EDX,ECX
XOR DL,0x5
OR R9B,DL
JNZ 0x0018ff16
CVTSI2SD XMM0,qword ptr [RSI + 0x8]
JMP 0x0018ff9a
LAB_0018ff16:
MOV R9D,EAX
XOR R9B,0x6
OR R9B,R8B
JNZ 0x0018ff4a
MOVSD XMM0,qword ptr [RDI + 0x8]
UNPCKLPS XMM0,xmmword ptr [0x001f0a70]
SUBPD XMM0,xmmword ptr [0x001f0a80]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
CMPEQSD XMM1,qword ptr [RSI + 0x8]
JMP 0x0018ff83
LAB_0018ff4a:
MOV R8D,EAX
XOR R8B,0x7
XOR CL,0x6
OR R8B,CL
JNZ 0x001900f1
MOVSD XMM0,qword ptr [RSI + 0x8]
UNPCKLPS XMM0,xmmword ptr [0x001f0a70]
SUBPD XMM0,xmmword ptr [0x001f0a80]
MOVAPD XMM1,XMM0
UNPCKHPD XMM1,XMM0
ADDSD XMM1,XMM0
CMPEQSD XMM1,qword ptr [RDI + 0x8]
LAB_0018ff83:
MOVQ RBX,XMM1
JMP 0x0018ffa5
caseD_4:
MOV AL,byte ptr [RDI + 0x8]
CMP AL,byte ptr [RSI + 0x8]
JMP 0x00190029
caseD_7:
MOVSD XMM0,qword ptr [RSI + 0x8]
LAB_0018ff9a:
CMPEQSD XMM0,qword ptr [RDI + 0x8]
LAB_0018ffa0:
MOVQ RBX,XMM0
LAB_0018ffa5:
AND EBX,0x1
JMP 0x001900e3
caseD_2:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RSI + 0x8]
MOV R14,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV RAX,R12
SUB RAX,R14
MOV R15,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,R15
CMP RAX,RCX
JNZ 0x001900a0
LAB_0018ffd5:
CMP R14,R12
JZ 0x001900e3
MOV RDI,R14
MOV RSI,R15
CALL 0x0018fe9a
MOV EBX,EAX
TEST AL,AL
JZ 0x001900e3
ADD R14,0x10
ADD R15,0x10
JMP 0x0018ffd5
caseD_3:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RSI + 0x8]
MOV RDX,qword ptr [RAX + 0x8]
CMP RDX,qword ptr [RCX + 0x8]
JNZ 0x001900a0
TEST RDX,RDX
JZ 0x001900e3
MOV RSI,qword ptr [RCX]
MOV RDI,qword ptr [RAX]
CALL 0x0011ba70
TEST EAX,EAX
LAB_00190029:
SETZ BL
JMP 0x001900e3
caseD_1:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV RAX,R12
SUB RAX,R15
MOV R14,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,R14
CMP RAX,RCX
JNZ 0x001900a0
CMP R15,R12
JZ 0x001900e3
ADD R14,0x20
LAB_00190062:
MOV RDX,qword ptr [R15 + 0x8]
CMP RDX,qword ptr [R14 + -0x18]
JNZ 0x001900a0
TEST RDX,RDX
JZ 0x00190081
MOV RSI,qword ptr [R14 + -0x20]
MOV RDI,qword ptr [R15]
CALL 0x0011ba70
TEST EAX,EAX
JNZ 0x001900a0
LAB_00190081:
LEA RDI,[R15 + 0x20]
MOV RSI,R14
CALL 0x0018fe9a
TEST AL,AL
JZ 0x001900a0
ADD R15,0x30
ADD R14,0x30
CMP R15,R12
JNZ 0x00190062
JMP 0x001900e3
LAB_001900a0:
XOR EBX,EBX
JMP 0x001900e3
caseD_8:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RSI + 0x8]
LEA RDX,[RAX + 0x18]
LEA RSI,[RAX + 0x20]
LEA RDI,[RSP + 0x20]
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RDI + 0x10],RAX
LEA RAX,[RCX + 0x18]
LEA RDX,[RCX + 0x20]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RDX
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RSI + 0x10],RCX
LAB_001900dc:
CALL 0x0019017a
MOV EBX,EAX
caseD_0:
MOV EAX,EBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001900f1:
MOV R8D,EAX
XOR R8B,0x6
OR R8B,DL
JZ 0x0018fecb
XOR AL,0x5
OR AL,CL
JZ 0x0018fecb
XOR EBX,EBX
XOR EDX,EDX
CALL 0x0019011e
JMP 0x001900e3
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* nlohmann::json_abi_v3_11_3::TEMPNAMEPLACEHOLDERVALUE(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
ulong nlohmann::json_abi_v3_11_3::operator==(basic_json *param_1,basic_json *param_2)
{
basic_json bVar1;
basic_json bVar2;
basic_json *pbVar3;
size_t sVar4;
int8 *puVar5;
long lVar6;
double dVar7;
char cVar8;
int iVar9;
uint uVar10;
ulong unaff_RBX;
basic_json *pbVar11;
basic_json *pbVar12;
int8 *puVar13;
bool bVar14;
long local_50;
long local_48;
long local_40;
long local_38;
long local_30;
long local_28;
bVar2 = *param_1;
bVar1 = *param_2;
if (bVar2 != bVar1) {
if (bVar2 == (basic_json)0x5 && ((byte)bVar1 ^ 7) == 0) {
bVar14 = (double)*(long *)(param_1 + 8) == *(double *)(param_2 + 8);
}
else {
if (bVar2 == (basic_json)0x7 && ((byte)bVar1 ^ 5) == 0) {
dVar7 = (double)*(long *)(param_2 + 8);
goto LAB_0018ff9a;
}
if (bVar2 == (basic_json)0x6 && ((byte)bVar1 ^ 7) == 0) {
bVar14 = ((double)CONCAT44(_UNK_001f0a74,(int)((ulong)*(int8 *)(param_1 + 8) >> 0x20))
- _UNK_001f0a88) +
((double)CONCAT44(_DAT_001f0a70,(int)*(int8 *)(param_1 + 8)) - _DAT_001f0a80)
== *(double *)(param_2 + 8);
}
else {
if (bVar2 != (basic_json)0x7 || ((byte)bVar1 ^ 6) != 0) {
if ((bVar2 != (basic_json)0x6 || ((byte)bVar1 ^ 5) != 0) &&
(bVar2 != (basic_json)0x5 || ((byte)bVar1 ^ 6) != 0)) {
unaff_RBX = 0;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::compares_unordered(param_1,param_2,false);
goto switchD_0018fec9_caseD_0;
}
goto switchD_0018fec9_caseD_5;
}
bVar14 = ((double)CONCAT44(_UNK_001f0a74,(int)((ulong)*(int8 *)(param_2 + 8) >> 0x20))
- _UNK_001f0a88) +
((double)CONCAT44(_DAT_001f0a70,(int)*(int8 *)(param_2 + 8)) - _DAT_001f0a80)
== *(double *)(param_1 + 8);
}
}
LAB_0018ffa5:
unaff_RBX = (ulong)(-(uint)bVar14 & 1);
goto switchD_0018fec9_caseD_0;
}
if (8 < (byte)bVar2) goto LAB_001900a0;
unaff_RBX = CONCAT71((int7)(unaff_RBX >> 8),1);
switch(bVar2) {
case (basic_json)0x0:
goto switchD_0018fec9_caseD_0;
case (basic_json)0x1:
puVar13 = (int8 *)**(long **)(param_1 + 8);
puVar5 = (int8 *)(*(long **)(param_1 + 8))[1];
lVar6 = **(long **)(param_2 + 8);
if ((long)puVar5 - (long)puVar13 == (*(long **)(param_2 + 8))[1] - lVar6) {
if (puVar13 != puVar5) {
pbVar11 = (basic_json *)(lVar6 + 0x20);
do {
sVar4 = puVar13[1];
if ((sVar4 != *(size_t *)(pbVar11 + -0x18)) ||
(((sVar4 != 0 &&
(iVar9 = bcmp((void *)*puVar13,*(void **)(pbVar11 + -0x20),sVar4), iVar9 != 0)) ||
(cVar8 = operator==((basic_json *)(puVar13 + 4),pbVar11), cVar8 == '\0'))))
goto LAB_001900a0;
puVar13 = puVar13 + 6;
pbVar11 = pbVar11 + 0x30;
} while (puVar13 != puVar5);
}
goto switchD_0018fec9_caseD_0;
}
break;
case (basic_json)0x2:
pbVar11 = (basic_json *)**(long **)(param_1 + 8);
pbVar3 = (basic_json *)(*(long **)(param_1 + 8))[1];
pbVar12 = (basic_json *)**(long **)(param_2 + 8);
if ((long)pbVar3 - (long)pbVar11 == (*(long **)(param_2 + 8))[1] - (long)pbVar12) {
for (; pbVar11 != pbVar3; pbVar11 = pbVar11 + 0x10) {
uVar10 = operator==(pbVar11,pbVar12);
unaff_RBX = (ulong)uVar10;
if ((char)uVar10 == '\0') break;
pbVar12 = pbVar12 + 0x10;
}
goto switchD_0018fec9_caseD_0;
}
break;
case (basic_json)0x3:
sVar4 = (*(int8 **)(param_1 + 8))[1];
if (sVar4 == (*(int8 **)(param_2 + 8))[1]) {
if (sVar4 == 0) goto switchD_0018fec9_caseD_0;
iVar9 = bcmp((void *)**(int8 **)(param_1 + 8),(void *)**(int8 **)(param_2 + 8),
sVar4);
bVar14 = iVar9 == 0;
goto LAB_00190029;
}
break;
case (basic_json)0x4:
bVar14 = param_1[8] == param_2[8];
goto LAB_00190029;
default:
switchD_0018fec9_caseD_5:
bVar14 = *(long *)(param_1 + 8) == *(long *)(param_2 + 8);
LAB_00190029:
unaff_RBX = CONCAT71((int7)(unaff_RBX >> 8),bVar14);
goto switchD_0018fec9_caseD_0;
case (basic_json)0x7:
dVar7 = *(double *)(param_2 + 8);
LAB_0018ff9a:
bVar14 = dVar7 == *(double *)(param_1 + 8);
goto LAB_0018ffa5;
case (basic_json)0x8:
local_28 = *(long *)(param_1 + 8);
local_40 = *(long *)(param_2 + 8);
local_30 = local_28 + 0x18;
local_38 = local_28 + 0x20;
local_48 = local_40 + 0x18;
local_50 = local_40 + 0x20;
/* try { // try from 001900dc to 001900e0 has its CatchHandler @ 00190116 */
uVar10 = std::
__tuple_compare<std::tuple<std::vector<unsigned_char,std::allocator<unsigned_char>>const&,unsigned_long_const&,bool_const&>,std::tuple<std::vector<unsigned_char,std::allocator<unsigned_char>>const&,unsigned_long_const&,bool_const&>,0ul,3ul>
::__eq((tuple *)&local_38,(tuple *)&local_50);
unaff_RBX = (ulong)uVar10;
goto switchD_0018fec9_caseD_0;
}
LAB_001900a0:
unaff_RBX = 0;
switchD_0018fec9_caseD_0:
return unaff_RBX & 0xffffffff;
}
|
|
1,997 | ha_federated::index_read_idx(unsigned char*, unsigned int, unsigned char const*, unsigned int, ha_rkey_function) | eloqsql/storage/federated/ha_federated.cc | int ha_federated::index_read_idx(uchar *buf, uint index, const uchar *key,
uint key_len, enum ha_rkey_function find_flag)
{
int retval;
MYSQL_RES *mysql_result;
DBUG_ENTER("ha_federated::index_read_idx");
if ((retval= index_read_idx_with_result_set(buf, index, key,
key_len, find_flag,
&mysql_result)))
DBUG_RETURN(retval);
mysql_free_result(mysql_result);
results.elements--;
DBUG_RETURN(0);
} | O3 | cpp | ha_federated::index_read_idx(unsigned char*, unsigned int, unsigned char const*, unsigned int, ha_rkey_function):
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %rax
movq %rax, (%rsp)
callq 0x8320
movl %eax, %r14d
testl %eax, %eax
jne 0xb8a7
movq -0x18(%rbp), %rdi
callq 0x8160
decl 0x558(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
| _ZN12ha_federated14index_read_idxEPhjPKhj16ha_rkey_function:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
lea rax, [rbp+var_18]
mov [rsp+20h+var_20], rax; __int64
call __ZN12ha_federated30index_read_idx_with_result_setEPhjPKhj16ha_rkey_functionPP12st_mysql_res; ha_federated::index_read_idx_with_result_set(uchar *,uint,uchar const*,uint,ha_rkey_function,st_mysql_res **)
mov r14d, eax
test eax, eax
jnz short loc_B8A7
mov rdi, [rbp+var_18]
call _mysql_free_result
dec dword ptr [rbx+558h]
loc_B8A7:
mov eax, r14d
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long ha_federated::index_read_idx(ha_federated *a1)
{
unsigned int idx_with_result_set; // r14d
long long v3[3]; // [rsp+8h] [rbp-18h] BYREF
idx_with_result_set = ha_federated::index_read_idx_with_result_set(a1, (long long)v3);
if ( !idx_with_result_set )
{
mysql_free_result(v3[0]);
--*((_DWORD *)a1 + 342);
}
return idx_with_result_set;
}
| index_read_idx:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA RAX,[RBP + -0x18]
MOV qword ptr [RSP],RAX
CALL 0x00108320
MOV R14D,EAX
TEST EAX,EAX
JNZ 0x0010b8a7
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00108160
DEC dword ptr [RBX + 0x558]
LAB_0010b8a7:
MOV EAX,R14D
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* ha_federated::index_read_idx(unsigned char*, unsigned int, unsigned char const*, unsigned int,
ha_rkey_function) */
int ha_federated::index_read_idx(long param_1)
{
int iVar1;
int8 local_20;
iVar1 = index_read_idx_with_result_set();
if (iVar1 == 0) {
mysql_free_result(local_20);
*(int *)(param_1 + 0x558) = *(int *)(param_1 + 0x558) + -1;
}
return iVar1;
}
|
|
1,998 | my_close | eloqsql/mysys/my_open.c | int my_close(File fd, myf MyFlags)
{
int err;
char *name= NULL;
DBUG_ENTER("my_close");
DBUG_PRINT("my",("fd: %d MyFlags: %lu",fd, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE)))
MyFlags|= my_global_flags;
if ((uint) fd < my_file_limit && my_file_info[fd].type != UNOPEN)
{
name= my_file_info[fd].name;
my_file_info[fd].name= NULL;
my_file_info[fd].type= UNOPEN;
}
#ifndef _WIN32
err= close(fd);
#else
err= my_win_close(fd);
#endif
if (err)
{
DBUG_PRINT("error",("Got error %d on close",err));
my_errno=errno;
if (MyFlags & (MY_FAE | MY_WME))
my_error(EE_BADCLOSE, MYF(ME_BELL | (MyFlags & (ME_NOTE | ME_ERROR_LOG))),
name,errno);
}
if (name)
{
my_free(name);
}
my_atomic_add32_explicit(&my_file_opened, -1, MY_MEMORY_ORDER_RELAXED);
DBUG_RETURN(err);
} | O3 | c | my_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
xorl %ebx, %ebx
movl $0x0, %r14d
testb $0x18, %r12b
jne 0xa053e
leaq 0xb677cd(%rip), %rax # 0xc07d08
movq (%rax), %r14
leaq 0x2e55cb(%rip), %rax # 0x385b10
cmpl %edi, (%rax)
jbe 0xa057d
leaq 0x2e55c8(%rip), %rax # 0x385b18
movq (%rax), %rdx
movslq %edi, %rcx
shlq $0x4, %rcx
cmpl $0x0, 0x8(%rdx,%rcx)
je 0xa057b
addq %rcx, %rdx
movq (%rdx), %rbx
movq $0x0, (%rdx)
movq (%rax), %rax
movl $0x0, 0x8(%rax,%rcx)
jmp 0xa057d
xorl %ebx, %ebx
callq 0x29190
movl %eax, %r15d
testl %eax, %eax
je 0xa05c6
orq %r12, %r14
callq 0x29790
movq %rax, %r12
movl (%rax), %r13d
callq 0xa1ab2
movl %r13d, (%rax)
testb $0x18, %r14b
je 0xa05c6
andl $0x440, %r14d # imm = 0x440
orq $0x4, %r14
movl (%r12), %ecx
movl $0x4, %edi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9dfc3
testq %rbx, %rbx
je 0xa05d3
movq %rbx, %rdi
callq 0x9ff6e
leaq 0xb6773a(%rip), %rax # 0xc07d14
lock
decl (%rax)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| my_close:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, rsi
xor ebx, ebx
mov r14d, 0
test r12b, 18h
jnz short loc_A053E
lea rax, my_global_flags
mov r14, [rax]
loc_A053E:
lea rax, my_file_limit
cmp [rax], edi
jbe short loc_A057D
lea rax, my_file_info
mov rdx, [rax]
movsxd rcx, edi
shl rcx, 4
cmp dword ptr [rdx+rcx+8], 0
jz short loc_A057B
add rdx, rcx
mov rbx, [rdx]
mov qword ptr [rdx], 0
mov rax, [rax]
mov dword ptr [rax+rcx+8], 0
jmp short loc_A057D
loc_A057B:
xor ebx, ebx
loc_A057D:
call _close
mov r15d, eax
test eax, eax
jz short loc_A05C6
or r14, r12
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
test r14b, 18h
jz short loc_A05C6
and r14d, 440h
or r14, 4
mov ecx, [r12]
mov edi, 4
mov rsi, r14
mov rdx, rbx
xor eax, eax
call my_error
loc_A05C6:
test rbx, rbx
jz short loc_A05D3
mov rdi, rbx
call my_free
loc_A05D3:
lea rax, my_file_opened
lock dec dword ptr [rax]
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_close(long long a1, __int16 a2)
{
long long v2; // rbx
__int16 v3; // r14
long long v4; // rcx
unsigned int v5; // r15d
__int16 v6; // r14
unsigned int *v7; // r12
unsigned int v8; // r13d
v2 = 0LL;
v3 = 0;
if ( (a2 & 0x18) == 0 )
v3 = my_global_flags;
if ( my_file_limit[0] > (unsigned int)a1 )
{
v4 = 16LL * (int)a1;
if ( *(_DWORD *)((char *)my_file_info + v4 + 8) )
{
v2 = *(_QWORD *)((char *)my_file_info + v4);
*(_QWORD *)((char *)my_file_info + v4) = 0LL;
*(_DWORD *)((char *)my_file_info + v4 + 8) = 0;
}
else
{
v2 = 0LL;
}
}
v5 = close(a1);
if ( v5 )
{
v6 = a2 | v3;
v7 = (unsigned int *)__errno_location(a1);
v8 = *v7;
*(_DWORD *)my_thread_var(a1) = v8;
if ( (v6 & 0x18) != 0 )
my_error(4u, v6 & 0x440 | 4LL, v2, *v7);
}
if ( v2 )
my_free(v2);
_InterlockedDecrement(my_file_opened);
return v5;
}
| my_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RSI
XOR EBX,EBX
MOV R14D,0x0
TEST R12B,0x18
JNZ 0x001a053e
LEA RAX,[0xd07d08]
MOV R14,qword ptr [RAX]
LAB_001a053e:
LEA RAX,[0x485b10]
CMP dword ptr [RAX],EDI
JBE 0x001a057d
LEA RAX,[0x485b18]
MOV RDX,qword ptr [RAX]
MOVSXD RCX,EDI
SHL RCX,0x4
CMP dword ptr [RDX + RCX*0x1 + 0x8],0x0
JZ 0x001a057b
ADD RDX,RCX
MOV RBX,qword ptr [RDX]
MOV qword ptr [RDX],0x0
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX + RCX*0x1 + 0x8],0x0
JMP 0x001a057d
LAB_001a057b:
XOR EBX,EBX
LAB_001a057d:
CALL 0x00129190
MOV R15D,EAX
TEST EAX,EAX
JZ 0x001a05c6
OR R14,R12
CALL 0x00129790
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x001a1ab2
MOV dword ptr [RAX],R13D
TEST R14B,0x18
JZ 0x001a05c6
AND R14D,0x440
OR R14,0x4
MOV ECX,dword ptr [R12]
MOV EDI,0x4
MOV RSI,R14
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0019dfc3
LAB_001a05c6:
TEST RBX,RBX
JZ 0x001a05d3
MOV RDI,RBX
CALL 0x0019ff6e
LAB_001a05d3:
LEA RAX,[0xd07d14]
DEC.LOCK dword ptr [RAX]
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_close(uint param_1,ulong param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
long lVar5;
long lVar6;
ulong uVar7;
lVar6 = 0;
uVar7 = 0;
if ((param_2 & 0x18) == 0) {
uVar7 = my_global_flags;
}
if (param_1 < my_file_limit) {
lVar5 = (long)(int)param_1 * 0x10;
if (*(int *)(my_file_info + lVar5 + 8) == 0) {
lVar6 = 0;
}
else {
lVar6 = *(long *)(my_file_info + lVar5);
*(long *)(my_file_info + lVar5) = 0;
*(int4 *)(my_file_info + lVar5 + 8) = 0;
}
}
iVar2 = close(param_1);
if (iVar2 != 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (((uVar7 | param_2) & 0x18) != 0) {
my_error(4,(uint)(uVar7 | param_2) & 0x440 | 4,lVar6,*piVar3);
}
}
if (lVar6 != 0) {
my_free(lVar6);
}
LOCK();
my_file_opened = my_file_opened + -1;
UNLOCK();
return iVar2;
}
|
|
1,999 | OpenSubdiv::v3_6_0::Bfr::FaceSurface::reviseSdcOptionsInEffect() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/faceSurface.cpp | void
FaceSurface::reviseSdcOptionsInEffect() {
//
// "Override" (ignore, set to default) any options not affecting
// the shape of the limit surface. The boundary and face-varying
// interpolation options are fixed/ignored for all cases. Whether
// other options have an effect depends on the topology present.
//
// This is done, in part, to make accurate comparisons between
// the topologies of two surfaces. For example, the presence of
// differing creasing methods should not lead to two topologically
// identical surfaces with no creasing being considered different.
//
// This is to be used on construction on irregular surfaces AFTER
// the combined tags have been determined.
//
assert(!_isRegular);
MultiVertexTag const & tags = _combinedTag;
Sdc::Options & options = _optionsInEffect;
// Boundary and face-varying interpolation fixed/ignored for all:
options.SetVtxBoundaryInterpolation(Sdc::Options::VTX_BOUNDARY_EDGE_ONLY);
options.SetFVarLinearInterpolation( Sdc::Options::FVAR_LINEAR_ALL);
// Crease-method ignored when no semi-sharp creasing:
if (options.GetCreasingMethod() != Sdc::Options::CREASE_UNIFORM) {
if (!tags.HasSemiSharpEdges() && !tags.HasSemiSharpVertices()) {
options.SetCreasingMethod(Sdc::Options::CREASE_UNIFORM);
}
}
// Catmark triangle smoothing ignored if not Catmark with triangles:
if (options.GetTriangleSubdivision() != Sdc::Options::TRI_SUB_CATMARK) {
// This is slightly stronger than necessary -- will keep the
// tri-smooth setting if Catmark and any non-quads:
if ((GetSdcScheme() != Sdc::SCHEME_CATMARK) ||
!tags.HasIrregularFaceSizes()) {
options.SetTriangleSubdivision(Sdc::Options::TRI_SUB_CATMARK);
}
}
// Non-default values of any future options will warrant attention
} | O0 | cpp | OpenSubdiv::v3_6_0::Bfr::FaceSurface::reviseSdcOptionsInEffect():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0x8e(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1857b0
jmp 0x1857b2
jmp 0x1857d1
leaq 0x70a9f(%rip), %rdi # 0x1f6258
leaq 0x70aa4(%rip), %rsi # 0x1f6264
movl $0xdd, %edx
leaq 0x70af5(%rip), %rcx # 0x1f62c1
callq 0xc9440
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x88, %rcx
movq %rcx, -0x10(%rbp)
addq $0x8a, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xc5050
movq -0x18(%rbp), %rdi
movl $0x5, %esi
callq 0xd2af0
movq -0x18(%rbp), %rdi
callq 0xd39f0
cmpl $0x0, %eax
je 0x18583e
movq -0x10(%rbp), %rdi
callq 0xd2230
testb $0x1, %al
jne 0x18583c
movq -0x10(%rbp), %rdi
callq 0xcbdc0
testb $0x1, %al
jne 0x18583c
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc5460
jmp 0x18583e
movq -0x18(%rbp), %rdi
callq 0xcc6c0
cmpl $0x0, %eax
je 0x185874
movq -0x20(%rbp), %rdi
callq 0xcacd0
cmpl $0x1, %eax
jne 0x185867
movq -0x10(%rbp), %rdi
callq 0xd1440
testb $0x1, %al
jne 0x185872
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc9970
jmp 0x185874
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN10OpenSubdiv6v3_6_03Bfr11FaceSurface24reviseSdcOptionsInEffectEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov al, [rax+8Eh]
shr al, 2
and al, 1
movzx eax, al
cmp eax, 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_1857B0
jmp short loc_1857B2
loc_1857B0:
jmp short loc_1857D1
loc_1857B2:
lea rdi, aIsregular; "!_isRegular"
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0DDh
lea rcx, aVoidOpensubdiv_114; "void OpenSubdiv::v3_6_0::Bfr::FaceSurfa"...
call ___assert_fail
loc_1857D1:
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 88h
mov [rbp+var_10], rcx
add rax, 8Ah
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
mov esi, 1
call __ZN10OpenSubdiv6v3_6_03Sdc7Options27SetVtxBoundaryInterpolationENS2_24VtxBoundaryInterpolationE; OpenSubdiv::v3_6_0::Sdc::Options::SetVtxBoundaryInterpolation(OpenSubdiv::v3_6_0::Sdc::Options::VtxBoundaryInterpolation)
mov rdi, [rbp+var_18]
mov esi, 5
call __ZN10OpenSubdiv6v3_6_03Sdc7Options26SetFVarLinearInterpolationENS2_23FVarLinearInterpolationE; OpenSubdiv::v3_6_0::Sdc::Options::SetFVarLinearInterpolation(OpenSubdiv::v3_6_0::Sdc::Options::FVarLinearInterpolation)
mov rdi, [rbp+var_18]; this
call __ZNK10OpenSubdiv6v3_6_03Sdc7Options17GetCreasingMethodEv; OpenSubdiv::v3_6_0::Sdc::Options::GetCreasingMethod(void)
cmp eax, 0
jz short loc_18583E
mov rdi, [rbp+var_10]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr14MultiVertexTag17HasSemiSharpEdgesEv; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasSemiSharpEdges(void)
test al, 1
jnz short loc_18583C
mov rdi, [rbp+var_10]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr14MultiVertexTag20HasSemiSharpVerticesEv; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasSemiSharpVertices(void)
test al, 1
jnz short loc_18583C
mov rdi, [rbp+var_18]
xor esi, esi
call __ZN10OpenSubdiv6v3_6_03Sdc7Options17SetCreasingMethodENS2_14CreasingMethodE; OpenSubdiv::v3_6_0::Sdc::Options::SetCreasingMethod(OpenSubdiv::v3_6_0::Sdc::Options::CreasingMethod)
loc_18583C:
jmp short $+2
loc_18583E:
mov rdi, [rbp+var_18]; this
call __ZNK10OpenSubdiv6v3_6_03Sdc7Options22GetTriangleSubdivisionEv; OpenSubdiv::v3_6_0::Sdc::Options::GetTriangleSubdivision(void)
cmp eax, 0
jz short loc_185874
mov rdi, [rbp+var_20]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr11FaceSurface12GetSdcSchemeEv; OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetSdcScheme(void)
cmp eax, 1
jnz short loc_185867
mov rdi, [rbp+var_10]; this
call __ZNK10OpenSubdiv6v3_6_03Bfr14MultiVertexTag21HasIrregularFaceSizesEv; OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasIrregularFaceSizes(void)
test al, 1
jnz short loc_185872
loc_185867:
mov rdi, [rbp+var_18]
xor esi, esi
call __ZN10OpenSubdiv6v3_6_03Sdc7Options22SetTriangleSubdivisionENS2_19TriangleSubdivisionE; OpenSubdiv::v3_6_0::Sdc::Options::SetTriangleSubdivision(OpenSubdiv::v3_6_0::Sdc::Options::TriangleSubdivision)
loc_185872:
jmp short $+2
loc_185874:
add rsp, 20h
pop rbp
retn
| long long OpenSubdiv::v3_6_0::Bfr::FaceSurface::reviseSdcOptionsInEffect(
OpenSubdiv::v3_6_0::Bfr::FaceSurface *this)
{
int CreasingMethod; // eax
long long result; // rax
OpenSubdiv::v3_6_0::Sdc::Options *v3; // [rsp+8h] [rbp-18h]
OpenSubdiv::v3_6_0::Bfr::MultiVertexTag *v4; // [rsp+10h] [rbp-10h]
if ( (*((_BYTE *)this + 142) & 4) != 0 )
__assert_fail(
"!_isRegular",
"/workspace/llm4binary/github/2025_star3/NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/faceSurface.cpp",
221LL,
"void OpenSubdiv::v3_6_0::Bfr::FaceSurface::reviseSdcOptionsInEffect()");
v4 = (OpenSubdiv::v3_6_0::Bfr::FaceSurface *)((char *)this + 136);
v3 = (OpenSubdiv::v3_6_0::Bfr::FaceSurface *)((char *)this + 138);
OpenSubdiv::v3_6_0::Sdc::Options::SetVtxBoundaryInterpolation((char *)this + 138, 1LL);
OpenSubdiv::v3_6_0::Sdc::Options::SetFVarLinearInterpolation((char *)this + 138, 5LL);
CreasingMethod = OpenSubdiv::v3_6_0::Sdc::Options::GetCreasingMethod((OpenSubdiv::v3_6_0::Bfr::FaceSurface *)((char *)this + 138));
if ( CreasingMethod
&& (OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasSemiSharpEdges(v4) & 1) == 0
&& (OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasSemiSharpVertices(v4) & 1) == 0 )
{
OpenSubdiv::v3_6_0::Sdc::Options::SetCreasingMethod(v3, 0LL);
}
result = OpenSubdiv::v3_6_0::Sdc::Options::GetTriangleSubdivision(v3);
if ( (_DWORD)result )
{
if ( (unsigned int)OpenSubdiv::v3_6_0::Bfr::FaceSurface::GetSdcScheme(this) != 1 )
return OpenSubdiv::v3_6_0::Sdc::Options::SetTriangleSubdivision(v3, 0LL);
result = OpenSubdiv::v3_6_0::Bfr::MultiVertexTag::HasIrregularFaceSizes(v4);
if ( (result & 1) == 0 )
return OpenSubdiv::v3_6_0::Sdc::Options::SetTriangleSubdivision(v3, 0LL);
}
return result;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.