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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
2,600 | plutovg_surface_write_to_jpg_stream | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-surface.c | bool plutovg_surface_write_to_jpg_stream(const plutovg_surface_t* surface, plutovg_write_func_t write_func, void* closure, int quality)
{
plutovg_surface_write_begin(surface);
int success = stbi_write_jpg_to_func(write_func, closure, surface->width, surface->height, 4, surface->data, quality);
plutovg_surface_write_end(surface);
return success;
} | O1 | c | plutovg_surface_write_to_jpg_stream:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movq %rdi, %rsi
callq 0xdf8a
movl 0x4(%rbx), %esi
movl 0x8(%rbx), %edx
movq 0x10(%rbx), %rcx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movq $0x0, 0x50(%rdi)
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movl %ebp, %r8d
callq 0x1a3fc
movl %eax, %ebp
movq 0x10(%rbx), %rdi
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movq %rdi, %rsi
callq 0xe06f
testl %ebp, %ebp
setne %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| plutovg_surface_write_to_jpg_stream:
push rbp
push r15
push r14
push rbx
sub rsp, 58h
mov ebp, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, [rdi+10h]
mov edx, [rbx+4]
mov ecx, [rbx+8]
mov r8d, [rbx+0Ch]
mov rsi, rdi
call plutovg_convert_argb_to_rgba
mov esi, [rbx+4]
mov edx, [rbx+8]
mov rcx, [rbx+10h]
xorps xmm0, xmm0
mov rdi, rsp
movaps xmmword ptr [rdi], xmm0
movaps xmmword ptr [rdi+40h], xmm0
movaps xmmword ptr [rdi+30h], xmm0
movaps xmmword ptr [rdi+20h], xmm0
movaps xmmword ptr [rdi+10h], xmm0
mov qword ptr [rdi+50h], 0
mov [rdi], r15
mov [rdi+8], r14
mov r8d, ebp
call stbi_write_jpg_core
mov ebp, eax
mov rdi, [rbx+10h]
mov edx, [rbx+4]
mov ecx, [rbx+8]
mov r8d, [rbx+0Ch]
mov rsi, rdi
call plutovg_convert_rgba_to_argb
test ebp, ebp
setnz al
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
| bool plutovg_surface_write_to_jpg_stream(long long a1, long long a2, long long a3, unsigned int a4)
{
long long v8; // rsi
long long v9; // rdx
long long v10; // rcx
long long v11; // r9
int v12; // ebp
_QWORD v14[2]; // [rsp+0h] [rbp-78h] BYREF
__int128 v15; // [rsp+10h] [rbp-68h]
__int128 v16; // [rsp+20h] [rbp-58h]
__int128 v17; // [rsp+30h] [rbp-48h]
__int128 v18; // [rsp+40h] [rbp-38h]
long long v19; // [rsp+50h] [rbp-28h]
plutovg_convert_argb_to_rgba(
*(_QWORD *)(a1 + 16),
*(_QWORD *)(a1 + 16),
*(unsigned int *)(a1 + 4),
*(unsigned int *)(a1 + 8),
*(unsigned int *)(a1 + 12));
v8 = *(unsigned int *)(a1 + 4);
v9 = *(unsigned int *)(a1 + 8);
v10 = *(_QWORD *)(a1 + 16);
v18 = 0LL;
v17 = 0LL;
v16 = 0LL;
v15 = 0LL;
v19 = 0LL;
v14[0] = a2;
v14[1] = a3;
v12 = ((long long ( *)(_QWORD *, long long, long long, long long, _QWORD, long long))stbi_write_jpg_core)(
v14,
v8,
v9,
v10,
a4,
v11);
plutovg_convert_rgba_to_argb(
*(_QWORD *)(a1 + 16),
*(_QWORD *)(a1 + 16),
*(unsigned int *)(a1 + 4),
*(unsigned int *)(a1 + 8),
*(unsigned int *)(a1 + 12));
return v12 != 0;
}
| plutovg_surface_write_to_jpg_stream:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV EBP,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
MOV EDX,dword ptr [RBX + 0x4]
MOV ECX,dword ptr [RBX + 0x8]
MOV R8D,dword ptr [RBX + 0xc]
MOV RSI,RDI
CALL 0x0010df8a
MOV ESI,dword ptr [RBX + 0x4]
MOV EDX,dword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBX + 0x10]
XORPS XMM0,XMM0
MOV RDI,RSP
MOVAPS xmmword ptr [RDI],XMM0
MOVAPS xmmword ptr [RDI + 0x40],XMM0
MOVAPS xmmword ptr [RDI + 0x30],XMM0
MOVAPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOV qword ptr [RDI + 0x50],0x0
MOV qword ptr [RDI],R15
MOV qword ptr [RDI + 0x8],R14
MOV R8D,EBP
CALL 0x0011a3fc
MOV EBP,EAX
MOV RDI,qword ptr [RBX + 0x10]
MOV EDX,dword ptr [RBX + 0x4]
MOV ECX,dword ptr [RBX + 0x8]
MOV R8D,dword ptr [RBX + 0xc]
MOV RSI,RDI
CALL 0x0010e06f
TEST EBP,EBP
SETNZ AL
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
|
bool plutovg_surface_write_to_jpg_stream
(long param_1,int8 param_2,int8 param_3,int4 param_4)
{
int iVar1;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
int8 uStack_30;
int8 local_28;
plutovg_convert_argb_to_rgba
(*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x10),
*(int4 *)(param_1 + 4),*(int4 *)(param_1 + 8),
*(int4 *)(param_1 + 0xc));
local_38 = 0;
uStack_30 = 0;
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
local_68 = 0;
uStack_60 = 0;
local_28 = 0;
local_78 = param_2;
uStack_70 = param_3;
iVar1 = stbi_write_jpg_core(&local_78,*(int4 *)(param_1 + 4),*(int4 *)(param_1 + 8),
*(int8 *)(param_1 + 0x10),param_4);
plutovg_convert_rgba_to_argb
(*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x10),
*(int4 *)(param_1 + 4),*(int4 *)(param_1 + 8),
*(int4 *)(param_1 + 0xc));
return iVar1 != 0;
}
|
|
2,601 | nlohmann::json_abi_v3_11_3::detail::parse_error nlohmann::json_abi_v3_11_3::detail::parse_error::create<std::nullptr_t, 0>(int, nlohmann::json_abi_v3_11_3::detail::position_t const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | hkr04[P]cpp-mcp/common/json.hpp | static parse_error create(int id_, const position_t& pos, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("parse_error", id_), "parse error",
position_string(pos), ": ", exception::diagnostics(context), what_arg);
return {id_, pos.chars_read_total, w.c_str()};
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::parse_error nlohmann::json_abi_v3_11_3::detail::parse_error::create<std::nullptr_t, 0>(int, nlohmann::json_abi_v3_11_3::detail::position_t const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x11dc5(%rip), %rsi # 0x5ad96
leaq 0x11dc9(%rip), %rdx # 0x5ada1
leaq 0x8(%rsp), %rdi
callq 0xf902
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0xf1b8
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x4d012
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %r15, (%rsp)
leaq 0x11d81(%rip), %rdx # 0x5ada2
leaq 0x11ed8(%rip), %r8 # 0x5af00
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r9
callq 0x4cf09
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4905b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa630
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49076
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa630
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49091
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa630
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x490a8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa630
movq (%r14), %r14
movq 0x88(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf420
leaq 0x329dc(%rip), %rax # 0x7baa0
movq %rax, (%rbx)
movq %r14, 0x20(%rbx)
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x490ec
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xa630
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49199
movq 0x98(%rsp), %rsi
jmp 0x4918c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4913d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xa630
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4915d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xa630
jmp 0x4915d
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4917d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xa630
jmp 0x4917d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x49199
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa630
jmp 0x49199
movq %rax, %rbx
movq %rbx, %rdi
callq 0xaa50
nop
| _ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
lea r12, [rsp+0D8h+var_C0]
mov [r12-10h], r12
lea rsi, aParseError; "parse_error"
lea rdx, aParseError+0Bh; ""
lea rdi, [rsp+0D8h+var_D0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0D8h+var_70]; int
lea rsi, [rsp+0D8h+var_D0]; int
mov edx, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea rdi, [rsp+0D8h+var_90]; int
mov rsi, r14; int
call _ZN8nlohmann16json_abi_v3_11_36detail11parse_error15position_stringB5cxx11ERKNS1_10position_tE; nlohmann::json_abi_v3_11_3::detail::parse_error::position_string(nlohmann::json_abi_v3_11_3::detail::position_t const&)
lea r13, [rsp+0D8h+var_A0]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
mov [rsp+0D8h+var_D8], r15
lea rdx, aParseError_0; "parse error"
lea r8, aSubtype+9; ": "
lea rdi, [rsp+0D8h+var_50]
lea rsi, [rsp+0D8h+var_70]
lea rcx, [rsp+0D8h+var_90]
lea r9, [rsp+0D8h+var_B0]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_RA12_KcS8_RA3_S9_S8_RKS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&>(std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&)
mov rdi, [rsp+0D8h+var_B0]; void *
cmp rdi, r13
jz short loc_4905B
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4905B:
lea rax, [rsp+0D8h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_49076
mov rsi, [rsp+0D8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_49076:
lea rax, [rsp+0D8h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_49091
mov rsi, [rsp+0D8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_49091:
mov rdi, [rsp+0D8h+var_D0]; void *
cmp rdi, r12
jz short loc_490A8
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_490A8:
mov r14, [r14]
mov rdx, [rsp+0D8h+var_50]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionC2EiPKc; nlohmann::json_abi_v3_11_3::detail::exception::exception(int,char const*)
lea rax, off_7BAA0
mov [rbx], rax
mov [rbx+20h], r14
lea rax, [rsp+0D8h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_490EC
mov rsi, [rsp+0D8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_490EC:
mov rax, rbx
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_90]
mov rdi, [rax-10h]
cmp rdi, rax
jz loc_49199
mov rsi, [rsp+arg_90]
jmp short loc_4918C
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_4913D
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4913D:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4915D
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_4915D
mov rbx, rax
loc_4915D:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4917D
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_4917D
mov rbx, rax
loc_4917D:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_49199
mov rsi, [rsp+arg_10]
loc_4918C:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_49199
mov rbx, rax
loc_49199:
mov rdi, rbx
call __Unwind_Resume
| nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
long long *a3,
long long a4)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // r14
void *v12; // [rsp+0h] [rbp-D8h]
void *v13[2]; // [rsp+8h] [rbp-D0h] BYREF
_QWORD v14[2]; // [rsp+18h] [rbp-C0h] BYREF
void *v15; // [rsp+28h] [rbp-B0h] BYREF
long long v16; // [rsp+30h] [rbp-A8h]
_QWORD v17[2]; // [rsp+38h] [rbp-A0h] BYREF
int v18[4]; // [rsp+48h] [rbp-90h] BYREF
long long v19; // [rsp+58h] [rbp-80h] BYREF
int v20[4]; // [rsp+68h] [rbp-70h] BYREF
long long v21; // [rsp+78h] [rbp-60h] BYREF
char *v22; // [rsp+88h] [rbp-50h] BYREF
long long v23; // [rsp+98h] [rbp-40h] BYREF
v13[0] = v14;
std::string::_M_construct<char const*>((long long)v13, "parse_error", (long long)"");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v20, (long long)v13, a2);
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string[abi:cxx11](
(int)v18,
(int)a3,
v6,
v7,
v8,
v9,
v12,
(int)v13[0],
(long long)v13[1],
v14[0],
(void *)v14[1],
(int)v15,
v16);
v15 = v17;
v16 = 0LL;
LOBYTE(v17[0]) = 0;
nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,char const(&)[12],std::string,char const(&)[3],std::string,std::string const&>(
(unsigned int)&v22,
(unsigned int)v20,
(unsigned int)"parse error",
(unsigned int)v18,
(unsigned int)": ",
(unsigned int)&v15,
a4);
if ( v15 != v17 )
operator delete(v15, v17[0] + 1LL);
if ( *(long long **)v18 != &v19 )
operator delete(*(void **)v18, v19 + 1);
if ( *(long long **)v20 != &v21 )
operator delete(*(void **)v20, v21 + 1);
if ( v13[0] != v14 )
operator delete(v13[0], v14[0] + 1LL);
v10 = *a3;
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v22);
*(_QWORD *)this = off_7BAA0;
*((_QWORD *)this + 4) = v10;
if ( v22 != (char *)&v23 )
operator delete(v22, v23 + 1);
return this;
}
| _ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R15,RCX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
LAB_00148fca:
LEA RSI,[0x15ad96]
LEA RDX,[0x15ada1]
LEA RDI,[RSP + 0x8]
CALL 0x0010f902
LAB_00148fe2:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x8]
MOV EDX,EBP
CALL 0x0010f1b8
LAB_00148ff3:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
CALL 0x0014d012
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
LAB_00149016:
MOV qword ptr [RSP],R15
LEA RDX,[0x15ada2]
LEA R8,[0x15af00]
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x68]
LEA RCX,[RSP + 0x48]
LEA R9,[RSP + 0x28]
CALL 0x0014cf09
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0014905b
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0010a630
LAB_0014905b:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00149076
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0010a630
LAB_00149076:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00149091
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0010a630
LAB_00149091:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x001490a8
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010a630
LAB_001490a8:
MOV R14,qword ptr [R14]
MOV RDX,qword ptr [RSP + 0x88]
LAB_001490b3:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0010f420
LAB_001490bd:
LEA RAX,[0x17baa0]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x20],R14
LEA RAX,[RSP + 0x98]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001490ec
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x0010a630
LAB_001490ec:
MOV RAX,RBX
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
exception *
_ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(exception *param_1,int param_2,position_t *param_3,string *param_4)
{
int8 uVar1;
long *local_d0 [2];
long local_c0 [2];
int1 *local_b0;
int8 local_a8;
int1 local_a0;
int7 uStack_9f;
long *local_90 [2];
long local_80 [2];
long *local_70 [2];
long local_60 [2];
long *local_50 [2];
long local_40 [2];
/* try { // try from 00148fca to 00148fe1 has its CatchHandler @ 00149196 */
local_d0[0] = local_c0;
std::__cxx11::string::_M_construct<char_const*>(local_d0,"parse_error","");
/* try { // try from 00148fe2 to 00148ff2 has its CatchHandler @ 0014917a */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_70,(string *)local_d0,param_2);
/* try { // try from 00148ff3 to 00148fff has its CatchHandler @ 0014915a */
nlohmann::json_abi_v3_11_3::detail::parse_error::position_string_abi_cxx11_
((parse_error *)local_90,param_3);
local_a8 = 0;
local_a0 = 0;
/* try { // try from 00149016 to 00149043 has its CatchHandler @ 00149123 */
local_b0 = &local_a0;
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,std::__cxx11::string,char_const(&)[12],std::__cxx11::string,char_const(&)[3],std::__cxx11::string,std::__cxx11::string_const&>
((detail *)local_50,(string *)local_70,"parse error",(string *)local_90,": ",
(string *)&local_b0,param_4);
if (local_b0 != &local_a0) {
operator_delete(local_b0,CONCAT71(uStack_9f,local_a0) + 1);
}
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_d0[0] != local_c0) {
operator_delete(local_d0[0],local_c0[0] + 1);
}
uVar1 = *(int8 *)param_3;
/* try { // try from 001490b3 to 001490bc has its CatchHandler @ 00149101 */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,(char *)local_50[0]);
*(int ***)param_1 = &PTR__exception_0017baa0;
*(int8 *)(param_1 + 0x20) = uVar1;
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return param_1;
}
|
|
2,602 | ma_feof | eloqsql/libmariadb/libmariadb/ma_io.c | int ma_feof(MA_FILE *file)
{
if (!file)
return -1;
switch (file->type) {
case MA_FILE_LOCAL:
return feof((FILE *)file->ptr);
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
return rio_plugin->methods->mfeof(file);
break;
#endif
default:
return -1;
}
} | O0 | c | ma_feof:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x364ec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3653c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x36506
jmp 0x364fc
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x36518
jmp 0x36535
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x136a0
movl %eax, -0x4(%rbp)
jmp 0x3653c
leaq 0x2b7c1(%rip), %rax # 0x61ce0
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x3653c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_feof:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_364EC
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_3653C
loc_364EC:
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_14], eax
sub eax, 1
jz short loc_36506
jmp short $+2
loc_364FC:
mov eax, [rbp+var_14]
sub eax, 2
jz short loc_36518
jmp short loc_36535
loc_36506:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _feof
mov [rbp+var_4], eax
jmp short loc_3653C
loc_36518:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax+10h]
mov rdi, [rbp+var_10]
call rax
mov [rbp+var_4], eax
jmp short loc_3653C
loc_36535:
mov [rbp+var_4], 0FFFFFFFFh
loc_3653C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long ma_feof(long long a1)
{
if ( a1 )
{
if ( *(_DWORD *)a1 == 1 )
{
return (unsigned int)feof(*(_QWORD *)(a1 + 8));
}
else if ( *(_DWORD *)a1 == 2 )
{
return (unsigned int)(*(long long ( **)(long long))(*(_QWORD *)(rio_plugin + 88LL) + 16LL))(a1);
}
else
{
return (unsigned int)-1;
}
}
else
{
return (unsigned int)-1;
}
}
| ma_feof:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001364ec
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0013653c
LAB_001364ec:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
SUB EAX,0x1
JZ 0x00136506
JMP 0x001364fc
LAB_001364fc:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
JZ 0x00136518
JMP 0x00136535
LAB_00136506:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001136a0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013653c
LAB_00136518:
LEA RAX,[0x161ce0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013653c
LAB_00136535:
MOV dword ptr [RBP + -0x4],0xffffffff
LAB_0013653c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int ma_feof(int *param_1)
{
int local_c;
if (param_1 == (int *)0x0) {
local_c = -1;
}
else if (*param_1 == 1) {
local_c = feof(*(FILE **)(param_1 + 2));
}
else if (*param_1 == 2) {
local_c = (**(code **)(*(long *)(rio_plugin + 0x58) + 0x10))(param_1);
}
else {
local_c = -1;
}
return local_c;
}
|
|
2,603 | get_closure_var2 | bluesky950520[P]quickjs/quickjs.c | static int get_closure_var2(JSContext *ctx, JSFunctionDef *s,
JSFunctionDef *fd, BOOL is_local,
BOOL is_arg, int var_idx, JSAtom var_name,
BOOL is_const, BOOL is_lexical,
JSVarKindEnum var_kind)
{
int i;
if (fd != s->parent) {
var_idx = get_closure_var2(ctx, s->parent, fd, is_local,
is_arg, var_idx, var_name,
is_const, is_lexical, var_kind);
if (var_idx < 0)
return -1;
is_local = FALSE;
}
for(i = 0; i < s->closure_var_count; i++) {
JSClosureVar *cv = &s->closure_var[i];
if (cv->var_idx == var_idx && cv->is_arg == is_arg &&
cv->is_local == is_local)
return i;
}
return add_closure_var(ctx, s, is_local, is_arg, var_idx, var_name,
is_const, is_lexical, var_kind);
} | O1 | c | get_closure_var2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rsi, %r14
movq %rdi, %r12
movl 0x58(%rsp), %r11d
movl 0x50(%rsp), %ebp
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %r10d
movq 0x8(%rsi), %rsi
cmpq %rdx, %rsi
movq %r10, %r13
je 0x6db91
movq %r12, %rdi
movl %ebx, %r8d
movq %r11, %r15
pushq %r11
pushq %rbp
movq %rax, %rbp
pushq %rax
pushq %r10
callq 0x6db35
addq $0x20, %rsp
testl %eax, %eax
js 0x6dc1b
movl %eax, %r9d
xorl %ecx, %ecx
jmp 0x6db97
movq %r11, %r15
movq %rax, %rbp
movslq 0x198(%r14), %rdx
testq %rdx, %rdx
movq %r13, %r11
jle 0x6dbf4
movq 0x1a0(%r14), %rsi
xorl %edi, %edi
movzwl 0x2(%rsi,%rdi,8), %r10d
movb $0x1, %r8b
cmpl %r10d, %r9d
jne 0x6dbe7
movzbl (%rsi,%rdi,8), %r10d
movl %r10d, %r11d
shrl %r11d
andl $0x1, %r11d
cmpl %ebx, %r11d
jne 0x6dbe4
andl $0x1, %r10d
cmpl %r10d, %ecx
movq %r13, %r11
jne 0x6dbe7
xorl %r8d, %r8d
movl %edi, %eax
jmp 0x6dbe7
movq %r13, %r11
testb %r8b, %r8b
je 0x6dc20
incq %rdi
cmpq %rdi, %rdx
jne 0x6dbaf
subq $0x8, %rsp
movq %r12, %rdi
movq %r14, %rsi
movl %ecx, %edx
movl %ebx, %ecx
movl %r9d, %r8d
movl %r11d, %r9d
pushq %r15
movl 0x60(%rsp), %eax
pushq %rax
pushq %rbp
callq 0x6ce80
addq $0x28, %rsp
jmp 0x6dc24
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| get_closure_var2:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r8d
mov r14, rsi
mov r12, rdi
mov r11d, [rsp+38h+arg_18]
mov ebp, [rsp+38h+arg_10]
mov eax, [rsp+38h+arg_8]
mov r10d, [rsp+38h+arg_0]
mov rsi, [rsi+8]
cmp rsi, rdx
mov r13, r10
jz short loc_6DB91
mov rdi, r12
mov r8d, ebx
mov r15, r11
push r11
push rbp
mov rbp, rax
push rax
push r10
call get_closure_var2
add rsp, 20h
test eax, eax
js loc_6DC1B
mov r9d, eax
xor ecx, ecx
jmp short loc_6DB97
loc_6DB91:
mov r15, r11
mov rbp, rax
loc_6DB97:
movsxd rdx, dword ptr [r14+198h]
test rdx, rdx
mov r11, r13
jle short loc_6DBF4
mov rsi, [r14+1A0h]
xor edi, edi
loc_6DBAF:
movzx r10d, word ptr [rsi+rdi*8+2]
mov r8b, 1
cmp r9d, r10d
jnz short loc_6DBE7
movzx r10d, byte ptr [rsi+rdi*8]
mov r11d, r10d
shr r11d, 1
and r11d, 1
cmp r11d, ebx
jnz short loc_6DBE4
and r10d, 1
cmp ecx, r10d
mov r11, r13
jnz short loc_6DBE7
xor r8d, r8d
mov eax, edi
jmp short loc_6DBE7
loc_6DBE4:
mov r11, r13
loc_6DBE7:
test r8b, r8b
jz short loc_6DC20
inc rdi
cmp rdx, rdi
jnz short loc_6DBAF
loc_6DBF4:
sub rsp, 8
mov rdi, r12
mov rsi, r14
mov edx, ecx
mov ecx, ebx
mov r8d, r9d
mov r9d, r11d
push r15
mov eax, [rsp+48h+arg_10]
push rax
push rbp
call add_closure_var
add rsp, 28h
jmp short loc_6DC24
loc_6DC1B:
mov eax, 0FFFFFFFFh
loc_6DC20:
add rsp, 8
loc_6DC24:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long get_closure_var2(
long long a1,
long long a2,
long long a3,
int a4,
unsigned int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
unsigned int a15,
unsigned int a16,
int a17,
int a18)
{
long long result; // rax
long long v22; // rsi
char v23; // r15
char v24; // bp
long long v25; // rdx
unsigned int v26; // r11d
long long v27; // rsi
long long v28; // rdi
char v29; // r8
result = a16;
v22 = *(_QWORD *)(a2 + 8);
if ( v22 == a3 )
{
v23 = a18;
v24 = a16;
}
else
{
v23 = a18;
v24 = a16;
result = get_closure_var2(a1, v22, a3, a4, a5, a6, a15, a16, a17, a18);
if ( (int)result < 0 )
return 0xFFFFFFFFLL;
a6 = result;
a4 = 0;
}
v25 = *(int *)(a2 + 408);
v26 = a15;
if ( v25 <= 0 )
return add_closure_var(a1, a2, a4, a5, a6, v26, a7, a8, a9, a10, a11, a12, a13, a14, v24, a17, v23);
v27 = *(_QWORD *)(a2 + 416);
v28 = 0LL;
while ( 1 )
{
v29 = 1;
if ( a6 == *(unsigned __int16 *)(v27 + 8 * v28 + 2) )
{
if ( ((*(unsigned __int8 *)(v27 + 8 * v28) >> 1) & 1) == a5 )
{
v26 = a15;
if ( a4 == (*(_BYTE *)(v27 + 8 * v28) & 1) )
{
v29 = 0;
result = (unsigned int)v28;
}
}
else
{
v26 = a15;
}
}
if ( !v29 )
break;
if ( v25 == ++v28 )
return add_closure_var(a1, a2, a4, a5, a6, v26, a7, a8, a9, a10, a11, a12, a13, a14, v24, a17, v23);
}
return result;
}
| |||
2,604 | get_closure_var2 | bluesky950520[P]quickjs/quickjs.c | static int get_closure_var2(JSContext *ctx, JSFunctionDef *s,
JSFunctionDef *fd, BOOL is_local,
BOOL is_arg, int var_idx, JSAtom var_name,
BOOL is_const, BOOL is_lexical,
JSVarKindEnum var_kind)
{
int i;
if (fd != s->parent) {
var_idx = get_closure_var2(ctx, s->parent, fd, is_local,
is_arg, var_idx, var_name,
is_const, is_lexical, var_kind);
if (var_idx < 0)
return -1;
is_local = FALSE;
}
for(i = 0; i < s->closure_var_count; i++) {
JSClosureVar *cv = &s->closure_var[i];
if (cv->var_idx == var_idx && cv->is_arg == is_arg &&
cv->is_local == is_local)
return i;
}
return add_closure_var(ctx, s, is_local, is_arg, var_idx, var_name,
is_const, is_lexical, var_kind);
} | O2 | c | get_closure_var2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rsi, %r14
movq %rdi, %r12
movl 0x58(%rsp), %r13d
movl 0x50(%rsp), %r11d
movl 0x48(%rsp), %r10d
movl 0x40(%rsp), %eax
movq 0x8(%rsi), %rsi
cmpq %rdx, %rsi
je 0x5c1cb
movq %r12, %rdi
movl %ebx, %r8d
pushq %r13
movq %r11, %r13
pushq %r11
movq %r10, %rbp
pushq %r10
movq %rax, %r15
pushq %rax
callq 0x5c166
addq $0x20, %rsp
testl %eax, %eax
js 0x5c232
movl %eax, %r9d
xorl %ecx, %ecx
movq %rbp, %r10
movq %r13, %r11
movl 0x58(%rsp), %r13d
jmp 0x5c1ce
movq %rax, %r15
movl 0x198(%r14), %edx
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x5c20d
movq 0x1a0(%r14), %rsi
movzwl 0x2(%rsi,%rax,8), %edi
cmpl %edi, %r9d
jne 0x5c208
movzbl (%rsi,%rax,8), %esi
movl %esi, %edi
shrl %edi
andl $0x1, %edi
cmpl %ebx, %edi
jne 0x5c208
andl $0x1, %esi
cmpl %esi, %ecx
je 0x5c235
incq %rax
jmp 0x5c1dc
subq $0x8, %rsp
movq %r12, %rdi
movq %r14, %rsi
movl %ecx, %edx
movl %ebx, %ecx
movl %r9d, %r8d
movl %r15d, %r9d
pushq %r13
pushq %r11
pushq %r10
callq 0x5bdfd
addq $0x28, %rsp
jmp 0x5c239
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| get_closure_var2:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, r8d
mov r14, rsi
mov r12, rdi
mov r13d, [rsp+38h+arg_18]
mov r11d, [rsp+38h+arg_10]
mov r10d, [rsp+38h+arg_8]
mov eax, [rsp+38h+arg_0]
mov rsi, [rsi+8]
cmp rsi, rdx
jz short loc_5C1CB
mov rdi, r12
mov r8d, ebx
push r13
mov r13, r11
push r11
mov rbp, r10
push r10
mov r15, rax
push rax
call get_closure_var2
add rsp, 20h
test eax, eax
js short loc_5C232
mov r9d, eax
xor ecx, ecx
mov r10, rbp
mov r11, r13
mov r13d, [rsp+38h+arg_18]
jmp short loc_5C1CE
loc_5C1CB:
mov r15, rax
loc_5C1CE:
mov edx, [r14+198h]
xor eax, eax
test edx, edx
cmovle edx, eax
loc_5C1DC:
cmp rdx, rax
jz short loc_5C20D
mov rsi, [r14+1A0h]
movzx edi, word ptr [rsi+rax*8+2]
cmp r9d, edi
jnz short loc_5C208
movzx esi, byte ptr [rsi+rax*8]
mov edi, esi
shr edi, 1
and edi, 1
cmp edi, ebx
jnz short loc_5C208
and esi, 1
cmp ecx, esi
jz short loc_5C235
loc_5C208:
inc rax
jmp short loc_5C1DC
loc_5C20D:
sub rsp, 8
mov rdi, r12
mov rsi, r14
mov edx, ecx
mov ecx, ebx
mov r8d, r9d
mov r9d, r15d
push r13
push r11
push r10
call add_closure_var
add rsp, 28h
jmp short loc_5C239
loc_5C232:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_5C235:
add rsp, 8
loc_5C239:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long get_closure_var2(
long long a1,
long long a2,
long long a3,
int a4,
unsigned int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
unsigned int a15,
int a16,
int a17,
int a18)
{
char v20; // r13
char v21; // r11
char v22; // r10
long long v23; // rsi
unsigned int v24; // r15d
int closure_var2; // eax
long long v26; // rdx
long long result; // rax
long long v28; // rsi
unsigned int v29; // esi
v20 = a18;
v21 = a17;
v22 = a16;
v23 = *(_QWORD *)(a2 + 8);
if ( v23 == a3 )
{
v24 = a15;
}
else
{
v24 = a15;
closure_var2 = get_closure_var2(a1, v23, a3, a4, a5, a6, a15, a16, a17, a18);
if ( closure_var2 < 0 )
return -1LL;
a6 = closure_var2;
a4 = 0;
v22 = a16;
v21 = a17;
v20 = a18;
}
v26 = *(unsigned int *)(a2 + 408);
result = 0LL;
if ( (int)v26 <= 0 )
v26 = 0LL;
while ( v26 != result )
{
v28 = *(_QWORD *)(a2 + 416);
if ( a6 == *(unsigned __int16 *)(v28 + 8 * result + 2) )
{
v29 = *(unsigned __int8 *)(v28 + 8 * result);
if ( ((v29 >> 1) & 1) == a5 && a4 == (v29 & 1) )
return result;
}
++result;
}
return add_closure_var(a1, a2, a4, a5, a6, v24, a7, a8, a9, a10, a11, a12, a13, a14, v22, v21, v20);
}
| get_closure_var2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,R8D
MOV R14,RSI
MOV R12,RDI
MOV R13D,dword ptr [RSP + 0x58]
MOV R11D,dword ptr [RSP + 0x50]
MOV R10D,dword ptr [RSP + 0x48]
MOV EAX,dword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSI + 0x8]
CMP RSI,RDX
JZ 0x0015c1cb
MOV RDI,R12
MOV R8D,EBX
PUSH R13
MOV R13,R11
PUSH R11
MOV RBP,R10
PUSH R10
MOV R15,RAX
PUSH RAX
CALL 0x0015c166
ADD RSP,0x20
TEST EAX,EAX
JS 0x0015c232
MOV R9D,EAX
XOR ECX,ECX
MOV R10,RBP
MOV R11,R13
MOV R13D,dword ptr [RSP + 0x58]
JMP 0x0015c1ce
LAB_0015c1cb:
MOV R15,RAX
LAB_0015c1ce:
MOV EDX,dword ptr [R14 + 0x198]
XOR EAX,EAX
TEST EDX,EDX
CMOVLE EDX,EAX
LAB_0015c1dc:
CMP RDX,RAX
JZ 0x0015c20d
MOV RSI,qword ptr [R14 + 0x1a0]
MOVZX EDI,word ptr [RSI + RAX*0x8 + 0x2]
CMP R9D,EDI
JNZ 0x0015c208
MOVZX ESI,byte ptr [RSI + RAX*0x8]
MOV EDI,ESI
SHR EDI,0x1
AND EDI,0x1
CMP EDI,EBX
JNZ 0x0015c208
AND ESI,0x1
CMP ECX,ESI
JZ 0x0015c235
LAB_0015c208:
INC RAX
JMP 0x0015c1dc
LAB_0015c20d:
SUB RSP,0x8
MOV RDI,R12
MOV RSI,R14
MOV EDX,ECX
MOV ECX,EBX
MOV R8D,R9D
MOV R9D,R15D
PUSH R13
PUSH R11
PUSH R10
CALL 0x0015bdfd
ADD RSP,0x28
JMP 0x0015c239
LAB_0015c232:
PUSH -0x1
POP RAX
LAB_0015c235:
ADD RSP,0x8
LAB_0015c239:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong get_closure_var2(int8 param_1,long param_2,long param_3,uint param_4,uint param_5,
uint param_6,int4 param_7,int4 param_8,int4 param_9,
int4 param_10)
{
byte bVar1;
ulong uVar2;
ulong uVar3;
if (*(long *)(param_2 + 8) != param_3) {
param_6 = get_closure_var2(param_1);
if ((int)param_6 < 0) {
return 0xffffffffffffffff;
}
param_4 = 0;
}
uVar2 = 0;
uVar3 = (ulong)*(uint *)(param_2 + 0x198);
if ((int)*(uint *)(param_2 + 0x198) < 1) {
uVar3 = uVar2;
}
while( true ) {
if (uVar3 == uVar2) {
uVar3 = add_closure_var(param_1,param_2,param_4,param_5,param_6,param_7,param_8,param_9,
param_10);
return uVar3;
}
if (((param_6 == *(ushort *)(*(long *)(param_2 + 0x1a0) + 2 + uVar2 * 8)) &&
(bVar1 = *(byte *)(*(long *)(param_2 + 0x1a0) + uVar2 * 8), (bVar1 >> 1 & 1) == param_5)) &&
(param_4 == (bVar1 & 1))) break;
uVar2 = uVar2 + 1;
}
return uVar2;
}
|
|
2,605 | my_uca_generate_implicit_page | eloqsql/strings/ctype-uca.c | static my_bool
my_uca_generate_implicit_page(MY_CHARSET_LOADER *loader,
MY_UCA_WEIGHT_LEVEL *dst,
uint page)
{
uint chc, size= 256 * dst->lengths[page] * sizeof(uint16);
if (!(dst->weights[page]= (uint16 *) (loader->once_alloc)(size)))
return TRUE;
memset(dst->weights[page], 0, size);
for (chc= 0 ; chc < 256; chc++)
{
uint16 *w= dst->weights[page] + chc * dst->lengths[page];
my_uca_implicit_weight_put(w, (page << 8) + chc, dst->levelno);
}
return FALSE;
} | O0 | c | my_uca_generate_implicit_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
cltq
shlq %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edi
callq *%rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x1c(%rbp), %edx
movq %rax, (%rcx,%rdx,8)
cmpq $0x0, %rax
jne 0x5befd
movb $0x1, -0x1(%rbp)
jmp 0x5bf84
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x24180
movl $0x0, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp) # imm = 0x100
jae 0x5bf80
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rdx
movl -0x1c(%rbp), %esi
movzbl (%rdx,%rsi), %edx
imull %edx, %ecx
movl %ecx, %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %eax
shll $0x8, %eax
addl -0x20(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %edx
callq 0x5bf90
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5bf1f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_uca_generate_implicit_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov ecx, [rbp+var_1C]
movzx eax, byte ptr [rax+rcx]
shl eax, 8
cdqe
shl rax, 1
mov [rbp+var_24], eax
mov rax, [rbp+var_10]
mov rax, [rax+80h]
mov ecx, [rbp+var_24]
mov edi, ecx
call rax
mov rcx, [rbp+var_18]
mov rcx, [rcx+10h]
mov edx, [rbp+var_1C]
mov [rcx+rdx*8], rax
cmp rax, 0
jnz short loc_5BEFD
mov [rbp+var_1], 1
jmp loc_5BF84
loc_5BEFD:
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov ecx, [rbp+var_1C]
mov rdi, [rax+rcx*8]
mov eax, [rbp+var_24]
mov edx, eax
xor esi, esi
call _memset
mov [rbp+var_20], 0
loc_5BF1F:
cmp [rbp+var_20], 100h
jnb short loc_5BF80
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov ecx, [rbp+var_1C]
mov rax, [rax+rcx*8]
mov ecx, [rbp+var_20]
mov rdx, [rbp+var_18]
mov rdx, [rdx+8]
mov esi, [rbp+var_1C]
movzx edx, byte ptr [rdx+rsi]
imul ecx, edx
mov ecx, ecx
shl rcx, 1
add rax, rcx
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov eax, [rbp+var_1C]
shl eax, 8
add eax, [rbp+var_20]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_18]
mov edx, [rax+30h]
call my_uca_implicit_weight_put
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp short loc_5BF1F
loc_5BF80:
mov [rbp+var_1], 0
loc_5BF84:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char my_uca_generate_implicit_page(long long a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int v5; // [rsp+Ch] [rbp-24h]
unsigned int i; // [rsp+10h] [rbp-20h]
v5 = *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a3) << 9;
v3 = (*(long long ( **)(_QWORD))(a1 + 128))(v5);
*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8LL * a3) = v3;
if ( !v3 )
return 1;
memset(*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8LL * a3), 0LL, v5);
for ( i = 0; i < 0x100; ++i )
my_uca_implicit_weight_put(
2LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + a3) * i + *(_QWORD *)(*(_QWORD *)(a2 + 16) + 8LL * a3),
i + (a3 << 8),
*(unsigned int *)(a2 + 48));
return 0;
}
| my_uca_generate_implicit_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x1c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SHL EAX,0x8
CDQE
SHL RAX,0x1
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RBP + -0x24]
MOV EDI,ECX
CALL RAX
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX + 0x10]
MOV EDX,dword ptr [RBP + -0x1c]
MOV qword ptr [RCX + RDX*0x8],RAX
CMP RAX,0x0
JNZ 0x0015befd
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015bf84
LAB_0015befd:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x00124180
MOV dword ptr [RBP + -0x20],0x0
LAB_0015bf1f:
CMP dword ptr [RBP + -0x20],0x100
JNC 0x0015bf80
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV ECX,dword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX + 0x8]
MOV ESI,dword ptr [RBP + -0x1c]
MOVZX EDX,byte ptr [RDX + RSI*0x1]
IMUL ECX,EDX
MOV ECX,ECX
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x8
ADD EAX,dword ptr [RBP + -0x20]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX + 0x30]
CALL 0x0015bf90
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0015bf1f
LAB_0015bf80:
MOV byte ptr [RBP + -0x1],0x0
LAB_0015bf84:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 my_uca_generate_implicit_page(long param_1,long param_2,uint param_3)
{
size_t __n;
long lVar1;
int4 local_28;
int1 local_9;
__n = (long)(int)((uint)*(byte *)(*(long *)(param_2 + 8) + (ulong)param_3) << 8) << 1;
lVar1 = (**(code **)(param_1 + 0x80))(__n);
*(long *)(*(long *)(param_2 + 0x10) + (ulong)param_3 * 8) = lVar1;
if (lVar1 == 0) {
local_9 = 1;
}
else {
memset(*(void **)(*(long *)(param_2 + 0x10) + (ulong)param_3 * 8),0,__n);
for (local_28 = 0; local_28 < 0x100; local_28 = local_28 + 1) {
my_uca_implicit_weight_put
(*(long *)(*(long *)(param_2 + 0x10) + (ulong)param_3 * 8) +
(ulong)(local_28 * *(byte *)(*(long *)(param_2 + 8) + (ulong)param_3)) * 2,
param_3 * 0x100 + local_28,*(int4 *)(param_2 + 0x30));
}
local_9 = 0;
}
return local_9;
}
|
|
2,606 | nglog::LogDestination::SetLoggerImpl(nglog::base::Logger*) | ng-log[P]ng-log/src/logging.cc | void LogDestination::SetLoggerImpl(base::Logger* logger) {
if (logger_ == logger) {
// Prevent releasing currently held sink on reset
return;
}
if (logger_ && logger_ != &fileobject_) {
// Delete user-specified logger set via SetLogger().
delete logger_;
}
logger_ = logger;
} | O1 | cpp | nglog::LogDestination::SetLoggerImpl(nglog::base::Logger*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xc8(%rdi), %rdi
cmpq %rsi, %rdi
je 0x97b9
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
cmpq %r14, %rdi
sete %cl
orb %al, %cl
jne 0x97b2
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0xc8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN5nglog14LogDestination13SetLoggerImplEPNS_4base6LoggerE:
push r14
push rbx
push rax
mov r14, rdi
mov rdi, [rdi+0C8h]
cmp rdi, rsi
jz short loc_97B9
mov rbx, rsi
test rdi, rdi
setz al
cmp rdi, r14
setz cl
or cl, al
jnz short loc_97B2
mov rax, [rdi]
call qword ptr [rax+8]
loc_97B2:
mov [r14+0C8h], rbx
loc_97B9:
add rsp, 8
pop rbx
pop r14
retn
| char nglog::LogDestination::SetLoggerImpl(nglog::LogDestination *this, nglog::base::Logger *a2)
{
nglog::base::Logger *v3; // rdi
char result; // al
v3 = (nglog::base::Logger *)*((_QWORD *)this + 25);
if ( v3 != a2 )
{
result = v3 == 0LL;
if ( v3 != 0LL && v3 != this )
result = (*(long long ( **)(nglog::base::Logger *))(*(_QWORD *)v3 + 8LL))(v3);
*((_QWORD *)this + 25) = a2;
}
return result;
}
| SetLoggerImpl:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0xc8]
CMP RDI,RSI
JZ 0x001097b9
MOV RBX,RSI
TEST RDI,RDI
SETZ AL
CMP RDI,R14
SETZ CL
OR CL,AL
JNZ 0x001097b2
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_001097b2:
MOV qword ptr [R14 + 0xc8],RBX
LAB_001097b9:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nglog::LogDestination::SetLoggerImpl(nglog::base::Logger*) */
void __thiscall nglog::LogDestination::SetLoggerImpl(LogDestination *this,Logger *param_1)
{
Logger *pLVar1;
pLVar1 = *(Logger **)(this + 200);
if (pLVar1 != param_1) {
if (pLVar1 != (Logger *)this && pLVar1 != (Logger *)0x0) {
(**(code **)(*(long *)pLVar1 + 8))();
}
*(Logger **)(this + 200) = param_1;
}
return;
}
|
|
2,607 | my_charpos_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
} | O0 | c | my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x58a65
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5c100
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jne 0x58a45
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x58a98
jmp 0x58a47
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x58a10
cmpq $0x0, -0x28(%rbp)
je 0x58a81
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x58a90
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_charpos_utf16:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_58A10:
cmp [rbp+var_28], 0
jz short loc_58A65
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_ismbchar_1
mov [rbp+var_34], eax
cmp eax, 0
jnz short loc_58A45
mov rax, [rbp+var_20]
add rax, 2
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_58A98
loc_58A45:
jmp short $+2
loc_58A47:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp short loc_58A10
loc_58A65:
cmp [rbp+var_28], 0
jz short loc_58A81
mov rax, [rbp+var_20]
add rax, 2
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_40], rax
jmp short loc_58A90
loc_58A81:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_40], rax
loc_58A90:
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_58A98:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
unsigned int v5; // [rsp+Ch] [rbp-34h]
long long v8; // [rsp+28h] [rbp-18h]
v8 = a2;
while ( a4 )
{
v5 = my_ismbchar_1(a1, v8, a3);
if ( !v5 )
return a3 + 2 - a2;
v8 += v5;
--a4;
}
return v8 - a2;
}
| my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_00158a10:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00158a65
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0015c100
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JNZ 0x00158a45
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00158a98
LAB_00158a45:
JMP 0x00158a47
LAB_00158a47:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00158a10
LAB_00158a65:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00158a81
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00158a90
LAB_00158a81:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_00158a90:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00158a98:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00158a6c) */
long my_charpos_utf16(int8 param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long local_30;
long local_20;
local_30 = param_4;
local_20 = param_2;
while( true ) {
if (local_30 == 0) {
return local_20 - param_2;
}
uVar1 = my_ismbchar(param_1,local_20,param_3);
if (uVar1 == 0) break;
local_20 = local_20 + (ulong)uVar1;
local_30 = local_30 + -1;
}
return (param_3 + 2) - param_2;
}
|
|
2,608 | my_charpos_utf16 | eloqsql/strings/ctype-ucs2.c | static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
} | O3 | c | my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %r12
testq %rcx, %rcx
je 0x45e85
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r13
movq %rbx, %r12
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
cmpl $0x1, %eax
jle 0x45e7e
movl %eax, %eax
addq %rax, %r12
decq %r15
jne 0x45e57
jmp 0x45e85
addq $0x2, %r14
movq %r14, %r12
subq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_charpos_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r12, rsi
test rcx, rcx
jz short loc_45E85
mov r15, rcx
mov r14, rdx
mov r13, rdi
mov r12, rbx
loc_45E57:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r12
mov rdx, r14
call qword ptr [rax+0C0h]
cmp eax, 1
jle short loc_45E7E
mov eax, eax
add r12, rax
dec r15
jnz short loc_45E57
jmp short loc_45E85
loc_45E7E:
add r14, 2
mov r12, r14
loc_45E85:
sub r12, rbx
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r12
long long v5; // r15
int v7; // eax
v4 = a2;
if ( a4 )
{
v5 = a4;
v4 = a2;
while ( 1 )
{
v7 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, v4, a3);
if ( v7 <= 1 )
break;
v4 += (unsigned int)v7;
if ( !--v5 )
return v4 - a2;
}
v4 = a3 + 2;
}
return v4 - a2;
}
| my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R12,RSI
TEST RCX,RCX
JZ 0x00145e85
MOV R15,RCX
MOV R14,RDX
MOV R13,RDI
MOV R12,RBX
LAB_00145e57:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R14
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x1
JLE 0x00145e7e
MOV EAX,EAX
ADD R12,RAX
DEC R15
JNZ 0x00145e57
JMP 0x00145e85
LAB_00145e7e:
ADD R14,0x2
MOV R12,R14
LAB_00145e85:
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_utf16(long param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long lVar2;
lVar2 = param_2;
if (param_4 != 0) {
do {
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,lVar2,param_3);
if ((int)uVar1 < 2) {
lVar2 = param_3 + 2;
break;
}
lVar2 = lVar2 + (ulong)uVar1;
param_4 = param_4 + -1;
} while (param_4 != 0);
}
return lVar2 - param_2;
}
|
|
2,609 | my_caseup_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map= cs->to_upper;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_caseup_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0x40fcb
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x40fb5
popq %rbp
retq
| my_caseup_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_40FCB
push rbp
mov rbp, rsp
mov rdx, [rdi+50h]
xor edi, edi
loc_40FB5:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_40FB5
pop rbp
locret_40FCB:
retn
| long long my_caseup_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 80);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_caseup_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x00140fcb
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x50]
XOR EDI,EDI
LAB_00140fb5:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x00140fb5
POP RBP
LAB_00140fcb:
RET
|
void my_caseup_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x50);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
|
|
2,610 | int10_to_str | eloqsql/strings/int2str.c | char *int10_to_str(long int val,char *dst,int radix)
{
char buffer[65];
register char *p;
long int new_val;
unsigned long int uval = (unsigned long int) val;
if (radix < 0) /* -10 */
{
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
} | O3 | c | int10_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
testl %edx, %edx
setns %al
testq %rdi, %rdi
setns %cl
orb %al, %cl
jne 0x99f3b
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
leaq -0x11(%rbp), %r8
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %r9
movq %rdx, %rcx
movb $0x0, 0x1(%r8)
shrq $0x3, %rcx
imull $0xf6, %ecx, %eax
addl %edi, %eax
addb $0x30, %al
movb %al, (%r8)
cmpq $0xa, %rdi
jb 0x99f92
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r8)
decq %r8
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x99f6e
decq %rsi
movb (%r8), %al
incq %r8
movb %al, 0x1(%rsi)
incq %rsi
testb %al, %al
jne 0x99f95
movq %fs:0x28, %rax
cmpq -0x8(%rbp), %rax
jne 0x99fbd
movq %rsi, %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x372b0
nop
| int10_to_str:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
test edx, edx
setns al
test rdi, rdi
setns cl
or cl, al
jnz short loc_99F3B
mov byte ptr [rsi], 2Dh ; '-'
inc rsi
neg rdi
loc_99F3B:
lea r8, [rbp+var_11]
mov r9, 0CCCCCCCCCCCCCCCDh
mov rax, rdi
mul r9
mov rcx, rdx
mov byte ptr [r8+1], 0
shr rcx, 3
imul eax, ecx, 0F6h
add eax, edi
add al, 30h ; '0'
mov [r8], al
cmp rdi, 0Ah
jb short loc_99F92
loc_99F6E:
mov rax, rcx
mul r9
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r8-1], al
dec r8
cmp rcx, 9
mov rcx, rdx
ja short loc_99F6E
loc_99F92:
dec rsi
loc_99F95:
mov al, [r8]
inc r8
mov [rsi+1], al
inc rsi
test al, al
jnz short loc_99F95
mov rax, fs:28h
cmp rax, [rbp+var_8]
jnz short loc_99FBD
mov rax, rsi
add rsp, 50h
pop rbp
retn
loc_99FBD:
call ___stack_chk_fail
| _BYTE * int10_to_str(unsigned long long a1, _BYTE *a2, int a3)
{
char *v3; // r8
unsigned long long v4; // rcx
bool v5; // cc
_BYTE *v6; // rsi
char v7; // al
_BYTE v9[9]; // [rsp+3Fh] [rbp-11h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
if ( a3 < 0 && (a1 & 0x8000000000000000LL) != 0LL )
{
*a2++ = 45;
a1 = -(long long)a1;
}
v3 = v9;
v9[1] = 0;
v4 = a1 / 0xA;
v9[0] = a1 % 0xA + 48;
if ( a1 >= 0xA )
{
do
{
*--v3 = v4 % 0xA + 48;
v5 = v4 <= 9;
v4 /= 0xAuLL;
}
while ( !v5 );
}
v6 = a2 - 1;
do
{
v7 = *v3++;
*++v6 = v7;
}
while ( v7 );
return v6;
}
| int10_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
TEST EDX,EDX
SETNS AL
TEST RDI,RDI
SETNS CL
OR CL,AL
JNZ 0x00199f3b
MOV byte ptr [RSI],0x2d
INC RSI
NEG RDI
LAB_00199f3b:
LEA R8,[RBP + -0x11]
MOV R9,-0x3333333333333333
MOV RAX,RDI
MUL R9
MOV RCX,RDX
MOV byte ptr [R8 + 0x1],0x0
SHR RCX,0x3
IMUL EAX,ECX,0xf6
ADD EAX,EDI
ADD AL,0x30
MOV byte ptr [R8],AL
CMP RDI,0xa
JC 0x00199f92
LAB_00199f6e:
MOV RAX,RCX
MUL R9
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R8 + -0x1],AL
DEC R8
CMP RCX,0x9
MOV RCX,RDX
JA 0x00199f6e
LAB_00199f92:
DEC RSI
LAB_00199f95:
MOV AL,byte ptr [R8]
INC R8
MOV byte ptr [RSI + 0x1],AL
INC RSI
TEST AL,AL
JNZ 0x00199f95
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x8]
JNZ 0x00199fbd
MOV RAX,RSI
ADD RSP,0x50
POP RBP
RET
LAB_00199fbd:
CALL 0x001372b0
|
int1 * int10_to_str(ulong param_1,int1 *param_2,int param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_1 < 0 && param_3 < 0) {
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_1 = -param_1;
}
pcVar4 = local_1a + 1;
local_1a[2] = 0;
local_1a[1] = (char)(param_1 / 10) * -10 + (char)param_1 + '0';
uVar3 = param_1 / 10;
while (uVar2 = uVar3, 9 < param_1) {
pcVar4[-1] = (char)(uVar2 / 10) * -10 + (char)uVar2 + '0';
pcVar4 = pcVar4 + -1;
uVar3 = uVar2 / 10;
param_1 = uVar2;
}
param_2 = param_2 + -1;
do {
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
param_2[1] = cVar1;
param_2 = param_2 + 1;
} while (cVar1 != '\0');
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
|
|
2,611 | ggml_hash_set_new | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_hash_set ggml_hash_set_new(size_t size) {
size = ggml_hash_size(size);
struct ggml_hash_set result;
result.size = size;
result.keys = GGML_MALLOC(sizeof(struct ggml_tensor *) * size);
result.used = GGML_CALLOC(ggml_bitset_size(size), sizeof(ggml_bitset_t));
return result;
} | O0 | c | ggml_hash_set_new:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x42340
movq -0x18(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, (%rdi)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0x4bc50
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x8(%rbp), %rdi
callq 0x556e0
movq %rax, %rdi
movl $0x4, %esi
callq 0x55610
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| ggml_hash_set_new:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_10], rdi
mov [rbp+var_8], rsi
mov rdi, [rbp+var_8]
call _ggml_hash_size
mov rdi, [rbp+var_18]
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov [rdi], rax
mov rdi, [rbp+var_8]
shl rdi, 3
call ggml_malloc
mov rdi, [rbp+var_18]
mov [rdi+10h], rax
mov rdi, [rbp+var_8]
call ggml_bitset_size
mov rdi, rax
mov esi, 4
call ggml_calloc
mov rdi, [rbp+var_18]
mov rcx, rax
mov rax, [rbp+var_10]
mov [rdi+8], rcx
add rsp, 20h
pop rbp
retn
| long long * ggml_hash_set_new(long long *a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
long long *result; // rax
long long v5; // [rsp+18h] [rbp-8h]
v5 = ggml_hash_size(a2);
*a1 = v5;
a1[2] = ggml_malloc(8 * v5);
v2 = ggml_bitset_size(v5);
v3 = ggml_calloc(v2, 4LL);
result = a1;
a1[1] = v3;
return result;
}
| ggml_hash_set_new:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00142340
MOV RDI,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RBP + -0x8]
SHL RDI,0x3
CALL 0x0014bc50
MOV RDI,qword ptr [RBP + -0x18]
MOV qword ptr [RDI + 0x10],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001556e0
MOV RDI,RAX
MOV ESI,0x4
CALL 0x00155610
MOV RDI,qword ptr [RBP + -0x18]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RDI + 0x8],RCX
ADD RSP,0x20
POP RBP
RET
|
long * ggml_hash_set_new(long *param_1,int8 param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
lVar1 = ggml_hash_size(param_2);
*param_1 = lVar1;
lVar2 = ggml_malloc(lVar1 << 3);
param_1[2] = lVar2;
uVar3 = ggml_bitset_size(lVar1);
lVar1 = ggml_calloc(uVar3,4);
param_1[1] = lVar1;
return param_1;
}
|
|
2,612 | ggml_hash_set_new | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c | struct ggml_hash_set ggml_hash_set_new(size_t size) {
size = ggml_hash_size(size);
struct ggml_hash_set result;
result.size = size;
result.keys = GGML_MALLOC(sizeof(struct ggml_tensor *) * size);
result.used = GGML_CALLOC(ggml_bitset_size(size), sizeof(ggml_bitset_t));
return result;
} | O2 | c | ggml_hash_set_new:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1d190
movq %rax, %r14
movq %rax, (%rbx)
leaq (,%rax,8), %rdi
callq 0x210b2
movq %rax, 0x10(%rbx)
addq $0x1f, %r14
cmpq $0x1f, %r14
ja 0x2675e
leaq 0x2a2ef(%rip), %rsi # 0x50a3e
xorl %r14d, %r14d
pushq $0x3
popq %rdi
xorl %eax, %eax
callq 0x1db70
jmp 0x26775
shrq $0x5, %r14
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x1e010
movq %rax, %r14
testq %rax, %rax
je 0x26784
movq %r14, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x29da1(%rip), %rsi # 0x5052c
leaq 0x2a2f1(%rip), %rdx # 0x50a83
pushq $0x4
popq %rdi
movsd 0x278ab(%rip), %xmm0 # 0x4e048
movb $0x1, %al
callq 0x1db70
leaq 0x27dd8(%rip), %rdi # 0x4e583
leaq 0x29da7(%rip), %rdx # 0x50559
movl $0x14a, %esi # imm = 0x14A
xorl %eax, %eax
callq 0x1f9b0
| ggml_hash_set_new:
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, rsi
call _ggml_hash_size
mov r14, rax
mov [rbx], rax
lea rdi, ds:0[rax*8]
call ggml_malloc
mov [rbx+10h], rax
add r14, 1Fh
cmp r14, 1Fh
ja short loc_2675E
lea rsi, aBehaviorMayBeU_1; "Behavior may be unexpected when allocat"...
xor r14d, r14d
push 3
pop rdi
xor eax, eax
call _ggml_log_internal
jmp short loc_26775
loc_2675E:
shr r14, 5
push 4
pop rsi
mov rdi, r14
call _calloc
mov r14, rax
test rax, rax
jz short loc_26784
loc_26775:
mov [rbx+8], r14
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
loc_26784:
lea rsi, aSFailedToAlloc; "%s: failed to allocate %6.2f MB\n"
lea rdx, aGgmlCalloc; "ggml_calloc"
push 4
pop rdi
movsd xmm0, cs:qword_4E048
mov al, 1
call _ggml_log_internal
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aFatalError; "fatal error"
mov esi, 14Ah
xor eax, eax
call _ggml_abort
| long long * ggml_hash_set_new(
long long *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
char v10; // al
long long v11; // r14
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
unsigned long long v24; // r14
long long v25; // r14
long long v26; // rcx
long long v27; // r8
long long v28; // r9
__m128 v29; // xmm4
__m128 v30; // xmm5
long long v32; // rcx
long long v33; // r8
long long v34; // r9
__m128 v35; // xmm4
__m128 v36; // xmm5
char v37; // [rsp-8h] [rbp-18h]
v37 = v10;
v11 = ggml_hash_size(a2);
*a1 = v11;
a1[2] = ggml_malloc(8 * v11, a3, a4, a5, a6, v16, v17, a9, a10, a2, v12, v13, v14, v15);
v24 = v11 + 31;
if ( v24 > 0x1F )
{
v25 = calloc(v24 >> 5, 4LL);
if ( !v25 )
{
ggml_log_internal(
(__m128)0x3ED0000000000000uLL,
a4,
a5,
a6,
v29,
v30,
a9,
a10,
4LL,
(long long)"%s: failed to allocate %6.2f MB\n",
(long long)"ggml_calloc",
v26,
v27,
v28);
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
330,
(long long)"fatal error",
v32,
v33,
v34,
(__m128)0x3ED0000000000000uLL,
a4,
a5,
a6,
v35,
v36,
a9,
a10,
v37);
}
}
else
{
v25 = 0LL;
ggml_log_internal(
a3,
a4,
a5,
a6,
v22,
v23,
a9,
a10,
3LL,
(long long)"Behavior may be unexpected when allocating 0 bytes for ggml_calloc!\n",
v18,
v19,
v20,
v21);
}
a1[1] = v25;
return a1;
}
| ggml_hash_set_new:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,RSI
CALL 0x0011d190
MOV R14,RAX
MOV qword ptr [RBX],RAX
LEA RDI,[RAX*0x8]
CALL 0x001210b2
MOV qword ptr [RBX + 0x10],RAX
ADD R14,0x1f
CMP R14,0x1f
JA 0x0012675e
LEA RSI,[0x150a3e]
XOR R14D,R14D
PUSH 0x3
POP RDI
XOR EAX,EAX
CALL 0x0011db70
JMP 0x00126775
LAB_0012675e:
SHR R14,0x5
PUSH 0x4
POP RSI
MOV RDI,R14
CALL 0x0011e010
MOV R14,RAX
TEST RAX,RAX
JZ 0x00126784
LAB_00126775:
MOV qword ptr [RBX + 0x8],R14
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00126784:
LEA RSI,[0x15052c]
LEA RDX,[0x150a83]
PUSH 0x4
POP RDI
MOVSD XMM0,qword ptr [0x0014e048]
MOV AL,0x1
CALL 0x0011db70
LEA RDI,[0x14e583]
LEA RDX,[0x150559]
MOV ESI,0x14a
XOR EAX,EAX
CALL 0x0011f9b0
|
long * ggml_hash_set_new(long *param_1,int8 param_2)
{
long lVar1;
long lVar2;
void *pvVar3;
lVar1 = ggml_hash_size(param_2);
*param_1 = lVar1;
lVar2 = ggml_malloc(lVar1 * 8);
param_1[2] = lVar2;
if (lVar1 + 0x1fU < 0x20) {
pvVar3 = (void *)0x0;
ggml_log_internal(3,"Behavior may be unexpected when allocating 0 bytes for ggml_calloc!\n");
}
else {
pvVar3 = calloc(lVar1 + 0x1fU >> 5,4);
if (pvVar3 == (void *)0x0) {
ggml_log_internal(DAT_0014e048,4,"%s: failed to allocate %6.2f MB\n","ggml_calloc");
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c"
,0x14a,"fatal error");
}
}
param_1[1] = (long)pvVar3;
return param_1;
}
|
|
2,613 | sqr_fp2x2 | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/fp12_tower.c | static void sqr_fp2x2(vec768x ret, const vec384x a)
{
#if 1
sqr_382x(ret, a, BLS12_381_P); /* +~5% in final exponentiation */
#else
vec384 t0, t1;
add_mod_384(t0, a[0], a[1], BLS12_381_P);
sub_mod_384(t1, a[0], a[1], BLS12_381_P);
mul_384(ret[1], a[0], a[1]);
add_mod_384x384(ret[1], ret[1], ret[1], BLS12_381_P);
mul_384(ret[0], t0, t1);
#endif
} | O0 | c | sqr_fp2x2:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x1c4a1(%rip), %rdx # 0x54cf0
callq 0x45160
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| sqr_fp2x2:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, BLS12_381_P
call sqr_382x
add rsp, 10h
pop rbp
retn
| long long sqr_fp2x2(long long a1, long long a2)
{
return sqr_382x(a1, a2, &BLS12_381_P);
}
| sqr_fp2x2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0x154cf0]
CALL 0x00145160
ADD RSP,0x10
POP RBP
RET
|
void sqr_fp2x2(int8 param_1,int8 param_2)
{
sqr_382x(param_1,param_2,BLS12_381_P);
return;
}
|
|
2,614 | my_strnncollsp_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_strnncollsp_tis620(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a0, size_t a_length,
const uchar *b0, size_t b_length)
{
uchar buf[80], *end, *a, *b, *alloced= NULL;
size_t length;
int res= 0;
a= buf;
if ((a_length + b_length +2) > (int) sizeof(buf))
alloced= a= (uchar*) my_malloc(PSI_INSTRUMENT_ME, a_length+b_length+2, MYF(MY_FAE));
b= a + a_length+1;
if (a_length)
memcpy((char*) a, (char*) a0, a_length);
a[a_length]= 0; /* if length(a0)> len1, need to put 'end of string' */
if (b_length)
memcpy((char *)b, (char *)b0, b_length);
b[b_length]= 0; /* put end of string */
a_length= thai2sortable(a, a_length);
b_length= thai2sortable(b, b_length);
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
{
res= ((int) a[-1] - (int) b[-1]);
goto ret;
}
}
res= a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
ret:
if (alloced)
my_free(alloced);
return res;
} | O0 | c | my_strnncollsp_tis620:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x70(%rbp)
movq %rdx, -0x78(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x88(%rbp)
movq $0x0, -0xa8(%rbp)
movl $0x0, -0xb4(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
addq -0x88(%rbp), %rax
addq $0x2, %rax
cmpq $0x50, %rax
jbe 0x7f01d
movq -0x78(%rbp), %rsi
addq -0x88(%rbp), %rsi
addq $0x2, %rsi
xorl %edi, %edi
movl $0x8, %edx
callq 0x5b130
movq %rax, -0x98(%rbp)
movq %rax, -0xa8(%rbp)
movq -0x98(%rbp), %rax
addq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0x7f04e
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x26280
movq -0x98(%rbp), %rax
movq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpq $0x0, -0x88(%rbp)
je 0x7f07e
movq -0xa0(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x26280
movq -0xa0(%rbp), %rax
movq -0x88(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x7f380
movq %rax, -0x78(%rbp)
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x7f380
movq %rax, -0x88(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jae 0x7f0e6
movq -0x78(%rbp), %rax
movq %rax, -0xc8(%rbp)
jmp 0x7f0f4
movq -0x88(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rax
movq -0xc8(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
addq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x90(%rbp), %rax
jae 0x7f17c
movq -0x98(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x98(%rbp)
movzbl (%rax), %eax
movq -0xa0(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0xa0(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x7f17a
movq -0x98(%rbp), %rax
movzbl -0x1(%rax), %eax
movq -0xa0(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0xb4(%rbp)
jmp 0x7f1fd
jmp 0x7f113
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jne 0x7f193
xorl %eax, %eax
movl %eax, -0xcc(%rbp)
jmp 0x7f1f1
movq -0x78(%rbp), %rax
cmpq -0x88(%rbp), %rax
jae 0x7f1c8
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rsi
subq -0xb0(%rbp), %rsi
callq 0x6d280
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0xd0(%rbp)
jmp 0x7f1e5
movq -0x98(%rbp), %rdi
movq -0x78(%rbp), %rsi
subq -0xb0(%rbp), %rsi
callq 0x6d280
movl %eax, -0xd0(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
movl %eax, -0xb4(%rbp)
cmpq $0x0, -0xa8(%rbp)
je 0x7f213
movq -0xa8(%rbp), %rdi
callq 0x5b4b0
movl -0xb4(%rbp), %eax
movl %eax, -0xd4(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x7f240
movl -0xd4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
callq 0x26370
nopw %cs:(%rax,%rax)
| my_strnncollsp_tis620:
push rbp
mov rbp, rsp
sub rsp, 0E0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov [rbp+var_80], rcx
mov [rbp+var_88], r8
mov [rbp+var_A8], 0
mov [rbp+var_B4], 0
lea rax, [rbp+var_60]
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
add rax, [rbp+var_88]
add rax, 2
cmp rax, 50h ; 'P'
jbe short loc_7F01D
mov rsi, [rbp+var_78]
add rsi, [rbp+var_88]
add rsi, 2
xor edi, edi
mov edx, 8
call my_malloc
mov [rbp+var_98], rax
mov [rbp+var_A8], rax
loc_7F01D:
mov rax, [rbp+var_98]
add rax, [rbp+var_78]
add rax, 1
mov [rbp+var_A0], rax
cmp [rbp+var_78], 0
jz short loc_7F04E
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_70]
mov rdx, [rbp+var_78]
call _memcpy
loc_7F04E:
mov rax, [rbp+var_98]
mov rcx, [rbp+var_78]
mov byte ptr [rax+rcx], 0
cmp [rbp+var_88], 0
jz short loc_7F07E
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_88]
call _memcpy
loc_7F07E:
mov rax, [rbp+var_A0]
mov rcx, [rbp+var_88]
mov byte ptr [rax+rcx], 0
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_78]
call thai2sortable
mov [rbp+var_78], rax
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_88]
call thai2sortable
mov [rbp+var_88], rax
mov rax, [rbp+var_98]
mov [rbp+var_C0], rax
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnb short loc_7F0E6
mov rax, [rbp+var_78]
mov [rbp+var_C8], rax
jmp short loc_7F0F4
loc_7F0E6:
mov rax, [rbp+var_88]
mov [rbp+var_C8], rax
loc_7F0F4:
mov rax, [rbp+var_C0]
mov rcx, [rbp+var_C8]
mov [rbp+var_B0], rcx
add rax, rcx
mov [rbp+var_90], rax
loc_7F113:
mov rax, [rbp+var_98]
cmp rax, [rbp+var_90]
jnb short loc_7F17C
mov rax, [rbp+var_98]
mov rcx, rax
add rcx, 1
mov [rbp+var_98], rcx
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_A0]
mov rdx, rcx
add rdx, 1
mov [rbp+var_A0], rdx
movzx ecx, byte ptr [rcx]
cmp eax, ecx
jz short loc_7F17A
mov rax, [rbp+var_98]
movzx eax, byte ptr [rax-1]
mov rcx, [rbp+var_A0]
movzx ecx, byte ptr [rcx-1]
sub eax, ecx
mov [rbp+var_B4], eax
jmp loc_7F1FD
loc_7F17A:
jmp short loc_7F113
loc_7F17C:
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnz short loc_7F193
xor eax, eax
mov [rbp+var_CC], eax
jmp short loc_7F1F1
loc_7F193:
mov rax, [rbp+var_78]
cmp rax, [rbp+var_88]
jnb short loc_7F1C8
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_88]
sub rsi, [rbp+var_B0]
call my_strnncollsp_padspace_bin
mov ecx, eax
xor eax, eax
sub eax, ecx
mov [rbp+var_D0], eax
jmp short loc_7F1E5
loc_7F1C8:
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_78]
sub rsi, [rbp+var_B0]
call my_strnncollsp_padspace_bin
mov [rbp+var_D0], eax
loc_7F1E5:
mov eax, [rbp+var_D0]
mov [rbp+var_CC], eax
loc_7F1F1:
mov eax, [rbp+var_CC]
mov [rbp+var_B4], eax
loc_7F1FD:
cmp [rbp+var_A8], 0
jz short loc_7F213
mov rdi, [rbp+var_A8]
call my_free
loc_7F213:
mov eax, [rbp+var_B4]
mov [rbp+var_D4], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_7F240
mov eax, [rbp+var_D4]
add rsp, 0E0h
pop rbp
retn
loc_7F240:
call ___stack_chk_fail
| long long my_strnncollsp_tis620(long long a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned __int8 *v5; // rax
unsigned __int8 *v6; // rcx
int v8; // [rsp+10h] [rbp-D0h]
unsigned int v9; // [rsp+14h] [rbp-CCh]
unsigned long long v10; // [rsp+18h] [rbp-C8h]
unsigned __int8 *v11; // [rsp+20h] [rbp-C0h]
unsigned int v12; // [rsp+2Ch] [rbp-B4h]
long long v13; // [rsp+38h] [rbp-A8h]
unsigned __int8 *v14; // [rsp+40h] [rbp-A0h]
unsigned __int8 *v15; // [rsp+48h] [rbp-98h]
unsigned long long v17; // [rsp+58h] [rbp-88h]
unsigned long long v20; // [rsp+68h] [rbp-78h]
char v21; // [rsp+80h] [rbp-60h] BYREF
unsigned long long v22; // [rsp+D8h] [rbp-8h]
v22 = __readfsqword(0x28u);
v13 = 0LL;
v15 = (unsigned __int8 *)&v21;
if ( (unsigned long long)(a5 + a3 + 2) > 0x50 )
{
v15 = (unsigned __int8 *)my_malloc(0, a5 + a3 + 2, 8);
v13 = (long long)v15;
}
v14 = &v15[a3 + 1];
if ( a3 )
memcpy(v15, a2, a3);
v15[a3] = 0;
if ( a5 )
memcpy(v14, a4, a5);
v14[a5] = 0;
v20 = thai2sortable(v15, a3);
v17 = thai2sortable(v14, a5);
v11 = v15;
if ( v20 >= v17 )
v10 = v17;
else
v10 = v20;
while ( v15 < &v11[v10] )
{
v5 = v15++;
v6 = v14++;
if ( *v5 != *v6 )
{
v12 = *(v15 - 1) - *(v14 - 1);
goto LABEL_21;
}
}
if ( v20 == v17 )
{
v9 = 0;
}
else
{
if ( v20 >= v17 )
v8 = my_strnncollsp_padspace_bin(v15, v20 - v10);
else
v8 = -(int)my_strnncollsp_padspace_bin(v14, v17 - v10);
v9 = v8;
}
v12 = v9;
LABEL_21:
if ( v13 )
my_free(v13);
return v12;
}
| my_strnncollsp_tis620:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV qword ptr [RBP + -0x80],RCX
MOV qword ptr [RBP + -0x88],R8
MOV qword ptr [RBP + -0xa8],0x0
MOV dword ptr [RBP + -0xb4],0x0
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,qword ptr [RBP + -0x88]
ADD RAX,0x2
CMP RAX,0x50
JBE 0x0017f01d
MOV RSI,qword ptr [RBP + -0x78]
ADD RSI,qword ptr [RBP + -0x88]
ADD RSI,0x2
XOR EDI,EDI
MOV EDX,0x8
CALL 0x0015b130
MOV qword ptr [RBP + -0x98],RAX
MOV qword ptr [RBP + -0xa8],RAX
LAB_0017f01d:
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0xa0],RAX
CMP qword ptr [RBP + -0x78],0x0
JZ 0x0017f04e
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,qword ptr [RBP + -0x78]
CALL 0x00126280
LAB_0017f04e:
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX + RCX*0x1],0x0
CMP qword ptr [RBP + -0x88],0x0
JZ 0x0017f07e
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x88]
CALL 0x00126280
LAB_0017f07e:
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x88]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x78]
CALL 0x0017f380
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x88]
CALL 0x0017f380
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNC 0x0017f0e6
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xc8],RAX
JMP 0x0017f0f4
LAB_0017f0e6:
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0xc8],RAX
LAB_0017f0f4:
MOV RAX,qword ptr [RBP + -0xc0]
MOV RCX,qword ptr [RBP + -0xc8]
MOV qword ptr [RBP + -0xb0],RCX
ADD RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
LAB_0017f113:
MOV RAX,qword ptr [RBP + -0x98]
CMP RAX,qword ptr [RBP + -0x90]
JNC 0x0017f17c
MOV RAX,qword ptr [RBP + -0x98]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x98],RCX
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0xa0]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0xa0],RDX
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
JZ 0x0017f17a
MOV RAX,qword ptr [RBP + -0x98]
MOVZX EAX,byte ptr [RAX + -0x1]
MOV RCX,qword ptr [RBP + -0xa0]
MOVZX ECX,byte ptr [RCX + -0x1]
SUB EAX,ECX
MOV dword ptr [RBP + -0xb4],EAX
JMP 0x0017f1fd
LAB_0017f17a:
JMP 0x0017f113
LAB_0017f17c:
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNZ 0x0017f193
XOR EAX,EAX
MOV dword ptr [RBP + -0xcc],EAX
JMP 0x0017f1f1
LAB_0017f193:
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,qword ptr [RBP + -0x88]
JNC 0x0017f1c8
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x88]
SUB RSI,qword ptr [RBP + -0xb0]
CALL 0x0016d280
MOV ECX,EAX
XOR EAX,EAX
SUB EAX,ECX
MOV dword ptr [RBP + -0xd0],EAX
JMP 0x0017f1e5
LAB_0017f1c8:
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x78]
SUB RSI,qword ptr [RBP + -0xb0]
CALL 0x0016d280
MOV dword ptr [RBP + -0xd0],EAX
LAB_0017f1e5:
MOV EAX,dword ptr [RBP + -0xd0]
MOV dword ptr [RBP + -0xcc],EAX
LAB_0017f1f1:
MOV EAX,dword ptr [RBP + -0xcc]
MOV dword ptr [RBP + -0xb4],EAX
LAB_0017f1fd:
CMP qword ptr [RBP + -0xa8],0x0
JZ 0x0017f213
MOV RDI,qword ptr [RBP + -0xa8]
CALL 0x0015b4b0
LAB_0017f213:
MOV EAX,dword ptr [RBP + -0xb4]
MOV dword ptr [RBP + -0xd4],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0017f240
MOV EAX,dword ptr [RBP + -0xd4]
ADD RSP,0xe0
POP RBP
RET
LAB_0017f240:
CALL 0x00126370
|
int my_strnncollsp_tis620
(int8 param_1,void *param_2,size_t param_3,void *param_4,size_t param_5)
{
byte *pbVar1;
byte *__dest;
ulong uVar2;
ulong uVar3;
byte *pbVar4;
long in_FS_OFFSET;
int local_d8;
int local_d4;
ulong local_d0;
int local_bc;
byte *local_b0;
byte *local_a8;
byte *local_a0;
byte local_68 [88];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_b0 = (byte *)0x0;
local_a0 = local_68;
if (0x50 < param_3 + param_5 + 2) {
local_b0 = (byte *)my_malloc(0,param_3 + param_5 + 2,8);
local_a0 = local_b0;
}
__dest = local_a0 + param_3 + 1;
if (param_3 != 0) {
memcpy(local_a0,param_2,param_3);
}
local_a0[param_3] = 0;
if (param_5 != 0) {
memcpy(__dest,param_4,param_5);
}
__dest[param_5] = 0;
uVar2 = thai2sortable(local_a0,param_3);
uVar3 = thai2sortable(__dest,param_5);
local_d0 = uVar3;
if (uVar2 < uVar3) {
local_d0 = uVar2;
}
pbVar4 = local_a0 + local_d0;
pbVar1 = local_a0;
do {
local_a0 = pbVar1;
local_a8 = __dest;
if (pbVar4 <= local_a0) {
if (uVar2 == uVar3) {
local_d4 = 0;
}
else {
if (uVar2 < uVar3) {
local_d8 = my_strnncollsp_padspace_bin(local_a8,uVar3 - local_d0);
local_d8 = -local_d8;
}
else {
local_d8 = my_strnncollsp_padspace_bin(local_a0,uVar2 - local_d0);
}
local_d4 = local_d8;
}
local_bc = local_d4;
goto LAB_0017f1fd;
}
__dest = local_a8 + 1;
pbVar1 = local_a0 + 1;
} while (*local_a0 == *local_a8);
local_bc = (uint)*local_a0 - (uint)*local_a8;
LAB_0017f1fd:
if (local_b0 != (byte *)0x0) {
my_free(local_b0);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_bc;
}
|
|
2,615 | copy_uca_collation | eloqsql/mysys/charset.c | static void
copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
CHARSET_INFO *loaded)
{
to->cset= from->cset;
to->coll= from->coll;
/*
Single-level UCA collation have strnxfrm_multiple=8.
In case of a multi-level UCA collation we use strnxfrm_multiply=4.
That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller
to allocate a buffer smaller size for each level, for performance purpose,
and to fit longer VARCHARs to @@max_sort_length.
This makes filesort produce non-precise order for some rare Unicode
characters that produce more than 4 weights (long expansions).
UCA requires 2 bytes per weight multiplied by the number of levels.
In case of a 2-level collation, each character requires 4*2=8 bytes.
Therefore, the longest VARCHAR that fits into the default @@max_sort_length
is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)
would fit.
Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,
for the same purpose.
TODO: we could add a new LDML syntax to choose strxfrm_multiply value.
*/
to->strxfrm_multiply= loaded->levels_for_order > 1 ?
4 : from->strxfrm_multiply;
to->min_sort_char= from->min_sort_char;
to->max_sort_char= from->max_sort_char;
to->mbminlen= from->mbminlen;
to->mbmaxlen= from->mbmaxlen;
to->caseup_multiply= from->caseup_multiply;
to->casedn_multiply= from->casedn_multiply;
to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |
MY_CS_STRNXFRM | MY_CS_UNICODE;
} | O0 | c | copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x18(%rbp), %rax
movzbl 0xb2(%rax), %eax
cmpl $0x1, %eax
jle 0x7e1d6
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7e1e3
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
movq -0x10(%rbp), %rax
movb 0x94(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x94(%rax)
movq -0x10(%rbp), %rax
movb 0x95(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x95(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x2c8, %ecx # imm = 0x2C8
movl %ecx, 0xc(%rax)
popq %rbp
retq
nop
| copy_uca_collation:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov rcx, [rax+0B8h]
mov rax, [rbp+var_8]
mov [rax+0B8h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0C0h]
mov rax, [rbp+var_8]
mov [rax+0C0h], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+0B2h]
cmp eax, 1
jle short loc_7E1D6
mov eax, 4
mov [rbp+var_1C], eax
jmp short loc_7E1E3
loc_7E1D6:
mov rax, [rbp+var_10]
mov eax, [rax+90h]
mov [rbp+var_1C], eax
loc_7E1E3:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_8]
mov [rax+90h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+0A0h]
mov rax, [rbp+var_8]
mov [rax+0A0h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0A8h]
mov rax, [rbp+var_8]
mov [rax+0A8h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+98h]
mov rax, [rbp+var_8]
mov [rax+98h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+9Ch]
mov rax, [rbp+var_8]
mov [rax+9Ch], ecx
mov rax, [rbp+var_10]
mov cl, [rax+94h]
mov rax, [rbp+var_8]
mov [rax+94h], cl
mov rax, [rbp+var_10]
mov cl, [rax+95h]
mov rax, [rbp+var_8]
mov [rax+95h], cl
mov rax, [rbp+var_8]
mov ecx, [rax+0Ch]
or ecx, 2C8h
mov [rax+0Ch], ecx
pop rbp
retn
| long long copy_uca_collation(long long a1, long long a2, long long a3)
{
long long result; // rax
int v4; // [rsp+0h] [rbp-1Ch]
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
if ( *(unsigned __int8 *)(a3 + 178) <= 1u )
v4 = *(_DWORD *)(a2 + 144);
else
v4 = 4;
*(_DWORD *)(a1 + 144) = v4;
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a2 + 160);
*(_QWORD *)(a1 + 168) = *(_QWORD *)(a2 + 168);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 152);
*(_DWORD *)(a1 + 156) = *(_DWORD *)(a2 + 156);
*(_BYTE *)(a1 + 148) = *(_BYTE *)(a2 + 148);
*(_BYTE *)(a1 + 149) = *(_BYTE *)(a2 + 149);
result = a1;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
| copy_uca_collation:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xb8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xc0],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0xb2]
CMP EAX,0x1
JLE 0x0017e1d6
MOV EAX,0x4
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0017e1e3
LAB_0017e1d6:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x1c],EAX
LAB_0017e1e3:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x90],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xa8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x98],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x9c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x9c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x94]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x94],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x95]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x95],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,0x2c8
MOV dword ptr [RAX + 0xc],ECX
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 local_24;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
if (*(byte *)(param_3 + 0xb2) < 2) {
local_24 = *(int4 *)(param_2 + 0x90);
}
else {
local_24 = 4;
}
*(int4 *)(param_1 + 0x90) = local_24;
*(int8 *)(param_1 + 0xa0) = *(int8 *)(param_2 + 0xa0);
*(int8 *)(param_1 + 0xa8) = *(int8 *)(param_2 + 0xa8);
*(int4 *)(param_1 + 0x98) = *(int4 *)(param_2 + 0x98);
*(int4 *)(param_1 + 0x9c) = *(int4 *)(param_2 + 0x9c);
*(int1 *)(param_1 + 0x94) = *(int1 *)(param_2 + 0x94);
*(int1 *)(param_1 + 0x95) = *(int1 *)(param_2 + 0x95);
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | 0x2c8;
return;
}
|
|
2,616 | copy_uca_collation | eloqsql/mysys/charset.c | static void
copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
CHARSET_INFO *loaded)
{
to->cset= from->cset;
to->coll= from->coll;
/*
Single-level UCA collation have strnxfrm_multiple=8.
In case of a multi-level UCA collation we use strnxfrm_multiply=4.
That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller
to allocate a buffer smaller size for each level, for performance purpose,
and to fit longer VARCHARs to @@max_sort_length.
This makes filesort produce non-precise order for some rare Unicode
characters that produce more than 4 weights (long expansions).
UCA requires 2 bytes per weight multiplied by the number of levels.
In case of a 2-level collation, each character requires 4*2=8 bytes.
Therefore, the longest VARCHAR that fits into the default @@max_sort_length
is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)
would fit.
Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,
for the same purpose.
TODO: we could add a new LDML syntax to choose strxfrm_multiply value.
*/
to->strxfrm_multiply= loaded->levels_for_order > 1 ?
4 : from->strxfrm_multiply;
to->min_sort_char= from->min_sort_char;
to->max_sort_char= from->max_sort_char;
to->mbminlen= from->mbminlen;
to->mbmaxlen= from->mbmaxlen;
to->caseup_multiply= from->caseup_multiply;
to->casedn_multiply= from->casedn_multiply;
to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |
MY_CS_STRNXFRM | MY_CS_UNICODE;
} | O3 | c | copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq 0xb8(%rsi), %rax
movq %rax, 0xb8(%rdi)
movq 0xc0(%rsi), %rax
movq %rax, 0xc0(%rdi)
movl $0x4, %eax
cmpb $0x1, 0xb2(%rdx)
ja 0x64267
movl 0x90(%rsi), %eax
movl %eax, 0x90(%rdi)
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movq 0xa8(%rsi), %rax
movq %rax, 0xa8(%rdi)
movl 0x98(%rsi), %eax
movl %eax, 0x98(%rdi)
movl 0x9c(%rsi), %eax
movl %eax, 0x9c(%rdi)
movb 0x94(%rsi), %al
movb %al, 0x94(%rdi)
movb 0x95(%rsi), %al
movb %al, 0x95(%rdi)
orl $0x2c8, 0xc(%rdi) # imm = 0x2C8
popq %rbp
retq
| copy_uca_collation:
push rbp
mov rbp, rsp
mov rax, [rsi+0B8h]
mov [rdi+0B8h], rax
mov rax, [rsi+0C0h]
mov [rdi+0C0h], rax
mov eax, 4
cmp byte ptr [rdx+0B2h], 1
ja short loc_64267
mov eax, [rsi+90h]
loc_64267:
mov [rdi+90h], eax
mov rax, [rsi+0A0h]
mov [rdi+0A0h], rax
mov rax, [rsi+0A8h]
mov [rdi+0A8h], rax
mov eax, [rsi+98h]
mov [rdi+98h], eax
mov eax, [rsi+9Ch]
mov [rdi+9Ch], eax
mov al, [rsi+94h]
mov [rdi+94h], al
mov al, [rsi+95h]
mov [rdi+95h], al
or dword ptr [rdi+0Ch], 2C8h
pop rbp
retn
| char copy_uca_collation(long long a1, long long a2, long long a3)
{
int v3; // eax
char result; // al
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
v3 = 4;
if ( *(_BYTE *)(a3 + 178) <= 1u )
v3 = *(_DWORD *)(a2 + 144);
*(_DWORD *)(a1 + 144) = v3;
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a2 + 160);
*(_QWORD *)(a1 + 168) = *(_QWORD *)(a2 + 168);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 152);
*(_DWORD *)(a1 + 156) = *(_DWORD *)(a2 + 156);
*(_BYTE *)(a1 + 148) = *(_BYTE *)(a2 + 148);
result = *(_BYTE *)(a2 + 149);
*(_BYTE *)(a1 + 149) = result;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
| copy_uca_collation:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI + 0xb8]
MOV qword ptr [RDI + 0xb8],RAX
MOV RAX,qword ptr [RSI + 0xc0]
MOV qword ptr [RDI + 0xc0],RAX
MOV EAX,0x4
CMP byte ptr [RDX + 0xb2],0x1
JA 0x00164267
MOV EAX,dword ptr [RSI + 0x90]
LAB_00164267:
MOV dword ptr [RDI + 0x90],EAX
MOV RAX,qword ptr [RSI + 0xa0]
MOV qword ptr [RDI + 0xa0],RAX
MOV RAX,qword ptr [RSI + 0xa8]
MOV qword ptr [RDI + 0xa8],RAX
MOV EAX,dword ptr [RSI + 0x98]
MOV dword ptr [RDI + 0x98],EAX
MOV EAX,dword ptr [RSI + 0x9c]
MOV dword ptr [RDI + 0x9c],EAX
MOV AL,byte ptr [RSI + 0x94]
MOV byte ptr [RDI + 0x94],AL
MOV AL,byte ptr [RSI + 0x95]
MOV byte ptr [RDI + 0x95],AL
OR dword ptr [RDI + 0xc],0x2c8
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 uVar1;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
uVar1 = 4;
if (*(byte *)(param_3 + 0xb2) < 2) {
uVar1 = *(int4 *)(param_2 + 0x90);
}
*(int4 *)(param_1 + 0x90) = uVar1;
*(int8 *)(param_1 + 0xa0) = *(int8 *)(param_2 + 0xa0);
*(int8 *)(param_1 + 0xa8) = *(int8 *)(param_2 + 0xa8);
*(int4 *)(param_1 + 0x98) = *(int4 *)(param_2 + 0x98);
*(int4 *)(param_1 + 0x9c) = *(int4 *)(param_2 + 0x9c);
*(int1 *)(param_1 + 0x94) = *(int1 *)(param_2 + 0x94);
*(int1 *)(param_1 + 0x95) = *(int1 *)(param_2 + 0x95);
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | 0x2c8;
return;
}
|
|
2,617 | minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!left) throw std::runtime_error("BinaryOpExpr.left is null");
if (!right) throw std::runtime_error("BinaryOpExpr.right is null");
auto l = left->evaluate(context);
auto do_eval = [&](const Value & l) -> Value {
if (op == Op::Is || op == Op::IsNot) {
auto t = dynamic_cast<VariableExpr*>(right.get());
if (!t) throw std::runtime_error("Right side of 'is' operator must be a variable");
auto eval = [&]() {
const auto & name = t->get_name();
if (name == "none") return l.is_null();
if (name == "boolean") return l.is_boolean();
if (name == "integer") return l.is_number_integer();
if (name == "float") return l.is_number_float();
if (name == "number") return l.is_number();
if (name == "string") return l.is_string();
if (name == "mapping") return l.is_object();
if (name == "iterable") return l.is_iterable();
if (name == "sequence") return l.is_array();
if (name == "defined") return !l.is_null();
throw std::runtime_error("Unknown type for 'is' operator: " + name);
};
auto value = eval();
return Value(op == Op::Is ? value : !value);
}
if (op == Op::And) {
if (!l.to_bool()) return Value(false);
return right->evaluate(context).to_bool();
} else if (op == Op::Or) {
if (l.to_bool()) return l;
return right->evaluate(context);
}
auto r = right->evaluate(context);
switch (op) {
case Op::StrConcat: return l.to_str() + r.to_str();
case Op::Add: return l + r;
case Op::Sub: return l - r;
case Op::Mul: return l * r;
case Op::Div: return l / r;
case Op::MulMul: return std::pow(l.get<double>(), r.get<double>());
case Op::DivDiv: return l.get<int64_t>() / r.get<int64_t>();
case Op::Mod: return l.get<int64_t>() % r.get<int64_t>();
case Op::Eq: return l == r;
case Op::Ne: return l != r;
case Op::Lt: return l < r;
case Op::Gt: return l > r;
case Op::Le: return l <= r;
case Op::Ge: return l >= r;
case Op::In: return (r.is_array() || r.is_object()) && r.contains(l);
case Op::NotIn: return !(r.is_array() && r.contains(l));
default: break;
}
throw std::runtime_error("Unknown binary operator");
};
if (l.is_callable()) {
return Value::callable([l, do_eval](const std::shared_ptr<Context> & context, ArgumentsValue & args) {
auto ll = l.call(context, args);
return do_eval(ll); //args[0].second);
});
} else {
return do_eval(l);
}
} | O3 | cpp | minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x5a34f
cmpq $0x0, 0x30(%r15)
je 0x5a36d
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x40874
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x30(%r12)
je 0x5a29b
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x51fc2
movups 0x8(%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movups %xmm0, 0x50(%rsi)
leaq 0x18(%rsp), %rdi
callq 0x5a512
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5a4a6
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x5a22b
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x40bf2
movq %r14, %rdi
callq 0x4d7e0
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5a253
callq 0x32e06
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x5a265
callq 0x32e06
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x5a277
callq 0x32e06
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x5a2c4
movq 0x86d0d(%rip), %rax # 0xe0f98
cmpb $0x0, (%rax)
je 0x5a2af
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5a2b9
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x5a5fc
jmp 0x5a2c4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x5a2c4
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x40bf2
movq %r14, %rdi
callq 0x4d7e0
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x5a2e9
callq 0x32e06
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x5a2f8
callq 0x32e06
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x5a307
callq 0x32e06
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x5a33d
movq 0x86c80(%rip), %rax # 0xe0f98
cmpb $0x0, (%rax)
je 0x5a328
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x5a332
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x5a33d
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x18380
movq %rax, %r14
leaq 0x54fcd(%rip), %rsi # 0xaf330
movq %rax, %rdi
callq 0x18280
jmp 0x5a389
movl $0x10, %edi
callq 0x18380
movq %rax, %r14
leaq 0x54fc9(%rip), %rsi # 0xaf34a
movq %rax, %rdi
callq 0x18280
movq 0x86c60(%rip), %rsi # 0xe0ff0
movq 0x86bd9(%rip), %rdx # 0xe0f70
movq %r14, %rdi
callq 0x18bb0
jmp 0x5a3ea
jmp 0x5a3d0
jmp 0x5a3a5
movq %rax, %rbx
movq %r14, %rdi
callq 0x18520
jmp 0x5a3f7
movq %rax, %rbx
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x5a3db
leaq 0x18(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x5a3db
movq %rax, %rdi
callq 0x1f25d
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x5a570
jmp 0x5a3ed
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x40b66
movq %rbx, %rdi
callq 0x18c10
nop
| _ZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 0E8h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_5A34F
cmp qword ptr [r15+30h], 0
jz loc_5A36D
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+108h+var_D0]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov qword ptr [rsp+108h+var_100], r15
mov qword ptr [rsp+108h+var_100+8], r14
cmp qword ptr [r12+30h], 0
jz loc_5A29B
lea rdi, [rsp+108h+var_80]; this
lea rsi, [rsp+108h+var_D0]; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
movups xmm0, [rsp+108h+var_100]
lea rsi, [rsp+108h+var_80]
movups xmmword ptr [rsi+50h], xmm0
lea rdi, [rsp+108h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEC2IZNKS0_12BinaryOpExpr11do_evaluateES6_EUlS6_S8_E_vEEOT_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1} &&)
lea rsi, [rsp+108h+var_F0]
mov rdi, rbx
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
mov rax, [rsp+108h+var_E0]
test rax, rax
jz short loc_5A22B
lea rdi, [rsp+108h+var_F0]
mov rsi, rdi
mov edx, 3
call rax
loc_5A22B:
lea r14, [rsp+108h+var_40]
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 rdi, [r14-8]
test rdi, rdi
jz short loc_5A253
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A253:
mov rdi, [rsp+108h+var_58]
test rdi, rdi
jz short loc_5A265
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A265:
mov rdi, [rsp+108h+var_68]
test rdi, rdi
jz short loc_5A277
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A277:
mov rdi, [rsp+108h+var_78]
test rdi, rdi
jz short loc_5A2C4
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_5A2AF
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5A2B9
loc_5A29B:
lea rsi, [rsp+108h+var_100]
lea rdx, [rsp+108h+var_D0]
mov rdi, rbx; this
call _ZZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEEENKUlRKNS_5ValueEE_clES8_; minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}::operator()(minja::Value const&)
jmp short loc_5A2C4
loc_5A2AF:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5A2B9:
cmp eax, 1
jnz short loc_5A2C4
mov rax, [rdi]
call qword ptr [rax+18h]
loc_5A2C4:
lea r14, [rsp+108h+var_90]
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 rdi, [r14-8]
test rdi, rdi
jz short loc_5A2E9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A2E9:
mov rdi, [rsp+108h+var_A8]
test rdi, rdi
jz short loc_5A2F8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A2F8:
mov rdi, [rsp+108h+var_B8]
test rdi, rdi
jz short loc_5A307
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A307:
mov rdi, [rsp+108h+var_C8]
test rdi, rdi
jz short loc_5A33D
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_5A328
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_5A332
loc_5A328:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_5A332:
cmp eax, 1
jnz short loc_5A33D
mov rax, [rdi]
call qword ptr [rax+18h]
loc_5A33D:
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r14
pop r15
retn
loc_5A34F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprLe; "BinaryOpExpr.left is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_5A389
loc_5A36D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprRi; "BinaryOpExpr.right is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_5A389:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_5A3EA
jmp short loc_5A3D0
jmp short $+2
loc_5A3A5:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_5A3F7
mov rbx, rax
mov rax, [rsp+108h+var_E0]
test rax, rax
jz short loc_5A3DB
lea rdi, [rsp+108h+var_F0]
mov rsi, rdi
mov edx, 3
call rax
jmp short loc_5A3DB
loc_5A3D0:
mov rdi, rax
call __clang_call_terminate
mov rbx, rax
loc_5A3DB:
lea rdi, [rsp+108h+var_80]
call _ZZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEEENUlS5_RNS_14ArgumentsValueEE_D2Ev; minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1}::~ArgumentsValue()
jmp short loc_5A3ED
loc_5A3EA:
mov rbx, rax
loc_5A3ED:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_5A3F7:
mov rdi, rbx
call __Unwind_Resume
| minja::Value * minja::BinaryOpExpr::do_evaluate(minja::Value *this, long long a2, long long a3)
{
void (***v4)(void); // rsi
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // rdi
signed __int32 v12; // eax
long long v13; // rdi
signed __int32 v14; // eax
std::runtime_error *exception; // r14
__int128 v17; // [rsp+8h] [rbp-100h]
_BYTE v18[16]; // [rsp+18h] [rbp-F0h] BYREF
void ( *v19)(_BYTE *, _BYTE *, long long); // [rsp+28h] [rbp-E0h]
_BYTE v20[8]; // [rsp+38h] [rbp-D0h] BYREF
long long v21; // [rsp+40h] [rbp-C8h]
volatile signed __int32 *v22; // [rsp+50h] [rbp-B8h]
volatile signed __int32 *v23; // [rsp+60h] [rbp-A8h]
long long v24; // [rsp+68h] [rbp-A0h]
volatile signed __int32 *v25; // [rsp+70h] [rbp-98h]
void **v26[2]; // [rsp+78h] [rbp-90h] BYREF
_BYTE v27[8]; // [rsp+88h] [rbp-80h] BYREF
long long v28; // [rsp+90h] [rbp-78h]
volatile signed __int32 *v29; // [rsp+A0h] [rbp-68h]
volatile signed __int32 *v30; // [rsp+B0h] [rbp-58h]
volatile signed __int32 *v31; // [rsp+C0h] [rbp-48h]
void **v32[2]; // [rsp+C8h] [rbp-40h] BYREF
__int128 v33; // [rsp+D8h] [rbp-30h]
v4 = *(void (****)(void))(a2 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.left is null");
goto LABEL_34;
}
if ( !*(_QWORD *)(a2 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.right is null");
LABEL_34:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v20, v4);
*(_QWORD *)&v17 = a2;
*((_QWORD *)&v17 + 1) = a3;
if ( v24 )
{
minja::Value::Value((minja::Value *)v27, (const minja::Value *)v20);
v33 = v17;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(v18);
minja::Value::callable((_DWORD)this, (unsigned int)v18, v7, v8, v9, v10);
if ( v19 )
v19(v18, v18, 3LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v32);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(v32);
if ( v31 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v31);
if ( v30 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
if ( v29 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v29);
v11 = v28;
if ( v28 )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v28 + 12);
*(_DWORD *)(v28 + 12) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(v28 + 12), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
}
else
{
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)const::{lambda(minja::Value const&)#1}::operator()(this);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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 *)v26);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v26);
if ( v25 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v25);
if ( v23 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v23);
if ( v22 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v22);
v13 = v21;
if ( v21 )
{
if ( _libc_single_threaded )
{
v14 = *(_DWORD *)(v21 + 12);
*(_DWORD *)(v21 + 12) = v14 - 1;
}
else
{
v14 = _InterlockedExchangeAdd((volatile signed __int32 *)(v21 + 12), 0xFFFFFFFF);
}
if ( v14 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v13 + 24LL))(v13, 0LL);
}
return this;
}
| do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x0015a34f
CMP qword ptr [R15 + 0x30],0x0
JZ 0x0015a36d
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x00140874
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],R14
CMP qword ptr [R12 + 0x30],0x0
JZ 0x0015a29b
LAB_0015a1d8:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x38]
CALL 0x00151fc2
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x88]
MOVUPS xmmword ptr [RSI + 0x50],XMM0
LAB_0015a1fb:
LEA RDI,[RSP + 0x18]
CALL 0x0015a512
LAB_0015a205:
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x0015a4a6
MOV RAX,qword ptr [RSP + 0x28]
TEST RAX,RAX
JZ 0x0015a22b
LAB_0015a21c:
LEA RDI,[RSP + 0x18]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0015a22b:
LEA R14,[RSP + 0xc8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00140bf2
MOV RDI,R14
CALL 0x0014d7e0
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0015a253
CALL 0x00132e06
LAB_0015a253:
MOV RDI,qword ptr [RSP + 0xb0]
TEST RDI,RDI
JZ 0x0015a265
CALL 0x00132e06
LAB_0015a265:
MOV RDI,qword ptr [RSP + 0xa0]
TEST RDI,RDI
JZ 0x0015a277
CALL 0x00132e06
LAB_0015a277:
MOV RDI,qword ptr [RSP + 0x90]
TEST RDI,RDI
JZ 0x0015a2c4
MOV RAX,qword ptr [0x001e0f98]
CMP byte ptr [RAX],0x0
JZ 0x0015a2af
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015a2b9
LAB_0015a29b:
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x38]
MOV RDI,RBX
CALL 0x0015a5fc
LAB_0015a2ad:
JMP 0x0015a2c4
LAB_0015a2af:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015a2b9:
CMP EAX,0x1
JNZ 0x0015a2c4
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0015a2c4:
LEA R14,[RSP + 0x78]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00140bf2
MOV RDI,R14
CALL 0x0014d7e0
MOV RDI,qword ptr [R14 + -0x8]
TEST RDI,RDI
JZ 0x0015a2e9
CALL 0x00132e06
LAB_0015a2e9:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x0015a2f8
CALL 0x00132e06
LAB_0015a2f8:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x0015a307
CALL 0x00132e06
LAB_0015a307:
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0015a33d
MOV RAX,qword ptr [0x001e0f98]
CMP byte ptr [RAX],0x0
JZ 0x0015a328
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0015a332
LAB_0015a328:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0015a332:
CMP EAX,0x1
JNZ 0x0015a33d
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0015a33d:
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0015a34f:
MOV EDI,0x10
CALL 0x00118380
MOV R14,RAX
LAB_0015a35c:
LEA RSI,[0x1af330]
MOV RDI,RAX
CALL 0x00118280
LAB_0015a36b:
JMP 0x0015a389
LAB_0015a36d:
MOV EDI,0x10
CALL 0x00118380
MOV R14,RAX
LAB_0015a37a:
LEA RSI,[0x1af34a]
MOV RDI,RAX
CALL 0x00118280
LAB_0015a389:
MOV RSI,qword ptr [0x001e0ff0]
MOV RDX,qword ptr [0x001e0f70]
MOV RDI,R14
CALL 0x00118bb0
|
/* minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::BinaryOpExpr::do_evaluate(shared_ptr *param_1)
{
int *piVar1;
int iVar2;
runtime_error *this;
int8 in_RDX;
long in_RSI;
long local_100;
int8 uStack_f8;
_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ local_f0 [16];
code *local_e0;
Expression local_d0 [8];
long *local_c8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_a8;
long local_a0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
data local_90 [16];
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
long local_30;
int8 uStack_28;
if (*(shared_ptr **)(in_RSI + 0x20) == (shared_ptr *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015a35c to 0015a36a has its CatchHandler @ 0015a3a5 */
std::runtime_error::runtime_error(this,"BinaryOpExpr.left is null");
}
else {
if (*(long *)(in_RSI + 0x30) != 0) {
Expression::evaluate(local_d0,*(shared_ptr **)(in_RSI + 0x20));
if (local_a0 == 0) {
/* try { // try from 0015a29b to 0015a2ac has its CatchHandler @ 0015a39f */
const::{lambda(minja::Value_const&)#1}::operator()
((_lambda_minja__Value_const___1_ *)param_1,(Value *)&local_100);
}
else {
/* try { // try from 0015a1d8 to 0015a1e9 has its CatchHandler @ 0015a3ea */
local_100 = in_RSI;
uStack_f8 = in_RDX;
Value::Value(local_80,(Value *)local_d0);
local_30 = local_100;
uStack_28 = uStack_f8;
/* try { // try from 0015a1fb to 0015a204 has its CatchHandler @ 0015a3d8 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context>const&)const::_lambda(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)_1_,void>
(local_f0);
/* try { // try from 0015a205 to 0015a211 has its CatchHandler @ 0015a3b2 */
Value::callable((Value *)param_1,local_f0);
if (local_e0 != (code *)0x0) {
/* try { // try from 0015a21c to 0015a22a has its CatchHandler @ 0015a3a1 */
(*local_e0)(local_f0,local_f0,3);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001e0f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*PTR___libc_single_threaded_001e0f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0015a37a to 0015a388 has its CatchHandler @ 0015a3a3 */
std::runtime_error::runtime_error(this,"BinaryOpExpr.right is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001e0ff0,PTR__runtime_error_001e0f70);
}
|
|
2,618 | ssz_dump_to_str | corpus-core[P]colibri-stateless/src/util/ssz.c | char* ssz_dump_to_str(ssz_ob_t ob, bool include_name, bool write_unit_as_hex) {
ssz_dump_t ctx = {
.buf = {0},
.write_unit_as_hex = write_unit_as_hex,
};
dump(&ctx, ob, include_name ? ob.def->name : NULL, 0);
return (char*) ctx.buf.data.data;
} | O0 | c | ssz_dump_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movb %dil, %cl
leaq 0x10(%rbp), %rdx
movq %rdx, -0x30(%rbp)
andb $0x1, %cl
movb %cl, -0x1(%rbp)
andb $0x1, %al
movb %al, -0x2(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
movb -0x2(%rbp), %al
andb $0x1, %al
movb %al, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
je 0x1b810
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1b818
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x1b818
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1b850
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
| ssz_dump_to_str:
push rbp
mov rbp, rsp
sub rsp, 50h
mov al, sil
mov cl, dil
lea rdx, [rbp+arg_0]
mov [rbp+var_30], rdx
and cl, 1
mov [rbp+var_1], cl
and al, 1
mov [rbp+var_2], al
lea rdi, [rbp+var_28]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov al, [rbp+var_2]
and al, 1
mov [rbp+var_10], al
test [rbp+var_1], 1
jz short loc_1B810
mov rax, [rbp+var_30]
mov rax, [rax+10h]
mov rax, [rax]
mov [rbp+var_38], rax
jmp short loc_1B818
loc_1B810:
xor eax, eax
mov [rbp+var_38], rax
jmp short $+2
loc_1B818:
mov rax, [rbp+var_30]
mov rsi, [rbp+var_38]
lea rdi, [rbp+var_28]
xor edx, edx
mov rcx, [rax]
mov [rsp+50h+var_50], rcx
mov rcx, [rax+8]
mov [rsp+50h+var_48], rcx
mov rax, [rax+10h]
mov [rsp+50h+var_40], rax
call dump
mov rax, [rbp+var_20]
add rsp, 50h
pop rbp
retn
| long long ssz_dump_to_str(
char a1,
char a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
long long a8,
_QWORD *a9)
{
int v9; // r8d
int v10; // r9d
_BYTE v12[8]; // [rsp+28h] [rbp-28h] BYREF
long long v13; // [rsp+30h] [rbp-20h]
char v14; // [rsp+40h] [rbp-10h]
char v15; // [rsp+4Eh] [rbp-2h]
char v16; // [rsp+4Fh] [rbp-1h]
v16 = a1 & 1;
v15 = a2 & 1;
memset(v12, 0LL, 32LL);
v14 = v15 & 1;
if ( (v16 & 1) != 0 )
dump((unsigned int)v12, *a9, 0, a8, v9, v10, a7, a8, a9);
else
dump((unsigned int)v12, 0, 0, a8, v9, v10, a7, a8, a9);
return v13;
}
| ssz_dump_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV AL,SIL
MOV CL,DIL
LEA RDX,[RBP + 0x10]
MOV qword ptr [RBP + -0x30],RDX
AND CL,0x1
MOV byte ptr [RBP + -0x1],CL
AND AL,0x1
MOV byte ptr [RBP + -0x2],AL
LEA RDI,[RBP + -0x28]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
MOV AL,byte ptr [RBP + -0x2]
AND AL,0x1
MOV byte ptr [RBP + -0x10],AL
TEST byte ptr [RBP + -0x1],0x1
JZ 0x0011b810
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0011b818
LAB_0011b810:
XOR EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0011b818
LAB_0011b818:
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
LEA RDI,[RBP + -0x28]
XOR EDX,EDX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x0011b850
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x50
POP RBP
RET
|
int8 ssz_dump_to_str(byte param_1,byte param_2)
{
int8 *in_stack_00000018;
int8 local_40;
int1 local_30 [8];
int8 local_28;
byte local_18;
byte local_a;
byte local_9;
local_9 = param_1 & 1;
local_a = param_2 & 1;
memset(local_30,0,0x20);
local_18 = local_a & 1;
if ((local_9 & 1) == 0) {
local_40 = 0;
}
else {
local_40 = *in_stack_00000018;
}
dump(local_30,local_40,0);
return local_28;
}
|
|
2,619 | inheritance_source_by_id | eloqsql/mysys/charset.c | static CHARSET_INFO *inheritance_source_by_id(CHARSET_INFO *cs, uint refid)
{
CHARSET_INFO *refcs;
return refid && refid != cs->number &&
(refcs= all_charsets[refid]) &&
(refcs->state & MY_CS_AVAILABLE) ? refcs : NULL;
} | O0 | c | inheritance_source_by_id:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xe0d31
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0xe0d31
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xba4a98(%rip), %rax # 0xc857a0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xe0d31
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0xe0d31
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xe0d39
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0xe0d39
movq -0x20(%rbp), %rax
popq %rbp
retq
nop
| inheritance_source_by_id:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 0
jz short loc_E0D31
mov eax, [rbp+var_C]
mov rcx, [rbp+var_8]
cmp eax, [rcx]
jz short loc_E0D31
mov eax, [rbp+var_C]
mov ecx, eax
lea rax, all_charsets
mov rax, [rax+rcx*8]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_E0D31
mov rax, [rbp+var_18]
mov eax, [rax+0Ch]
and eax, 200h
cmp eax, 0
jz short loc_E0D31
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
jmp short loc_E0D39
loc_E0D31:
xor eax, eax
mov [rbp+var_20], rax
jmp short $+2
loc_E0D39:
mov rax, [rbp+var_20]
pop rbp
retn
| long long inheritance_source_by_id(_DWORD *a1, int a2)
{
long long v4; // [rsp+8h] [rbp-18h]
if ( a2 && a2 != *a1 && (v4 = all_charsets[a2]) != 0 && (*(_DWORD *)(v4 + 12) & 0x200) != 0 )
return all_charsets[a2];
else
return 0LL;
}
| inheritance_source_by_id:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001e0d31
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX]
JZ 0x001e0d31
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
LEA RAX,[0xd857a0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x001e0d31
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x200
CMP EAX,0x0
JZ 0x001e0d31
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e0d39
LAB_001e0d31:
XOR EAX,EAX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e0d39
LAB_001e0d39:
MOV RAX,qword ptr [RBP + -0x20]
POP RBP
RET
|
long inheritance_source_by_id(uint *param_1,uint param_2)
{
long local_28;
if ((((param_2 == 0) || (param_2 == *param_1)) ||
(local_28 = (&all_charsets)[param_2], local_28 == 0)) ||
((*(uint *)(local_28 + 0xc) & 0x200) == 0)) {
local_28 = 0;
}
return local_28;
}
|
|
2,620 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> insert( const value_type& value )
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, value.first))
{
return {it, false};
}
}
Container::push_back(value);
return {--this->end(), true};
} | O2 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::insert(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x88ef9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a920
testb %al, %al
jne 0x88f10
addq $0x30, %rbx
jmp 0x88ede
movq %r14, %rdi
movq %r15, %rsi
callq 0x88f1c
movq 0x8(%r14), %rbx
addq $-0x30, %rbx
movb $0x1, %dl
jmp 0x88f12
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE6insertERKSI_:
push r15
push r14
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_88EDE:
cmp rbx, [r14+8]
jz short loc_88EF9
mov rdi, rbx
mov rsi, r15
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, al
jnz short loc_88F10
add rbx, 30h ; '0'
jmp short loc_88EDE
loc_88EF9:
mov rdi, r14
mov rsi, r15
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE9push_backERKSG_; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::push_back(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFD0h
mov dl, 1
jmp short loc_88F12
loc_88F10:
xor edx, edx
loc_88F12:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
| long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::insert(
_QWORD **a1,
_QWORD *a2)
{
_QWORD *i; // rbx
for ( i = *a1; i != a1[1]; i += 6 )
{
if ( std::operator==<char>(i, a2) )
return (long long)i;
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::push_back(
a1,
a2);
return (long long)(a1[1] - 6);
}
| insert:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_00188ede:
CMP RBX,qword ptr [R14 + 0x8]
JZ 0x00188ef9
MOV RDI,RBX
MOV RSI,R15
CALL 0x0013a920
TEST AL,AL
JNZ 0x00188f10
ADD RBX,0x30
JMP 0x00188ede
LAB_00188ef9:
MOV RDI,R14
MOV RSI,R15
CALL 0x00188f1c
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x30
MOV DL,0x1
JMP 0x00188f12
LAB_00188f10:
XOR EDX,EDX
LAB_00188f12:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::insert(std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > const&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::insert(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,pair *param_1)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
string *psVar3;
int1 auVar4 [16];
psVar3 = *(string **)this;
do {
if (psVar3 == *(string **)(this + 8)) {
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::push_back((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,param_1);
psVar3 = (string *)(*(long *)(this + 8) + -0x30);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_00188f12:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = psVar3;
return auVar4;
}
cVar1 = std::operator==(psVar3,(string *)param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_00188f12;
}
psVar3 = psVar3 + 0x30;
} while( true );
}
|
|
2,621 | type_inference_get_explicit_type | eshkol/src/frontend/type_inference/context.c | Type* type_inference_get_explicit_type(TypeInferenceContext* context, const AstNode* node) {
assert(context != NULL);
// Check if node is NULL
if (node == NULL) {
return NULL;
}
// Check if the node is in the explicit context
for (size_t i = 0; i < context->explicit_count; i++) {
if (context->explicit_nodes[i] == node) {
return context->explicit_types[i];
}
}
// Check if the node has an explicit type stored directly
if (node->type_info) {
return node->type_info;
}
return NULL;
} | O3 | c | type_inference_get_explicit_type:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x38a0
testq %rsi, %rsi
je 0x3890
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x388a
movq 0x30(%rdi), %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
cmpq %rsi, (%rdx,%r8,8)
je 0x3894
incq %r8
addq $-0x8, %rcx
cmpq %r8, %rax
jne 0x3878
addq $0x18, %rsi
jmp 0x389b
xorl %eax, %eax
jmp 0x389e
movq 0x38(%rdi), %rsi
subq %rcx, %rsi
movq (%rsi), %rax
popq %rbp
retq
leaq 0xa7f2(%rip), %rdi # 0xe099
leaq 0xb475(%rip), %rsi # 0xed23
leaq 0xb667(%rip), %rcx # 0xef1c
movl $0xff, %edx
callq 0x1130
| type_inference_get_explicit_type:
push rbp
mov rbp, rsp
test rdi, rdi
jz short loc_38A0
test rsi, rsi
jz short loc_3890
mov rax, [rdi+48h]
test rax, rax
jz short loc_388A
mov rdx, [rdi+30h]
xor ecx, ecx
xor r8d, r8d
loc_3878:
cmp [rdx+r8*8], rsi
jz short loc_3894
inc r8
add rcx, 0FFFFFFFFFFFFFFF8h
cmp rax, r8
jnz short loc_3878
loc_388A:
add rsi, 18h
jmp short loc_389B
loc_3890:
xor eax, eax
jmp short loc_389E
loc_3894:
mov rsi, [rdi+38h]
sub rsi, rcx
loc_389B:
mov rax, [rsi]
loc_389E:
pop rbp
retn
loc_38A0:
lea rdi, aTypeContextNul+5; "context != NULL"
lea rsi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/eshkol"...
lea rcx, aTypeTypeInfere_0; "Type *type_inference_get_explicit_type("...
mov edx, 0FFh
call ___assert_fail
| long long type_inference_get_explicit_type(_QWORD *a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
long long v4; // r8
long long v5; // rsi
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/frontend/type_inference/context.c",
255LL,
"Type *type_inference_get_explicit_type(TypeInferenceContext *, const AstNode *)");
if ( !a2 )
return 0LL;
v2 = a1[9];
if ( v2 )
{
v3 = 0LL;
v4 = 0LL;
while ( *(_QWORD *)(a1[6] + 8 * v4) != a2 )
{
++v4;
v3 -= 8LL;
if ( v2 == v4 )
goto LABEL_7;
}
v5 = a1[7] - v3;
}
else
{
LABEL_7:
v5 = a2 + 24;
}
return *(_QWORD *)v5;
}
| type_inference_get_explicit_type:
PUSH RBP
MOV RBP,RSP
TEST RDI,RDI
JZ 0x001038a0
TEST RSI,RSI
JZ 0x00103890
MOV RAX,qword ptr [RDI + 0x48]
TEST RAX,RAX
JZ 0x0010388a
MOV RDX,qword ptr [RDI + 0x30]
XOR ECX,ECX
XOR R8D,R8D
LAB_00103878:
CMP qword ptr [RDX + R8*0x8],RSI
JZ 0x00103894
INC R8
ADD RCX,-0x8
CMP RAX,R8
JNZ 0x00103878
LAB_0010388a:
ADD RSI,0x18
JMP 0x0010389b
LAB_00103890:
XOR EAX,EAX
JMP 0x0010389e
LAB_00103894:
MOV RSI,qword ptr [RDI + 0x38]
SUB RSI,RCX
LAB_0010389b:
MOV RAX,qword ptr [RSI]
LAB_0010389e:
POP RBP
RET
LAB_001038a0:
LEA RDI,[0x10e099]
LEA RSI,[0x10ed23]
LEA RCX,[0x10ef1c]
MOV EDX,0xff
CALL 0x00101130
|
int8 type_inference_get_explicit_type(long param_1,long param_2)
{
int8 uVar1;
long lVar2;
int8 *puVar3;
long lVar4;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github2025/eshkol/src/frontend/type_inference/context.c",
0xff,
"Type *type_inference_get_explicit_type(TypeInferenceContext *, const AstNode *)")
;
}
if (param_2 == 0) {
uVar1 = 0;
}
else {
if (*(long *)(param_1 + 0x48) != 0) {
lVar2 = 0;
lVar4 = 0;
do {
if (*(long *)(*(long *)(param_1 + 0x30) + lVar4 * 8) == param_2) {
puVar3 = (int8 *)(*(long *)(param_1 + 0x38) - lVar2);
goto LAB_0010389b;
}
lVar4 = lVar4 + 1;
lVar2 = lVar2 + -8;
} while (*(long *)(param_1 + 0x48) != lVar4);
}
puVar3 = (int8 *)(param_2 + 0x18);
LAB_0010389b:
uVar1 = *puVar3;
}
return uVar1;
}
|
|
2,622 | ma_state_info_read_dsk | eloqsql/storage/maria/ma_open.c | uint _ma_state_info_read_dsk(File file __attribute__((unused)),
MARIA_STATE_INFO *state __attribute__((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
uchar buff[MARIA_STATE_INFO_SIZE + MARIA_STATE_EXTRA_SIZE];
/* trick to detect transactional tables */
DBUG_ASSERT(state->create_rename_lsn == LSN_IMPOSSIBLE);
if (!maria_single_user)
{
if (mysql_file_pread(file, buff, state->state_length, 0L, MYF(MY_NABP)))
return 1;
_ma_state_info_read(buff, state);
}
#endif
return 0;
} | O0 | c | ma_state_info_read_dsk:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
popq %rbp
retq
nop
| _ma_state_info_read_dsk:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
xor eax, eax
pop rbp
retn
| long long ma_state_info_read_dsk()
{
return 0LL;
}
| _ma_state_info_read_dsk:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_state_info_read_dsk(void)
{
return 0;
}
|
|
2,623 | ma_state_info_read_dsk | eloqsql/storage/maria/ma_open.c | uint _ma_state_info_read_dsk(File file __attribute__((unused)),
MARIA_STATE_INFO *state __attribute__((unused)))
{
#ifdef MARIA_EXTERNAL_LOCKING
uchar buff[MARIA_STATE_INFO_SIZE + MARIA_STATE_EXTRA_SIZE];
/* trick to detect transactional tables */
DBUG_ASSERT(state->create_rename_lsn == LSN_IMPOSSIBLE);
if (!maria_single_user)
{
if (mysql_file_pread(file, buff, state->state_length, 0L, MYF(MY_NABP)))
return 1;
_ma_state_info_read(buff, state);
}
#endif
return 0;
} | O3 | c | ma_state_info_read_dsk:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
popq %rbp
retq
| _ma_state_info_read_dsk:
push rbp
mov rbp, rsp
xor eax, eax
pop rbp
retn
| long long ma_state_info_read_dsk()
{
return 0LL;
}
| _ma_state_info_read_dsk:
PUSH RBP
MOV RBP,RSP
XOR EAX,EAX
POP RBP
RET
|
int8 _ma_state_info_read_dsk(void)
{
return 0;
}
|
|
2,624 | ma_hashtbl_delete | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | my_bool ma_hashtbl_delete(MA_HASHTBL *hash,uchar *record)
{
uint blength,pos2,pos_hashnr,lastpos_hashnr,idx,empty_index;
MA_HASHTBL_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
if (!hash->records)
return(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,MA_HASHTBL_LINK*);
/* Search after record with key */
pos=data+ hash_mask(rec_hashnr(hash,record),blength,hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
return(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
hash->current_record= NO_RECORD;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos->data=empty->data;
pos->next=empty->next;
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr=rec_hashnr(hash,lastpos->data);
/* pos is where lastpos should be */
pos=data+hash_mask(lastpos_hashnr,hash->blength,hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr=rec_hashnr(hash,pos->data);
/* pos3 is where the pos should be */
pos3= data+hash_mask(pos_hashnr,hash->blength,hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= hash_mask(lastpos_hashnr,blength,hash->records+1);
if (pos2 == hash_mask(pos_hashnr,blength,hash->records+1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
ma_pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
return(0);
} | O3 | c | ma_hashtbl_delete:
movb $0x1, %al
cmpl $0x0, 0x8(%rdi)
je 0x33b80
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %r12d
movq 0x18(%rdi), %r13
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x33914
leaq -0x58(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%r15), %esi
jmp 0x33921
movl 0x4(%r14), %esi
movl %esi, -0x58(%rbp)
movl (%r14), %edi
addq %rbx, %rdi
callq *0x40(%r14)
movl %eax, %r15d
movl 0x8(%r14), %esi
leal -0x1(%r12), %r8d
andl %r8d, %eax
shrl %r12d
decl %r12d
movq %r12, -0x70(%rbp)
andl %r12d, %r15d
cmpl %esi, %eax
cmovbl %eax, %r15d
movq %r15, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %r12
cmpq %rbx, 0x8(%r13,%rax)
je 0x3397e
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl (%r12), %r15d
cmpq %rcx, %r15
je 0x339b3
movq %r12, %rax
movq %r15, %rdx
shlq $0x4, %rdx
leaq (%rdx,%r13), %r12
cmpq %rbx, 0x8(%r13,%rdx)
jne 0x3395e
jmp 0x33980
xorl %eax, %eax
decl %esi
movl %esi, 0x8(%r14)
movl 0xc(%r14), %ecx
shrl %ecx
cmpl %ecx, %esi
jae 0x33994
movl %ecx, 0xc(%r14)
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
movl %esi, %r9d
shlq $0x4, %r9
addq %r13, %r9
movl (%r12), %ecx
testq %rax, %rax
je 0x339ba
movl %ecx, (%rax)
jmp 0x339e0
movb $0x1, %al
jmp 0x33b72
cmpl $-0x1, %ecx
je 0x339e0
movq %rcx, %rax
shlq $0x4, %rax
movq 0x8(%r13,%rax), %rdx
movq %rdx, 0x8(%r12)
movl (%r13,%rax), %edx
movl %edx, (%r12)
leaq (%rax,%r13), %r12
movl %ecx, %r15d
leaq 0x18(%r14), %rdi
cmpq %r9, %r12
je 0x33b5d
movq %rdi, -0x38(%rbp)
movl %r8d, -0x54(%rbp)
movl %esi, -0x50(%rbp)
movq %r9, -0x48(%rbp)
movq 0x8(%r9), %rdi
movq 0x30(%r14), %rax
testq %rax, %rax
movq %rbx, -0x40(%rbp)
je 0x33a1f
leaq -0x5c(%rbp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%rbx), %esi
jmp 0x33a2c
movl 0x4(%r14), %esi
movl %esi, -0x5c(%rbp)
movl (%r14), %eax
addq %rax, %rdi
callq *0x40(%r14)
movl 0xc(%r14), %ebx
leal -0x1(%rbx), %ecx
andl %eax, %ecx
shrl %ebx
decl %ebx
andl %eax, %ebx
cmpl 0x8(%r14), %ecx
cmovbl %ecx, %ebx
movq %rbx, %rcx
shlq $0x4, %rcx
addq %r13, %rcx
cmpq %r12, %rcx
je 0x33a7c
movl %eax, -0x4c(%rbp)
movq %rcx, -0x68(%rbp)
movq 0x8(%rcx), %rdi
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x33a8d
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
leaq -0x2c(%rbp), %rax
movl (%rax), %esi
jmp 0x33a9a
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r12)
jmp 0x33b55
movl 0x4(%r14), %esi
movl %esi, -0x2c(%rbp)
movl (%r14), %eax
addq %rax, %rdi
callq *0x40(%r14)
movl 0x8(%r14), %ecx
movl 0xc(%r14), %edx
leal -0x1(%rdx), %esi
andl %eax, %esi
shrl %edx
decl %edx
andl %eax, %edx
cmpl %ecx, %esi
cmovbl %esi, %edx
cmpl %edx, %ebx
jne 0x33b29
leal 0x1(%rcx), %edx
movl -0x4c(%rbp), %r9d
movl %r9d, %esi
movl -0x54(%rbp), %r8d
andl %r8d, %esi
movq -0x70(%rbp), %rdi
andl %edi, %r9d
cmpl %edx, %esi
cmovbl %esi, %r9d
andl %eax, %r8d
andl %edi, %eax
cmpl %edx, %r8d
cmovbl %r8d, %eax
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl %eax, %r9d
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rdi
jne 0x33b01
cmpl %ecx, %r9d
jne 0x33b81
movl %ebx, %edx
movups (%rax), %xmm0
movups %xmm0, (%r12)
movl (%rdi), %eax
movl %r15d, %esi
movl %esi, %ecx
shlq $0x4, %rcx
movl (%r13,%rcx), %esi
cmpl %edx, %esi
jne 0x33b0e
addq %rcx, %r13
movl %eax, (%r13)
movl %r15d, (%rdi)
jmp 0x33b55
movq -0x68(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl %edx, %eax
shlq $0x4, %rax
movl (%r13,%rax), %edx
cmpl %ebx, %edx
jne 0x33b3f
addq %rax, %r13
movl %r15d, (%r13)
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rdi
callq 0x3267d
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x33b70
movq %rbx, %rdi
callq *%rax
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movups (%rax), %xmm0
movups %xmm0, (%r12)
movl -0x50(%rbp), %ecx
movl %ebx, %eax
shlq $0x4, %rax
movl (%r13,%rax), %ebx
cmpl %ecx, %ebx
jne 0x33b8c
jmp 0x33b4e
| ma_hashtbl_delete:
mov al, 1
cmp dword ptr [rdi+8], 0
jz locret_33B80
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
mov r12d, [rdi+0Ch]
mov r13, [rdi+18h]
mov rax, [rdi+30h]
test rax, rax
jz short loc_33914
lea r15, [rbp-58h]
mov rdi, rbx
mov rsi, r15
xor edx, edx
call rax
mov rdi, rax
mov esi, [r15]
jmp short loc_33921
loc_33914:
mov esi, [r14+4]
mov [rbp-58h], esi
mov edi, [r14]
add rdi, rbx
loc_33921:
call qword ptr [r14+40h]
mov r15d, eax
mov esi, [r14+8]
lea r8d, [r12-1]
and eax, r8d
shr r12d, 1
dec r12d
mov [rbp-70h], r12
and r15d, r12d
cmp eax, esi
cmovb r15d, eax
mov rax, r15
shl rax, 4
lea r12, [rax+r13]
cmp [r13+rax+8], rbx
jz short loc_3397E
mov ecx, 0FFFFFFFFh
loc_3395E:
mov r15d, [r12]
cmp r15, rcx
jz short loc_339B3
mov rax, r12
mov rdx, r15
shl rdx, 4
lea r12, [rdx+r13]
cmp [r13+rdx+8], rbx
jnz short loc_3395E
jmp short loc_33980
loc_3397E:
xor eax, eax
loc_33980:
dec esi
mov [r14+8], esi
mov ecx, [r14+0Ch]
shr ecx, 1
cmp esi, ecx
jnb short loc_33994
mov [r14+0Ch], ecx
loc_33994:
mov dword ptr [r14+10h], 0FFFFFFFFh
mov r9d, esi
shl r9, 4
add r9, r13
mov ecx, [r12]
test rax, rax
jz short loc_339BA
mov [rax], ecx
jmp short loc_339E0
loc_339B3:
mov al, 1
jmp loc_33B72
loc_339BA:
cmp ecx, 0FFFFFFFFh
jz short loc_339E0
mov rax, rcx
shl rax, 4
mov rdx, [r13+rax+8]
mov [r12+8], rdx
mov edx, [r13+rax+0]
mov [r12], edx
lea r12, [rax+r13]
mov r15d, ecx
loc_339E0:
lea rdi, [r14+18h]
cmp r12, r9
jz loc_33B5D
mov [rbp-38h], rdi
mov [rbp-54h], r8d
mov [rbp-50h], esi
mov [rbp-48h], r9
mov rdi, [r9+8]
mov rax, [r14+30h]
test rax, rax
mov [rbp-40h], rbx
jz short loc_33A1F
lea rbx, [rbp-5Ch]
mov rsi, rbx
xor edx, edx
call rax
mov rdi, rax
mov esi, [rbx]
jmp short loc_33A2C
loc_33A1F:
mov esi, [r14+4]
mov [rbp-5Ch], esi
mov eax, [r14]
add rdi, rax
loc_33A2C:
call qword ptr [r14+40h]
mov ebx, [r14+0Ch]
lea ecx, [rbx-1]
and ecx, eax
shr ebx, 1
dec ebx
and ebx, eax
cmp ecx, [r14+8]
cmovb ebx, ecx
mov rcx, rbx
shl rcx, 4
add rcx, r13
cmp rcx, r12
jz short loc_33A7C
mov [rbp-4Ch], eax
mov [rbp-68h], rcx
mov rdi, [rcx+8]
mov rax, [r14+30h]
test rax, rax
jz short loc_33A8D
lea rsi, [rbp-2Ch]
xor edx, edx
call rax
mov rdi, rax
lea rax, [rbp-2Ch]
mov esi, [rax]
jmp short loc_33A9A
loc_33A7C:
mov rax, [rbp-48h]
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
jmp loc_33B55
loc_33A8D:
mov esi, [r14+4]
mov [rbp-2Ch], esi
mov eax, [r14]
add rdi, rax
loc_33A9A:
call qword ptr [r14+40h]
mov ecx, [r14+8]
mov edx, [r14+0Ch]
lea esi, [rdx-1]
and esi, eax
shr edx, 1
dec edx
and edx, eax
cmp esi, ecx
cmovb edx, esi
cmp ebx, edx
jnz short loc_33B29
lea edx, [rcx+1]
mov r9d, [rbp-4Ch]
mov esi, r9d
mov r8d, [rbp-54h]
and esi, r8d
mov rdi, [rbp-70h]
and r9d, edi
cmp esi, edx
cmovb r9d, esi
and r8d, eax
and eax, edi
cmp r8d, edx
cmovb eax, r8d
mov edx, 0FFFFFFFFh
cmp r9d, eax
mov rax, [rbp-48h]
mov rdi, [rbp-68h]
jnz short loc_33B01
cmp r9d, ecx
jnz loc_33B81
mov edx, ebx
loc_33B01:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
mov eax, [rdi]
mov esi, r15d
loc_33B0E:
mov ecx, esi
shl rcx, 4
mov esi, [r13+rcx+0]
cmp esi, edx
jnz short loc_33B0E
add r13, rcx
mov [r13+0], eax
mov [rdi], r15d
jmp short loc_33B55
loc_33B29:
mov rcx, [rbp-68h]
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
mov rax, [rbp-48h]
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rcx], xmm0
loc_33B3F:
mov eax, edx
shl rax, 4
mov edx, [r13+rax+0]
cmp edx, ebx
jnz short loc_33B3F
loc_33B4E:
add r13, rax
mov [r13+0], r15d
loc_33B55:
mov rbx, [rbp-40h]
mov rdi, [rbp-38h]
loc_33B5D:
call ma_pop_dynamic
mov rax, [r14+38h]
test rax, rax
jz short loc_33B70
mov rdi, rbx
call rax
loc_33B70:
xor eax, eax
loc_33B72:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_33B80:
retn
loc_33B81:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
mov ecx, [rbp-50h]
loc_33B8C:
mov eax, ebx
shl rax, 4
mov ebx, [r13+rax+0]
cmp ebx, ecx
jnz short loc_33B8C
jmp short loc_33B4E
| char ma_hashtbl_delete(unsigned int *a1, long long a2)
{
char result; // al
long long v3; // rbx
unsigned int v5; // r12d
long long v6; // r13
long long ( *v7)(long long, unsigned int *, _QWORD); // rax
long long v8; // rdi
long long v9; // rsi
unsigned int v10; // r15d
unsigned int v11; // esi
unsigned int v12; // r8d
unsigned int v13; // eax
long long v14; // r15
unsigned int *v15; // r12
unsigned int *v16; // rax
unsigned int v17; // esi
unsigned int v18; // ecx
long long v19; // r9
long long v20; // rcx
long long v21; // rdi
long long v22; // rdi
long long ( *v23)(long long, unsigned int *, _QWORD); // rax
long long v24; // rdi
long long v25; // rsi
unsigned int v26; // eax
unsigned int v27; // ebx
unsigned int v28; // ecx
long long v29; // rbx
long long v30; // rcx
long long v31; // rdi
long long ( *v32)(long long, unsigned int *, _QWORD); // rax
long long v33; // rdi
long long v34; // rsi
int v35; // eax
unsigned int v36; // ecx
unsigned int v37; // edx
unsigned int v38; // esi
unsigned int v39; // edx
int v40; // r9d
unsigned int v41; // r8d
int v42; // eax
int v43; // edx
unsigned int v44; // esi
long long v45; // rcx
long long v46; // rax
void ( *v47)(long long); // rax
int v48; // [rsp-78h] [rbp-78h]
_DWORD *v49; // [rsp-70h] [rbp-70h]
unsigned int v50; // [rsp-64h] [rbp-64h] BYREF
unsigned int v51; // [rsp-60h] [rbp-60h] BYREF
unsigned int v52; // [rsp-5Ch] [rbp-5Ch]
unsigned int v53; // [rsp-58h] [rbp-58h]
unsigned int v54; // [rsp-54h] [rbp-54h]
_OWORD *v55; // [rsp-50h] [rbp-50h]
long long v56; // [rsp-48h] [rbp-48h]
unsigned int *v57; // [rsp-40h] [rbp-40h]
unsigned int v58; // [rsp-34h] [rbp-34h] BYREF
result = 1;
if ( !a1[2] )
return result;
v3 = a2;
v5 = a1[3];
v6 = *((_QWORD *)a1 + 3);
v7 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
if ( v7 )
{
v8 = v7(a2, &v51, 0LL);
v9 = v51;
}
else
{
v9 = a1[1];
v51 = a1[1];
v8 = v3 + *a1;
}
v10 = (*((long long ( **)(long long, long long))a1 + 8))(v8, v9);
v11 = a1[2];
v12 = v5 - 1;
v13 = (v5 - 1) & v10;
v48 = (v5 >> 1) - 1;
v14 = v48 & v10;
if ( v13 < v11 )
v14 = v13;
v15 = (unsigned int *)(16 * v14 + v6);
if ( *((_QWORD *)v15 + 1) == v3 )
{
v16 = 0LL;
LABEL_12:
v17 = v11 - 1;
a1[2] = v17;
v18 = a1[3] >> 1;
if ( v17 < v18 )
a1[3] = v18;
a1[4] = -1;
v19 = v6 + 16LL * v17;
v20 = *v15;
if ( v16 )
{
*v16 = v20;
}
else if ( (_DWORD)v20 != -1 )
{
*((_QWORD *)v15 + 1) = *(_QWORD *)(v6 + 16 * v20 + 8);
*v15 = *(_DWORD *)(v6 + 16 * v20);
v15 = (unsigned int *)(16 * v20 + v6);
LODWORD(v14) = v20;
}
v21 = (long long)(a1 + 6);
if ( v15 == (unsigned int *)v19 )
goto LABEL_47;
v57 = a1 + 6;
v52 = v12;
v53 = v17;
v55 = (_OWORD *)(v6 + 16LL * v17);
v22 = *(_QWORD *)(v19 + 8);
v23 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
v56 = v3;
if ( v23 )
{
v24 = v23(v22, &v50, 0LL);
v25 = v50;
}
else
{
v25 = a1[1];
v50 = a1[1];
v24 = *a1 + v22;
}
v26 = (*((long long ( **)(long long, long long))a1 + 8))(v24, v25);
v27 = a1[3];
v28 = v26 & (v27 - 1);
v29 = v26 & ((v27 >> 1) - 1);
if ( v28 < a1[2] )
v29 = v28;
v30 = v6 + 16 * v29;
if ( (unsigned int *)v30 == v15 )
{
*(_OWORD *)v15 = *v55;
}
else
{
v54 = v26;
v49 = (_DWORD *)(v6 + 16 * v29);
v31 = *(_QWORD *)(v30 + 8);
v32 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
if ( v32 )
{
v33 = v32(v31, &v58, 0LL);
v34 = v58;
}
else
{
v34 = a1[1];
v58 = a1[1];
v33 = *a1 + v31;
}
v35 = (*((long long ( **)(long long, long long))a1 + 8))(v33, v34);
v36 = a1[2];
v37 = a1[3];
v38 = v35 & (v37 - 1);
v39 = v35 & ((v37 >> 1) - 1);
if ( v38 < v36 )
v39 = v38;
if ( (_DWORD)v29 == v39 )
{
v40 = v48 & v54;
if ( (v52 & v54) < v36 + 1 )
v40 = v52 & v54;
v41 = v35 & v52;
v42 = v48 & v35;
if ( v41 < v36 + 1 )
v42 = v41;
v43 = -1;
if ( v40 != v42 )
goto LABEL_40;
if ( v40 == v36 )
{
v43 = v29;
LABEL_40:
*(_OWORD *)v15 = *v55;
v44 = v14;
do
{
v45 = 16LL * v44;
v44 = *(_DWORD *)(v6 + v45);
}
while ( v44 != v43 );
*(_DWORD *)(v45 + v6) = *v49;
*v49 = v14;
goto LABEL_46;
}
*(_OWORD *)v15 = *v55;
do
{
v46 = 16LL * (unsigned int)v29;
LODWORD(v29) = *(_DWORD *)(v6 + v46);
}
while ( (_DWORD)v29 != v53 );
}
else
{
*(_OWORD *)v15 = *(_OWORD *)v49;
*(_OWORD *)v49 = *v55;
do
{
v46 = 16LL * v39;
v39 = *(_DWORD *)(v6 + v46);
}
while ( v39 != (_DWORD)v29 );
}
*(_DWORD *)(v46 + v6) = v14;
}
LABEL_46:
v3 = v56;
v21 = (long long)v57;
LABEL_47:
ma_pop_dynamic(v21);
v47 = (void ( *)(long long))*((_QWORD *)a1 + 7);
if ( v47 )
v47(v3);
return 0;
}
while ( 1 )
{
v14 = *v15;
if ( v14 == 0xFFFFFFFFLL )
return 1;
v16 = v15;
v15 = (unsigned int *)(16 * v14 + v6);
if ( *((_QWORD *)v15 + 1) == v3 )
goto LABEL_12;
}
}
| ma_hashtbl_delete:
MOV AL,0x1
CMP dword ptr [RDI + 0x8],0x0
JZ 0x00133b80
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
MOV R12D,dword ptr [RDI + 0xc]
MOV R13,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x00133914
LEA R15,[RBP + -0x58]
MOV RDI,RBX
MOV RSI,R15
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [R15]
JMP 0x00133921
LAB_00133914:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x58],ESI
MOV EDI,dword ptr [R14]
ADD RDI,RBX
LAB_00133921:
CALL qword ptr [R14 + 0x40]
MOV R15D,EAX
MOV ESI,dword ptr [R14 + 0x8]
LEA R8D,[R12 + -0x1]
AND EAX,R8D
SHR R12D,0x1
DEC R12D
MOV qword ptr [RBP + -0x70],R12
AND R15D,R12D
CMP EAX,ESI
CMOVC R15D,EAX
MOV RAX,R15
SHL RAX,0x4
LEA R12,[RAX + R13*0x1]
CMP qword ptr [R13 + RAX*0x1 + 0x8],RBX
JZ 0x0013397e
MOV ECX,0xffffffff
LAB_0013395e:
MOV R15D,dword ptr [R12]
CMP R15,RCX
JZ 0x001339b3
MOV RAX,R12
MOV RDX,R15
SHL RDX,0x4
LEA R12,[RDX + R13*0x1]
CMP qword ptr [R13 + RDX*0x1 + 0x8],RBX
JNZ 0x0013395e
JMP 0x00133980
LAB_0013397e:
XOR EAX,EAX
LAB_00133980:
DEC ESI
MOV dword ptr [R14 + 0x8],ESI
MOV ECX,dword ptr [R14 + 0xc]
SHR ECX,0x1
CMP ESI,ECX
JNC 0x00133994
MOV dword ptr [R14 + 0xc],ECX
LAB_00133994:
MOV dword ptr [R14 + 0x10],0xffffffff
MOV R9D,ESI
SHL R9,0x4
ADD R9,R13
MOV ECX,dword ptr [R12]
TEST RAX,RAX
JZ 0x001339ba
MOV dword ptr [RAX],ECX
JMP 0x001339e0
LAB_001339b3:
MOV AL,0x1
JMP 0x00133b72
LAB_001339ba:
CMP ECX,-0x1
JZ 0x001339e0
MOV RAX,RCX
SHL RAX,0x4
MOV RDX,qword ptr [R13 + RAX*0x1 + 0x8]
MOV qword ptr [R12 + 0x8],RDX
MOV EDX,dword ptr [R13 + RAX*0x1]
MOV dword ptr [R12],EDX
LEA R12,[RAX + R13*0x1]
MOV R15D,ECX
LAB_001339e0:
LEA RDI,[R14 + 0x18]
CMP R12,R9
JZ 0x00133b5d
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x54],R8D
MOV dword ptr [RBP + -0x50],ESI
MOV qword ptr [RBP + -0x48],R9
MOV RDI,qword ptr [R9 + 0x8]
MOV RAX,qword ptr [R14 + 0x30]
TEST RAX,RAX
MOV qword ptr [RBP + -0x40],RBX
JZ 0x00133a1f
LEA RBX,[RBP + -0x5c]
MOV RSI,RBX
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [RBX]
JMP 0x00133a2c
LAB_00133a1f:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x5c],ESI
MOV EAX,dword ptr [R14]
ADD RDI,RAX
LAB_00133a2c:
CALL qword ptr [R14 + 0x40]
MOV EBX,dword ptr [R14 + 0xc]
LEA ECX,[RBX + -0x1]
AND ECX,EAX
SHR EBX,0x1
DEC EBX
AND EBX,EAX
CMP ECX,dword ptr [R14 + 0x8]
CMOVC EBX,ECX
MOV RCX,RBX
SHL RCX,0x4
ADD RCX,R13
CMP RCX,R12
JZ 0x00133a7c
MOV dword ptr [RBP + -0x4c],EAX
MOV qword ptr [RBP + -0x68],RCX
MOV RDI,qword ptr [RCX + 0x8]
MOV RAX,qword ptr [R14 + 0x30]
TEST RAX,RAX
JZ 0x00133a8d
LEA RSI,[RBP + -0x2c]
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
LEA RAX,[RBP + -0x2c]
MOV ESI,dword ptr [RAX]
JMP 0x00133a9a
LAB_00133a7c:
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
JMP 0x00133b55
LAB_00133a8d:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [R14]
ADD RDI,RAX
LAB_00133a9a:
CALL qword ptr [R14 + 0x40]
MOV ECX,dword ptr [R14 + 0x8]
MOV EDX,dword ptr [R14 + 0xc]
LEA ESI,[RDX + -0x1]
AND ESI,EAX
SHR EDX,0x1
DEC EDX
AND EDX,EAX
CMP ESI,ECX
CMOVC EDX,ESI
CMP EBX,EDX
JNZ 0x00133b29
LEA EDX,[RCX + 0x1]
MOV R9D,dword ptr [RBP + -0x4c]
MOV ESI,R9D
MOV R8D,dword ptr [RBP + -0x54]
AND ESI,R8D
MOV RDI,qword ptr [RBP + -0x70]
AND R9D,EDI
CMP ESI,EDX
CMOVC R9D,ESI
AND R8D,EAX
AND EAX,EDI
CMP R8D,EDX
CMOVC EAX,R8D
MOV EDX,0xffffffff
CMP R9D,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RBP + -0x68]
JNZ 0x00133b01
CMP R9D,ECX
JNZ 0x00133b81
MOV EDX,EBX
LAB_00133b01:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
MOV EAX,dword ptr [RDI]
MOV ESI,R15D
LAB_00133b0e:
MOV ECX,ESI
SHL RCX,0x4
MOV ESI,dword ptr [R13 + RCX*0x1]
CMP ESI,EDX
JNZ 0x00133b0e
ADD R13,RCX
MOV dword ptr [R13],EAX
MOV dword ptr [RDI],R15D
JMP 0x00133b55
LAB_00133b29:
MOV RCX,qword ptr [RBP + -0x68]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RCX],XMM0
LAB_00133b3f:
MOV EAX,EDX
SHL RAX,0x4
MOV EDX,dword ptr [R13 + RAX*0x1]
CMP EDX,EBX
JNZ 0x00133b3f
LAB_00133b4e:
ADD R13,RAX
MOV dword ptr [R13],R15D
LAB_00133b55:
MOV RBX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x38]
LAB_00133b5d:
CALL 0x0013267d
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
JZ 0x00133b70
MOV RDI,RBX
CALL RAX
LAB_00133b70:
XOR EAX,EAX
LAB_00133b72:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00133b80:
RET
LAB_00133b81:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
MOV ECX,dword ptr [RBP + -0x50]
LAB_00133b8c:
MOV EAX,EBX
SHL RAX,0x4
MOV EBX,dword ptr [R13 + RAX*0x1]
CMP EBX,ECX
JNZ 0x00133b8c
JMP 0x00133b4e
|
int8 ma_hashtbl_delete(uint *param_1,long param_2)
{
long lVar1;
int8 uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
long lVar6;
uint *puVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
uint *puVar11;
uint uVar12;
uint *puVar13;
ulong uVar14;
uint local_64;
uint local_60;
uint local_5c;
uint local_58;
uint local_54;
uint *local_50;
long local_48;
uint *local_40;
uint local_34;
if (param_1[2] == 0) {
return 1;
}
uVar9 = param_1[3];
lVar1 = *(long *)(param_1 + 6);
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_60 = param_1[1];
lVar6 = (ulong)*param_1 + param_2;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(param_2,&local_60,0);
}
uVar3 = (**(code **)(param_1 + 0x10))(lVar6,local_60);
uVar4 = uVar9 - 1;
uVar12 = (uVar9 >> 1) - 1;
uVar9 = uVar3 & uVar12;
if ((uVar3 & uVar4) < param_1[2]) {
uVar9 = uVar3 & uVar4;
}
uVar14 = (ulong)uVar9;
puVar13 = (uint *)(uVar14 * 0x10 + lVar1);
if (*(long *)(lVar1 + 8 + uVar14 * 0x10) == param_2) {
puVar7 = (uint *)0x0;
}
else {
do {
puVar7 = puVar13;
uVar14 = (ulong)*puVar7;
if (uVar14 == 0xffffffff) {
return 1;
}
puVar13 = (uint *)(uVar14 * 0x10 + lVar1);
} while (*(long *)(lVar1 + 8 + uVar14 * 0x10) != param_2);
}
uVar9 = param_1[2] - 1;
param_1[2] = uVar9;
if (uVar9 < param_1[3] >> 1) {
param_1[3] = param_1[3] >> 1;
}
param_1[4] = 0xffffffff;
puVar11 = (uint *)((ulong)uVar9 * 0x10 + lVar1);
uVar3 = *puVar13;
if (puVar7 == (uint *)0x0) {
if (uVar3 != 0xffffffff) {
lVar6 = (ulong)uVar3 * 0x10;
*(int8 *)(puVar13 + 2) = *(int8 *)(lVar1 + 8 + lVar6);
*puVar13 = *(uint *)(lVar1 + lVar6);
puVar13 = (uint *)(lVar6 + lVar1);
uVar14 = (ulong)uVar3;
}
}
else {
*puVar7 = uVar3;
}
puVar7 = param_1 + 6;
if (puVar13 != puVar11) {
local_5c = uVar4;
local_58 = uVar9;
local_50 = puVar11;
local_48 = param_2;
local_40 = puVar7;
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_64 = param_1[1];
lVar6 = *(long *)(puVar11 + 2) + (ulong)*param_1;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(*(long *)(puVar11 + 2),&local_64,0);
}
uVar4 = (**(code **)(param_1 + 0x10))(lVar6,local_64);
uVar3 = param_1[3] - 1 & uVar4;
uVar9 = (param_1[3] >> 1) - 1 & uVar4;
if (uVar3 < param_1[2]) {
uVar9 = uVar3;
}
uVar8 = (ulong)uVar9;
puVar11 = (uint *)(uVar8 * 0x10 + lVar1);
if (puVar11 == puVar13) {
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
param_2 = local_48;
puVar7 = local_40;
}
else {
local_54 = uVar4;
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_34 = param_1[1];
lVar6 = *(long *)(puVar11 + 2) + (ulong)*param_1;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(*(long *)(puVar11 + 2),&local_34,0);
}
uVar5 = (**(code **)(param_1 + 0x10))(lVar6,local_34);
uVar4 = param_1[2];
uVar10 = param_1[3] - 1 & uVar5;
uVar3 = (param_1[3] >> 1) - 1 & uVar5;
if (uVar10 < uVar4) {
uVar3 = uVar10;
}
uVar10 = (uint)uVar14;
param_2 = local_48;
puVar7 = local_40;
if (uVar9 == uVar3) {
uVar3 = local_54 & uVar12;
if ((local_54 & local_5c) < uVar4 + 1) {
uVar3 = local_54 & local_5c;
}
uVar12 = uVar5 & uVar12;
if ((local_5c & uVar5) < uVar4 + 1) {
uVar12 = local_5c & uVar5;
}
uVar5 = 0xffffffff;
if ((uVar3 != uVar12) || (uVar5 = uVar9, uVar3 == uVar4)) {
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
do {
lVar6 = uVar14 * 0x10;
uVar9 = *(uint *)(lVar1 + lVar6);
uVar14 = (ulong)uVar9;
} while (uVar9 != uVar5);
*(uint *)(lVar1 + lVar6) = *puVar11;
*puVar11 = uVar10;
goto LAB_00133b5d;
}
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
do {
lVar6 = uVar8 * 0x10;
uVar8 = (ulong)*(uint *)(lVar1 + lVar6);
} while (*(uint *)(lVar1 + lVar6) != local_58);
}
else {
uVar2 = *(int8 *)(puVar11 + 2);
*(int8 *)puVar13 = *(int8 *)puVar11;
*(int8 *)(puVar13 + 2) = uVar2;
uVar4 = local_50[1];
uVar12 = local_50[2];
uVar5 = local_50[3];
*puVar11 = *local_50;
puVar11[1] = uVar4;
puVar11[2] = uVar12;
puVar11[3] = uVar5;
do {
lVar6 = (ulong)uVar3 * 0x10;
uVar3 = *(uint *)(lVar1 + lVar6);
} while (uVar3 != uVar9);
}
*(uint *)(lVar1 + lVar6) = uVar10;
}
}
LAB_00133b5d:
ma_pop_dynamic(puVar7);
if (*(code **)(param_1 + 0xe) != (code *)0x0) {
(**(code **)(param_1 + 0xe))(param_2);
}
return 0;
}
|
|
2,625 | get_collation_number | eloqsql/mysys/charset.c | uint get_collation_number(const char *name, myf flags)
{
uint id;
char alias[64];
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_collation_number_internal(name)))
return id;
if ((name= get_collation_name_alias(name, alias, sizeof(alias),flags)))
return get_collation_number_internal(name);
return 0;
} | O3 | c | get_collation_number:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq 0x325404(%rip), %rdi # 0x3729f0
leaq 0x80(%rip), %rsi # 0x4d673
callq 0x252a0
movq %rbx, %rdi
callq 0x4d7f3
testl %eax, %eax
jne 0x4d656
leaq 0x13de8(%rip), %rsi # 0x613f3
movl $0x5, %edx
movq %rbx, %rdi
callq 0x253f0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x4d656
btl $0xa, %r14d
movl $0x33, %ecx
sbbl $-0x1, %ecx
addq $0x5, %rbx
leaq 0x13dc1(%rip), %rdx # 0x613f9
leaq -0x60(%rbp), %r14
movl $0x40, %esi
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x4a11e
movq %r14, %rdi
callq 0x4d7f3
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x4d66e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x25320
| get_collation_number:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
call get_collation_number_internal
test eax, eax
jnz short loc_4D656
lea rsi, aUtf8_0; "utf8_"
mov edx, 5
mov rdi, rbx
call _strncasecmp
mov ecx, eax
xor eax, eax
test ecx, ecx
jnz short loc_4D656
bt r14d, 0Ah
mov ecx, 33h ; '3'
sbb ecx, 0FFFFFFFFh
add rbx, 5
lea rdx, aUtf8mbCS; "utf8mb%c_%s"
lea r14, [rbp+var_60]
mov esi, 40h ; '@'
mov rdi, r14
mov r8, rbx
xor eax, eax
call my_snprintf
mov rdi, r14
call get_collation_number_internal
loc_4D656:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_4D66E
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_4D66E:
call ___stack_chk_fail
| long long get_collation_number(
long long a1,
__int16 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long result; // rax
int v11; // ecx
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
char v15[72]; // [rsp+0h] [rbp-60h] BYREF
unsigned long long v16; // [rsp+48h] [rbp-18h]
v16 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
result = get_collation_number_internal(a1);
if ( !(_DWORD)result )
{
v11 = strncasecmp(a1, "utf8_", 5LL);
result = 0LL;
if ( !v11 )
{
my_snprintf(
(unsigned long long)v15,
64LL,
"utf8mb%c_%s",
51 - ((unsigned int)((a2 & 0x400) != 0) - 1),
a1 + 5,
v12,
a3,
a4,
a5,
a6,
v13,
v14,
a9,
a10,
v15[0]);
return get_collation_number_internal(v15);
}
}
return result;
}
| get_collation_number:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[0x4729f0]
LEA RSI,[0x14d673]
CALL 0x001252a0
MOV RDI,RBX
CALL 0x0014d7f3
TEST EAX,EAX
JNZ 0x0014d656
LEA RSI,[0x1613f3]
MOV EDX,0x5
MOV RDI,RBX
CALL 0x001253f0
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
JNZ 0x0014d656
BT R14D,0xa
MOV ECX,0x33
SBB ECX,-0x1
ADD RBX,0x5
LEA RDX,[0x1613f9]
LEA R14,[RBP + -0x60]
MOV ESI,0x40
MOV RDI,R14
MOV R8,RBX
XOR EAX,EAX
CALL 0x0014a11e
MOV RDI,R14
CALL 0x0014d7f3
LAB_0014d656:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0014d66e
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0014d66e:
CALL 0x00125320
|
int8 get_collation_number(char *param_1,uint param_2)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
int1 local_68 [72];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
uVar2 = get_collation_number_internal(param_1);
if ((int)uVar2 == 0) {
iVar1 = strncasecmp(param_1,"utf8_",5);
uVar2 = 0;
if (iVar1 == 0) {
my_snprintf(local_68,0x40,"utf8mb%c_%s",0x34 - (uint)((param_2 >> 10 & 1) != 0),param_1 + 5);
uVar2 = get_collation_number_internal(local_68);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
2,626 | rtree_add_key | eloqsql/storage/myisam/rt_key.c | int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
uint key_length, uchar *page_buf, my_off_t *new_page)
{
uint page_size = mi_getint(page_buf);
uint nod_flag = mi_test_if_nod(page_buf);
DBUG_ENTER("rtree_add_key");
if (page_size + key_length + info->s->base.rec_reflength <=
keyinfo->block_length)
{
/* split won't be necessary */
if (nod_flag)
{
/* save key */
DBUG_ASSERT(_mi_kpos(nod_flag, key) < info->state->key_file_length);
memcpy(rt_PAGE_END(page_buf), key - nod_flag, key_length + nod_flag);
page_size += key_length + nod_flag;
}
else
{
/* save key */
DBUG_ASSERT(_mi_dpos(info, nod_flag, key + key_length +
info->s->base.rec_reflength) <
info->state->data_file_length + info->s->base.pack_reclength);
memcpy(rt_PAGE_END(page_buf), key, key_length +
info->s->base.rec_reflength);
page_size += key_length + info->s->base.rec_reflength;
}
mi_putint(page_buf, page_size, nod_flag);
DBUG_RETURN(0);
}
DBUG_RETURN((rtree_split_page(info, keyinfo, page_buf, key, key_length,
new_page) ? -1 : 1));
} | O3 | c | rtree_add_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %rcx
movq %rdi, %r15
movzbl 0x1(%r8), %eax
movzbl (%r8), %edi
movl %edi, %r12d
andl $0x7f, %r12d
shll $0x8, %r12d
orl %eax, %r12d
movq (%r15), %r8
testb %dil, %dil
js 0x45e5b
leal (%r12,%r14), %r10d
movl 0x178(%r8), %edx
addl %edx, %r10d
movzwl 0xe(%rsi), %r8d
cmpl %r8d, %r10d
ja 0x45e73
andl $0x7f, %edi
shll $0x8, %edi
orq %rax, %rdi
addq %rbx, %rdi
addl %r14d, %edx
movq %rcx, %rsi
callq 0x282f0
movq (%r15), %rax
addl 0x178(%rax), %r14d
xorl %eax, %eax
jmp 0x45ebc
movl 0x178(%r8), %edx
leal (%r12,%r14), %r10d
addl %edx, %r10d
movzwl 0xe(%rsi), %r11d
cmpl %r11d, %r10d
jbe 0x45e8e
movq %r15, %rdi
movq %rbx, %rdx
movl %r14d, %r8d
callq 0x48dc4
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x1, %eax
jmp 0x45eca
movl 0x17c(%r8), %esi
testq %rsi, %rsi
je 0x45e36
andl $0x7f, %edi
shll $0x8, %edi
orq %rax, %rdi
addq %rbx, %rdi
subq %rsi, %rcx
addl %esi, %r14d
movq %rcx, %rsi
movq %r14, %rdx
callq 0x282f0
movl $0x8000, %eax # imm = 0x8000
addl %r12d, %r14d
addl %r14d, %eax
movb %r14b, 0x1(%rbx)
movb %ah, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| rtree_add_key:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, r8
mov r14d, ecx
mov rcx, rdx
mov r15, rdi
movzx eax, byte ptr [r8+1]
movzx edi, byte ptr [r8]
mov r12d, edi
and r12d, 7Fh
shl r12d, 8
or r12d, eax
mov r8, [r15]
test dil, dil
js short loc_45E5B
lea r10d, [r12+r14]
mov edx, [r8+178h]
add r10d, edx
movzx r8d, word ptr [rsi+0Eh]
cmp r10d, r8d
ja short loc_45E73
loc_45E36:
and edi, 7Fh
shl edi, 8
or rdi, rax
add rdi, rbx
add edx, r14d
mov rsi, rcx
call _memcpy
mov rax, [r15]
add r14d, [rax+178h]
xor eax, eax
jmp short loc_45EBC
loc_45E5B:
mov edx, [r8+178h]
lea r10d, [r12+r14]
add r10d, edx
movzx r11d, word ptr [rsi+0Eh]
cmp r10d, r11d
jbe short loc_45E8E
loc_45E73:
mov rdi, r15
mov rdx, rbx
mov r8d, r14d
call rtree_split_page
mov ecx, eax
xor eax, eax
neg ecx
sbb eax, eax
or eax, 1
jmp short loc_45ECA
loc_45E8E:
mov esi, [r8+17Ch]
test rsi, rsi
jz short loc_45E36
and edi, 7Fh
shl edi, 8
or rdi, rax
add rdi, rbx
sub rcx, rsi
add r14d, esi
mov rsi, rcx
mov rdx, r14
call _memcpy
mov eax, 8000h
loc_45EBC:
add r14d, r12d
add eax, r14d
mov [rbx+1], r14b
mov [rbx], ah
xor eax, eax
loc_45ECA:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long rtree_add_key(long long *a1, long long a2, long long a3, unsigned int a4, char *a5)
{
long long v9; // rax
char v10; // di
int v11; // r12d
long long v12; // r8
int v13; // edx
long long v14; // r14
__int16 v15; // ax
long long v17; // rsi
__int16 v18; // r14
v9 = (unsigned __int8)a5[1];
v10 = *a5;
v11 = v9 | ((*a5 & 0x7F) << 8);
v12 = *a1;
if ( v10 >= 0 )
{
v13 = *(_DWORD *)(v12 + 376);
if ( v13 + v11 + a4 <= *(unsigned __int16 *)(a2 + 14) )
goto LABEL_3;
return (unsigned int)rtree_split_page(a1, a2, a5, a3, a4) != 0 ? -1 : 1;
}
v13 = *(_DWORD *)(v12 + 376);
if ( v13 + v11 + a4 > *(unsigned __int16 *)(a2 + 14) )
return (unsigned int)rtree_split_page(a1, a2, a5, a3, a4) != 0 ? -1 : 1;
v17 = *(unsigned int *)(v12 + 380);
if ( *(_DWORD *)(v12 + 380) )
{
v14 = (unsigned int)v17 + a4;
memcpy(&a5[v9 | ((unsigned __int8)(v10 & 0x7F) << 8)], a3 - v17, v14, a3 - v17);
v15 = 0x8000;
goto LABEL_8;
}
LABEL_3:
memcpy(&a5[v9 | ((unsigned __int8)(v10 & 0x7F) << 8)], a3, a4 + v13, a3);
LODWORD(v14) = *(_DWORD *)(*a1 + 376) + a4;
v15 = 0;
LABEL_8:
v18 = v11 + v14;
a5[1] = v18;
*a5 = (unsigned __int16)(v18 + v15) >> 8;
return 0LL;
}
| rtree_add_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,R8
MOV R14D,ECX
MOV RCX,RDX
MOV R15,RDI
MOVZX EAX,byte ptr [R8 + 0x1]
MOVZX EDI,byte ptr [R8]
MOV R12D,EDI
AND R12D,0x7f
SHL R12D,0x8
OR R12D,EAX
MOV R8,qword ptr [R15]
TEST DIL,DIL
JS 0x00145e5b
LEA R10D,[R12 + R14*0x1]
MOV EDX,dword ptr [R8 + 0x178]
ADD R10D,EDX
MOVZX R8D,word ptr [RSI + 0xe]
CMP R10D,R8D
JA 0x00145e73
LAB_00145e36:
AND EDI,0x7f
SHL EDI,0x8
OR RDI,RAX
ADD RDI,RBX
ADD EDX,R14D
MOV RSI,RCX
CALL 0x001282f0
MOV RAX,qword ptr [R15]
ADD R14D,dword ptr [RAX + 0x178]
XOR EAX,EAX
JMP 0x00145ebc
LAB_00145e5b:
MOV EDX,dword ptr [R8 + 0x178]
LEA R10D,[R12 + R14*0x1]
ADD R10D,EDX
MOVZX R11D,word ptr [RSI + 0xe]
CMP R10D,R11D
JBE 0x00145e8e
LAB_00145e73:
MOV RDI,R15
MOV RDX,RBX
MOV R8D,R14D
CALL 0x00148dc4
MOV ECX,EAX
XOR EAX,EAX
NEG ECX
SBB EAX,EAX
OR EAX,0x1
JMP 0x00145eca
LAB_00145e8e:
MOV ESI,dword ptr [R8 + 0x17c]
TEST RSI,RSI
JZ 0x00145e36
AND EDI,0x7f
SHL EDI,0x8
OR RDI,RAX
ADD RDI,RBX
SUB RCX,RSI
ADD R14D,ESI
MOV RSI,RCX
MOV RDX,R14
CALL 0x001282f0
MOV EAX,0x8000
LAB_00145ebc:
ADD R14D,R12D
ADD EAX,R14D
MOV byte ptr [RBX + 0x1],R14B
MOV byte ptr [RBX],AH
XOR EAX,EAX
LAB_00145eca:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
uint rtree_add_key(long *param_1,long param_2,void *param_3,int param_4,byte *param_5)
{
byte bVar1;
byte bVar2;
uint uVar3;
long lVar4;
int iVar5;
uint uVar6;
uint uVar7;
bVar1 = param_5[1];
bVar2 = *param_5;
uVar6 = (bVar2 & 0x7f) << 8 | (uint)bVar1;
lVar4 = *param_1;
if ((char)bVar2 < '\0') {
iVar5 = *(int *)(lVar4 + 0x178);
if ((uint)*(ushort *)(param_2 + 0xe) < uVar6 + param_4 + iVar5) goto LAB_00145e73;
uVar3 = *(uint *)(lVar4 + 0x17c);
if ((ulong)uVar3 != 0) {
uVar7 = param_4 + uVar3;
memcpy(param_5 + ((ulong)((bVar2 & 0x7f) << 8) | (ulong)bVar1),
(void *)((long)param_3 - (ulong)uVar3),(ulong)uVar7);
iVar5 = 0x8000;
goto LAB_00145ebc;
}
}
else {
iVar5 = *(int *)(lVar4 + 0x178);
if ((uint)*(ushort *)(param_2 + 0xe) < uVar6 + param_4 + iVar5) {
LAB_00145e73:
iVar5 = rtree_split_page(param_1,param_2,param_5,param_3,param_4);
return -(uint)(iVar5 != 0) | 1;
}
}
memcpy(param_5 + ((ulong)((bVar2 & 0x7f) << 8) | (ulong)bVar1),param_3,
(ulong)(uint)(iVar5 + param_4));
uVar7 = param_4 + *(int *)(*param_1 + 0x178);
iVar5 = 0;
LAB_00145ebc:
param_5[1] = (byte)(uVar7 + uVar6);
*param_5 = (byte)(iVar5 + uVar7 + uVar6 >> 8);
return 0;
}
|
|
2,627 | my_os_charset_to_mysql_charset | eloqsql/mysys/charset.c | static const char*
my_os_charset_to_mysql_charset(const char* csname)
{
const MY_CSET_OS_NAME* csp;
for (csp = charsets; csp->os_name; csp++)
{
if (!strcasecmp(csp->os_name, csname))
{
switch (csp->param)
{
case my_cs_exact:
return csp->my_name;
case my_cs_approx:
/*
Maybe we should print a warning eventually:
character set correspondence is not exact.
*/
return csp->my_name;
default:
return NULL;
}
}
}
return NULL;
} | O0 | c | my_os_charset_to_mysql_charset:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x19c28d(%rip), %rax # 0x1d07f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x345d6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x25370
cmpl $0x0, %eax
jne 0x345c6
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x345a0
jmp 0x34596
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x345ae
jmp 0x345bc
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x345de
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x345de
movq $0x0, -0x8(%rbp)
jmp 0x345de
jmp 0x345c8
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x34567
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_os_charset_to_mysql_charset:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
lea rax, charsets
mov [rbp+var_18], rax
loc_34567:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_345D6
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_10]
call _strcasecmp
cmp eax, 0
jnz short loc_345C6
mov rax, [rbp+var_18]
mov eax, [rax+10h]
mov [rbp+var_1C], eax
test eax, eax
jz short loc_345A0
jmp short $+2
loc_34596:
mov eax, [rbp+var_1C]
sub eax, 1
jz short loc_345AE
jmp short loc_345BC
loc_345A0:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_345DE
loc_345AE:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_345DE
loc_345BC:
mov [rbp+var_8], 0
jmp short loc_345DE
loc_345C6:
jmp short $+2
loc_345C8:
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_18], rax
jmp short loc_34567
loc_345D6:
mov [rbp+var_8], 0
loc_345DE:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| char * my_os_charset_to_mysql_charset(long long a1)
{
int v2; // [rsp+4h] [rbp-1Ch]
char **i; // [rsp+8h] [rbp-18h]
for ( i = charsets; ; i += 3 )
{
if ( !*i )
return 0LL;
if ( !(unsigned int)strcasecmp(*i, a1) )
break;
}
v2 = *((_DWORD *)i + 4);
if ( !v2 )
return i[1];
if ( v2 == 1 )
return i[1];
return 0LL;
}
| my_os_charset_to_mysql_charset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x2d07f0]
MOV qword ptr [RBP + -0x18],RAX
LAB_00134567:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x001345d6
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00125370
CMP EAX,0x0
JNZ 0x001345c6
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x1c],EAX
TEST EAX,EAX
JZ 0x001345a0
JMP 0x00134596
LAB_00134596:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
JZ 0x001345ae
JMP 0x001345bc
LAB_001345a0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001345de
LAB_001345ae:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001345de
LAB_001345bc:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001345de
LAB_001345c6:
JMP 0x001345c8
LAB_001345c8:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00134567
LAB_001345d6:
MOV qword ptr [RBP + -0x8],0x0
LAB_001345de:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * my_os_charset_to_mysql_charset(char *param_1)
{
int iVar1;
int **local_20;
local_20 = &charsets;
while( true ) {
if (*local_20 == (int *)0x0) {
return (int *)0x0;
}
iVar1 = strcasecmp(*local_20,param_1);
if (iVar1 == 0) break;
local_20 = local_20 + 3;
}
if (*(int *)(local_20 + 2) != 0) {
if (*(int *)(local_20 + 2) != 1) {
return (int *)0x0;
}
return local_20[1];
}
return local_20[1];
}
|
|
2,628 | psi_cond_timedwait | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD int psi_cond_timedwait(mysql_cond_t *that, mysql_mutex_t *mutex,
const struct timespec *abstime,
const char *file, uint line)
{
PSI_cond_locker_state state;
PSI_cond_locker *locker= PSI_COND_CALL(start_cond_wait)
(&state, that->m_psi, mutex->m_psi, PSI_COND_TIMEDWAIT, file, line);
int result= my_cond_timedwait(&that->m_cond, &mutex->m_mutex, abstime);
if (psi_likely(locker))
PSI_COND_CALL(end_cond_wait)(locker, result);
return result;
} | O0 | c | psi_cond_timedwait:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
leaq 0x1b1415(%rip), %rax # 0x1e4ca8
movq (%rax), %rax
movq 0x1c0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rdx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
leaq -0x60(%rbp), %rdi
movl $0x1, %ecx
callq *%rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x25580
movl %eax, -0x6c(%rbp)
cmpq $0x0, -0x68(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x33907
leaq 0x1b13b4(%rip), %rax # 0x1e4ca8
movq (%rax), %rax
movq 0x1c8(%rax), %rax
movq -0x68(%rbp), %rdi
movl -0x6c(%rbp), %esi
callq *%rax
movl -0x6c(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
| psi_cond_timedwait:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1C0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+30h]
mov rcx, [rbp+var_10]
mov rdx, [rcx+40h]
mov r8, [rbp+var_20]
mov r9d, [rbp+var_24]
lea rdi, [rbp+var_60]
mov ecx, 1
call rax
mov [rbp+var_68], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _pthread_cond_timedwait
mov [rbp+var_6C], eax
cmp [rbp+var_68], 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_33907
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1C8h]
mov rdi, [rbp+var_68]
mov esi, [rbp+var_6C]
call rax
loc_33907:
mov eax, [rbp+var_6C]
add rsp, 70h
pop rbp
retn
| long long psi_cond_timedwait(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
unsigned int v6; // [rsp+4h] [rbp-6Ch]
long long v7; // [rsp+8h] [rbp-68h]
_BYTE v8[60]; // [rsp+10h] [rbp-60h] BYREF
unsigned int v9; // [rsp+4Ch] [rbp-24h]
long long v10; // [rsp+50h] [rbp-20h]
long long v11; // [rsp+58h] [rbp-18h]
long long v12; // [rsp+60h] [rbp-10h]
long long v13; // [rsp+68h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
v7 = (*((long long ( **)(_BYTE *, _QWORD, _QWORD, long long, long long, _QWORD))PSI_server[0] + 56))(
v8,
*(_QWORD *)(a1 + 48),
*(_QWORD *)(a2 + 64),
1LL,
a4,
a5);
v6 = pthread_cond_timedwait(v13, v12, v11);
if ( v7 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 57))(v7, v6);
return v6;
}
| psi_cond_timedwait:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],R8D
LEA RAX,[0x2e4ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1c0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x30]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX + 0x40]
MOV R8,qword ptr [RBP + -0x20]
MOV R9D,dword ptr [RBP + -0x24]
LEA RDI,[RBP + -0x60]
MOV ECX,0x1
CALL RAX
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00125580
MOV dword ptr [RBP + -0x6c],EAX
CMP qword ptr [RBP + -0x68],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00133907
LEA RAX,[0x2e4ca8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1c8]
MOV RDI,qword ptr [RBP + -0x68]
MOV ESI,dword ptr [RBP + -0x6c]
CALL RAX
LAB_00133907:
MOV EAX,dword ptr [RBP + -0x6c]
ADD RSP,0x70
POP RBP
RET
|
int psi_cond_timedwait(pthread_cond_t *param_1,pthread_mutex_t *param_2,timespec *param_3,
int8 param_4,int4 param_5)
{
int iVar1;
long lVar2;
int1 local_68 [60];
int4 local_2c;
int8 local_28;
timespec *local_20;
pthread_mutex_t *local_18;
pthread_cond_t *local_10;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1c0))
(local_68,param_1[1].__align,*(int8 *)((long)param_2 + 0x40),1,param_4,
param_5);
iVar1 = pthread_cond_timedwait(local_10,local_18,local_20);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1c8))(lVar2,iVar1);
}
return iVar1;
}
|
|
2,629 | my_load_defaults | eloqsql/mysys/my_default.c | int my_load_defaults(const char *conf_file, const char **groups, int *argc,
char ***argv, const char ***default_directories)
{
DYNAMIC_ARRAY args;
int args_used= 0;
int error= 0;
MEM_ROOT alloc;
char *ptr,**res;
const char **dirs;
DBUG_ENTER("my_load_defaults");
init_alloc_root(key_memory_defaults, &alloc, 512, 0, MYF(0));
if ((dirs= init_default_directories(&alloc)) == NULL)
goto err;
args_used= get_defaults_options(*argv);
if (my_init_dynamic_array(key_memory_defaults, &args, sizeof(char*), 128, 64,
MYF(0)))
goto err;
insert_dynamic(&args, *argv);/* Name MUST be set, even by embedded library */
*argc-= args_used;
*argv+= args_used;
if (!my_no_defaults)
{
TYPELIB group; // XXX
struct handle_option_ctx ctx;
group.count=0;
group.name= "defaults";
group.type_names= groups;
for (; *groups ; groups++)
group.count++;
ctx.alloc= &alloc;
ctx.args= &args;
ctx.group= &group;
if ((error= my_search_option_files(conf_file, &ctx, dirs)))
{
delete_dynamic(&args);
free_root(&alloc,MYF(0));
DBUG_RETURN(error);
}
}
if (!(ptr=(char*) alloc_root(&alloc, sizeof(alloc) +
(args.elements + *argc + 3) * sizeof(char*))))
goto err;
res= (char**) (ptr+sizeof(alloc));
/* found arguments + command line arguments to new array */
memcpy(res, args.buffer, args.elements * sizeof(char*));
if (my_defaults_mark_files)
{
res[args.elements++]= file_marker;
res[args.elements++]= (char*)"";
}
if (*argc)
memcpy(res + args.elements, *argv, *argc * sizeof(char*));
(*argc)+= args.elements;
*argv= res;
(*argv)[*argc]= 0;
*(MEM_ROOT*) ptr= alloc; /* Save alloc root for free */
delete_dynamic(&args);
if (my_print_defaults)
{
int i;
printf("%s would have been started with the following arguments:\n",
**argv);
for (i=1 ; i < *argc ; i++)
printf("%s ", (*argv)[i]);
puts("");
DBUG_RETURN(4);
}
if (default_directories)
*default_directories= dirs;
DBUG_RETURN(0);
err:
fprintf(stderr,"Fatal error in defaults handling. Program aborted\n");
DBUG_RETURN(2);
} | O3 | c | my_load_defaults:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, -0xa8(%rbp)
movq %rcx, %r12
movq %rdx, -0x30(%rbp)
movq %rsi, %r13
movq %rdi, -0xb0(%rbp)
leaq 0xb642f7(%rip), %rbx # 0xc147f8
movl (%rbx), %edi
leaq -0xf0(%rbp), %r15
movl $0x200, %edx # imm = 0x200
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa1938
movq %r15, %rdi
callq 0xb09ef
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0xb0566
movq (%r12), %rdi
callq 0xb0304
movl %eax, %r14d
movl (%rbx), %edi
movq $0x0, (%rsp)
leaq -0x88(%rbp), %rsi
movl $0x8, %edx
xorl %ecx, %ecx
movl $0x80, %r8d
movl $0x40, %r9d
callq 0x9691c
testb %al, %al
je 0xb059e
movq 0x2dda43(%rip), %rax # 0x38dfb0
movq (%rax), %rdi
leaq 0x35319(%rip), %rdx # 0xe5890
movl $0x1, %esi
xorl %eax, %eax
callq 0x2a1e0
movl $0x2, %r14d
movl %r14d, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rsi
movq %r12, %rbx
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x969ba
movq -0x30(%rbp), %rcx
subl %r14d, (%rcx)
movslq %r14d, %rax
shlq $0x3, %rax
movq %rbx, -0x40(%rbp)
addq %rax, (%rbx)
leaq 0xb64991(%rip), %rax # 0xc14f61
cmpb $0x0, (%rax)
je 0xb0682
movl -0x80(%rbp), %eax
movl (%rcx), %ecx
addl %ecx, %eax
addl $0x3, %eax
leaq 0x40(,%rax,8), %rsi
leaq -0xf0(%rbp), %rdi
callq 0xa1a8f
testq %rax, %rax
je 0xb0566
movq %rax, %r15
leaq 0x40(%rax), %r12
movq -0x88(%rbp), %rsi
movl -0x80(%rbp), %ebx
leaq (,%rbx,8), %rdx
movq %r12, %rdi
callq 0x2a0a0
leaq 0xb64938(%rip), %rax # 0xc14f60
cmpb $0x0, (%rax)
je 0xb0656
movq 0x2e08b4(%rip), %rax # 0x390ee8
movl %ebx, %ecx
incl %ecx
movl %ecx, -0x80(%rbp)
movq %rax, (%r12,%rbx,8)
movl -0x80(%rbp), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x80(%rbp)
leaq 0x313d0(%rip), %rcx # 0xe1a1f
movq %rcx, (%r12,%rax,8)
movl -0x80(%rbp), %ebx
movq -0x30(%rbp), %r13
movslq (%r13), %rdx
testq %rdx, %rdx
je 0xb06c8
movl %ebx, %eax
leaq (%r12,%rax,8), %rdi
movq -0x40(%rbp), %r14
movq (%r14), %rsi
shlq $0x3, %rdx
callq 0x2a0a0
movl -0x80(%rbp), %ebx
movl (%r13), %eax
jmp 0xb06ce
movl $0x0, -0x60(%rbp)
leaq 0x35158(%rip), %rax # 0xe57e8
movq %rax, -0x58(%rbp)
movq %r13, -0x50(%rbp)
cmpq $0x0, (%r13)
je 0xb07b1
movl $0x1, %eax
xorl %ecx, %ecx
addl $0x2, %eax
cmpq $0x0, 0x8(%r13,%rcx,8)
leaq 0x1(%rcx), %rcx
jne 0xb06aa
movl %ecx, -0x60(%rbp)
movl %eax, %r14d
shlq $0x3, %r14
jmp 0xb07b7
xorl %eax, %eax
movq -0x40(%rbp), %r14
addl %ebx, %eax
movl %eax, (%r13)
movq %r12, (%r14)
movslq (%r13), %rax
movq $0x0, 0x40(%r15,%rax,8)
movups -0xf0(%rbp), %xmm0
movups -0xe0(%rbp), %xmm1
movups -0xd0(%rbp), %xmm2
movups -0xc0(%rbp), %xmm3
movups %xmm3, 0x30(%r15)
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
leaq -0x88(%rbp), %rdi
callq 0x96c14
leaq 0xb6483c(%rip), %rax # 0xc14f62
cmpb $0x0, (%rax)
je 0xb0792
movq %r14, %r15
movq (%r14), %rax
movq (%rax), %rdx
leaq 0x3511b(%rip), %rsi # 0xe5856
movl $0x1, %edi
xorl %eax, %eax
callq 0x2a800
cmpl $0x2, (%r13)
jl 0xb077d
movl $0x1, %r14d
leaq 0x3458b(%rip), %rbx # 0xe4ce6
movq (%r15), %rax
movq (%rax,%r14,8), %rdx
movl $0x1, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2a800
incq %r14
movslq (%r13), %rax
cmpq %rax, %r14
jl 0xb075b
movl $0xa, %edi
callq 0x2a910
movl $0x4, %r14d
jmp 0xb0589
xorl %r14d, %r14d
movq -0xa8(%rbp), %rax
testq %rax, %rax
je 0xb0589
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xb0589
movl $0x8, %r14d
movq %r15, -0xa0(%rbp)
movq %r12, -0x98(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0xb64799(%rip), %rax # 0xc14f70
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb089b
callq 0x2a320
movq %rax, %r13
leaq -0xf0(%rbp), %rdi
movq %r14, %rsi
callq 0xa1a8f
movl $0x2, %r14d
testq %rax, %rax
je 0xb097f
movq %rax, %r15
cmpl $0x0, -0x60(%rbp)
je 0xb0888
incq %r13
xorl %r12d, %r12d
movq -0x50(%rbp), %rcx
movq (%rcx,%r12,8), %rdi
movq %rdi, (%r15,%r12,8)
callq 0x2a320
movq %rax, %r14
movq -0xa0(%rbp), %rdi
leal (%rax,%r13), %esi
callq 0xa1a8f
testq %rax, %rax
je 0xb0979
movq %rax, %rbx
movl -0x60(%rbp), %eax
addl %r12d, %eax
movq %rbx, (%r15,%rax,8)
movq (%r15,%r12,8), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2a0a0
addq %r14, %rbx
leaq 0xb64705(%rip), %rax # 0xc14f70
movq (%rax), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x2a0a0
incq %r12
movl -0x60(%rbp), %ecx
cmpq %rcx, %r12
jb 0xb0818
addl %ecx, %ecx
jmp 0xb088a
xorl %ecx, %ecx
movl %ecx, -0x60(%rbp)
movq %r15, -0x50(%rbp)
movl %ecx, %ecx
movq $0x0, (%r15,%rcx,8)
leaq 0xb646c6(%rip), %rbx # 0xc14f68
movq (%rbx), %rcx
testq %rcx, %rcx
jne 0xb099e
movq -0xb0(%rbp), %r13
movq %r13, %rdi
callq 0x996f4
testq %rax, %rax
je 0xb0900
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0xb0db2
testl %eax, %eax
jns 0xb09e6
movq 0x2dd6ce(%rip), %rax # 0x38dfb0
movq (%rax), %rdi
leaq 0x34fa4(%rip), %rdx # 0xe5890
movl $0x1, %r14d
movl $0x1, %esi
xorl %eax, %eax
callq 0x2a1e0
jmp 0xb097f
movq -0x38(%rbp), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xb09e6
movq -0x38(%rbp), %r14
addq $0x8, %r14
leaq 0xb64659(%rip), %rbx # 0xc14f78
leaq 0x310f9(%rip), %r15 # 0xe1a1f
leaq -0xa0(%rbp), %r12
cmpb $0x0, (%rsi)
je 0xb0943
movq %r12, %rdi
movq %r13, %rdx
callq 0xb0db2
testl %eax, %eax
jns 0xb094b
jmp 0xb08db
movq (%rbx), %rcx
testq %rcx, %rcx
jne 0xb095c
movq (%r14), %rsi
addq $0x8, %r14
testq %rsi, %rsi
jne 0xb092d
jmp 0xb09e6
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x31066
testl %eax, %eax
js 0xb08db
je 0xb094b
jmp 0xb09c1
movl $0x2, %r14d
leaq -0x88(%rbp), %rdi
callq 0x96c14
leaq -0xf0(%rbp), %rdi
xorl %esi, %esi
callq 0xa1d07
jmp 0xb0589
leaq 0x3107a(%rip), %rdx # 0xe1a1f
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
xorl %r8d, %r8d
callq 0x31066
testl %eax, %eax
js 0xb08db
je 0xb09e6
movq 0x2dd5e8(%rip), %rax # 0x38dfb0
movq (%rax), %rdi
movq (%rbx), %rcx
leaq 0x351b2(%rip), %rdx # 0xe5b87
movl $0x1, %esi
xorl %eax, %eax
callq 0x2a1e0
jmp 0xb08db
movq -0x30(%rbp), %rcx
jmp 0xb05d9
| my_load_defaults:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov [rbp+var_A8], r8
mov r12, rcx
mov [rbp+var_30], rdx
mov r13, rsi
mov [rbp+var_B0], rdi
lea rbx, key_memory_defaults
mov edi, [rbx]
lea r15, [rbp+var_F0]
mov edx, 200h
mov rsi, r15
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rdi, r15
call init_default_directories
mov [rbp+var_38], rax
test rax, rax
jz short loc_B0566
mov rdi, [r12]
call get_defaults_options
mov r14d, eax
mov edi, [rbx]
mov [rsp+100h+var_100], 0
lea rsi, [rbp+var_88]
mov edx, 8
xor ecx, ecx
mov r8d, 80h
mov r9d, 40h ; '@'
call init_dynamic_array2
test al, al
jz short loc_B059E
loc_B0566:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rdx, aFatalErrorInDe; "Fatal error in defaults handling. Progr"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov r14d, 2
loc_B0589:
mov eax, r14d
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B059E:
mov rsi, [r12]
mov rbx, r12
lea r12, [rbp+var_88]
mov rdi, r12
call insert_dynamic
mov rcx, [rbp+var_30]
sub [rcx], r14d
movsxd rax, r14d
shl rax, 3
mov [rbp+var_40], rbx
add [rbx], rax
lea rax, my_no_defaults
cmp byte ptr [rax], 0
jz loc_B0682
loc_B05D9:
mov eax, [rbp+var_80]
mov ecx, [rcx]
add eax, ecx
add eax, 3
lea rsi, ds:40h[rax*8]
lea rdi, [rbp+var_F0]
call alloc_root
test rax, rax
jz loc_B0566
mov r15, rax
lea r12, [rax+40h]
mov rsi, [rbp+var_88]
mov ebx, [rbp+var_80]
lea rdx, ds:0[rbx*8]
mov rdi, r12
call _memcpy
lea rax, my_defaults_mark_files
cmp byte ptr [rax], 0
jz short loc_B0656
mov rax, cs:file_marker
mov ecx, ebx
inc ecx
mov [rbp+var_80], ecx
mov [r12+rbx*8], rax
mov eax, [rbp+var_80]
lea ecx, [rax+1]
mov [rbp+var_80], ecx
lea rcx, aUsageSOptions+15h; ""
mov [r12+rax*8], rcx
mov ebx, [rbp+var_80]
loc_B0656:
mov r13, [rbp+var_30]
movsxd rdx, dword ptr [r13+0]
test rdx, rdx
jz short loc_B06C8
mov eax, ebx
lea rdi, [r12+rax*8]
mov r14, [rbp+var_40]
mov rsi, [r14]
shl rdx, 3
call _memcpy
mov ebx, [rbp+var_80]
mov eax, [r13+0]
jmp short loc_B06CE
loc_B0682:
mov [rbp+var_60], 0
lea rax, aNoDefaults+5; "defaults"
mov [rbp+var_58], rax
mov [rbp+var_50], r13
cmp qword ptr [r13+0], 0
jz loc_B07B1
mov eax, 1
xor ecx, ecx
loc_B06AA:
add eax, 2
cmp qword ptr [r13+rcx*8+8], 0
lea rcx, [rcx+1]
jnz short loc_B06AA
mov [rbp+var_60], ecx
mov r14d, eax
shl r14, 3
jmp loc_B07B7
loc_B06C8:
xor eax, eax
mov r14, [rbp+var_40]
loc_B06CE:
add eax, ebx
mov [r13+0], eax
mov [r14], r12
movsxd rax, dword ptr [r13+0]
mov qword ptr [r15+rax*8+40h], 0
movups xmm0, [rbp+var_F0]
movups xmm1, [rbp+var_E0]
movups xmm2, [rbp+var_D0]
movups xmm3, [rbp+var_C0]
movups xmmword ptr [r15+30h], xmm3
movups xmmword ptr [r15+20h], xmm2
movups xmmword ptr [r15+10h], xmm1
movups xmmword ptr [r15], xmm0
lea rdi, [rbp+var_88]
call delete_dynamic
lea rax, my_print_defaults
cmp byte ptr [rax], 0
jz short loc_B0792
mov r15, r14
mov rax, [r14]
mov rdx, [rax]
lea rsi, aSWouldHaveBeen; "%s would have been started with the fol"...
mov edi, 1
xor eax, eax
call ___printf_chk
cmp dword ptr [r13+0], 2
jl short loc_B077D
mov r14d, 1
lea rbx, aSS+4; "%s "
loc_B075B:
mov rax, [r15]
mov rdx, [rax+r14*8]
mov edi, 1
mov rsi, rbx
xor eax, eax
call ___printf_chk
inc r14
movsxd rax, dword ptr [r13+0]
cmp r14, rax
jl short loc_B075B
loc_B077D:
mov edi, 0Ah
call _putchar
mov r14d, 4
jmp loc_B0589
loc_B0792:
xor r14d, r14d
mov rax, [rbp+var_A8]
test rax, rax
jz loc_B0589
mov rcx, [rbp+var_38]
mov [rax], rcx
jmp loc_B0589
loc_B07B1:
mov r14d, 8
loc_B07B7:
mov [rbp+var_A0], r15
mov [rbp+var_98], r12
lea rax, [rbp+var_60]
mov [rbp+var_90], rax
lea rax, my_defaults_group_suffix
mov rdi, [rax]
test rdi, rdi
jz loc_B089B
call _strlen
mov r13, rax
lea rdi, [rbp+var_F0]
mov rsi, r14
call alloc_root
mov r14d, 2
test rax, rax
jz loc_B097F
mov r15, rax
cmp [rbp+var_60], 0
jz short loc_B0888
inc r13
xor r12d, r12d
loc_B0818:
mov rcx, [rbp+var_50]
mov rdi, [rcx+r12*8]
mov [r15+r12*8], rdi
call _strlen
mov r14, rax
mov rdi, [rbp+var_A0]
lea esi, [rax+r13]
call alloc_root
test rax, rax
jz loc_B0979
mov rbx, rax
mov eax, [rbp+var_60]
add eax, r12d
mov [r15+rax*8], rbx
mov rsi, [r15+r12*8]
mov rdi, rbx
mov rdx, r14
call _memcpy
add rbx, r14
lea rax, my_defaults_group_suffix
mov rsi, [rax]
mov rdi, rbx
mov rdx, r13
call _memcpy
inc r12
mov ecx, [rbp+var_60]
cmp r12, rcx
jb short loc_B0818
add ecx, ecx
jmp short loc_B088A
loc_B0888:
xor ecx, ecx
loc_B088A:
mov [rbp+var_60], ecx
mov [rbp+var_50], r15
mov ecx, ecx
mov qword ptr [r15+rcx*8], 0
loc_B089B:
lea rbx, my_defaults_file
mov rcx, [rbx]
test rcx, rcx
jnz loc_B099E
mov r13, [rbp+var_B0]
mov rdi, r13
call dirname_length
test rax, rax
jz short loc_B0900
lea rdi, [rbp+var_A0]
xor esi, esi
mov rdx, r13
call search_default_file
test eax, eax
jns loc_B09E6
loc_B08DB:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rdx, aFatalErrorInDe; "Fatal error in defaults handling. Progr"...
mov r14d, 1
mov esi, 1
xor eax, eax
call ___fprintf_chk
jmp short loc_B097F
loc_B0900:
mov rax, [rbp+var_38]
mov rsi, [rax]
test rsi, rsi
jz loc_B09E6
mov r14, [rbp+var_38]
add r14, 8
lea rbx, my_defaults_extra_file
lea r15, aUsageSOptions+15h; ""
lea r12, [rbp+var_A0]
loc_B092D:
cmp byte ptr [rsi], 0
jz short loc_B0943
mov rdi, r12
mov rdx, r13
call search_default_file
test eax, eax
jns short loc_B094B
jmp short loc_B08DB
loc_B0943:
mov rcx, [rbx]
test rcx, rcx
jnz short loc_B095C
loc_B094B:
mov rsi, [r14]
add r14, 8
test rsi, rsi
jnz short loc_B092D
jmp loc_B09E6
loc_B095C:
mov rdi, r12
mov rsi, r15
mov rdx, r15
xor r8d, r8d
call search_default_file_with_ext
test eax, eax
js loc_B08DB
jz short loc_B094B
jmp short loc_B09C1
loc_B0979:
mov r14d, 2
loc_B097F:
lea rdi, [rbp+var_88]
call delete_dynamic
lea rdi, [rbp+var_F0]
xor esi, esi
call free_root
jmp loc_B0589
loc_B099E:
lea rdx, aUsageSOptions+15h; ""
lea rdi, [rbp+var_A0]
mov rsi, rdx
xor r8d, r8d
call search_default_file_with_ext
test eax, eax
js loc_B08DB
jz short loc_B09E6
loc_B09C1:
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rcx, [rbx]
lea rdx, aCouldNotOpenRe; "Could not open required defaults file: "...
mov esi, 1
xor eax, eax
call ___fprintf_chk
jmp loc_B08DB
loc_B09E6:
mov rcx, [rbp+var_30]
jmp loc_B05D9
| long long my_load_defaults(_BYTE *a1, char *a2, int *a3, long long *a4, _QWORD *a5)
{
int defaults_options; // r14d
unsigned int v7; // r14d
_DWORD *v9; // rcx
char *v10; // rax
char *v11; // r15
const char **v12; // r12
long long v13; // rbx
long long v14; // rax
int *v15; // r13
const char ***v16; // r14
int v17; // eax
unsigned int v18; // eax
long long v19; // rcx
long long v21; // r14
__int128 v22; // xmm0
__int128 v23; // xmm1
__int128 v24; // xmm2
const char ***v25; // r15
long long v26; // r14
long long v27; // r13
char *v28; // rax
char *v29; // r15
long long v30; // r13
long long v31; // r12
long long v32; // rdi
long long v33; // r14
char *v34; // rax
char *v35; // rbx
unsigned int v36; // ecx
const char **v37; // rbx
_BYTE *v38; // r13
_BYTE *v39; // rsi
_BYTE **v40; // r14
int v41; // eax
int v42; // eax
_OWORD v43[4]; // [rsp+10h] [rbp-F0h] BYREF
_BYTE *v44; // [rsp+50h] [rbp-B0h]
_QWORD *v45; // [rsp+58h] [rbp-A8h]
long long v46[3]; // [rsp+60h] [rbp-A0h] BYREF
long long v47; // [rsp+78h] [rbp-88h] BYREF
unsigned int v48; // [rsp+80h] [rbp-80h]
unsigned int v49; // [rsp+A0h] [rbp-60h] BYREF
char *v50; // [rsp+A8h] [rbp-58h]
char *v51; // [rsp+B0h] [rbp-50h]
long long *v52; // [rsp+C0h] [rbp-40h]
_BYTE **inited; // [rsp+C8h] [rbp-38h]
int *v54; // [rsp+D0h] [rbp-30h]
v45 = a5;
v54 = a3;
v44 = a1;
init_alloc_root(key_memory_defaults, (long long *)v43, 512LL, 0LL, 0LL);
inited = (_BYTE **)init_default_directories(v43);
if ( !inited )
goto LABEL_3;
defaults_options = get_defaults_options(*a4);
if ( (unsigned __int8)init_dynamic_array2(key_memory_defaults, (long long)&v47, 8u, 0LL, 0x80u, 0x40u, 0LL) )
goto LABEL_3;
insert_dynamic((long long)&v47, *a4);
v9 = v54;
*v54 -= defaults_options;
v52 = a4;
*a4 += 8LL * defaults_options;
if ( my_no_defaults )
goto LABEL_6;
v49 = 0;
v50 = "defaults";
v51 = a2;
if ( *(_QWORD *)a2 )
{
v18 = 1;
v19 = 0LL;
do
v18 += 2;
while ( *(_QWORD *)&a2[8 * v19++ + 8] != 0LL );
v49 = v19;
v21 = 8LL * v18;
}
else
{
v21 = 8LL;
}
v46[0] = (long long)v43;
v46[1] = (long long)&v47;
v46[2] = (long long)&v49;
if ( my_defaults_group_suffix )
{
v27 = strlen(my_defaults_group_suffix);
v28 = alloc_root((long long)v43, v21);
v7 = 2;
if ( !v28 )
{
LABEL_49:
delete_dynamic(&v47);
free_root(v43, 0);
return v7;
}
v29 = v28;
if ( v49 )
{
v30 = v27 + 1;
v31 = 0LL;
while ( 1 )
{
v32 = *(_QWORD *)&v51[8 * v31];
*(_QWORD *)&v29[8 * v31] = v32;
v33 = strlen(v32);
v34 = alloc_root(v46[0], (unsigned int)(v33 + v30));
if ( !v34 )
break;
v35 = v34;
*(_QWORD *)&v29[8 * (unsigned int)v31 + 8 * v49] = v34;
memcpy(v34, *(_QWORD *)&v29[8 * v31], v33);
memcpy(&v35[v33], my_defaults_group_suffix, v30);
if ( ++v31 >= (unsigned long long)v49 )
{
v36 = 2 * v49;
goto LABEL_32;
}
}
v7 = 2;
goto LABEL_49;
}
v36 = 0;
LABEL_32:
v49 = v36;
v51 = v29;
*(_QWORD *)&v29[8 * v36] = 0LL;
}
v37 = &my_defaults_file;
if ( my_defaults_file )
{
v42 = search_default_file_with_ext((long long)v46, "", (int)"", (long long)my_defaults_file, 0);
if ( v42 < 0 )
goto LABEL_36;
if ( v42 )
{
LABEL_52:
__fprintf_chk(stderr, 1LL, "Could not open required defaults file: %s\n", *v37);
goto LABEL_36;
}
}
else
{
v38 = v44;
if ( dirname_length(v44) )
{
if ( (int)search_default_file(v46, 0LL, v38) < 0 )
{
LABEL_36:
v7 = 1;
__fprintf_chk(stderr, 1LL, "Fatal error in defaults handling. Program aborted\n");
goto LABEL_49;
}
}
else
{
v39 = *inited;
if ( *inited )
{
v40 = inited + 1;
v37 = &my_defaults_extra_file;
do
{
if ( *v39 )
{
if ( (int)search_default_file(v46, v39, v38) < 0 )
goto LABEL_36;
}
else if ( my_defaults_extra_file )
{
v41 = search_default_file_with_ext((long long)v46, "", (int)"", (long long)my_defaults_extra_file, 0);
if ( v41 < 0 )
goto LABEL_36;
if ( v41 )
goto LABEL_52;
}
v39 = *v40++;
}
while ( v39 );
}
}
}
v9 = v54;
LABEL_6:
v10 = alloc_root((long long)v43, 8LL * (*v9 + v48 + 3) + 64);
if ( !v10 )
{
LABEL_3:
__fprintf_chk(stderr, 1LL, "Fatal error in defaults handling. Program aborted\n");
return 2;
}
v11 = v10;
v12 = (const char **)(v10 + 64);
v13 = v48;
memcpy(v10 + 64, v47, 8LL * v48);
if ( my_defaults_mark_files )
{
v48 = v13 + 1;
v12[v13] = file_marker[0];
v14 = v48++;
v12[v14] = "";
LODWORD(v13) = v48;
}
v15 = v54;
if ( *v54 )
{
v16 = (const char ***)v52;
memcpy(&v12[(unsigned int)v13], *v52, 8LL * *v54);
LODWORD(v13) = v48;
v17 = *v15;
}
else
{
v17 = 0;
v16 = (const char ***)v52;
}
*v15 = v13 + v17;
*v16 = v12;
*(_QWORD *)&v11[8 * *v15 + 64] = 0LL;
v22 = v43[0];
v23 = v43[1];
v24 = v43[2];
*((_OWORD *)v11 + 3) = v43[3];
*((_OWORD *)v11 + 2) = v24;
*((_OWORD *)v11 + 1) = v23;
*(_OWORD *)v11 = v22;
delete_dynamic(&v47);
if ( my_print_defaults )
{
v25 = v16;
__printf_chk(1LL, "%s would have been started with the following arguments:\n", **v16);
if ( *v15 >= 2 )
{
v26 = 1LL;
do
__printf_chk(1LL, "%s ", (*v25)[v26++]);
while ( v26 < *v15 );
}
putchar(10LL);
return 4;
}
else
{
v7 = 0;
if ( v45 )
*v45 = inited;
}
return v7;
}
| my_load_defaults:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RBP + -0xa8],R8
MOV R12,RCX
MOV qword ptr [RBP + -0x30],RDX
MOV R13,RSI
MOV qword ptr [RBP + -0xb0],RDI
LEA RBX,[0xd147f8]
MOV EDI,dword ptr [RBX]
LEA R15,[RBP + -0xf0]
MOV EDX,0x200
MOV RSI,R15
XOR ECX,ECX
XOR R8D,R8D
CALL 0x001a1938
MOV RDI,R15
CALL 0x001b09ef
MOV qword ptr [RBP + -0x38],RAX
TEST RAX,RAX
JZ 0x001b0566
MOV RDI,qword ptr [R12]
CALL 0x001b0304
MOV R14D,EAX
MOV EDI,dword ptr [RBX]
MOV qword ptr [RSP],0x0
LEA RSI,[RBP + -0x88]
MOV EDX,0x8
XOR ECX,ECX
MOV R8D,0x80
MOV R9D,0x40
CALL 0x0019691c
TEST AL,AL
JZ 0x001b059e
LAB_001b0566:
MOV RAX,qword ptr [0x0048dfb0]
MOV RDI,qword ptr [RAX]
LEA RDX,[0x1e5890]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0012a1e0
MOV R14D,0x2
LAB_001b0589:
MOV EAX,R14D
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b059e:
MOV RSI,qword ptr [R12]
MOV RBX,R12
LEA R12,[RBP + -0x88]
MOV RDI,R12
CALL 0x001969ba
MOV RCX,qword ptr [RBP + -0x30]
SUB dword ptr [RCX],R14D
MOVSXD RAX,R14D
SHL RAX,0x3
MOV qword ptr [RBP + -0x40],RBX
ADD qword ptr [RBX],RAX
LEA RAX,[0xd14f61]
CMP byte ptr [RAX],0x0
JZ 0x001b0682
LAB_001b05d9:
MOV EAX,dword ptr [RBP + -0x80]
MOV ECX,dword ptr [RCX]
ADD EAX,ECX
ADD EAX,0x3
LEA RSI,[0x40 + RAX*0x8]
LEA RDI,[RBP + -0xf0]
CALL 0x001a1a8f
TEST RAX,RAX
JZ 0x001b0566
MOV R15,RAX
LEA R12,[RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x88]
MOV EBX,dword ptr [RBP + -0x80]
LEA RDX,[RBX*0x8]
MOV RDI,R12
CALL 0x0012a0a0
LEA RAX,[0xd14f60]
CMP byte ptr [RAX],0x0
JZ 0x001b0656
MOV RAX,qword ptr [0x00490ee8]
MOV ECX,EBX
INC ECX
MOV dword ptr [RBP + -0x80],ECX
MOV qword ptr [R12 + RBX*0x8],RAX
MOV EAX,dword ptr [RBP + -0x80]
LEA ECX,[RAX + 0x1]
MOV dword ptr [RBP + -0x80],ECX
LEA RCX,[0x1e1a1f]
MOV qword ptr [R12 + RAX*0x8],RCX
MOV EBX,dword ptr [RBP + -0x80]
LAB_001b0656:
MOV R13,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [R13]
TEST RDX,RDX
JZ 0x001b06c8
MOV EAX,EBX
LEA RDI,[R12 + RAX*0x8]
MOV R14,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [R14]
SHL RDX,0x3
CALL 0x0012a0a0
MOV EBX,dword ptr [RBP + -0x80]
MOV EAX,dword ptr [R13]
JMP 0x001b06ce
LAB_001b0682:
MOV dword ptr [RBP + -0x60],0x0
LEA RAX,[0x1e57e8]
MOV qword ptr [RBP + -0x58],RAX
MOV qword ptr [RBP + -0x50],R13
CMP qword ptr [R13],0x0
JZ 0x001b07b1
MOV EAX,0x1
XOR ECX,ECX
LAB_001b06aa:
ADD EAX,0x2
CMP qword ptr [R13 + RCX*0x8 + 0x8],0x0
LEA RCX,[RCX + 0x1]
JNZ 0x001b06aa
MOV dword ptr [RBP + -0x60],ECX
MOV R14D,EAX
SHL R14,0x3
JMP 0x001b07b7
LAB_001b06c8:
XOR EAX,EAX
MOV R14,qword ptr [RBP + -0x40]
LAB_001b06ce:
ADD EAX,EBX
MOV dword ptr [R13],EAX
MOV qword ptr [R14],R12
MOVSXD RAX,dword ptr [R13]
MOV qword ptr [R15 + RAX*0x8 + 0x40],0x0
MOVUPS XMM0,xmmword ptr [RBP + -0xf0]
MOVUPS XMM1,xmmword ptr [RBP + -0xe0]
MOVUPS XMM2,xmmword ptr [RBP + -0xd0]
MOVUPS XMM3,xmmword ptr [RBP + -0xc0]
MOVUPS xmmword ptr [R15 + 0x30],XMM3
MOVUPS xmmword ptr [R15 + 0x20],XMM2
MOVUPS xmmword ptr [R15 + 0x10],XMM1
MOVUPS xmmword ptr [R15],XMM0
LEA RDI,[RBP + -0x88]
CALL 0x00196c14
LEA RAX,[0xd14f62]
CMP byte ptr [RAX],0x0
JZ 0x001b0792
MOV R15,R14
MOV RAX,qword ptr [R14]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x1e5856]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x0012a800
CMP dword ptr [R13],0x2
JL 0x001b077d
MOV R14D,0x1
LEA RBX,[0x1e4ce6]
LAB_001b075b:
MOV RAX,qword ptr [R15]
MOV RDX,qword ptr [RAX + R14*0x8]
MOV EDI,0x1
MOV RSI,RBX
XOR EAX,EAX
CALL 0x0012a800
INC R14
MOVSXD RAX,dword ptr [R13]
CMP R14,RAX
JL 0x001b075b
LAB_001b077d:
MOV EDI,0xa
CALL 0x0012a910
MOV R14D,0x4
JMP 0x001b0589
LAB_001b0792:
XOR R14D,R14D
MOV RAX,qword ptr [RBP + -0xa8]
TEST RAX,RAX
JZ 0x001b0589
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
JMP 0x001b0589
LAB_001b07b1:
MOV R14D,0x8
LAB_001b07b7:
MOV qword ptr [RBP + -0xa0],R15
MOV qword ptr [RBP + -0x98],R12
LEA RAX,[RBP + -0x60]
MOV qword ptr [RBP + -0x90],RAX
LEA RAX,[0xd14f70]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x001b089b
CALL 0x0012a320
MOV R13,RAX
LEA RDI,[RBP + -0xf0]
MOV RSI,R14
CALL 0x001a1a8f
MOV R14D,0x2
TEST RAX,RAX
JZ 0x001b097f
MOV R15,RAX
CMP dword ptr [RBP + -0x60],0x0
JZ 0x001b0888
INC R13
XOR R12D,R12D
LAB_001b0818:
MOV RCX,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RCX + R12*0x8]
MOV qword ptr [R15 + R12*0x8],RDI
CALL 0x0012a320
MOV R14,RAX
MOV RDI,qword ptr [RBP + -0xa0]
LEA ESI,[RAX + R13*0x1]
CALL 0x001a1a8f
TEST RAX,RAX
JZ 0x001b0979
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,R12D
MOV qword ptr [R15 + RAX*0x8],RBX
MOV RSI,qword ptr [R15 + R12*0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x0012a0a0
ADD RBX,R14
LEA RAX,[0xd14f70]
MOV RSI,qword ptr [RAX]
MOV RDI,RBX
MOV RDX,R13
CALL 0x0012a0a0
INC R12
MOV ECX,dword ptr [RBP + -0x60]
CMP R12,RCX
JC 0x001b0818
ADD ECX,ECX
JMP 0x001b088a
LAB_001b0888:
XOR ECX,ECX
LAB_001b088a:
MOV dword ptr [RBP + -0x60],ECX
MOV qword ptr [RBP + -0x50],R15
MOV ECX,ECX
MOV qword ptr [R15 + RCX*0x8],0x0
LAB_001b089b:
LEA RBX,[0xd14f68]
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JNZ 0x001b099e
MOV R13,qword ptr [RBP + -0xb0]
MOV RDI,R13
CALL 0x001996f4
TEST RAX,RAX
JZ 0x001b0900
LEA RDI,[RBP + -0xa0]
XOR ESI,ESI
MOV RDX,R13
CALL 0x001b0db2
TEST EAX,EAX
JNS 0x001b09e6
LAB_001b08db:
MOV RAX,qword ptr [0x0048dfb0]
MOV RDI,qword ptr [RAX]
LEA RDX,[0x1e5890]
MOV R14D,0x1
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0012a1e0
JMP 0x001b097f
LAB_001b0900:
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX]
TEST RSI,RSI
JZ 0x001b09e6
MOV R14,qword ptr [RBP + -0x38]
ADD R14,0x8
LEA RBX,[0xd14f78]
LEA R15,[0x1e1a1f]
LEA R12,[RBP + -0xa0]
LAB_001b092d:
CMP byte ptr [RSI],0x0
JZ 0x001b0943
MOV RDI,R12
MOV RDX,R13
CALL 0x001b0db2
TEST EAX,EAX
JNS 0x001b094b
JMP 0x001b08db
LAB_001b0943:
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JNZ 0x001b095c
LAB_001b094b:
MOV RSI,qword ptr [R14]
ADD R14,0x8
TEST RSI,RSI
JNZ 0x001b092d
JMP 0x001b09e6
LAB_001b095c:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R15
XOR R8D,R8D
CALL 0x00131066
TEST EAX,EAX
JS 0x001b08db
JZ 0x001b094b
JMP 0x001b09c1
LAB_001b0979:
MOV R14D,0x2
LAB_001b097f:
LEA RDI,[RBP + -0x88]
CALL 0x00196c14
LEA RDI,[RBP + -0xf0]
XOR ESI,ESI
CALL 0x001a1d07
JMP 0x001b0589
LAB_001b099e:
LEA RDX,[0x1e1a1f]
LEA RDI,[RBP + -0xa0]
MOV RSI,RDX
XOR R8D,R8D
CALL 0x00131066
TEST EAX,EAX
JS 0x001b08db
JZ 0x001b09e6
LAB_001b09c1:
MOV RAX,qword ptr [0x0048dfb0]
MOV RDI,qword ptr [RAX]
MOV RCX,qword ptr [RBX]
LEA RDX,[0x1e5b87]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x0012a1e0
JMP 0x001b08db
LAB_001b09e6:
MOV RCX,qword ptr [RBP + -0x30]
JMP 0x001b05d9
|
int8
my_load_defaults(int8 param_1,long *param_2,int *param_3,long *param_4,int8 *param_5)
{
int4 *__dest;
long lVar1;
int *piVar2;
char cVar3;
int iVar4;
uint uVar5;
int4 *puVar6;
size_t sVar7;
long *plVar8;
size_t __n;
void *__dest_00;
int8 *puVar9;
char *pcVar10;
ulong uVar11;
long lVar12;
int8 uVar13;
int8 *puVar14;
int4 local_f8;
int4 uStack_f4;
int4 uStack_f0;
int4 uStack_ec;
int4 local_e8;
int4 uStack_e4;
int4 uStack_e0;
int4 uStack_dc;
int4 local_d8;
int4 uStack_d4;
int4 uStack_d0;
int4 uStack_cc;
int4 local_c8;
int4 uStack_c4;
int4 uStack_c0;
int4 uStack_bc;
int8 local_b8;
int8 *local_b0;
int4 *local_a8;
void **local_a0;
uint *local_98;
void *local_90;
uint local_88;
uint local_68 [2];
char *local_60;
long *local_58;
long *local_48;
int8 *local_40;
int *local_38;
local_b8 = param_1;
local_b0 = param_5;
local_38 = param_3;
init_alloc_root(key_memory_defaults,&local_f8,0x200,0,0);
local_40 = (int8 *)init_default_directories(&local_f8);
if (local_40 == (int8 *)0x0) goto LAB_001b0566;
iVar4 = get_defaults_options(*param_4);
cVar3 = init_dynamic_array2(key_memory_defaults,&local_90,8,0,0x80,0x40,0);
if (cVar3 != '\0') goto LAB_001b0566;
insert_dynamic(&local_90,*param_4);
*local_38 = *local_38 - iVar4;
*param_4 = *param_4 + (long)iVar4 * 8;
local_48 = param_4;
if (my_no_defaults == '\0') {
local_68[0] = 0;
local_60 = "defaults";
if (*param_2 == 0) {
lVar12 = 8;
}
else {
uVar5 = 1;
lVar12 = 0;
do {
uVar5 = uVar5 + 2;
lVar1 = lVar12 + 1;
lVar12 = lVar12 + 1;
} while (param_2[lVar1] != 0);
local_68[0] = (uint)lVar12;
lVar12 = (ulong)uVar5 << 3;
}
local_98 = local_68;
local_a8 = &local_f8;
local_a0 = &local_90;
local_58 = param_2;
if (my_defaults_group_suffix != (char *)0x0) {
local_58 = param_2;
sVar7 = strlen(my_defaults_group_suffix);
plVar8 = (long *)alloc_root(&local_f8,lVar12);
uVar13 = 2;
if (plVar8 == (long *)0x0) goto LAB_001b097f;
if (local_68[0] == 0) {
local_68[0] = 0;
}
else {
uVar11 = 0;
do {
pcVar10 = (char *)local_58[uVar11];
plVar8[uVar11] = (long)pcVar10;
__n = strlen(pcVar10);
__dest_00 = (void *)alloc_root(local_a8,(int)__n + (int)(sVar7 + 1));
if (__dest_00 == (void *)0x0) {
uVar13 = 2;
goto LAB_001b097f;
}
plVar8[local_68[0] + (int)uVar11] = (long)__dest_00;
memcpy(__dest_00,(void *)plVar8[uVar11],__n);
memcpy((void *)((long)__dest_00 + __n),my_defaults_group_suffix,sVar7 + 1);
uVar11 = uVar11 + 1;
} while (uVar11 < local_68[0]);
local_68[0] = local_68[0] * 2;
}
plVar8[local_68[0]] = 0;
local_58 = plVar8;
}
uVar13 = local_b8;
puVar9 = &my_defaults_file;
if (my_defaults_file != 0) {
iVar4 = search_default_file_with_ext(&local_a8,"","",my_defaults_file,0);
if (-1 < iVar4) {
if (iVar4 == 0) goto LAB_001b05d9;
LAB_001b09c1:
__fprintf_chk(*(int8 *)PTR_stderr_0048dfb0,1,
"Could not open required defaults file: %s\n",*puVar9);
}
LAB_001b08db:
uVar13 = 1;
__fprintf_chk(*(int8 *)PTR_stderr_0048dfb0,1,
"Fatal error in defaults handling. Program aborted\n");
LAB_001b097f:
delete_dynamic(&local_90);
free_root(&local_f8,0);
return uVar13;
}
lVar12 = dirname_length(local_b8);
if (lVar12 == 0) {
pcVar10 = (char *)*local_40;
if (pcVar10 != (char *)0x0) {
puVar9 = &my_defaults_extra_file;
puVar14 = local_40;
do {
puVar14 = puVar14 + 1;
if (*pcVar10 == '\0') {
if (my_defaults_extra_file != 0) {
iVar4 = search_default_file_with_ext(&local_a8,"","",my_defaults_extra_file,0);
if (iVar4 < 0) goto LAB_001b08db;
if (iVar4 != 0) goto LAB_001b09c1;
}
}
else {
iVar4 = search_default_file(&local_a8,pcVar10,uVar13);
if (iVar4 < 0) goto LAB_001b08db;
}
pcVar10 = (char *)*puVar14;
} while (pcVar10 != (char *)0x0);
}
}
else {
iVar4 = search_default_file(&local_a8,0,uVar13);
if (iVar4 < 0) goto LAB_001b08db;
}
}
LAB_001b05d9:
puVar6 = (int4 *)alloc_root(&local_f8,(ulong)(local_88 + *local_38 + 3) * 8 + 0x40);
uVar5 = local_88;
if (puVar6 != (int4 *)0x0) {
__dest = puVar6 + 0x10;
uVar11 = (ulong)local_88;
memcpy(__dest,local_90,uVar11 * 8);
piVar2 = local_38;
plVar8 = local_48;
if (my_defaults_mark_files != '\0') {
*(int **)(__dest + uVar11 * 2) = file_marker;
local_88 = uVar5 + 2;
*(char **)(__dest + (ulong)(uVar5 + 1) * 2) = "";
uVar11 = (ulong)local_88;
}
uVar5 = (uint)uVar11;
if ((long)*local_38 == 0) {
iVar4 = 0;
}
else {
memcpy(__dest + uVar11 * 2,(void *)*local_48,(long)*local_38 << 3);
iVar4 = *piVar2;
uVar5 = local_88;
}
*piVar2 = iVar4 + uVar5;
*plVar8 = (long)__dest;
*(int8 *)(puVar6 + (long)*piVar2 * 2 + 0x10) = 0;
puVar6[0xc] = local_c8;
puVar6[0xd] = uStack_c4;
puVar6[0xe] = uStack_c0;
puVar6[0xf] = uStack_bc;
puVar6[8] = local_d8;
puVar6[9] = uStack_d4;
puVar6[10] = uStack_d0;
puVar6[0xb] = uStack_cc;
puVar6[4] = local_e8;
puVar6[5] = uStack_e4;
puVar6[6] = uStack_e0;
puVar6[7] = uStack_dc;
*puVar6 = local_f8;
puVar6[1] = uStack_f4;
puVar6[2] = uStack_f0;
puVar6[3] = uStack_ec;
delete_dynamic(&local_90);
if (my_print_defaults != '\0') {
__printf_chk(1,"%s would have been started with the following arguments:\n",
*(int8 *)*plVar8);
if (1 < *piVar2) {
lVar12 = 1;
do {
__printf_chk(1,&DAT_001e4ce6,*(int8 *)(*plVar8 + lVar12 * 8));
lVar12 = lVar12 + 1;
} while (lVar12 < *piVar2);
}
putchar(10);
return 4;
}
if (local_b0 == (int8 *)0x0) {
return 0;
}
*local_b0 = local_40;
return 0;
}
LAB_001b0566:
__fprintf_chk(*(int8 *)PTR_stderr_0048dfb0,1,
"Fatal error in defaults handling. Program aborted\n");
return 2;
}
|
|
2,630 | mysql_load_plugin | eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c | struct st_mysql_client_plugin * STDCALL
mysql_load_plugin(MYSQL *mysql, const char *name, int type, int argc, ...)
{
struct st_mysql_client_plugin *p;
va_list args;
va_start(args, argc);
p= mysql_load_plugin_v(mysql, name, type, argc, args);
va_end(args);
return p;
} | O3 | c | mysql_load_plugin:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x2a775
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %r8
movq %r10, 0x10(%r8)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000020, %rax # imm = 0x3000000020
movq %rax, (%r8)
callq 0x2a48b
addq $0xd0, %rsp
popq %rbp
retq
| mysql_load_plugin:
push rbp
mov rbp, rsp
sub rsp, 0D0h
lea r10, [rbp+var_D0]
mov [r10+20h], r8
mov [r10+28h], r9
test al, al
jz short loc_2A775
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_2A775:
lea r8, [rbp+var_20]
mov [r8+10h], r10
lea rax, [rbp+arg_0]
mov [r8+8], rax
mov rax, 3000000020h
mov [r8], rax
call mysql_load_plugin_v
add rsp, 0D0h
pop rbp
retn
| long long mysql_load_plugin(
long long a1,
const char *a2,
int a3,
unsigned int a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+20h] [rbp-B0h]
long long v18; // [rsp+28h] [rbp-A8h]
__m128 v19; // [rsp+30h] [rbp-A0h]
__m128 v20; // [rsp+40h] [rbp-90h]
__m128 v21; // [rsp+50h] [rbp-80h]
__m128 v22; // [rsp+60h] [rbp-70h]
__m128 v23; // [rsp+70h] [rbp-60h]
__m128 v24; // [rsp+80h] [rbp-50h]
__m128 v25; // [rsp+90h] [rbp-40h]
__m128 v26; // [rsp+A0h] [rbp-30h]
_QWORD v27[4]; // [rsp+B0h] [rbp-20h] BYREF
v19 = a7;
v20 = a8;
v21 = a9;
v22 = a10;
v23 = a11;
v24 = a12;
v25 = a13;
v26 = a14;
v17 = a5;
v18 = a6;
v27[2] = &v16;
v27[1] = &a15;
v27[0] = 0x3000000020LL;
return mysql_load_plugin_v(a1, a2, a3, a4, (long long)v27);
}
| mysql_load_plugin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
LEA R10,[RBP + -0xd0]
MOV qword ptr [R10 + 0x20],R8
MOV qword ptr [R10 + 0x28],R9
TEST AL,AL
JZ 0x0012a775
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0012a775:
LEA R8,[RBP + -0x20]
MOV qword ptr [R8 + 0x10],R10
LEA RAX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RAX
MOV RAX,0x3000000020
MOV qword ptr [R8],RAX
CALL 0x0012a48b
ADD RSP,0xd0
POP RBP
RET
|
void mysql_load_plugin(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8)
{
char in_AL;
int8 in_R8;
int8 in_R9;
int1 local_d8 [32];
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000020;
local_b8 = in_R8;
local_b0 = in_R9;
mysql_load_plugin_v();
return;
}
|
|
2,631 | minja::Parser::parseMathUnaryPlusMinus() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseMathUnaryPlusMinus() {
static std::regex unary_plus_minus_tok(R"(\+|-(?![}%#]\}))");
auto op_str = consumeToken(unary_plus_minus_tok);
auto expr = parseExpansion();
if (!expr) throw std::runtime_error("Expected expr of 'unary plus/minus/expansion' expression");
if (!op_str.empty()) {
auto op = op_str == "+" ? UnaryOpExpr::Op::Plus : UnaryOpExpr::Op::Minus;
return std::make_shared<UnaryOpExpr>(get_location(), std::move(expr), op);
}
return expr;
} | O0 | cpp | minja::Parser::parseMathUnaryPlusMinus():
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x18de50(%rip), %rax # 0x2a62e8
cmpb $0x0, (%rax)
jne 0x1184ee
leaq 0x18de44(%rip), %rdi # 0x2a62e8
callq 0x5a600
cmpl $0x0, %eax
je 0x1184ee
leaq 0x18de13(%rip), %rdi # 0x2a62c8
leaq 0xfab50(%rip), %rsi # 0x21300c
movl $0x10, %edx
callq 0xc00b0
jmp 0x1184c8
leaq -0x57f3f(%rip), %rdi # 0xc0590
leaq 0x18ddf2(%rip), %rsi # 0x2a62c8
leaq 0x18d5db(%rip), %rdx # 0x2a5ab8
callq 0x5af50
leaq 0x18ddff(%rip), %rdi # 0x2a62e8
callq 0x5aa00
movq 0x28(%rsp), %rsi
leaq 0x18ddce(%rip), %rdx # 0x2a62c8
leaq 0x78(%rsp), %rdi
movl $0x1, %ecx
callq 0x10dad0
movq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x118910
jmp 0x11851a
leaq 0x68(%rsp), %rdi
callq 0x10dcb0
testb $0x1, %al
jne 0x1185e6
movl $0x10, %edi
callq 0x5a690
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0xfabae(%rip), %rsi # 0x2130f6
callq 0x5a480
jmp 0x11854f
movq 0x10(%rsp), %rdi
movq 0x18ca55(%rip), %rsi # 0x2a4fb0
movq 0x18ca16(%rip), %rdx # 0x2a4f78
callq 0x5ab00
jmp 0x1186f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x18dd61(%rip), %rdi # 0x2a62e8
callq 0x5a720
jmp 0x1186e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1186da
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
callq 0x5af70
jmp 0x1186d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1186d0
leaq 0x78(%rsp), %rdi
callq 0x5a4f0
testb $0x1, %al
jne 0x118698
leaq 0xfb5a5(%rip), %rsi # 0x213ba4
leaq 0x78(%rsp), %rdi
callq 0x8df00
movb %al, 0xf(%rsp)
jmp 0x11860f
movq 0x28(%rsp), %rsi
movb 0xf(%rsp), %al
notb %al
movzbl %al, %eax
andl $0x1, %eax
movl %eax, 0x64(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x10d0b0
jmp 0x118630
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x64(%rsp), %rcx
callq 0x118bb0
jmp 0x11864b
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1128a0
leaq 0x50(%rsp), %rdi
callq 0x1128d0
leaq 0x38(%rsp), %rdi
callq 0x110670
movl $0x1, 0x34(%rsp)
jmp 0x1186af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x110670
jmp 0x1186d0
movq 0x18(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x111db0
movl $0x1, 0x34(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x10dac0
leaq 0x78(%rsp), %rdi
callq 0x5b568
movq 0x20(%rsp), %rax
addq $0xb8, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0x10dac0
leaq 0x78(%rsp), %rdi
callq 0x5b568
movq 0xa0(%rsp), %rdi
callq 0x5abc0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN5minja6Parser23parseMathUnaryPlusMinusEv:
sub rsp, 0B8h
mov [rsp+0B8h+var_A0], rdi
mov rax, rdi
mov [rsp+0B8h+var_98], rax
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_10], rsi
mov rax, [rsp+0B8h+var_10]
mov [rsp+0B8h+var_90], rax
lea rax, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; `guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
cmp byte ptr [rax], 0
jnz short loc_1184EE
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_1184EE
lea rdi, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
lea rsi, asc_21300C; "\\+|-(?![}%#]\\})"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
jmp short $+2
loc_1184C8:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_release
loc_1184EE:
mov rsi, [rsp+0B8h+var_90]
lea rdx, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
lea rdi, [rsp+0B8h+var_40]
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
mov rsi, [rsp+0B8h+var_90]
lea rdi, [rsp+0B8h+var_50]; this
call _ZN5minja6Parser14parseExpansionEv; minja::Parser::parseExpansion(void)
jmp short $+2
loc_11851A:
lea rdi, [rsp+0B8h+var_50]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_1185E6
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
lea rsi, aExpectedExprOf; "Expected expr of 'unary plus/minus/expa"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_11854F:
mov rdi, [rsp+0B8h+var_A8]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_1186F1
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_1186E4
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp loc_1186DA
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
call ___cxa_free_exception
jmp loc_1186D0
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp loc_1186D0
loc_1185E6:
lea rdi, [rsp+0B8h+var_40]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz loc_118698
lea rsi, aSRN_0+0Bh; "+"
lea rdi, [rsp+0B8h+var_40]
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+0B8h+var_A9], al
jmp short $+2
loc_11860F:
mov rsi, [rsp+0B8h+var_90]
mov al, [rsp+0B8h+var_A9]
not al
movzx eax, al
and eax, 1
mov [rsp+0B8h+var_54], eax
lea rdi, [rsp+0B8h+var_80]; this
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
jmp short $+2
loc_118630:
lea rdi, [rsp+0B8h+var_68]
lea rsi, [rsp+0B8h+var_80]
lea rdx, [rsp+0B8h+var_50]
lea rcx, [rsp+0B8h+var_54]
call _ZSt11make_sharedIN5minja11UnaryOpExprEJNS0_8LocationESt10shared_ptrINS0_10ExpressionEERNS1_2OpEEES3_IT_EDpOT0_; std::make_shared<minja::UnaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &>(minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &)
jmp short $+2
loc_11864B:
mov rdi, [rsp+0B8h+var_A0]
lea rsi, [rsp+0B8h+var_68]
call _ZNSt10shared_ptrIN5minja10ExpressionEEC2INS0_11UnaryOpExprEvEEOS_IT_E; std::shared_ptr<minja::Expression>::shared_ptr<minja::UnaryOpExpr,void>(std::shared_ptr&&<minja::UnaryOpExpr>)
lea rdi, [rsp+0B8h+var_68]
call _ZNSt10shared_ptrIN5minja11UnaryOpExprEED2Ev; std::shared_ptr<minja::UnaryOpExpr>::~shared_ptr()
lea rdi, [rsp+0B8h+var_80]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
mov [rsp+0B8h+var_84], 1
jmp short loc_1186AF
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_30]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
jmp short loc_1186D0
loc_118698:
mov rdi, [rsp+0B8h+var_A0]
lea rsi, [rsp+0B8h+var_50]
call _ZNSt10shared_ptrIN5minja10ExpressionEEC2EOS2_; std::shared_ptr<minja::Expression>::shared_ptr(std::shared_ptr<minja::Expression>&&)
mov [rsp+0B8h+var_84], 1
loc_1186AF:
lea rdi, [rsp+0B8h+var_50]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
lea rdi, [rsp+0B8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rsp+0B8h+var_98]
add rsp, 0B8h
retn
loc_1186D0:
lea rdi, [rsp+arg_60]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
loc_1186DA:
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1186E4:
mov rdi, [rsp+arg_98]
call __Unwind_Resume
loc_1186F1:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
| minja::Parser * minja::Parser::parseMathUnaryPlusMinus(minja::Parser *this, long long a2)
{
int v2; // r8d
int v3; // r9d
std::runtime_error *exception; // [rsp+10h] [rbp-A8h]
_BYTE v6[24]; // [rsp+38h] [rbp-80h] BYREF
_BYTE v7[20]; // [rsp+50h] [rbp-68h] BYREF
BOOL v8; // [rsp+64h] [rbp-54h] BYREF
_QWORD v9[2]; // [rsp+68h] [rbp-50h] BYREF
_BYTE v10[48]; // [rsp+78h] [rbp-40h] BYREF
long long v11; // [rsp+A8h] [rbp-10h]
minja::Parser *v12; // [rsp+B0h] [rbp-8h]
v12 = this;
v11 = a2;
if ( !(_BYTE)`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
(long long)"\\+|-(?![}%#]\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)v10,
a2,
(long long)&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
1u);
minja::Parser::parseExpansion((minja::Parser *)v9);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(v9) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected expr of 'unary plus/minus/expansion' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (std::string::empty(v10) & 1) != 0 )
{
std::shared_ptr<minja::Expression>::shared_ptr((long long)this, (long long)v9);
}
else
{
v8 = !std::operator==<char>((long long)v10, (long long)"+");
minja::Parser::get_location((minja::Parser *)v6, a2);
std::make_shared<minja::UnaryOpExpr,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &>(
(unsigned int)v7,
(unsigned int)v6,
(unsigned int)v9,
(unsigned int)&v8,
v2,
v3);
std::shared_ptr<minja::Expression>::shared_ptr<minja::UnaryOpExpr,void>((long long)this, (long long)v7);
std::shared_ptr<minja::UnaryOpExpr>::~shared_ptr((long long)v7);
minja::Location::~Location((minja::Location *)v6);
}
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v9);
std::string::~string(v10);
return this;
}
| |||
2,632 | minja::Parser::parseMathUnaryPlusMinus() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseMathUnaryPlusMinus() {
static std::regex unary_plus_minus_tok(R"(\+|-(?![}%#]\}))");
auto op_str = consumeToken(unary_plus_minus_tok);
auto expr = parseExpansion();
if (!expr) throw std::runtime_error("Expected expr of 'unary plus/minus/expansion' expression");
if (!op_str.empty()) {
auto op = op_str == "+" ? UnaryOpExpr::Op::Plus : UnaryOpExpr::Op::Minus;
return std::make_shared<UnaryOpExpr>(get_location(), std::move(expr), op);
}
return expr;
} | O1 | cpp | minja::Parser::parseMathUnaryPlusMinus():
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa6594(%rip), %rax # 0x130108
movb (%rax), %al
testb %al, %al
je 0x89cb2
leaq 0xa6563(%rip), %rdx # 0x1300e8
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x84f66
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x89e30
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x89d09
cmpq $0x0, 0x38(%rsp)
je 0x89bfd
leaq 0x6a61c(%rip), %rsi # 0xf41dd
leaq 0x30(%rsp), %rdi
callq 0x1b220
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
movl %ecx, 0x1c(%rsp)
movq (%r14), %rax
movq %rax, 0x50(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x89c1f
movq 0xa5395(%rip), %rcx # 0x12ef88
cmpb $0x0, (%rcx)
je 0x89c1b
incl 0x8(%rax)
jmp 0x89c1f
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x10(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsp)
jmp 0x89c7d
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
leaq 0x50(%rsp), %rcx
movq %rax, 0x10(%rcx)
leaq 0x28(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x20(%rsp), %rsi
leaq 0x7(%rsp), %rdx
leaq 0x8(%rsp), %r8
leaq 0x1c(%rsp), %r9
callq 0x96940
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movaps 0x20(%rsp), %xmm0
movq %rax, 0x28(%rsp)
movups %xmm0, (%rbx)
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x89c7d
callq 0x6e1aa
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x89c8c
callq 0x6e1aa
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x89ca7
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0xa644f(%rip), %rdi # 0x130108
callq 0x1c010
testl %eax, %eax
je 0x89b7e
leaq 0xa641b(%rip), %rdi # 0x1300e8
leaq 0x69971(%rip), %rsi # 0xf3645
movl $0x10, %edx
callq 0x631da
leaq -0x26803(%rip), %rdi # 0x634e2
leaq 0xa63fc(%rip), %rsi # 0x1300e8
leaq 0xa5be5(%rip), %rdx # 0x12f8d8
callq 0x1b7c0
leaq 0xa6409(%rip), %rdi # 0x130108
callq 0x1b5c0
jmp 0x89b7e
movl $0x10, %edi
callq 0x1b450
movq %rax, %r14
leaq 0x69a12(%rip), %rsi # 0xf372f
movq %rax, %rdi
callq 0x1b330
movq 0xa52c4(%rip), %rsi # 0x12eff0
movq 0xa522d(%rip), %rdx # 0x12ef60
movq %r14, %rdi
callq 0x1bf30
movq %rax, %rbx
leaq 0xa63c3(%rip), %rdi # 0x130108
callq 0x1b5b0
jmp 0x89d9f
movq %rax, %rbx
jmp 0x89d70
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b690
jmp 0x89d70
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x89d70
callq 0x6e1aa
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x89d84
callq 0x6e1aa
jmp 0x89d84
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x89d9f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1b8f0
movq %rbx, %rdi
callq 0x1bfb0
nop
| _ZN5minja6Parser23parseMathUnaryPlusMinusEv:
push r14
push rbx
sub rsp, 68h
mov r14, rsi
mov rbx, rdi
lea rax, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; `guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
mov al, [rax]
test al, al
jz loc_89CB2
loc_89B7E:
lea rdx, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
lea rdi, [rsp+78h+var_48]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rdi, [rsp+78h+var_70]; this
mov rsi, r14
call _ZN5minja6Parser14parseExpansionEv; minja::Parser::parseExpansion(void)
mov rax, [rsp+78h+var_70]
test rax, rax
jz loc_89D09
cmp [rsp+78h+var_40], 0
jz short loc_89BFD
lea rsi, aSRN_0+0Bh; "+"
lea rdi, [rsp+78h+var_48]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
xor ecx, ecx
test eax, eax
setnz cl
mov [rsp+78h+var_5C], ecx
mov rax, [r14]
mov [rsp+78h+var_28], rax
mov rax, [r14+8]
mov [rsp+78h+var_20], rax
test rax, rax
jz short loc_89C1F
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_89C1B
inc dword ptr [rax+8]
jmp short loc_89C1F
loc_89BFD:
mov [rbx], rax
xor eax, eax
mov [rbx+8], rax
mov rcx, [rsp+78h+var_68]
mov [rsp+78h+var_68], rax
mov [rbx+8], rcx
mov [rsp+78h+var_70], rax
jmp short loc_89C7D
loc_89C1B:
lock inc dword ptr [rax+8]
loc_89C1F:
mov rax, [r14+20h]
sub rax, [r14+10h]
lea rcx, [rsp+78h+var_28]
mov [rcx+10h], rax
lea rdi, [rsp+78h+var_58+8]
mov qword ptr [rdi-8], 0
lea rsi, [rsp+78h+var_58]
lea rdx, [rsp+78h+var_71]
lea r8, [rsp+78h+var_70]
lea r9, [rsp+78h+var_5C]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5minja11UnaryOpExprESaIS5_EJNS4_8LocationESt10shared_ptrINS4_10ExpressionEERNS5_2OpEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::UnaryOpExpr,std::allocator<minja::UnaryOpExpr>,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &>(minja::UnaryOpExpr *&,std::_Sp_alloc_shared_tag<std::allocator<minja::UnaryOpExpr>>,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &)
xor eax, eax
mov [rbx+8], rax
movaps xmm0, [rsp+78h+var_58]
mov qword ptr [rsp+78h+var_58+8], rax
movups xmmword ptr [rbx], xmm0
mov qword ptr [rsp+78h+var_58], rax
mov rdi, [rsp+78h+var_20]
test rdi, rdi
jz short loc_89C7D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89C7D:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_89C8C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89C8C:
lea rax, [rsp+78h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_89CA7
mov rsi, [rsp+78h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_89CA7:
mov rax, rbx
add rsp, 68h
pop rbx
pop r14
retn
loc_89CB2:
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_89B7E
lea rdi, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok
lea rsi, asc_F3645; "\\+|-(?![}%#]\\})"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_89B7E
loc_89D09:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedExprOf; "Expected expr of 'unary plus/minus/expa"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser23parseMathUnaryPlusMinusEvE20unary_plus_minus_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_89D9F
mov rbx, rax
jmp short loc_89D70
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_89D70
mov rbx, rax
mov rdi, [rsp+78h+var_20]
test rdi, rdi
jz short loc_89D70
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89D70:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_89D84
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_89D84
mov rbx, rax
loc_89D84:
lea rax, [rsp+78h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_89D9F
mov rsi, [rsp+78h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_89D9F:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::parseMathUnaryPlusMinus(minja::Parser *this, long long *a2)
{
volatile signed __int32 *v2; // rax
volatile signed __int32 *v3; // rcx
__int128 v4; // xmm0
std::runtime_error *exception; // r14
char v7; // [rsp+7h] [rbp-71h] BYREF
long long v8; // [rsp+8h] [rbp-70h] BYREF
volatile signed __int32 *v9; // [rsp+10h] [rbp-68h]
BOOL v10; // [rsp+1Ch] [rbp-5Ch] BYREF
__int128 v11; // [rsp+20h] [rbp-58h] BYREF
void *v12[2]; // [rsp+30h] [rbp-48h] BYREF
long long v13; // [rsp+40h] [rbp-38h] BYREF
long long v14; // [rsp+50h] [rbp-28h] BYREF
volatile signed __int32 *v15; // [rsp+58h] [rbp-20h]
long long v16; // [rsp+60h] [rbp-18h]
if ( !(_BYTE)`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
(long long)"\\+|-(?![}%#]\\})",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)v12,
(long long)a2,
(long long)&minja::Parser::parseMathUnaryPlusMinus(void)::unary_plus_minus_tok[abi:cxx11],
1u);
minja::Parser::parseExpansion((minja::Parser *)&v8);
if ( !v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected expr of 'unary plus/minus/expansion' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v12[1] )
{
v10 = std::string::compare(v12, "+") != 0;
v14 = *a2;
v2 = (volatile signed __int32 *)a2[1];
v15 = v2;
if ( v2 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v2 + 2);
else
_InterlockedIncrement(v2 + 2);
}
v16 = a2[4] - a2[2];
*(_QWORD *)&v11 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::UnaryOpExpr,std::allocator<minja::UnaryOpExpr>,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op &>(
(char *)&v11 + 8,
&v11,
&v7,
&v14,
&v8,
&v10);
*((_QWORD *)this + 1) = 0LL;
v4 = v11;
*((_QWORD *)&v11 + 1) = 0LL;
*(_OWORD *)this = v4;
*(_QWORD *)&v11 = 0LL;
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
}
else
{
*(_QWORD *)this = v8;
*((_QWORD *)this + 1) = 0LL;
v3 = v9;
v9 = 0LL;
*((_QWORD *)this + 1) = v3;
v8 = 0LL;
}
if ( v9 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v9);
if ( v12[0] != &v13 )
operator delete(v12[0], v13 + 1);
return this;
}
| parseMathUnaryPlusMinus:
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[0x230108]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00189cb2
LAB_00189b7e:
LEA RDX,[0x2300e8]
LEA RDI,[RSP + 0x30]
MOV RSI,R14
MOV ECX,0x1
CALL 0x00184f66
LAB_00189b97:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x00189e30
MOV RAX,qword ptr [RSP + 0x8]
TEST RAX,RAX
JZ 0x00189d09
CMP qword ptr [RSP + 0x38],0x0
JZ 0x00189bfd
LEA RSI,[0x1f41dd]
LEA RDI,[RSP + 0x30]
CALL 0x0011b220
XOR ECX,ECX
TEST EAX,EAX
SETNZ CL
MOV dword ptr [RSP + 0x1c],ECX
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x50],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x58],RAX
TEST RAX,RAX
JZ 0x00189c1f
MOV RCX,qword ptr [0x0022ef88]
CMP byte ptr [RCX],0x0
JZ 0x00189c1b
INC dword ptr [RAX + 0x8]
JMP 0x00189c1f
LAB_00189bfd:
MOV qword ptr [RBX],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RBX + 0x8],RCX
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00189c7d
LAB_00189c1b:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00189c1f:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
LEA RCX,[RSP + 0x50]
MOV qword ptr [RCX + 0x10],RAX
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI + -0x8],0x0
LAB_00189c3d:
LEA RSI,[RSP + 0x20]
LEA RDX,[RSP + 0x7]
LEA R8,[RSP + 0x8]
LEA R9,[RSP + 0x1c]
CALL 0x00196940
XOR EAX,EAX
MOV qword ptr [RBX + 0x8],RAX
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x00189c7d
CALL 0x0016e1aa
LAB_00189c7d:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00189c8c
CALL 0x0016e1aa
LAB_00189c8c:
LEA RAX,[RSP + 0x40]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00189ca7
MOV RSI,qword ptr [RSP + 0x40]
INC RSI
CALL 0x0011b8f0
LAB_00189ca7:
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP R14
RET
LAB_00189cb2:
LEA RDI,[0x230108]
CALL 0x0011c010
TEST EAX,EAX
JZ 0x00189b7e
LAB_00189cc6:
LEA RDI,[0x2300e8]
LEA RSI,[0x1f3645]
MOV EDX,0x10
CALL 0x001631da
LAB_00189cde:
LEA RDI,[0x1634e2]
LEA RSI,[0x2300e8]
LEA RDX,[0x22f8d8]
CALL 0x0011b7c0
LEA RDI,[0x230108]
CALL 0x0011b5c0
JMP 0x00189b7e
LAB_00189d09:
MOV EDI,0x10
CALL 0x0011b450
MOV R14,RAX
LAB_00189d16:
LEA RSI,[0x1f372f]
MOV RDI,RAX
CALL 0x0011b330
LAB_00189d25:
MOV RSI,qword ptr [0x0022eff0]
MOV RDX,qword ptr [0x0022ef60]
MOV RDI,R14
CALL 0x0011bf30
|
/* minja::Parser::parseMathUnaryPlusMinus() */
void minja::Parser::parseMathUnaryPlusMinus(void)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
long lVar2;
int iVar3;
runtime_error *this;
int8 *in_RSI;
long *in_RDI;
int1 local_71;
long local_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
uint local_5c;
long local_58;
long lStack_50;
long *local_48;
long local_40;
long local_38 [2];
int8 local_28;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_20;
long local_18;
if (parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_ == '\0') {
iVar3 = __cxa_guard_acquire(&parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_);
if (iVar3 != 0) {
/* try { // try from 00189cc6 to 00189cdd has its CatchHandler @ 00189d3b */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_,"\\+|-(?![}%#]\\})",0x10
);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseMathUnaryPlusMinus()::unary_plus_minus_tok_abi_cxx11_);
}
}
consumeToken(&local_48);
/* try { // try from 00189b97 to 00189ba3 has its CatchHandler @ 00189d81 */
parseExpansion();
p_Var1 = local_68;
if (local_70 != 0) {
if (local_40 == 0) {
*in_RDI = local_70;
in_RDI[1] = 0;
local_68 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
in_RDI[1] = (long)p_Var1;
local_70 = 0;
}
else {
iVar3 = std::__cxx11::string::compare((char *)&local_48);
local_5c = (uint)(iVar3 != 0);
local_28 = *in_RSI;
local_20 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (local_20 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_0022ef88 == '\0') {
LOCK();
*(int *)(local_20 + 8) = *(int *)(local_20 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_20 + 8) = *(int *)(local_20 + 8) + 1;
}
}
local_18 = in_RSI[4] - in_RSI[2];
local_58 = 0;
/* try { // try from 00189c3d to 00189c55 has its CatchHandler @ 00189d5e */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<minja::UnaryOpExpr,std::allocator<minja::UnaryOpExpr>,minja::Location,std::shared_ptr<minja::Expression>,minja::UnaryOpExpr::Op&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&lStack_50,&local_58,&local_71,
&local_28,&local_70,&local_5c);
lVar2 = lStack_50;
in_RDI[1] = 0;
lStack_50 = 0;
*in_RDI = local_58;
in_RDI[1] = lVar2;
local_58 = 0;
if (local_20 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_20);
}
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_48 != local_38) {
operator_delete(local_48,local_38[0] + 1);
}
return;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189d16 to 00189d24 has its CatchHandler @ 00189d51 */
std::runtime_error::runtime_error
(this,"Expected expr of \'unary plus/minus/expansion\' expression");
/* try { // try from 00189d25 to 00189d3a has its CatchHandler @ 00189d4c */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0022eff0,PTR__runtime_error_0022ef60);
}
|
|
2,633 | wait_for_readers | eloqsql/storage/maria/ma_pagecache.c | static inline void wait_for_readers(PAGECACHE *pagecache
__attribute__((unused)),
PAGECACHE_BLOCK_LINK *block
__attribute__((unused)))
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ASSERT(block->condvar == NULL);
while (block->hash_link->requests)
{
DBUG_ENTER("wait_for_readers");
DBUG_PRINT("wait",
("suspend thread: %s %ld block: %u",
thread->name, (ulong) thread->id,
PCBLOCK_NUMBER(pagecache, block)));
block->condvar= &thread->suspend;
pagecache_pthread_cond_wait(&thread->suspend, &pagecache->cache_lock);
block->condvar= NULL;
DBUG_VOID_RETURN;
}
} | O3 | c | wait_for_readers:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa8156
movq 0x20(%rbx), %rcx
cmpl $0x0, 0x68(%rcx)
je 0x40923
movq %rax, %rcx
addq $0x8, %rax
movq %rax, 0x28(%rbx)
addq $0xc8, %r14
cmpq $0x0, 0x38(%rcx)
jne 0x40928
movq %rax, %rdi
movq %r14, %rsi
callq 0x2a460
movq $0x0, 0x28(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa11ee(%rip), %rdx # 0xe1b1d
movq %rax, %rdi
movq %r14, %rsi
movl $0x64d, %ecx # imm = 0x64D
callq 0x30914
jmp 0x4091b
| wait_for_readers:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _my_thread_var
mov rcx, [rbx+20h]
cmp dword ptr [rcx+68h], 0
jz short loc_40923
mov rcx, rax
add rax, 8
mov [rbx+28h], rax
add r14, 0C8h
cmp qword ptr [rcx+38h], 0
jnz short loc_40928
mov rdi, rax
mov rsi, r14
call _pthread_cond_wait
loc_4091B:
mov qword ptr [rbx+28h], 0
loc_40923:
pop rbx
pop r14
pop rbp
retn
loc_40928:
lea rdx, aWorkspaceLlm4b_26; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov rsi, r14
mov ecx, 64Dh
call psi_cond_wait
jmp short loc_4091B
| long long wait_for_readers(long long a1, long long a2)
{
long long result; // rax
long long v3; // rcx
long long v4; // rax
long long v5; // r14
result = my_thread_var(a1);
if ( *(_DWORD *)(*(_QWORD *)(a2 + 32) + 104LL) )
{
v3 = result;
v4 = result + 8;
*(_QWORD *)(a2 + 40) = v4;
v5 = a1 + 200;
if ( *(_QWORD *)(v3 + 56) )
result = psi_cond_wait(
v4,
v5,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x64Du);
else
result = pthread_cond_wait(v4, v5);
*(_QWORD *)(a2 + 40) = 0LL;
}
return result;
}
| wait_for_readers:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001a8156
MOV RCX,qword ptr [RBX + 0x20]
CMP dword ptr [RCX + 0x68],0x0
JZ 0x00140923
MOV RCX,RAX
ADD RAX,0x8
MOV qword ptr [RBX + 0x28],RAX
ADD R14,0xc8
CMP qword ptr [RCX + 0x38],0x0
JNZ 0x00140928
MOV RDI,RAX
MOV RSI,R14
CALL 0x0012a460
LAB_0014091b:
MOV qword ptr [RBX + 0x28],0x0
LAB_00140923:
POP RBX
POP R14
POP RBP
RET
LAB_00140928:
LEA RDX,[0x1e1b1d]
MOV RDI,RAX
MOV RSI,R14
MOV ECX,0x64d
CALL 0x00130914
JMP 0x0014091b
|
void wait_for_readers(long param_1,long param_2)
{
long lVar1;
pthread_cond_t *__cond;
lVar1 = _my_thread_var();
if (*(int *)(*(long *)(param_2 + 0x20) + 0x68) != 0) {
__cond = (pthread_cond_t *)(lVar1 + 8);
*(pthread_cond_t **)(param_2 + 0x28) = __cond;
if (*(long *)(lVar1 + 0x38) == 0) {
pthread_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200));
}
else {
psi_cond_wait(__cond,(pthread_mutex_t *)(param_1 + 200),
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x64d);
}
*(int8 *)(param_2 + 0x28) = 0;
}
return;
}
|
|
2,634 | directory_file_name | eloqsql/mysys/my_lib.c | static char *directory_file_name (char * dst, const char *src)
{
/* Process as Unix format: just remove test the final slash. */
char *end;
DBUG_ASSERT(strlen(src) < (FN_REFLEN + 1));
if (src[0] == 0)
src= (char*) "."; /* Use empty as current */
end= strnmov(dst, src, FN_REFLEN + 1);
if (end[-1] != FN_LIBCHAR)
{
*end++= FN_LIBCHAR; /* Add last '/' */
*end='\0';
}
return end;
} | O0 | c | directory_file_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x7cfe2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x7cff9
leaq 0x50e08(%rip), %rax # 0xcddfd
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0xc6e60
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x7d035
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x2f, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| directory_file_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_7CFE2:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_7CFF9
lea rax, aInvalidOrMissi+21h; "."
mov [rbp+var_10], rax
loc_7CFF9:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, 201h
call strnmov
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax-1]
cmp eax, 2Fh ; '/'
jz short loc_7D035
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
loc_7D035:
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| _BYTE * directory_file_name(long long a1, char *a2)
{
_BYTE *v2; // rax
_BYTE *v4; // [rsp+8h] [rbp-18h]
char *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
if ( !*a2 )
v5 = ".";
v4 = (_BYTE *)strnmov(a1, v5, 513LL);
if ( *(v4 - 1) != 47 )
{
v2 = v4++;
*v2 = 47;
*v4 = 0;
}
return v4;
}
| directory_file_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0017cfe2
LAB_0017cfe2:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x0017cff9
LEA RAX,[0x1cddfd]
MOV qword ptr [RBP + -0x10],RAX
LAB_0017cff9:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x201
CALL 0x001c6e60
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX + -0x1]
CMP EAX,0x2f
JZ 0x0017d035
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
LAB_0017d035:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int1 * directory_file_name(int8 param_1,char *param_2)
{
int1 *puVar1;
int1 *local_20;
char *local_18;
local_18 = param_2;
if (*param_2 == '\0') {
local_18 = ".";
}
puVar1 = (int1 *)strnmov(param_1,local_18,0x201);
local_20 = puVar1;
if (puVar1[-1] != '/') {
local_20 = puVar1 + 1;
*puVar1 = 0x2f;
*local_20 = 0;
}
return local_20;
}
|
|
2,635 | init_queue | eloqsql/mysys/queues.c | int init_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *),
void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent)
{
DBUG_ENTER("init_queue");
if ((queue->root= (uchar **) my_malloc(key_memory_QUEUE,
(max_elements + 1) * sizeof(void*),
MYF(MY_WME))) == 0)
DBUG_RETURN(1);
queue->elements= 0;
queue->compare= compare;
queue->first_cmp_arg= first_cmp_arg;
queue->max_elements= max_elements;
queue->offset_to_key= offset_to_key;
queue->offset_to_queue_pos= offset_to_queue_pos;
queue->auto_extent= auto_extent;
queue_set_max_at_top(queue, max_at_top);
DBUG_RETURN(0);
} | O3 | c | init_queue:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, -0x30(%rbp)
movq %r8, %r13
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x35757c(%rip), %rax # 0x3b67d0
movl (%rax), %edi
leal 0x1(%r15), %esi
shlq $0x3, %rsi
movl $0x10, %edx
callq 0x5d03d
movq %rax, (%rbx)
testq %rax, %rax
je 0x5f2ab
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
movl $0x0, 0x10(%rbx)
movq %r13, 0x28(%rbx)
movq -0x30(%rbp), %rdx
movq %rdx, 0x8(%rbx)
movl %r15d, 0x14(%rbx)
movl %r12d, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
movl %eax, 0x20(%rbx)
xorl %eax, %eax
negb %r14b
movl $0x0, %ecx
sbbl %ecx, %ecx
orl $0x1, %ecx
movl %ecx, 0x24(%rbx)
jmp 0x5f2b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| init_queue:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rbp+var_30], r9
mov r13, r8
mov r14d, ecx
mov r12d, edx
mov r15d, esi
mov rbx, rdi
lea rax, key_memory_QUEUE
mov edi, [rax]
lea esi, [r15+1]
shl rsi, 3
mov edx, 10h
call my_malloc
mov [rbx], rax
test rax, rax
jz short loc_5F2AB
mov eax, [rbp+arg_8]
mov ecx, [rbp+arg_0]
mov dword ptr [rbx+10h], 0
mov [rbx+28h], r13
mov rdx, [rbp+var_30]
mov [rbx+8], rdx
mov [rbx+14h], r15d
mov [rbx+18h], r12d
mov [rbx+1Ch], ecx
mov [rbx+20h], eax
xor eax, eax
neg r14b
mov ecx, 0
sbb ecx, ecx
or ecx, 1
mov [rbx+24h], ecx
jmp short loc_5F2B0
loc_5F2AB:
mov eax, 1
loc_5F2B0:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long init_queue(long long a1, int a2, int a3, char a4, long long a5, long long a6, int a7, int a8)
{
long long v11; // rax
long long result; // rax
v11 = my_malloc(key_memory_QUEUE, (const char *)(8LL * (unsigned int)(a2 + 1)), 16);
*(_QWORD *)a1 = v11;
if ( !v11 )
return 1LL;
*(_DWORD *)(a1 + 16) = 0;
*(_QWORD *)(a1 + 40) = a5;
*(_QWORD *)(a1 + 8) = a6;
*(_DWORD *)(a1 + 20) = a2;
*(_DWORD *)(a1 + 24) = a3;
*(_DWORD *)(a1 + 28) = a7;
*(_DWORD *)(a1 + 32) = a8;
result = 0LL;
*(_DWORD *)(a1 + 36) = a4 != 0 ? -1 : 1;
return result;
}
| init_queue:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RBP + -0x30],R9
MOV R13,R8
MOV R14D,ECX
MOV R12D,EDX
MOV R15D,ESI
MOV RBX,RDI
LEA RAX,[0x4b67d0]
MOV EDI,dword ptr [RAX]
LEA ESI,[R15 + 0x1]
SHL RSI,0x3
MOV EDX,0x10
CALL 0x0015d03d
MOV qword ptr [RBX],RAX
TEST RAX,RAX
JZ 0x0015f2ab
MOV EAX,dword ptr [RBP + 0x18]
MOV ECX,dword ptr [RBP + 0x10]
MOV dword ptr [RBX + 0x10],0x0
MOV qword ptr [RBX + 0x28],R13
MOV RDX,qword ptr [RBP + -0x30]
MOV qword ptr [RBX + 0x8],RDX
MOV dword ptr [RBX + 0x14],R15D
MOV dword ptr [RBX + 0x18],R12D
MOV dword ptr [RBX + 0x1c],ECX
MOV dword ptr [RBX + 0x20],EAX
XOR EAX,EAX
NEG R14B
MOV ECX,0x0
SBB ECX,ECX
OR ECX,0x1
MOV dword ptr [RBX + 0x24],ECX
JMP 0x0015f2b0
LAB_0015f2ab:
MOV EAX,0x1
LAB_0015f2b0:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
bool init_queue(long *param_1,int param_2,int4 param_3,char param_4,long param_5,long param_6,
int4 param_7,int4 param_8)
{
long lVar1;
lVar1 = my_malloc(key_memory_QUEUE,(ulong)(param_2 + 1) << 3,0x10);
*param_1 = lVar1;
if (lVar1 != 0) {
*(int4 *)(param_1 + 2) = 0;
param_1[5] = param_5;
param_1[1] = param_6;
*(int *)((long)param_1 + 0x14) = param_2;
*(int4 *)(param_1 + 3) = param_3;
*(int4 *)((long)param_1 + 0x1c) = param_7;
*(int4 *)(param_1 + 4) = param_8;
*(uint *)((long)param_1 + 0x24) = -(uint)(param_4 != '\0') | 1;
}
return lVar1 == 0;
}
|
|
2,636 | ggml_compute_forward_sqrt_f32 | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_compute_forward_sqrt_f32(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
if (params->ith != 0) {
return;
}
assert(ggml_are_same_shape(src0, dst));
const int n = ggml_nrows(src0);
const int nc = src0->ne[0];
assert( dst->nb[0] == sizeof(float));
assert(src0->nb[0] == sizeof(float));
for (int i = 0; i < n; i++) {
ggml_vec_sqrt_f32(nc,
(float *) ((char *) dst->data + i*( dst->nb[1])),
(float *) ((char *) src0->data + i*(src0->nb[1])));
}
} | O0 | c | ggml_compute_forward_sqrt_f32:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2527d
jmp 0x25378
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe260
testb $0x1, %al
jne 0x25290
jmp 0x25292
jmp 0x252b1
leaq 0x4f021(%rip), %rdi # 0x742ba
leaq 0x4e8c2(%rip), %rsi # 0x73b62
movl $0x14c6, %edx # imm = 0x14C6
leaq 0x4f5ae(%rip), %rcx # 0x7485a
callq 0xd690
movq -0x18(%rbp), %rdi
callq 0xdc20
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x4, 0x30(%rax)
jne 0x252d5
jmp 0x252f4
leaq 0x4f545(%rip), %rdi # 0x74821
leaq 0x4e87f(%rip), %rsi # 0x73b62
movl $0x14cb, %edx # imm = 0x14CB
leaq 0x4f56b(%rip), %rcx # 0x7485a
callq 0xd690
movq -0x18(%rbp), %rax
cmpq $0x4, 0x30(%rax)
jne 0x25301
jmp 0x25320
leaq 0x4f535(%rip), %rdi # 0x7483d
leaq 0x4e853(%rip), %rsi # 0x73b62
movl $0x14cc, %edx # imm = 0x14CC
leaq 0x4f53f(%rip), %rcx # 0x7485a
callq 0xd690
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x25378
movl -0x20(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rsi
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq 0x38(%rcx), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0xf8(%rax), %rdx
movslq -0x24(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq 0x38(%rcx), %rax
addq %rax, %rdx
callq 0x25380
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25327
addq $0x30, %rsp
popq %rbp
retq
nop
| ggml_compute_forward_sqrt_f32:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
cmp dword ptr [rax], 0
jz short loc_2527D
jmp loc_25378
loc_2527D:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_10]
call _ggml_are_same_shape
test al, 1
jnz short loc_25290
jmp short loc_25292
loc_25290:
jmp short loc_252B1
loc_25292:
lea rdi, aGgmlCanRepeatS+1Fh; "ggml_are_same_shape(src0, dst)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 14C6h
lea rcx, aVoidGgmlComput_7; "void ggml_compute_forward_sqrt_f32(cons"...
call ___assert_fail
loc_252B1:
mov rdi, [rbp+var_18]
call _ggml_nrows
mov [rbp+var_1C], eax
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
cmp qword ptr [rax+30h], 4
jnz short loc_252D5
jmp short loc_252F4
loc_252D5:
lea rdi, aDstNb0SizeofFl; "dst->nb[0] == sizeof(float)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 14CBh
lea rcx, aVoidGgmlComput_7; "void ggml_compute_forward_sqrt_f32(cons"...
call ___assert_fail
loc_252F4:
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 4
jnz short loc_25301
jmp short loc_25320
loc_25301:
lea rdi, aSrc0Nb0SizeofF; "src0->nb[0] == sizeof(float)"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 14CCh
lea rcx, aVoidGgmlComput_7; "void ggml_compute_forward_sqrt_f32(cons"...
call ___assert_fail
loc_25320:
mov [rbp+var_24], 0
loc_25327:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_1C]
jge short loc_25378
mov edi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+0F8h]
movsxd rax, [rbp+var_24]
mov rcx, [rbp+var_10]
imul rax, [rcx+38h]
add rsi, rax
mov rax, [rbp+var_18]
mov rdx, [rax+0F8h]
movsxd rax, [rbp+var_24]
mov rcx, [rbp+var_18]
imul rax, [rcx+38h]
add rdx, rax
call ggml_vec_sqrt_f32
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_25327
loc_25378:
add rsp, 30h
pop rbp
retn
| unsigned long long ggml_compute_forward_sqrt_f32(_DWORD *a1, _QWORD *a2)
{
unsigned long long result; // rax
int v3; // eax
unsigned int i; // [rsp+Ch] [rbp-24h]
unsigned int v5; // [rsp+10h] [rbp-20h]
int v6; // [rsp+14h] [rbp-1Ch]
_QWORD *v7; // [rsp+18h] [rbp-18h]
v7 = (_QWORD *)a2[19];
result = (unsigned long long)a1;
if ( !*a1 )
{
if ( (ggml_are_same_shape(v7, a2) & 1) == 0 )
__assert_fail(
"ggml_are_same_shape(src0, dst)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
5318LL,
"void ggml_compute_forward_sqrt_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
v3 = ggml_nrows(v7);
v6 = v3;
v5 = v7[2];
if ( a2[6] != 4LL )
__assert_fail(
"dst->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
5323LL,
"void ggml_compute_forward_sqrt_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
if ( v7[6] != 4LL )
__assert_fail(
"src0->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
5324LL,
"void ggml_compute_forward_sqrt_f32(const struct ggml_compute_params *, struct ggml_tensor *)");
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= v6 )
break;
ggml_vec_sqrt_f32(v5, a2[7] * (int)i + a2[31], v7[7] * (int)i + v7[31]);
}
}
return result;
}
| ggml_compute_forward_sqrt_f32:
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 + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX],0x0
JZ 0x0012527d
JMP 0x00125378
LAB_0012527d:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0010e260
TEST AL,0x1
JNZ 0x00125290
JMP 0x00125292
LAB_00125290:
JMP 0x001252b1
LAB_00125292:
LEA RDI,[0x1742ba]
LEA RSI,[0x173b62]
MOV EDX,0x14c6
LEA RCX,[0x17485a]
CALL 0x0010d690
LAB_001252b1:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010dc20
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x30],0x4
JNZ 0x001252d5
JMP 0x001252f4
LAB_001252d5:
LEA RDI,[0x174821]
LEA RSI,[0x173b62]
MOV EDX,0x14cb
LEA RCX,[0x17485a]
CALL 0x0010d690
LAB_001252f4:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x30],0x4
JNZ 0x00125301
JMP 0x00125320
LAB_00125301:
LEA RDI,[0x17483d]
LEA RSI,[0x173b62]
MOV EDX,0x14cc
LEA RCX,[0x17485a]
CALL 0x0010d690
LAB_00125320:
MOV dword ptr [RBP + -0x24],0x0
LAB_00125327:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x00125378
MOV EDI,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0xf8]
MOVSXD RAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x10]
IMUL RAX,qword ptr [RCX + 0x38]
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0xf8]
MOVSXD RAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x18]
IMUL RAX,qword ptr [RCX + 0x38]
ADD RDX,RAX
CALL 0x00125380
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00125327
LAB_00125378:
ADD RSP,0x30
POP RBP
RET
|
void ggml_compute_forward_sqrt_f32(int *param_1,long param_2)
{
long lVar1;
int8 uVar2;
int iVar3;
ulong uVar4;
int local_2c;
lVar1 = *(long *)(param_2 + 0x98);
if (*param_1 == 0) {
uVar4 = ggml_are_same_shape(lVar1,param_2);
if ((uVar4 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ggml_are_same_shape(src0, dst)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x14c6,
"void ggml_compute_forward_sqrt_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
iVar3 = ggml_nrows(lVar1);
uVar2 = *(int8 *)(lVar1 + 0x10);
if (*(long *)(param_2 + 0x30) != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("dst->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x14cb,
"void ggml_compute_forward_sqrt_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
if (*(long *)(lVar1 + 0x30) != 4) {
/* WARNING: Subroutine does not return */
__assert_fail("src0->nb[0] == sizeof(float)",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0x14cc,
"void ggml_compute_forward_sqrt_f32(const struct ggml_compute_params *, struct ggml_tensor *)"
);
}
for (local_2c = 0; local_2c < iVar3; local_2c = local_2c + 1) {
ggml_vec_sqrt_f32((int)uVar2,
*(long *)(param_2 + 0xf8) + (long)local_2c * *(long *)(param_2 + 0x38),
*(long *)(lVar1 + 0xf8) + (long)local_2c * *(long *)(lVar1 + 0x38));
}
}
return;
}
|
|
2,637 | rapidcsv::Document::GetDataColumnCount() const | Andrewchistyakov[P]flashcards_lyc/src/rapidcsv.h | size_t GetDataColumnCount() const
{
const size_t firstDataRow = static_cast<size_t>((mLabelParams.mColumnNameIdx >= 0) ? mLabelParams.mColumnNameIdx : 0);
return (mData.size() > firstDataRow) ? mData.at(firstDataRow).size() : 0;
} | O0 | c | rapidcsv::Document::GetDataColumnCount() const:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x20(%rax)
jl 0x37fe6
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x37fed
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x37fed
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
cltq
movq %rax, -0x10(%rbp)
addq $0x68, %rdi
callq 0x322f0
cmpq -0x10(%rbp), %rax
jbe 0x38028
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x36bd0
movq %rax, %rdi
callq 0x18410
movq %rax, -0x28(%rbp)
jmp 0x38030
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x38030
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZNK8rapidcsv8Document18GetDataColumnCountEv:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
cmp dword ptr [rax+20h], 0
jl short loc_37FE6
mov rax, [rbp+var_18]
mov eax, [rax+20h]
mov [rbp+var_1C], eax
jmp short loc_37FED
loc_37FE6:
xor eax, eax
mov [rbp+var_1C], eax
jmp short $+2
loc_37FED:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_1C]
cdqe
mov [rbp+var_10], rax
add rdi, 68h ; 'h'
call _ZNKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE4sizeEv; std::vector<std::vector<std::string>>::size(void)
cmp rax, [rbp+var_10]
jbe short loc_38028
mov rdi, [rbp+var_18]
add rdi, 68h ; 'h'
mov rsi, [rbp+var_10]
call _ZNKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE2atEm; std::vector<std::vector<std::string>>::at(ulong)
mov rdi, rax
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov [rbp+var_28], rax
jmp short loc_38030
loc_38028:
xor eax, eax
mov [rbp+var_28], rax
jmp short $+2
loc_38030:
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| long long rapidcsv::Document::GetDataColumnCount(rapidcsv::Document *this)
{
_QWORD *v1; // rax
int v4; // [rsp+14h] [rbp-1Ch]
if ( *((int *)this + 8) < 0 )
v4 = 0;
else
v4 = *((_DWORD *)this + 8);
if ( std::vector<std::vector<std::string>>::size((_QWORD *)this + 13) <= (unsigned long long)v4 )
return 0LL;
v1 = (_QWORD *)std::vector<std::vector<std::string>>::at((long long)this + 104, v4);
return std::vector<std::string>::size(v1);
}
| GetDataColumnCount:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RAX + 0x20],0x0
JL 0x00137fe6
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00137fed
LAB_00137fe6:
XOR EAX,EAX
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00137fed
LAB_00137fed:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
MOV qword ptr [RBP + -0x10],RAX
ADD RDI,0x68
CALL 0x001322f0
CMP RAX,qword ptr [RBP + -0x10]
JBE 0x00138028
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x68
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00136bd0
MOV RDI,RAX
CALL 0x00118410
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00138030
LAB_00138028:
XOR EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00138030
LAB_00138030:
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
/* rapidcsv::Document::GetDataColumnCount() const */
int8 __thiscall rapidcsv::Document::GetDataColumnCount(Document *this)
{
ulong uVar1;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *this_00;
int8 local_30;
int local_24;
if (*(int *)(this + 0x20) < 0) {
local_24 = 0;
}
else {
local_24 = *(int *)(this + 0x20);
}
uVar1 = std::
vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
::size((vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
*)(this + 0x68));
if ((ulong)(long)local_24 < uVar1) {
this_00 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
std::
vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
::at((vector<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>,std::allocator<std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>>
*)(this + 0x68),(long)local_24);
local_30 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size(this_00)
;
}
else {
local_30 = 0;
}
return local_30;
}
|
|
2,638 | my_mb_wc_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_mb_wc_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80) /* ASCII: [00-7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
/* JIS-X-0201 Half width Katakana: [A1..DF] -> [U+FF61..U+FF9F] */
if (hi >= 0xA1 && hi <= 0xDF)
{
*pwc= cp932_to_unicode[hi];
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/* JIS-X-0208-MS [81..9F,E0..FC][40..7E,80..FC] */
if (!(pwc[0]= cp932_to_unicode[(hi << 8) + s[1]]))
return (iscp932head(hi) && iscp932tail(s[1])) ? -2 : MY_CS_ILSEQ;
return 2;
} | O3 | c | my_mb_wc_cp932:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x65dcb
movzbl (%rdx), %edi
testb %dil, %dil
js 0x65db1
movq %rdi, (%rsi)
jmp 0x65dc6
leal 0x5f(%rdi), %eax
cmpb $0x3e, %al
ja 0x65dcd
leaq 0x4bc91(%rip), %rax # 0xb1a50
movzwl (%rax,%rdi,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x65dcb
movzbl 0x1(%rdx), %eax
movl %edi, %ecx
shll $0x9, %ecx
leal (%rcx,%rax,2), %eax
leaq 0x4bc62(%rip), %rcx # 0xb1a50
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x65dcb
cmpb $-0x80, %dil
setne %al
cmpb $-0x60, %dil
setb %cl
andb %al, %cl
addb $0x20, %dil
cmpb $0x1d, %dil
setb %sil
orb %cl, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0x65dcb
movb 0x1(%rdx), %cl
leal -0x40(%rcx), %edx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpb $0x3f, %dl
jb 0x65dcb
movl $0x0, %eax
testb %cl, %cl
jns 0x65dcb
xorl %eax, %eax
cmpb $-0x3, %cl
setae %al
leal -0x2(,%rax,2), %eax
jmp 0x65dcb
| my_mb_wc_cp932:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_65DCB
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_65DB1
mov [rsi], rdi
jmp short loc_65DC6
loc_65DB1:
lea eax, [rdi+5Fh]
cmp al, 3Eh ; '>'
ja short loc_65DCD
lea rax, cp932_to_unicode
movzx eax, word ptr [rax+rdi*2]
mov [rsi], rax
loc_65DC6:
mov eax, 1
loc_65DCB:
pop rbp
retn
loc_65DCD:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_65DCB
movzx eax, byte ptr [rdx+1]
mov ecx, edi
shl ecx, 9
lea eax, [rcx+rax*2]
lea rcx, cp932_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_65DCB
cmp dil, 80h
setnz al
cmp dil, 0A0h
setb cl
and cl, al
add dil, 20h ; ' '
cmp dil, 1Dh
setb sil
or sil, cl
xor eax, eax
cmp sil, 1
jnz short loc_65DCB
mov cl, [rdx+1]
lea edx, [rcx-40h]
mov eax, 0FFFFFFFEh
cmp dl, 3Fh ; '?'
jb short loc_65DCB
mov eax, 0
test cl, cl
jns short loc_65DCB
xor eax, eax
cmp cl, 0FDh
setnb al
lea eax, ds:0FFFFFFFFFFFFFFFEh[rax*2]
jmp loc_65DCB
| long long my_mb_wc_cp932(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
char v7; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x3Eu )
{
*a2 = cp932_to_unicode[v5];
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = cp932_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
{
result = 0LL;
if ( (_BYTE)v5 != 0x80 && (unsigned __int8)v5 < 0xA0u || (unsigned __int8)(v5 + 32) < 0x1Du )
{
v7 = a3[1];
result = 4294967294LL;
if ( (unsigned __int8)(v7 - 64) >= 0x3Fu )
{
result = 0LL;
if ( v7 < 0 )
return 2 * (unsigned int)((unsigned __int8)v7 >= 0xFDu) - 2;
}
}
}
}
}
return result;
}
| my_mb_wc_cp932:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00165dcb
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x00165db1
MOV qword ptr [RSI],RDI
JMP 0x00165dc6
LAB_00165db1:
LEA EAX,[RDI + 0x5f]
CMP AL,0x3e
JA 0x00165dcd
LEA RAX,[0x1b1a50]
MOVZX EAX,word ptr [RAX + RDI*0x2]
MOV qword ptr [RSI],RAX
LAB_00165dc6:
MOV EAX,0x1
LAB_00165dcb:
POP RBP
RET
LAB_00165dcd:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x00165dcb
MOVZX EAX,byte ptr [RDX + 0x1]
MOV ECX,EDI
SHL ECX,0x9
LEA EAX,[RCX + RAX*0x2]
LEA RCX,[0x1b1a50]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x00165dcb
CMP DIL,0x80
SETNZ AL
CMP DIL,0xa0
SETC CL
AND CL,AL
ADD DIL,0x20
CMP DIL,0x1d
SETC SIL
OR SIL,CL
XOR EAX,EAX
CMP SIL,0x1
JNZ 0x00165dcb
MOV CL,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x40]
MOV EAX,0xfffffffe
CMP DL,0x3f
JC 0x00165dcb
MOV EAX,0x0
TEST CL,CL
JNS 0x00165dcb
XOR EAX,EAX
CMP CL,0xfd
SETNC AL
LEA EAX,[-0x2 + RAX*0x2]
JMP 0x00165dcb
|
int my_mb_wc_cp932(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if (0x3e < (byte)(bVar1 + 0x5f)) {
if (param_4 < param_3 + 2) {
return -0x66;
}
uVar2 = *(ushort *)(cp932_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 2;
}
if (0x1c < (byte)(bVar1 + 0x20) && (0x9f < bVar1 || bVar1 == 0x80)) {
return 0;
}
bVar1 = param_3[1];
if ((byte)(bVar1 - 0x40) < 0x3f) {
return -2;
}
if (-1 < (char)bVar1) {
return 0;
}
return (uint)(0xfc < bVar1) * 2 + -2;
}
*param_2 = (ulong)*(ushort *)(cp932_to_unicode + (ulong)bVar1 * 2);
}
else {
*param_2 = (ulong)bVar1;
}
iVar3 = 1;
}
return iVar3;
}
|
|
2,639 | BeginDrawing | csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rcore.c | void BeginDrawing(void)
{
// WARNING: Previously to BeginDrawing() other render textures drawing could happen,
// consequently the measure for update vs draw is not accurate (only the total frame time is accurate)
CORE.Time.current = GetTime(); // Number of elapsed seconds since InitTimer()
CORE.Time.update = CORE.Time.current - CORE.Time.previous;
CORE.Time.previous = CORE.Time.current;
rlLoadIdentity(); // Reset current matrix (modelview)
rlMultMatrixf(MatrixToFloat(CORE.Window.screenScale)); // Apply screen scaling
//rlTranslatef(0.375, 0.375, 0); // HACK to have 2D pixel-perfect drawing on OpenGL 1.1
// NOTE: Not required with OpenGL 3.3+
} | O3 | c | BeginDrawing:
subq $0x48, %rsp
callq 0xbe9ca
movsd %xmm0, 0xca6e3(%rip) # 0x13c660
movapd %xmm0, %xmm1
subsd 0xca6df(%rip), %xmm1 # 0x13c668
movsd %xmm1, 0xca6df(%rip) # 0x13c670
movsd %xmm0, 0xca6cf(%rip) # 0x13c668
movq 0xc91c0(%rip), %rax # 0x13b160
movl $0x3f800000, %ecx # imm = 0x3F800000
movl %ecx, (%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x4(%rax)
movl %ecx, 0x14(%rax)
movupd %xmm0, 0x18(%rax)
movl %ecx, 0x28(%rax)
movupd %xmm0, 0x2c(%rax)
movl %ecx, 0x3c(%rax)
movss 0xc9c59(%rip), %xmm0 # 0x13bc24
movss 0xc9c55(%rip), %xmm1 # 0x13bc28
movss 0xc9c51(%rip), %xmm2 # 0x13bc2c
movss 0xc9c4d(%rip), %xmm3 # 0x13bc30
movss 0xc9c49(%rip), %xmm4 # 0x13bc34
movss 0xc9c45(%rip), %xmm5 # 0x13bc38
movss 0xc9c41(%rip), %xmm6 # 0x13bc3c
movss 0xc9c3d(%rip), %xmm7 # 0x13bc40
movss 0xc9c38(%rip), %xmm8 # 0x13bc44
movss 0xc9c33(%rip), %xmm9 # 0x13bc48
movss 0xc9c2e(%rip), %xmm10 # 0x13bc4c
movss 0xc9c29(%rip), %xmm11 # 0x13bc50
movss 0xc9c24(%rip), %xmm12 # 0x13bc54
movss 0xc9c1f(%rip), %xmm13 # 0x13bc58
movss 0xc9c1a(%rip), %xmm14 # 0x13bc5c
movss 0xc9c15(%rip), %xmm15 # 0x13bc60
leaq 0x8(%rsp), %rdi
movss %xmm0, (%rdi)
movss %xmm4, 0x4(%rdi)
movss %xmm8, 0x8(%rdi)
movss %xmm12, 0xc(%rdi)
movss %xmm1, 0x10(%rdi)
movss %xmm5, 0x14(%rdi)
movss %xmm9, 0x18(%rdi)
movss %xmm13, 0x1c(%rdi)
movss %xmm2, 0x20(%rdi)
movss %xmm6, 0x24(%rdi)
movss %xmm10, 0x28(%rdi)
movss %xmm14, 0x2c(%rdi)
movss %xmm3, 0x30(%rdi)
movss %xmm7, 0x34(%rdi)
movss %xmm11, 0x38(%rdi)
movss %xmm15, 0x3c(%rdi)
callq 0x60adb
addq $0x48, %rsp
retq
| BeginDrawing:
sub rsp, 48h
call glfwGetTime
movsd cs:qword_13C660, xmm0
movapd xmm1, xmm0
subsd xmm1, cs:qword_13C668
movsd cs:qword_13C670, xmm1
movsd cs:qword_13C668, xmm0
mov rax, cs:qword_13B160
mov ecx, 3F800000h
mov [rax], ecx
xorpd xmm0, xmm0
movupd xmmword ptr [rax+4], xmm0
mov [rax+14h], ecx
movupd xmmword ptr [rax+18h], xmm0
mov [rax+28h], ecx
movupd xmmword ptr [rax+2Ch], xmm0
mov [rax+3Ch], ecx
movss xmm0, cs:dword_13BC24
movss xmm1, dword ptr cs:xmmword_13BC28
movss xmm2, dword ptr cs:xmmword_13BC28+4
movss xmm3, dword ptr cs:xmmword_13BC28+8
movss xmm4, dword ptr cs:xmmword_13BC28+0Ch
movss xmm5, cs:dword_13BC38
movss xmm6, dword ptr cs:xmmword_13BC3C
movss xmm7, dword ptr cs:xmmword_13BC3C+4
movss xmm8, dword ptr cs:xmmword_13BC3C+8
movss xmm9, dword ptr cs:xmmword_13BC3C+0Ch
movss xmm10, cs:dword_13BC4C
movss xmm11, dword ptr cs:xmmword_13BC50
movss xmm12, dword ptr cs:xmmword_13BC50+4
movss xmm13, dword ptr cs:xmmword_13BC50+8
movss xmm14, dword ptr cs:xmmword_13BC50+0Ch
movss xmm15, cs:dword_13BC60
lea rdi, [rsp+48h+var_40]
movss dword ptr [rdi], xmm0
movss dword ptr [rdi+4], xmm4
movss dword ptr [rdi+8], xmm8
movss dword ptr [rdi+0Ch], xmm12
movss dword ptr [rdi+10h], xmm1
movss dword ptr [rdi+14h], xmm5
movss dword ptr [rdi+18h], xmm9
movss dword ptr [rdi+1Ch], xmm13
movss dword ptr [rdi+20h], xmm2
movss dword ptr [rdi+24h], xmm6
movss dword ptr [rdi+28h], xmm10
movss dword ptr [rdi+2Ch], xmm14
movss dword ptr [rdi+30h], xmm3
movss dword ptr [rdi+34h], xmm7
movss dword ptr [rdi+38h], xmm11
movss dword ptr [rdi+3Ch], xmm15
call rlMultMatrixf
add rsp, 48h
retn
| void BeginDrawing(double a1, double a2, double a3, double a4, double a5, long long a6, long long a7)
{
long long v7; // rax
long long v8; // rdx
long long v9; // r8
long long v10; // r9
__int32 v11[16]; // [rsp+8h] [rbp-40h] BYREF
qword_13C660 = glfwGetTime(a1, a2, a3, a4, a5);
*(double *)&qword_13C670 = *(double *)&qword_13C660 - *(double *)&qword_13C668;
qword_13C668 = qword_13C660;
v7 = qword_13B160;
*(_DWORD *)qword_13B160 = 1065353216;
*(_OWORD *)(v7 + 4) = 0LL;
*(_DWORD *)(v7 + 20) = 1065353216;
*(_OWORD *)(v7 + 24) = 0LL;
*(_DWORD *)(v7 + 40) = 1065353216;
*(_OWORD *)(v7 + 44) = 0LL;
*(_DWORD *)(v7 + 60) = 1065353216;
v11[0] = dword_13BC24;
v11[1] = HIDWORD(xmmword_13BC28);
v11[2] = DWORD2(xmmword_13BC3C);
v11[3] = DWORD1(xmmword_13BC50);
v11[4] = xmmword_13BC28;
v11[5] = dword_13BC38;
v11[6] = HIDWORD(xmmword_13BC3C);
v11[7] = DWORD2(xmmword_13BC50);
v11[8] = DWORD1(xmmword_13BC28);
v11[9] = xmmword_13BC3C;
v11[10] = dword_13BC4C;
v11[11] = HIDWORD(xmmword_13BC50);
v11[12] = DWORD2(xmmword_13BC28);
v11[13] = DWORD1(xmmword_13BC3C);
v11[14] = xmmword_13BC50;
v11[15] = dword_13BC60;
rlMultMatrixf(
v11,
a7,
v8,
1065353216LL,
v9,
v10,
COERCE_DOUBLE((unsigned long long)dword_13BC24),
COERCE_DOUBLE((unsigned long long)(unsigned int)xmmword_13BC28),
COERCE_DOUBLE((unsigned long long)DWORD1(xmmword_13BC28)),
COERCE_DOUBLE((unsigned long long)DWORD2(xmmword_13BC28)),
(__m128)HIDWORD(xmmword_13BC28),
(__m128)(unsigned int)dword_13BC38,
(__m128)(unsigned int)xmmword_13BC3C,
(__m128)DWORD1(xmmword_13BC3C));
}
| BeginDrawing:
SUB RSP,0x48
CALL 0x001be9ca
MOVSD qword ptr [0x0023c660],XMM0
MOVAPD XMM1,XMM0
SUBSD XMM1,qword ptr [0x0023c668]
MOVSD qword ptr [0x0023c670],XMM1
MOVSD qword ptr [0x0023c668],XMM0
MOV RAX,qword ptr [0x0023b160]
MOV ECX,0x3f800000
MOV dword ptr [RAX],ECX
XORPD XMM0,XMM0
MOVUPD xmmword ptr [RAX + 0x4],XMM0
MOV dword ptr [RAX + 0x14],ECX
MOVUPD xmmword ptr [RAX + 0x18],XMM0
MOV dword ptr [RAX + 0x28],ECX
MOVUPD xmmword ptr [RAX + 0x2c],XMM0
MOV dword ptr [RAX + 0x3c],ECX
MOVSS XMM0,dword ptr [0x0023bc24]
MOVSS XMM1,dword ptr [0x0023bc28]
MOVSS XMM2,dword ptr [0x0023bc2c]
MOVSS XMM3,dword ptr [0x0023bc30]
MOVSS XMM4,dword ptr [0x0023bc34]
MOVSS XMM5,dword ptr [0x0023bc38]
MOVSS XMM6,dword ptr [0x0023bc3c]
MOVSS XMM7,dword ptr [0x0023bc40]
MOVSS XMM8,dword ptr [0x0023bc44]
MOVSS XMM9,dword ptr [0x0023bc48]
MOVSS XMM10,dword ptr [0x0023bc4c]
MOVSS XMM11,dword ptr [0x0023bc50]
MOVSS XMM12,dword ptr [0x0023bc54]
MOVSS XMM13,dword ptr [0x0023bc58]
MOVSS XMM14,dword ptr [0x0023bc5c]
MOVSS XMM15,dword ptr [0x0023bc60]
LEA RDI,[RSP + 0x8]
MOVSS dword ptr [RDI],XMM0
MOVSS dword ptr [RDI + 0x4],XMM4
MOVSS dword ptr [RDI + 0x8],XMM8
MOVSS dword ptr [RDI + 0xc],XMM12
MOVSS dword ptr [RDI + 0x10],XMM1
MOVSS dword ptr [RDI + 0x14],XMM5
MOVSS dword ptr [RDI + 0x18],XMM9
MOVSS dword ptr [RDI + 0x1c],XMM13
MOVSS dword ptr [RDI + 0x20],XMM2
MOVSS dword ptr [RDI + 0x24],XMM6
MOVSS dword ptr [RDI + 0x28],XMM10
MOVSS dword ptr [RDI + 0x2c],XMM14
MOVSS dword ptr [RDI + 0x30],XMM3
MOVSS dword ptr [RDI + 0x34],XMM7
MOVSS dword ptr [RDI + 0x38],XMM11
MOVSS dword ptr [RDI + 0x3c],XMM15
CALL 0x00160adb
ADD RSP,0x48
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void BeginDrawing(void)
{
int4 *puVar1;
_DAT_0023c660 = (double)glfwGetTime();
puVar1 = DAT_0023b160;
_DAT_0023c670 = _DAT_0023c660 - _DAT_0023c668;
_DAT_0023c668 = _DAT_0023c660;
*DAT_0023b160 = 0x3f800000;
*(int8 *)(puVar1 + 1) = 0;
*(int8 *)(puVar1 + 3) = 0;
puVar1[5] = 0x3f800000;
*(int8 *)(puVar1 + 6) = 0;
*(int8 *)(puVar1 + 8) = 0;
puVar1[10] = 0x3f800000;
*(int8 *)(puVar1 + 0xb) = 0;
*(int8 *)(puVar1 + 0xd) = 0;
puVar1[0xf] = 0x3f800000;
rlMultMatrixf();
return;
}
|
|
2,640 | use_head | eloqsql/storage/maria/ma_bitmap.c | static void use_head(MARIA_HA *info, pgcache_page_no_t page, uint size,
uint block_position)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
MARIA_BITMAP_BLOCK *block;
uchar *data;
uint offset, tmp, offset_page;
DBUG_ENTER("use_head");
DBUG_ASSERT(page % bitmap->pages_covered);
block= dynamic_element(&info->bitmap_blocks, block_position,
MARIA_BITMAP_BLOCK*);
block->page= page;
block->page_count= 1 + TAIL_BIT;
block->empty_space= size;
block->used= BLOCKUSED_TAIL;
/*
Mark place used by reading/writing 2 bytes at a time to handle
bitmaps in overlapping bytes
*/
offset_page= (uint) (page - bitmap->page - 1) * 3;
offset= offset_page & 7;
data= bitmap->map + offset_page / 8;
tmp= uint2korr(data);
block->org_bitmap_value= (tmp >> offset) & 7;
tmp= (tmp & ~(7 << offset)) | (FULL_HEAD_PAGE << offset);
int2store(data, tmp);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_VOID_RETURN;
} | O0 | c | use_head:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x20(%rbp)
jmp 0x613d5
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl $0x8001, 0x8(%rax) # imm = 0x8001
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rax
movb $0x4, 0x14(%rax)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
imull $0x3, %eax, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x3c(%rbp), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
shrl %cl, %eax
andl $0x7, %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x15(%rax)
movl -0x38(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x7, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl -0x34(%rbp), %ecx
movl $0x4, %edx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x38(%rbp), %eax
movw %ax, %cx
movq -0x48(%rbp), %rax
movw %cx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x614ae
jmp 0x614b0
jmp 0x614b2
popq %rbp
retq
nopw %cs:(%rax,%rax)
| use_head:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_18], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
add rax, 0A10h
mov [rbp+var_20], rax
jmp short $+2
loc_613D5:
mov rax, [rbp+var_8]
mov rax, [rax+2C0h]
mov ecx, [rbp+var_18]
imul rcx, 18h
add rax, rcx
mov [rbp+var_28], rax
mov rcx, [rbp+var_10]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_28]
mov dword ptr [rax+8], 8001h
mov ecx, [rbp+var_14]
mov rax, [rbp+var_28]
mov [rax+0Ch], ecx
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 4
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, [rcx+10h]
sub rax, 1
imul eax, 3
mov [rbp+var_3C], eax
mov eax, [rbp+var_3C]
and eax, 7
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov ecx, [rbp+var_3C]
shr ecx, 3
mov ecx, ecx
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax]
mov [rbp+var_38], eax
mov eax, [rbp+var_38]
mov ecx, [rbp+var_34]
shr eax, cl
and eax, 7
mov cl, al
mov rax, [rbp+var_28]
mov [rax+15h], cl
mov eax, [rbp+var_38]
mov ecx, [rbp+var_34]
mov edx, 7
shl edx, cl
mov ecx, edx
xor ecx, 0FFFFFFFFh
and eax, ecx
mov ecx, [rbp+var_34]
mov edx, 4
shl edx, cl
mov ecx, edx
or eax, ecx
mov [rbp+var_38], eax
mov rax, [rbp+var_30]
mov [rbp+var_48], rax
mov eax, [rbp+var_38]
mov cx, ax
mov rax, [rbp+var_48]
mov [rax], cx
mov rax, [rbp+var_20]
mov byte ptr [rax+20h], 1
jmp short $+2
loc_614AE:
jmp short $+2
loc_614B0:
jmp short $+2
loc_614B2:
pop rbp
retn
| long long use_head(_QWORD *a1, long long a2, int a3, unsigned int a4)
{
long long result; // rax
unsigned int v5; // [rsp+Ch] [rbp-3Ch]
unsigned int v6; // [rsp+10h] [rbp-38h]
_WORD *v7; // [rsp+18h] [rbp-30h]
long long v8; // [rsp+20h] [rbp-28h]
long long v9; // [rsp+28h] [rbp-20h]
v9 = *a1 + 2576LL;
v8 = 24LL * a4 + a1[88];
*(_QWORD *)v8 = a2;
*(_DWORD *)(v8 + 8) = 32769;
*(_DWORD *)(v8 + 12) = a3;
*(_BYTE *)(v8 + 20) = 4;
v5 = 3 * (a2 - *(_DWORD *)(v9 + 16) - 1);
v7 = (_WORD *)((v5 >> 3) + *(_QWORD *)(v9 + 8));
v6 = (unsigned __int16)*v7;
*(_BYTE *)(v8 + 21) = (v6 >> (v5 & 7)) & 7;
*v7 = (4 << (v5 & 7)) | ~(7 << (v5 & 7)) & v6;
result = v9;
*(_BYTE *)(v9 + 32) = 1;
return result;
}
| use_head:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x18],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001613d5
LAB_001613d5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV ECX,dword ptr [RBP + -0x18]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],0x8001
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x4
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RCX + 0x10]
SUB RAX,0x1
IMUL EAX,EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x3c]
AND EAX,0x7
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x3c]
SHR ECX,0x3
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x34]
SHR EAX,CL
AND EAX,0x7
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],CL
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x34]
MOV EDX,0x7
SHL EDX,CL
MOV ECX,EDX
XOR ECX,0xffffffff
AND EAX,ECX
MOV ECX,dword ptr [RBP + -0x34]
MOV EDX,0x4
SHL EDX,CL
MOV ECX,EDX
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0x38]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x48]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x20],0x1
JMP 0x001614ae
LAB_001614ae:
JMP 0x001614b0
LAB_001614b0:
JMP 0x001614b2
LAB_001614b2:
POP RBP
RET
|
void use_head(long *param_1,int8 param_2,int4 param_3,uint param_4)
{
ushort uVar1;
long lVar2;
uint uVar3;
int8 *puVar4;
ushort *puVar5;
byte bVar6;
lVar2 = *param_1;
puVar4 = (int8 *)(param_1[0x58] + (ulong)param_4 * 0x18);
*puVar4 = param_2;
*(int4 *)(puVar4 + 1) = 0x8001;
*(int4 *)((long)puVar4 + 0xc) = param_3;
*(int1 *)((long)puVar4 + 0x14) = 4;
uVar3 = (((int)param_2 - (int)*(int8 *)(lVar2 + 0xa20)) + -1) * 3;
bVar6 = (byte)uVar3 & 7;
puVar5 = (ushort *)(*(long *)(lVar2 + 0xa18) + (ulong)(uVar3 >> 3));
uVar1 = *puVar5;
*(byte *)((long)puVar4 + 0x15) = (byte)(uVar1 >> bVar6) & 7;
*puVar5 = uVar1 & ((ushort)(7 << bVar6) ^ 0xffff) | (ushort)(4 << bVar6);
*(int1 *)(lVar2 + 0xa30) = 1;
return;
}
|
|
2,641 | init_functions | eloqsql/mysys/mf_iocache.c | static void
init_functions(IO_CACHE* info)
{
enum cache_type type= info->type;
info->read_function = 0; /* Force a core if used */
info->write_function = 0; /* Force a core if used */
switch (type) {
case READ_NET:
/*
Must be initialized by the caller. The problem is that
_my_b_net_read has to be defined in sql directory because of
the dependency on THD, and therefore cannot be visible to
programs that link against mysys but know nothing about THD, such
as myisamchk
*/
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
break;
case SEQ_READ_APPEND:
info->read_function = _my_b_seq_read;
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
break;
case READ_CACHE:
if (info->myflags & MY_ENCRYPT)
{
DBUG_ASSERT(info->share == 0);
info->read_function = _my_b_encr_read;
break;
}
/* fall through */
case WRITE_CACHE:
if (info->myflags & MY_ENCRYPT)
{
info->write_function = _my_b_encr_write;
break;
}
/* fall through */
case READ_FIFO:
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
info->read_function = info->share ? _my_b_cache_read_r : _my_b_cache_read;
info->write_function = info->share ? _my_b_cache_write_r : _my_b_cache_write;
break;
case TYPE_NOT_SET:
DBUG_ASSERT(0);
break;
}
if (type == READ_CACHE || type == WRITE_CACHE || type == SEQ_READ_APPEND)
info->myflags|= MY_FULL_IO;
else
info->myflags&= ~MY_FULL_IO;
} | O0 | c | init_functions:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xb0(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xe0221
movq -0x18(%rbp), %rax
leaq 0x79499(%rip), %rcx # 0x1595c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xe013a
jmp 0xe013c
jmp 0xe0221
movq -0x8(%rbp), %rax
leaq 0x1e94(%rip), %rcx # 0xe1fe0
movq %rcx, 0xa0(%rax)
jmp 0xe0155
jmp 0xe0221
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0xe018d
jmp 0xe0171
jmp 0xe0173
leaq 0xba227e(%rip), %rax # 0xc823f8
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
jmp 0xe0221
jmp 0xe018f
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0xe01bb
leaq 0xba2255(%rip), %rax # 0xc82400
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
jmp 0xe0221
jmp 0xe01bd
jmp 0xe01bf
jmp 0xe01c1
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x224d(%rip), %rcx # 0xe2420
leaq 0xd46(%rip), %rax # 0xe0f20
cmpq $0x0, %rdx
cmovneq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x2661(%rip), %rcx # 0xe2860
leaq 0x114a(%rip), %rax # 0xe1350
cmpq $0x0, %rdx
cmovneq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
jmp 0xe0221
jmp 0xe021d
jmp 0xe021f
jmp 0xe0221
cmpl $0x1, -0xc(%rbp)
je 0xe0233
cmpl $0x2, -0xc(%rbp)
je 0xe0233
cmpl $0x3, -0xc(%rbp)
jne 0xe024e
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rcx
orq $0x200, %rcx # imm = 0x200
movq %rcx, 0xf8(%rax)
jmp 0xe026a
movq -0x8(%rbp), %rax
movabsq $0xfffffdff, %rcx # imm = 0xFFFFFDFF
andq 0xf8(%rax), %rcx
movq %rcx, 0xf8(%rax)
popq %rbp
retq
nopl (%rax)
| init_functions:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov eax, [rax+0B0h]
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
mov qword ptr [rax+0A0h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+0A8h], 0
mov eax, [rbp+var_C]
mov [rbp+var_18], rax
sub rax, 5; switch 6 cases
ja def_E0136; jumptable 00000000000E0136 default case
mov rax, [rbp+var_18]
lea rcx, jpt_E0136
movsxd rax, ds:(jpt_E0136 - 1595C8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_E0138:
jmp short $+2; jumptable 00000000000E0136 case 5
loc_E013A:
jmp short $+2
loc_E013C:
jmp def_E0136; jumptable 00000000000E0136 default case
loc_E0141:
mov rax, [rbp+var_8]; jumptable 00000000000E0136 case 3
lea rcx, _my_b_seq_read
mov [rax+0A0h], rcx
jmp short $+2
loc_E0155:
jmp def_E0136; jumptable 00000000000E0136 default case
loc_E015A:
mov rax, [rbp+var_8]; jumptable 00000000000E0136 case 1
mov rax, [rax+0F8h]
and rax, 40h
cmp rax, 0
jz short loc_E018D
jmp short $+2
loc_E0171:
jmp short $+2
loc_E0173:
lea rax, _my_b_encr_read
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+0A0h], rcx
jmp def_E0136; jumptable 00000000000E0136 default case
loc_E018D:
jmp short $+2; jumptable 00000000000E0136 case 2
loc_E018F:
mov rax, [rbp+var_8]; jumptable 00000000000E0136 case 2
mov rax, [rax+0F8h]
and rax, 40h
cmp rax, 0
jz short loc_E01BB
lea rax, _my_b_encr_write
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+0A8h], rcx
jmp short def_E0136; jumptable 00000000000E0136 default case
loc_E01BB:
jmp short $+2; jumptable 00000000000E0136 case 4
loc_E01BD:
jmp short $+2; jumptable 00000000000E0136 case 4
loc_E01BF:
jmp short $+2
loc_E01C1:
mov rax, [rbp+var_8]
mov rdx, [rax+98h]
lea rcx, _my_b_cache_read
lea rax, _my_b_cache_read_r
cmp rdx, 0
cmovnz rcx, rax
mov rax, [rbp+var_8]
mov [rax+0A0h], rcx
mov rax, [rbp+var_8]
mov rdx, [rax+98h]
lea rcx, _my_b_cache_write
lea rax, _my_b_cache_write_r
cmp rdx, 0
cmovnz rcx, rax
mov rax, [rbp+var_8]
mov [rax+0A8h], rcx
jmp short def_E0136; jumptable 00000000000E0136 default case
loc_E021B:
jmp short $+2; jumptable 00000000000E0136 case 0
loc_E021D:
jmp short $+2
loc_E021F:
jmp short $+2; jumptable 00000000000E0136 default case
def_E0136:
cmp [rbp+var_C], 1; jumptable 00000000000E0136 default case
jz short loc_E0233
cmp [rbp+var_C], 2
jz short loc_E0233
cmp [rbp+var_C], 3
jnz short loc_E024E
loc_E0233:
mov rax, [rbp+var_8]
mov rcx, [rax+0F8h]
or rcx, 200h
mov [rax+0F8h], rcx
jmp short loc_E026A
loc_E024E:
mov rax, [rbp+var_8]
mov rcx, 0FFFFFDFFh
and rcx, [rax+0F8h]
mov [rax+0F8h], rcx
loc_E026A:
pop rbp
retn
| long long init_functions(long long a1)
{
long long ( *v1)(); // rcx
long long ( *v2)(); // rcx
long long result; // rax
int v4; // [rsp+Ch] [rbp-Ch]
v4 = *(_DWORD *)(a1 + 176);
*(_QWORD *)(a1 + 160) = 0LL;
*(_QWORD *)(a1 + 168) = 0LL;
switch ( v4 )
{
case 1:
if ( (*(_QWORD *)(a1 + 248) & 0x40LL) == 0 )
goto LABEL_5;
*(_QWORD *)(a1 + 160) = my_b_encr_read;
break;
case 2:
LABEL_5:
if ( (*(_QWORD *)(a1 + 248) & 0x40LL) == 0 )
goto LABEL_7;
*(_QWORD *)(a1 + 168) = my_b_encr_write;
break;
case 3:
*(_QWORD *)(a1 + 160) = my_b_seq_read;
break;
case 4:
LABEL_7:
v1 = my_b_cache_read;
if ( *(_QWORD *)(a1 + 152) )
v1 = my_b_cache_read_r;
*(_QWORD *)(a1 + 160) = v1;
v2 = my_b_cache_write;
if ( *(_QWORD *)(a1 + 152) )
v2 = my_b_cache_write_r;
*(_QWORD *)(a1 + 168) = v2;
break;
default:
break;
}
if ( v4 == 1 || v4 == 2 || v4 == 3 )
{
result = a1;
*(_QWORD *)(a1 + 248) |= 0x200uLL;
}
else
{
result = a1;
*(_QWORD *)(a1 + 248) &= 0xFFFFFDFFuLL;
}
return result;
}
| init_functions:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xb0]
MOV dword ptr [RBP + -0xc],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],0x0
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x5
JA 0x001e0221
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x2595c8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
JMP 0x001e013a
LAB_001e013a:
JMP 0x001e013c
LAB_001e013c:
JMP 0x001e0221
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1e1fe0]
MOV qword ptr [RAX + 0xa0],RCX
JMP 0x001e0155
LAB_001e0155:
JMP 0x001e0221
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
AND RAX,0x40
CMP RAX,0x0
JZ 0x001e018d
JMP 0x001e0171
LAB_001e0171:
JMP 0x001e0173
LAB_001e0173:
LEA RAX,[0xd823f8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],RCX
JMP 0x001e0221
LAB_001e018d:
JMP 0x001e018f
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
AND RAX,0x40
CMP RAX,0x0
JZ 0x001e01bb
LEA RAX,[0xd82400]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],RCX
JMP 0x001e0221
LAB_001e01bb:
JMP 0x001e01bd
caseD_4:
JMP 0x001e01bf
LAB_001e01bf:
JMP 0x001e01c1
LAB_001e01c1:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RAX + 0x98]
LEA RCX,[0x1e2420]
LEA RAX,[0x1e0f20]
CMP RDX,0x0
CMOVNZ RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RAX + 0x98]
LEA RCX,[0x1e2860]
LEA RAX,[0x1e1350]
CMP RDX,0x0
CMOVNZ RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],RCX
JMP 0x001e0221
caseD_0:
JMP 0x001e021d
LAB_001e021d:
JMP 0x001e021f
LAB_001e021f:
JMP 0x001e0221
default:
CMP dword ptr [RBP + -0xc],0x1
JZ 0x001e0233
CMP dword ptr [RBP + -0xc],0x2
JZ 0x001e0233
CMP dword ptr [RBP + -0xc],0x3
JNZ 0x001e024e
LAB_001e0233:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0xf8]
OR RCX,0x200
MOV qword ptr [RAX + 0xf8],RCX
JMP 0x001e026a
LAB_001e024e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,0xfffffdff
AND RCX,qword ptr [RAX + 0xf8]
MOV qword ptr [RAX + 0xf8],RCX
LAB_001e026a:
POP RBP
RET
|
void init_functions(long param_1)
{
int iVar1;
code *pcVar2;
iVar1 = *(int *)(param_1 + 0xb0);
*(int8 *)(param_1 + 0xa0) = 0;
*(int8 *)(param_1 + 0xa8) = 0;
switch(iVar1) {
case 0:
break;
case 1:
if ((*(ulong *)(param_1 + 0xf8) & 0x40) != 0) {
*(int8 *)(param_1 + 0xa0) = _my_b_encr_read;
break;
}
case 2:
if ((*(ulong *)(param_1 + 0xf8) & 0x40) == 0) {
LAB_001e01c1:
pcVar2 = _my_b_cache_read;
if (*(long *)(param_1 + 0x98) != 0) {
pcVar2 = _my_b_cache_read_r;
}
*(code **)(param_1 + 0xa0) = pcVar2;
pcVar2 = _my_b_cache_write;
if (*(long *)(param_1 + 0x98) != 0) {
pcVar2 = _my_b_cache_write_r;
}
*(code **)(param_1 + 0xa8) = pcVar2;
}
else {
*(int8 *)(param_1 + 0xa8) = _my_b_encr_write;
}
break;
case 3:
*(code **)(param_1 + 0xa0) = _my_b_seq_read;
break;
case 4:
goto LAB_001e01c1;
case 5:
}
if (((iVar1 == 1) || (iVar1 == 2)) || (iVar1 == 3)) {
*(ulong *)(param_1 + 0xf8) = *(ulong *)(param_1 + 0xf8) | 0x200;
}
else {
*(ulong *)(param_1 + 0xf8) = *(ulong *)(param_1 + 0xf8) & 0xfffffdff;
}
return;
}
|
|
2,642 | my_coll_parser_scan_character_list | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_character_list(MY_COLL_RULE_PARSER *p,
my_wc_t *pwc, size_t limit,
const char *name)
{
if (my_coll_parser_curr(p)->term != MY_COLL_LEXEM_CHAR)
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_CHAR);
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_CHAR))
return 0;
while (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CHAR)
{
if (!my_coll_rule_expand(pwc, limit, my_coll_parser_curr(p)->code))
return my_coll_parser_too_long_error(p, name);
my_coll_parser_scan(p);
}
return 1;
} | O0 | c | my_coll_parser_scan_character_list:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ed70
cmpl $0x5, (%rax)
je 0x4fd6c
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x4f6b0
movl %eax, -0x4(%rbp)
jmp 0x4fe2c
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ed70
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0x4fe40
cmpl $0x0, %eax
jne 0x4fdad
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4feb0
movl %eax, -0x4(%rbp)
jmp 0x4fe2c
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x4f340
cmpl $0x0, %eax
jne 0x4fdc9
movl $0x0, -0x4(%rbp)
jmp 0x4fe2c
jmp 0x4fdcb
movq -0x10(%rbp), %rdi
callq 0x4ed70
cmpl $0x5, (%rax)
jne 0x4fe25
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4ed70
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movslq 0x24(%rax), %rdx
callq 0x4fe40
cmpl $0x0, %eax
jne 0x4fe1a
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4feb0
movl %eax, -0x4(%rbp)
jmp 0x4fe2c
movq -0x10(%rbp), %rdi
callq 0x4f550
jmp 0x4fdcb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_character_list:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jz short loc_4FD6C
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_expected_error
mov [rbp+var_4], eax
jmp loc_4FE2C
loc_4FD6C:
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_4FDAD
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_4FE2C
loc_4FDAD:
mov rdi, [rbp+var_10]
mov esi, 5
call my_coll_parser_scan_term
cmp eax, 0
jnz short loc_4FDC9
mov [rbp+var_4], 0
jmp short loc_4FE2C
loc_4FDC9:
jmp short $+2
loc_4FDCB:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 5
jnz short loc_4FE25
mov rax, [rbp+var_18]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
movsxd rdx, dword ptr [rax+24h]
call my_coll_rule_expand
cmp eax, 0
jnz short loc_4FE1A
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call my_coll_parser_too_long_error
mov [rbp+var_4], eax
jmp short loc_4FE2C
loc_4FE1A:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
jmp short loc_4FDCB
loc_4FE25:
mov [rbp+var_4], 1
loc_4FE2C:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long my_coll_parser_scan_character_list(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rax
long long v5; // rax
if ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v4 = my_coll_parser_curr(a1);
if ( (unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v4 + 36)) )
{
if ( (unsigned int)my_coll_parser_scan_term(a1, 5u) )
{
while ( *(_DWORD *)my_coll_parser_curr(a1) == 5 )
{
v5 = my_coll_parser_curr(a1);
if ( !(unsigned int)my_coll_rule_expand(a2, a3, *(int *)(v5 + 36)) )
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
my_coll_parser_scan(a1);
}
return 1;
}
else
{
return 0;
}
}
else
{
return (unsigned int)my_coll_parser_too_long_error(a1, a4);
}
}
else
{
return (unsigned int)my_coll_parser_expected_error(a1, 5u);
}
}
| my_coll_parser_scan_character_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ed70
CMP dword ptr [RAX],0x5
JZ 0x0014fd6c
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x0014f6b0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014fe2c
LAB_0014fd6c:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ed70
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x0014fe40
CMP EAX,0x0
JNZ 0x0014fdad
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0014feb0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014fe2c
LAB_0014fdad:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x5
CALL 0x0014f340
CMP EAX,0x0
JNZ 0x0014fdc9
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014fe2c
LAB_0014fdc9:
JMP 0x0014fdcb
LAB_0014fdcb:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ed70
CMP dword ptr [RAX],0x5
JNZ 0x0014fe25
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ed70
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOVSXD RDX,dword ptr [RAX + 0x24]
CALL 0x0014fe40
CMP EAX,0x0
JNZ 0x0014fe1a
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x0014feb0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014fe2c
LAB_0014fe1a:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014f550
JMP 0x0014fdcb
LAB_0014fe25:
MOV dword ptr [RBP + -0x4],0x1
LAB_0014fe2c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
my_coll_parser_scan_character_list
(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int iVar1;
int4 uVar2;
int *piVar3;
long lVar4;
int4 local_c;
piVar3 = (int *)my_coll_parser_curr(param_1);
if (*piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
local_c = my_coll_parser_too_long_error(param_1,param_4);
}
else {
iVar1 = my_coll_parser_scan_term(param_1,5);
if (iVar1 == 0) {
local_c = 0;
}
else {
while (piVar3 = (int *)my_coll_parser_curr(param_1), *piVar3 == 5) {
lVar4 = my_coll_parser_curr(param_1);
iVar1 = my_coll_rule_expand(param_2,param_3,(long)*(int *)(lVar4 + 0x24));
if (iVar1 == 0) {
uVar2 = my_coll_parser_too_long_error(param_1,param_4);
return uVar2;
}
my_coll_parser_scan(param_1);
}
local_c = 1;
}
}
}
else {
local_c = my_coll_parser_expected_error(param_1,5);
}
return local_c;
}
|
|
2,643 | calculate_gas_for_modexp | corpus-core[P]colibri-stateless/src/chains/eth/precompiles/precompiles_basic.c | static uint64_t calculate_gas_for_modexp(uint32_t l_base, uint32_t l_exp, uint32_t l_mod, bytes_t b_exp) {
uint64_t max_len = l_base > l_mod ? l_base : l_mod;
uint32_t words = (max_len + 7) / 8;
uint32_t multiplication_complexity = words * words;
uint32_t iteration_count = 0;
if (l_exp <= 32 && bytes_all_zero(b_exp)) {
iteration_count = 0;
}
else if (l_exp <= 32) {
// Calculate bit_length() - 1 of the exponent
uint32_t bit_length = 0;
for (int i = 0; i < b_exp.len; i++) {
if (b_exp.data[i] != 0) {
uint8_t byte = b_exp.data[i];
for (int j = 7; j >= 0; j--) {
if ((byte >> j) & 1) {
bit_length = i * 8 + j + 1;
break;
}
}
if (bit_length > 0) break;
}
}
iteration_count = bit_length > 0 ? bit_length - 1 : 0;
}
else if (l_exp > 32) {
// 8 * (Esize - 32) + bit_length of lower 256 bits - 1
uint32_t base_count = 8 * (l_exp - 32);
// Calculate bit_length of lower 256 bits
uint32_t bit_length = 0;
uint32_t bytes_to_check = l_exp > 64 ? 32 : l_exp - 32; // Only check up to 256 bits (32 bytes)
for (int i = 0; i < bytes_to_check; i++) {
if (b_exp.data[i] != 0) {
uint8_t byte = b_exp.data[i];
for (int j = 7; j >= 0; j--) {
if ((byte >> j) & 1) {
bit_length = i * 8 + j + 1;
break;
}
}
if (bit_length > 0) break;
}
}
iteration_count = base_count + (bit_length > 0 ? bit_length - 1 : 0);
}
// Ensure iteration_count is at least 1
uint32_t calculate_iteration_count = iteration_count > 0 ? iteration_count : 1;
// Calculate final gas cost
uint64_t dynamic_gas = multiplication_complexity * calculate_iteration_count / 3;
if (dynamic_gas < 200) dynamic_gas = 200;
return dynamic_gas;
} | O0 | c | calculate_gas_for_modexp:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %ecx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x9d7fb
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x9d801
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x7, %rax
shrq $0x3, %rax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
imull -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x20, -0x18(%rbp)
ja 0x9d850
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x9e340
testb $0x1, %al
jne 0x9d844
jmp 0x9d850
movl $0x0, -0x34(%rbp)
jmp 0x9d9ef
cmpl $0x20, -0x18(%rbp)
ja 0x9d905
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9d8e2
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x9d8d5
movq -0x8(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x3d(%rbp)
movl $0x7, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x9d8cb
movzbl -0x3d(%rbp), %eax
movl -0x44(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9d8be
movl -0x3c(%rbp), %eax
shll $0x3, %eax
addl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9d8cb
jmp 0x9d8c0
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x9d896
cmpl $0x0, -0x38(%rbp)
jbe 0x9d8d3
jmp 0x9d8e2
jmp 0x9d8d5
jmp 0x9d8d7
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x9d868
cmpl $0x0, -0x38(%rbp)
jbe 0x9d8f3
movl -0x38(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x9d8fa
xorl %eax, %eax
movl %eax, -0x70(%rbp)
jmp 0x9d8fa
movl -0x70(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x9d9ed
cmpl $0x20, -0x18(%rbp)
jbe 0x9d9eb
movl -0x18(%rbp), %eax
subl $0x20, %eax
shll $0x3, %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpl $0x40, -0x18(%rbp)
jbe 0x9d932
movl $0x20, %eax
movl %eax, -0x74(%rbp)
jmp 0x9d93b
movl -0x18(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
movl %eax, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x50(%rbp), %eax
jae 0x9d9c2
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x9d9b5
movq -0x8(%rbp), %rax
movslq -0x54(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x55(%rbp)
movl $0x7, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jl 0x9d9ab
movzbl -0x55(%rbp), %eax
movl -0x5c(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9d99e
movl -0x54(%rbp), %eax
shll $0x3, %eax
addl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x9d9ab
jmp 0x9d9a0
movl -0x5c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x9d976
cmpl $0x0, -0x4c(%rbp)
jbe 0x9d9b3
jmp 0x9d9c2
jmp 0x9d9b5
jmp 0x9d9b7
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x9d948
movl -0x48(%rbp), %eax
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x4c(%rbp)
jbe 0x9d9d9
movl -0x4c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x9d9e0
xorl %eax, %eax
movl %eax, -0x7c(%rbp)
jmp 0x9d9e0
movl -0x78(%rbp), %eax
movl -0x7c(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x34(%rbp)
jmp 0x9d9ed
jmp 0x9d9ef
cmpl $0x0, -0x34(%rbp)
jbe 0x9d9fd
movl -0x34(%rbp), %eax
movl %eax, -0x80(%rbp)
jmp 0x9da07
movl $0x1, %eax
movl %eax, -0x80(%rbp)
jmp 0x9da07
movl -0x80(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x30(%rbp), %eax
imull -0x60(%rbp), %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movq %rax, -0x68(%rbp)
cmpq $0xc8, -0x68(%rbp)
jae 0x9da35
movq $0xc8, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| calculate_gas_for_modexp:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], ecx
mov [rbp+var_8], r8
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jbe short loc_9D7FB
mov eax, [rbp+var_14]
mov [rbp+var_6C], eax
jmp short loc_9D801
loc_9D7FB:
mov eax, [rbp+var_1C]
mov [rbp+var_6C], eax
loc_9D801:
mov eax, [rbp+var_6C]
mov eax, eax
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
add rax, 7
shr rax, 3
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
imul eax, [rbp+var_2C]
mov [rbp+var_30], eax
mov [rbp+var_34], 0
cmp [rbp+var_18], 20h ; ' '
ja short loc_9D850
mov edi, [rbp+var_10]
mov rsi, [rbp+var_8]
xor edx, edx
call bytes_all_equal
test al, 1
jnz short loc_9D844
jmp short loc_9D850
loc_9D844:
mov [rbp+var_34], 0
jmp loc_9D9EF
loc_9D850:
cmp [rbp+var_18], 20h ; ' '
ja loc_9D905
mov [rbp+var_38], 0
mov [rbp+var_3C], 0
loc_9D868:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_10]
jnb short loc_9D8E2
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_3C]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0
jz short loc_9D8D5
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_3C]
mov al, [rax+rcx]
mov [rbp+var_3D], al
mov [rbp+var_44], 7
loc_9D896:
cmp [rbp+var_44], 0
jl short loc_9D8CB
movzx eax, [rbp+var_3D]
mov ecx, [rbp+var_44]
sar eax, cl
and eax, 1
cmp eax, 0
jz short loc_9D8BE
mov eax, [rbp+var_3C]
shl eax, 3
add eax, [rbp+var_44]
add eax, 1
mov [rbp+var_38], eax
jmp short loc_9D8CB
loc_9D8BE:
jmp short $+2
loc_9D8C0:
mov eax, [rbp+var_44]
add eax, 0FFFFFFFFh
mov [rbp+var_44], eax
jmp short loc_9D896
loc_9D8CB:
cmp [rbp+var_38], 0
jbe short loc_9D8D3
jmp short loc_9D8E2
loc_9D8D3:
jmp short $+2
loc_9D8D5:
jmp short $+2
loc_9D8D7:
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp short loc_9D868
loc_9D8E2:
cmp [rbp+var_38], 0
jbe short loc_9D8F3
mov eax, [rbp+var_38]
sub eax, 1
mov [rbp+var_70], eax
jmp short loc_9D8FA
loc_9D8F3:
xor eax, eax
mov [rbp+var_70], eax
jmp short $+2
loc_9D8FA:
mov eax, [rbp+var_70]
mov [rbp+var_34], eax
jmp loc_9D9ED
loc_9D905:
cmp [rbp+var_18], 20h ; ' '
jbe loc_9D9EB
mov eax, [rbp+var_18]
sub eax, 20h ; ' '
shl eax, 3
mov [rbp+var_48], eax
mov [rbp+var_4C], 0
cmp [rbp+var_18], 40h ; '@'
jbe short loc_9D932
mov eax, 20h ; ' '
mov [rbp+var_74], eax
jmp short loc_9D93B
loc_9D932:
mov eax, [rbp+var_18]
sub eax, 20h ; ' '
mov [rbp+var_74], eax
loc_9D93B:
mov eax, [rbp+var_74]
mov [rbp+var_50], eax
mov [rbp+var_54], 0
loc_9D948:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_50]
jnb short loc_9D9C2
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_54]
movzx eax, byte ptr [rax+rcx]
cmp eax, 0
jz short loc_9D9B5
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_54]
mov al, [rax+rcx]
mov [rbp+var_55], al
mov [rbp+var_5C], 7
loc_9D976:
cmp [rbp+var_5C], 0
jl short loc_9D9AB
movzx eax, [rbp+var_55]
mov ecx, [rbp+var_5C]
sar eax, cl
and eax, 1
cmp eax, 0
jz short loc_9D99E
mov eax, [rbp+var_54]
shl eax, 3
add eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_4C], eax
jmp short loc_9D9AB
loc_9D99E:
jmp short $+2
loc_9D9A0:
mov eax, [rbp+var_5C]
add eax, 0FFFFFFFFh
mov [rbp+var_5C], eax
jmp short loc_9D976
loc_9D9AB:
cmp [rbp+var_4C], 0
jbe short loc_9D9B3
jmp short loc_9D9C2
loc_9D9B3:
jmp short $+2
loc_9D9B5:
jmp short $+2
loc_9D9B7:
mov eax, [rbp+var_54]
add eax, 1
mov [rbp+var_54], eax
jmp short loc_9D948
loc_9D9C2:
mov eax, [rbp+var_48]
mov [rbp+var_78], eax
cmp [rbp+var_4C], 0
jbe short loc_9D9D9
mov eax, [rbp+var_4C]
sub eax, 1
mov [rbp+var_7C], eax
jmp short loc_9D9E0
loc_9D9D9:
xor eax, eax
mov [rbp+var_7C], eax
jmp short $+2
loc_9D9E0:
mov eax, [rbp+var_78]
mov ecx, [rbp+var_7C]
add eax, ecx
mov [rbp+var_34], eax
loc_9D9EB:
jmp short $+2
loc_9D9ED:
jmp short $+2
loc_9D9EF:
cmp [rbp+var_34], 0
jbe short loc_9D9FD
mov eax, [rbp+var_34]
mov [rbp+var_80], eax
jmp short loc_9DA07
loc_9D9FD:
mov eax, 1
mov [rbp+var_80], eax
jmp short $+2
loc_9DA07:
mov eax, [rbp+var_80]
mov [rbp+var_60], eax
mov eax, [rbp+var_30]
imul eax, [rbp+var_60]
mov ecx, 3
xor edx, edx
div ecx
mov eax, eax
mov [rbp+var_68], rax
cmp [rbp+var_68], 0C8h
jnb short loc_9DA35
mov [rbp+var_68], 0C8h
loc_9DA35:
mov rax, [rbp+var_68]
add rsp, 80h
pop rbp
retn
| long long calculate_gas_for_modexp(
unsigned int a1,
unsigned int a2,
unsigned int a3,
unsigned int a4,
long long a5)
{
int v6; // [rsp+0h] [rbp-80h]
int v7; // [rsp+4h] [rbp-7Ch]
unsigned int v8; // [rsp+Ch] [rbp-74h]
int v9; // [rsp+10h] [rbp-70h]
unsigned int v10; // [rsp+14h] [rbp-6Ch]
unsigned long long v11; // [rsp+18h] [rbp-68h]
int j; // [rsp+24h] [rbp-5Ch]
signed int i; // [rsp+2Ch] [rbp-54h]
int v14; // [rsp+34h] [rbp-4Ch]
int m; // [rsp+3Ch] [rbp-44h]
unsigned int k; // [rsp+44h] [rbp-3Ch]
int v17; // [rsp+48h] [rbp-38h]
int v18; // [rsp+4Ch] [rbp-34h]
if ( a1 <= a3 )
v10 = a3;
else
v10 = a1;
if ( a2 <= 0x20 && (bytes_all_equal(a4, a5, 0LL) & 1) != 0 )
{
v18 = 0;
}
else if ( a2 > 0x20 )
{
v14 = 0;
if ( a2 <= 0x40 )
v8 = a2 - 32;
else
v8 = 32;
for ( i = 0; i < v8; ++i )
{
if ( *(_BYTE *)(a5 + i) )
{
for ( j = 7; j >= 0; --j )
{
if ( (((int)*(unsigned __int8 *)(a5 + i) >> j) & 1) != 0 )
{
v14 = j + 8 * i + 1;
break;
}
}
if ( v14 )
break;
}
}
if ( v14 )
v7 = v14 - 1;
else
v7 = 0;
v18 = v7 + 8 * (a2 - 32);
}
else
{
v17 = 0;
for ( k = 0; k < a4; ++k )
{
if ( *(_BYTE *)(a5 + (int)k) )
{
for ( m = 7; m >= 0; --m )
{
if ( (((int)*(unsigned __int8 *)(a5 + (int)k) >> m) & 1) != 0 )
{
v17 = m + 8 * k + 1;
break;
}
}
if ( v17 )
break;
}
}
if ( v17 )
v9 = v17 - 1;
else
v9 = 0;
v18 = v9;
}
if ( v18 )
v6 = v18;
else
v6 = 1;
v11 = v6 * (unsigned int)(((unsigned long long)v10 + 7) >> 3) * (unsigned int)(((unsigned long long)v10 + 7) >> 3) / 3;
if ( v11 < 0xC8 )
return 200LL;
return v11;
}
| calculate_gas_for_modexp:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x10],ECX
MOV qword ptr [RBP + -0x8],R8
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JBE 0x0019d7fb
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x0019d801
LAB_0019d7fb:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x6c],EAX
LAB_0019d801:
MOV EAX,dword ptr [RBP + -0x6c]
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x7
SHR RAX,0x3
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
IMUL EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x30],EAX
MOV dword ptr [RBP + -0x34],0x0
CMP dword ptr [RBP + -0x18],0x20
JA 0x0019d850
MOV EDI,dword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
XOR EDX,EDX
CALL 0x0019e340
TEST AL,0x1
JNZ 0x0019d844
JMP 0x0019d850
LAB_0019d844:
MOV dword ptr [RBP + -0x34],0x0
JMP 0x0019d9ef
LAB_0019d850:
CMP dword ptr [RBP + -0x18],0x20
JA 0x0019d905
MOV dword ptr [RBP + -0x38],0x0
MOV dword ptr [RBP + -0x3c],0x0
LAB_0019d868:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x10]
JNC 0x0019d8e2
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
JZ 0x0019d8d5
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x3d],AL
MOV dword ptr [RBP + -0x44],0x7
LAB_0019d896:
CMP dword ptr [RBP + -0x44],0x0
JL 0x0019d8cb
MOVZX EAX,byte ptr [RBP + -0x3d]
MOV ECX,dword ptr [RBP + -0x44]
SAR EAX,CL
AND EAX,0x1
CMP EAX,0x0
JZ 0x0019d8be
MOV EAX,dword ptr [RBP + -0x3c]
SHL EAX,0x3
ADD EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0019d8cb
LAB_0019d8be:
JMP 0x0019d8c0
LAB_0019d8c0:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0019d896
LAB_0019d8cb:
CMP dword ptr [RBP + -0x38],0x0
JBE 0x0019d8d3
JMP 0x0019d8e2
LAB_0019d8d3:
JMP 0x0019d8d5
LAB_0019d8d5:
JMP 0x0019d8d7
LAB_0019d8d7:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0019d868
LAB_0019d8e2:
CMP dword ptr [RBP + -0x38],0x0
JBE 0x0019d8f3
MOV EAX,dword ptr [RBP + -0x38]
SUB EAX,0x1
MOV dword ptr [RBP + -0x70],EAX
JMP 0x0019d8fa
LAB_0019d8f3:
XOR EAX,EAX
MOV dword ptr [RBP + -0x70],EAX
JMP 0x0019d8fa
LAB_0019d8fa:
MOV EAX,dword ptr [RBP + -0x70]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0019d9ed
LAB_0019d905:
CMP dword ptr [RBP + -0x18],0x20
JBE 0x0019d9eb
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x20
SHL EAX,0x3
MOV dword ptr [RBP + -0x48],EAX
MOV dword ptr [RBP + -0x4c],0x0
CMP dword ptr [RBP + -0x18],0x40
JBE 0x0019d932
MOV EAX,0x20
MOV dword ptr [RBP + -0x74],EAX
JMP 0x0019d93b
LAB_0019d932:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x20
MOV dword ptr [RBP + -0x74],EAX
LAB_0019d93b:
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0x50],EAX
MOV dword ptr [RBP + -0x54],0x0
LAB_0019d948:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x50]
JNC 0x0019d9c2
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x54]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x0
JZ 0x0019d9b5
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x54]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x55],AL
MOV dword ptr [RBP + -0x5c],0x7
LAB_0019d976:
CMP dword ptr [RBP + -0x5c],0x0
JL 0x0019d9ab
MOVZX EAX,byte ptr [RBP + -0x55]
MOV ECX,dword ptr [RBP + -0x5c]
SAR EAX,CL
AND EAX,0x1
CMP EAX,0x0
JZ 0x0019d99e
MOV EAX,dword ptr [RBP + -0x54]
SHL EAX,0x3
ADD EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x0019d9ab
LAB_0019d99e:
JMP 0x0019d9a0
LAB_0019d9a0:
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x0019d976
LAB_0019d9ab:
CMP dword ptr [RBP + -0x4c],0x0
JBE 0x0019d9b3
JMP 0x0019d9c2
LAB_0019d9b3:
JMP 0x0019d9b5
LAB_0019d9b5:
JMP 0x0019d9b7
LAB_0019d9b7:
MOV EAX,dword ptr [RBP + -0x54]
ADD EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0019d948
LAB_0019d9c2:
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x78],EAX
CMP dword ptr [RBP + -0x4c],0x0
JBE 0x0019d9d9
MOV EAX,dword ptr [RBP + -0x4c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x0019d9e0
LAB_0019d9d9:
XOR EAX,EAX
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x0019d9e0
LAB_0019d9e0:
MOV EAX,dword ptr [RBP + -0x78]
MOV ECX,dword ptr [RBP + -0x7c]
ADD EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
LAB_0019d9eb:
JMP 0x0019d9ed
LAB_0019d9ed:
JMP 0x0019d9ef
LAB_0019d9ef:
CMP dword ptr [RBP + -0x34],0x0
JBE 0x0019d9fd
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x80],EAX
JMP 0x0019da07
LAB_0019d9fd:
MOV EAX,0x1
MOV dword ptr [RBP + -0x80],EAX
JMP 0x0019da07
LAB_0019da07:
MOV EAX,dword ptr [RBP + -0x80]
MOV dword ptr [RBP + -0x60],EAX
MOV EAX,dword ptr [RBP + -0x30]
IMUL EAX,dword ptr [RBP + -0x60]
MOV ECX,0x3
XOR EDX,EDX
DIV ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x68],RAX
CMP qword ptr [RBP + -0x68],0xc8
JNC 0x0019da35
MOV qword ptr [RBP + -0x68],0xc8
LAB_0019da35:
MOV RAX,qword ptr [RBP + -0x68]
ADD RSP,0x80
POP RBP
RET
|
int1 [16]
calculate_gas_for_modexp(uint param_1,uint param_2,uint param_3,uint param_4,long param_5)
{
int iVar1;
ulong uVar2;
int1 auVar3 [16];
int local_88;
int local_84;
uint local_7c;
int local_78;
uint local_74;
ulong local_70;
int local_64;
uint local_5c;
int local_54;
int local_4c;
uint local_44;
int local_40;
int local_3c;
local_74 = param_3;
if (param_3 < param_1) {
local_74 = param_1;
}
iVar1 = (int)((ulong)local_74 + 7 >> 3);
local_3c = 0;
if ((param_2 < 0x21) && (uVar2 = bytes_all_equal(param_4,param_5,0), (uVar2 & 1) != 0)) {
local_3c = 0;
}
else if (param_2 < 0x21) {
local_40 = 0;
for (local_44 = 0; local_44 < param_4; local_44 = local_44 + 1) {
if (*(char *)(param_5 + (int)local_44) != '\0') {
for (local_4c = 7; -1 < local_4c; local_4c = local_4c + -1) {
if (((int)(uint)*(byte *)(param_5 + (int)local_44) >> ((byte)local_4c & 0x1f) & 1U) != 0)
{
local_40 = local_44 * 8 + local_4c + 1;
break;
}
}
if (local_40 != 0) break;
}
}
if (local_40 == 0) {
local_78 = 0;
}
else {
local_78 = local_40 + -1;
}
local_3c = local_78;
}
else if (0x20 < param_2) {
local_54 = 0;
if (param_2 < 0x41) {
local_7c = param_2 - 0x20;
}
else {
local_7c = 0x20;
}
for (local_5c = 0; local_5c < local_7c; local_5c = local_5c + 1) {
if (*(char *)(param_5 + (int)local_5c) != '\0') {
for (local_64 = 7; -1 < local_64; local_64 = local_64 + -1) {
if (((int)(uint)*(byte *)(param_5 + (int)local_5c) >> ((byte)local_64 & 0x1f) & 1U) != 0)
{
local_54 = local_5c * 8 + local_64 + 1;
break;
}
}
if (local_54 != 0) break;
}
}
if (local_54 == 0) {
local_84 = 0;
}
else {
local_84 = local_54 + -1;
}
local_3c = (param_2 - 0x20) * 8 + local_84;
}
if (local_3c == 0) {
local_88 = 1;
}
else {
local_88 = local_3c;
}
uVar2 = (ulong)(uint)(iVar1 * iVar1 * local_88);
local_70 = uVar2 / 3;
if (local_70 < 200) {
local_70 = 200;
}
auVar3._8_8_ = uVar2 % 3;
auVar3._0_8_ = local_70;
return auVar3;
}
|
|
2,644 | copy_str16 | bluesky950520[P]quickjs/quickjs.c | static void copy_str16(uint16_t *dst, const JSString *p, int offset, int len)
{
if (p->is_wide_char) {
memcpy(dst, p->u.str16 + offset, len * 2);
} else {
const uint8_t *src1 = p->u.str8 + offset;
int i;
for(i = 0; i < len; i++)
dst[i] = src1[i];
}
} | O2 | c | copy_str16:
movq %rsi, %rax
addq $0x18, %rsi
testb $-0x80, 0x7(%rax)
jne 0x3a89b
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x3a8a2
movzbl (%rsi,%rax), %ecx
movw %cx, (%rdi,%rax,2)
incq %rax
jmp 0x3a889
addl %edx, %edx
jmp 0xe5c0
retq
| copy_str16:
mov rax, rsi
add rsi, 18h
test byte ptr [rax+7], 80h
jnz short loc_3A89B
xor eax, eax
test edx, edx
cmovle edx, eax
loc_3A889:
cmp rdx, rax
jz short locret_3A8A2
movzx ecx, byte ptr [rsi+rax]
mov [rdi+rax*2], cx
inc rax
jmp short loc_3A889
loc_3A89B:
add edx, edx
jmp _memcpy
locret_3A8A2:
retn
| long long copy_str16(long long a1, long long a2, long long a3)
{
long long v4; // rsi
long long result; // rax
v4 = a2 + 24;
if ( *(char *)(a2 + 7) < 0 )
return memcpy(a1, v4, (unsigned int)(2 * a3));
result = 0LL;
if ( (int)a3 <= 0 )
a3 = 0LL;
while ( a3 != result )
{
*(_WORD *)(a1 + 2 * result) = *(unsigned __int8 *)(v4 + result);
++result;
}
return result;
}
| copy_str16:
MOV RAX,RSI
ADD RSI,0x18
TEST byte ptr [RAX + 0x7],0x80
JNZ 0x0013a89b
XOR EAX,EAX
TEST EDX,EDX
CMOVLE EDX,EAX
LAB_0013a889:
CMP RDX,RAX
JZ 0x0013a8a2
MOVZX ECX,byte ptr [RSI + RAX*0x1]
MOV word ptr [RDI + RAX*0x2],CX
INC RAX
JMP 0x0013a889
LAB_0013a89b:
ADD EDX,EDX
JMP 0x0010e5c0
LAB_0013a8a2:
RET
|
void copy_str16(void *param_1,long param_2,uint param_3)
{
ulong uVar1;
ulong uVar2;
if ((*(byte *)(param_2 + 7) & 0x80) == 0) {
uVar1 = 0;
uVar2 = (ulong)param_3;
if ((int)param_3 < 1) {
uVar2 = uVar1;
}
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
*(ushort *)((long)param_1 + uVar1 * 2) = (ushort)*(byte *)(param_2 + 0x18 + uVar1);
}
return;
}
memcpy(param_1,(void *)(param_2 + 0x18),(ulong)(param_3 * 2));
return;
}
|
|
2,645 | GetCameraMatrix2D | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | Matrix GetCameraMatrix2D(Camera2D camera)
{
Matrix matTransform = { 0 };
// The camera in world-space is set by
// 1. Move it to target
// 2. Rotate by -rotation and scale by (1/zoom)
// When setting higher scale, it's more intuitive for the world to become bigger (= camera become smaller),
// not for the camera getting bigger, hence the invert. Same deal with rotation
// 3. Move it by (-offset);
// Offset defines target transform relative to screen, but since we're effectively "moving" screen (camera)
// we need to do it into opposite direction (inverse transform)
// Having camera transform in world-space, inverse of it gives the modelview transform
// Since (A*B*C)' = C'*B'*A', the modelview is
// 1. Move to offset
// 2. Rotate and Scale
// 3. Move by -target
Matrix matOrigin = MatrixTranslate(-camera.target.x, -camera.target.y, 0.0f);
Matrix matRotation = MatrixRotate((Vector3){ 0.0f, 0.0f, 1.0f }, camera.rotation*DEG2RAD);
Matrix matScale = MatrixScale(camera.zoom, camera.zoom, 1.0f);
Matrix matTranslation = MatrixTranslate(camera.offset.x, camera.offset.y, 0.0f);
matTransform = MatrixMultiply(MatrixMultiply(matOrigin, MatrixMultiply(matScale, matRotation)), matTranslation);
return matTransform;
} | O0 | c | GetCameraMatrix2D:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movaps 0xd95c0(%rip), %xmm2 # 0x1a8120
movss 0x8(%rax), %xmm0
movss 0xc(%rax), %xmm1
pxor %xmm2, %xmm0
pxor %xmm2, %xmm1
leaq -0x40(%rbp), %rdi
xorps %xmm2, %xmm2
callq 0xbeca0
movq -0x1f8(%rbp), %rax
movl $0x0, -0x8c(%rbp)
movl $0x0, -0x88(%rbp)
movl $0x3f800000, -0x84(%rbp) # imm = 0x3F800000
movss 0x10(%rax), %xmm2
movss 0xe4780(%rip), %xmm0 # 0x1b3330
mulss %xmm0, %xmm2
movl -0x84(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x8c(%rbp), %rax
movq %rax, -0xa0(%rbp)
movsd -0xa0(%rbp), %xmm0
movss -0x98(%rbp), %xmm1
leaq -0x80(%rbp), %rdi
callq 0xbed60
movq -0x1f8(%rbp), %rax
movss 0x14(%rax), %xmm0
movss 0x14(%rax), %xmm1
leaq -0xe0(%rbp), %rdi
movss 0xd54ed(%rip), %xmm2 # 0x1a40f4
callq 0xbf6b0
movq -0x1f8(%rbp), %rax
movss (%rax), %xmm0
movss 0x4(%rax), %xmm1
leaq -0x120(%rbp), %rdi
xorps %xmm2, %xmm2
callq 0xbeca0
movups -0x80(%rbp), %xmm0
movups -0x70(%rbp), %xmm1
movups -0x60(%rbp), %xmm2
movups -0x50(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x70(%rax)
movups %xmm2, 0x60(%rax)
movups %xmm1, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups -0xe0(%rbp), %xmm0
movups -0xd0(%rbp), %xmm1
movups -0xc0(%rbp), %xmm2
movups -0xb0(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x1e0(%rbp), %rdi
callq 0xbe810
movups -0x1e0(%rbp), %xmm0
movups -0x1d0(%rbp), %xmm1
movups -0x1c0(%rbp), %xmm2
movups -0x1b0(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x70(%rax)
movups %xmm2, 0x60(%rax)
movups %xmm1, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups -0x40(%rbp), %xmm0
movups -0x30(%rbp), %xmm1
movups -0x20(%rbp), %xmm2
movups -0x10(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x1a0(%rbp), %rdi
callq 0xbe810
movups -0x120(%rbp), %xmm0
movups -0x110(%rbp), %xmm1
movups -0x100(%rbp), %xmm2
movups -0xf0(%rbp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x70(%rax)
movups %xmm2, 0x60(%rax)
movups %xmm1, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups -0x1a0(%rbp), %xmm0
movups -0x190(%rbp), %xmm1
movups -0x180(%rbp), %xmm2
movups -0x170(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x160(%rbp), %rdi
callq 0xbe810
movq -0x1f0(%rbp), %rdi
leaq -0x160(%rbp), %rsi
movl $0x40, %edx
callq 0xa400
movq -0x1e8(%rbp), %rax
addq $0x280, %rsp # imm = 0x280
popq %rbp
retq
nopl (%rax)
| GetCameraMatrix2D:
push rbp
mov rbp, rsp
sub rsp, 280h
mov [rbp+var_1F0], rdi
mov rax, rdi
mov [rbp+var_1E8], rax
lea rax, [rbp+arg_0]
mov [rbp+var_1F8], rax
xorps xmm0, xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
movaps xmm2, cs:xmmword_1A8120
movss xmm0, dword ptr [rax+8]
movss xmm1, dword ptr [rax+0Ch]
pxor xmm0, xmm2
pxor xmm1, xmm2
lea rdi, [rbp+var_40]
xorps xmm2, xmm2
call MatrixTranslate
mov rax, [rbp+var_1F8]
mov dword ptr [rbp+var_8C], 0
mov dword ptr [rbp+var_8C+4], 0
mov [rbp+var_84], 3F800000h
movss xmm2, dword ptr [rax+10h]
movss xmm0, cs:dword_1B3330
mulss xmm2, xmm0
mov eax, [rbp+var_84]
mov [rbp+var_98], eax
mov rax, [rbp+var_8C]
mov [rbp+var_A0], rax
movsd xmm0, [rbp+var_A0]
movss xmm1, [rbp+var_98]
lea rdi, [rbp+var_80]
call MatrixRotate
mov rax, [rbp+var_1F8]
movss xmm0, dword ptr [rax+14h]
movss xmm1, dword ptr [rax+14h]
lea rdi, [rbp+var_E0]
movss xmm2, cs:dword_1A40F4
call MatrixScale
mov rax, [rbp+var_1F8]
movss xmm0, dword ptr [rax]
movss xmm1, dword ptr [rax+4]
lea rdi, [rbp+var_120]
xorps xmm2, xmm2
call MatrixTranslate
movups xmm0, [rbp+var_80]
movups xmm1, [rbp+var_70]
movups xmm2, [rbp+var_60]
movups xmm3, [rbp+var_50]
mov rax, rsp
movups xmmword ptr [rax+70h], xmm3
movups xmmword ptr [rax+60h], xmm2
movups xmmword ptr [rax+50h], xmm1
movups xmmword ptr [rax+40h], xmm0
movups xmm0, [rbp+var_E0]
movups xmm1, [rbp+var_D0]
movups xmm2, [rbp+var_C0]
movups xmm3, [rbp+var_B0]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
lea rdi, [rbp+var_1E0]
call MatrixMultiply
movups xmm0, [rbp+var_1E0]
movups xmm1, [rbp+var_1D0]
movups xmm2, [rbp+var_1C0]
movups xmm3, [rbp+var_1B0]
mov rax, rsp
movups xmmword ptr [rax+70h], xmm3
movups xmmword ptr [rax+60h], xmm2
movups xmmword ptr [rax+50h], xmm1
movups xmmword ptr [rax+40h], xmm0
movups xmm0, [rbp+var_40]
movups xmm1, [rbp+var_30]
movups xmm2, [rbp+var_20]
movups xmm3, [rbp+var_10]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
lea rdi, [rbp+var_1A0]
call MatrixMultiply
movups xmm0, [rbp+var_120]
movups xmm1, [rbp+var_110]
movups xmm2, [rbp+var_100]
movups xmm3, [rbp+var_F0]
mov rax, rsp
movups xmmword ptr [rax+70h], xmm3
movups xmmword ptr [rax+60h], xmm2
movups xmmword ptr [rax+50h], xmm1
movups xmmword ptr [rax+40h], xmm0
movups xmm0, [rbp+var_1A0]
movups xmm1, [rbp+var_190]
movups xmm2, [rbp+var_180]
movups xmm3, [rbp+var_170]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
lea rdi, [rbp+var_160]
call MatrixMultiply
mov rdi, [rbp+var_1F0]
lea rsi, [rbp+var_160]
mov edx, 40h ; '@'
call _memcpy
mov rax, [rbp+var_1E8]
add rsp, 280h
pop rbp
retn
| _OWORD * GetCameraMatrix2D(
_OWORD *a1,
long long a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
double a7,
double a8,
double a9,
double a10,
double a11,
double a12,
double a13,
double a14,
long long a15,
long long a16,
long long a17)
{
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
double v21; // xmm4_8
double v22; // xmm5_8
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
double v27; // xmm4_8
double v28; // xmm5_8
long long v29; // rdx
long long v30; // rcx
long long v31; // r8
long long v32; // r9
double v33; // xmm4_8
double v34; // xmm5_8
double v36[8]; // [rsp+A0h] [rbp-1E0h] BYREF
double v37[2]; // [rsp+E0h] [rbp-1A0h] BYREF
double v38; // [rsp+F0h] [rbp-190h]
double v39; // [rsp+F8h] [rbp-188h]
double v40; // [rsp+100h] [rbp-180h]
double v41; // [rsp+108h] [rbp-178h]
double v42; // [rsp+110h] [rbp-170h]
double v43; // [rsp+118h] [rbp-168h]
float v44[16]; // [rsp+120h] [rbp-160h] BYREF
double v45[8]; // [rsp+160h] [rbp-120h] BYREF
double v46[2]; // [rsp+1A0h] [rbp-E0h] BYREF
double v47; // [rsp+1B0h] [rbp-D0h]
double v48; // [rsp+1B8h] [rbp-C8h]
double v49; // [rsp+1C0h] [rbp-C0h]
double v50; // [rsp+1C8h] [rbp-B8h]
double v51; // [rsp+1D0h] [rbp-B0h]
double v52; // [rsp+1D8h] [rbp-A8h]
long long v53; // [rsp+1E0h] [rbp-A0h]
int v54; // [rsp+1E8h] [rbp-98h]
long long v55; // [rsp+1F4h] [rbp-8Ch]
int v56; // [rsp+1FCh] [rbp-84h]
double v57[8]; // [rsp+200h] [rbp-80h] BYREF
double v58[2]; // [rsp+240h] [rbp-40h] BYREF
double v59; // [rsp+250h] [rbp-30h]
double v60; // [rsp+258h] [rbp-28h]
double v61; // [rsp+260h] [rbp-20h]
double v62; // [rsp+268h] [rbp-18h]
double v63; // [rsp+270h] [rbp-10h]
double v64; // [rsp+278h] [rbp-8h]
a1[3] = 0LL;
a1[2] = 0LL;
a1[1] = 0LL;
*a1 = 0LL;
MatrixTranslate(
(long long)v58,
*(float *)_mm_xor_si128((__m128i)(unsigned int)a16, (__m128i)xmmword_1A8120).m128i_i32,
*(float *)_mm_xor_si128((__m128i)HIDWORD(a16), (__m128i)xmmword_1A8120).m128i_i32,
0.0);
v55 = 0LL;
v56 = 1065353216;
v54 = 1065353216;
v53 = 0LL;
MatrixRotate((long long)v57, 0.0, 1.0, *(float *)&a17 * 0.017453292);
MatrixScale((long long)v46, *((float *)&a17 + 1), *((float *)&a17 + 1), 1.0);
MatrixTranslate((long long)v45, *(float *)&a15, *((float *)&a15 + 1), 0.0);
MatrixMultiply(
(float *)v36,
a2,
v17,
v18,
v19,
v20,
v46[0],
v47,
v49,
v51,
v21,
v22,
a13,
a14,
v46[0],
v46[1],
v47,
v48,
v49,
v50,
v51,
v52,
v57[0],
*(long long *)&v57[1],
*(long long *)&v57[2],
*(long long *)&v57[3],
*(long long *)&v57[4],
*(long long *)&v57[5],
*(long long *)&v57[6],
*(long long *)&v57[7]);
MatrixMultiply(
(float *)v37,
a2,
v23,
v24,
v25,
v26,
v58[0],
v59,
v61,
v63,
v27,
v28,
a13,
a14,
v58[0],
v58[1],
v59,
v60,
v61,
v62,
v63,
v64,
v36[0],
*(long long *)&v36[1],
*(long long *)&v36[2],
*(long long *)&v36[3],
*(long long *)&v36[4],
*(long long *)&v36[5],
*(long long *)&v36[6],
*(long long *)&v36[7]);
MatrixMultiply(
v44,
a2,
v29,
v30,
v31,
v32,
v37[0],
v38,
v40,
v42,
v33,
v34,
a13,
a14,
v37[0],
v37[1],
v38,
v39,
v40,
v41,
v42,
v43,
v45[0],
*(long long *)&v45[1],
*(long long *)&v45[2],
*(long long *)&v45[3],
*(long long *)&v45[4],
*(long long *)&v45[5],
*(long long *)&v45[6],
*(long long *)&v45[7]);
memcpy(a1, v44, 64LL);
return a1;
}
| GetCameraMatrix2D:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x280
MOV qword ptr [RBP + -0x1f0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x1e8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x1f8],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOVAPS XMM2,xmmword ptr [0x002a8120]
MOVSS XMM0,dword ptr [RAX + 0x8]
MOVSS XMM1,dword ptr [RAX + 0xc]
PXOR XMM0,XMM2
PXOR XMM1,XMM2
LEA RDI,[RBP + -0x40]
XORPS XMM2,XMM2
CALL 0x001beca0
MOV RAX,qword ptr [RBP + -0x1f8]
MOV dword ptr [RBP + -0x8c],0x0
MOV dword ptr [RBP + -0x88],0x0
MOV dword ptr [RBP + -0x84],0x3f800000
MOVSS XMM2,dword ptr [RAX + 0x10]
MOVSS XMM0,dword ptr [0x002b3330]
MULSS XMM2,XMM0
MOV EAX,dword ptr [RBP + -0x84]
MOV dword ptr [RBP + -0x98],EAX
MOV RAX,qword ptr [RBP + -0x8c]
MOV qword ptr [RBP + -0xa0],RAX
MOVSD XMM0,qword ptr [RBP + -0xa0]
MOVSS XMM1,dword ptr [RBP + -0x98]
LEA RDI,[RBP + -0x80]
CALL 0x001bed60
MOV RAX,qword ptr [RBP + -0x1f8]
MOVSS XMM0,dword ptr [RAX + 0x14]
MOVSS XMM1,dword ptr [RAX + 0x14]
LEA RDI,[RBP + -0xe0]
MOVSS XMM2,dword ptr [0x002a40f4]
CALL 0x001bf6b0
MOV RAX,qword ptr [RBP + -0x1f8]
MOVSS XMM0,dword ptr [RAX]
MOVSS XMM1,dword ptr [RAX + 0x4]
LEA RDI,[RBP + -0x120]
XORPS XMM2,XMM2
CALL 0x001beca0
MOVUPS XMM0,xmmword ptr [RBP + -0x80]
MOVUPS XMM1,xmmword ptr [RBP + -0x70]
MOVUPS XMM2,xmmword ptr [RBP + -0x60]
MOVUPS XMM3,xmmword ptr [RBP + -0x50]
MOV RAX,RSP
MOVUPS xmmword ptr [RAX + 0x70],XMM3
MOVUPS xmmword ptr [RAX + 0x60],XMM2
MOVUPS xmmword ptr [RAX + 0x50],XMM1
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [RBP + -0xe0]
MOVUPS XMM1,xmmword ptr [RBP + -0xd0]
MOVUPS XMM2,xmmword ptr [RBP + -0xc0]
MOVUPS XMM3,xmmword ptr [RBP + -0xb0]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
LEA RDI,[RBP + -0x1e0]
CALL 0x001be810
MOVUPS XMM0,xmmword ptr [RBP + -0x1e0]
MOVUPS XMM1,xmmword ptr [RBP + -0x1d0]
MOVUPS XMM2,xmmword ptr [RBP + -0x1c0]
MOVUPS XMM3,xmmword ptr [RBP + -0x1b0]
MOV RAX,RSP
MOVUPS xmmword ptr [RAX + 0x70],XMM3
MOVUPS xmmword ptr [RAX + 0x60],XMM2
MOVUPS xmmword ptr [RAX + 0x50],XMM1
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [RBP + -0x40]
MOVUPS XMM1,xmmword ptr [RBP + -0x30]
MOVUPS XMM2,xmmword ptr [RBP + -0x20]
MOVUPS XMM3,xmmword ptr [RBP + -0x10]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
LEA RDI,[RBP + -0x1a0]
CALL 0x001be810
MOVUPS XMM0,xmmword ptr [RBP + -0x120]
MOVUPS XMM1,xmmword ptr [RBP + -0x110]
MOVUPS XMM2,xmmword ptr [RBP + -0x100]
MOVUPS XMM3,xmmword ptr [RBP + -0xf0]
MOV RAX,RSP
MOVUPS xmmword ptr [RAX + 0x70],XMM3
MOVUPS xmmword ptr [RAX + 0x60],XMM2
MOVUPS xmmword ptr [RAX + 0x50],XMM1
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [RBP + -0x1a0]
MOVUPS XMM1,xmmword ptr [RBP + -0x190]
MOVUPS XMM2,xmmword ptr [RBP + -0x180]
MOVUPS XMM3,xmmword ptr [RBP + -0x170]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
LEA RDI,[RBP + -0x160]
CALL 0x001be810
MOV RDI,qword ptr [RBP + -0x1f0]
LEA RSI,[RBP + -0x160]
MOV EDX,0x40
CALL 0x0010a400
MOV RAX,qword ptr [RBP + -0x1e8]
ADD RSP,0x280
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * GetCameraMatrix2D(int8 *param_1)
{
ulong in_stack_00000010;
int1 local_1e8 [64];
int1 local_1a8 [64];
int1 local_168 [64];
int1 local_128 [64];
int1 local_e8 [64];
int8 local_a8;
int4 local_a0;
int4 local_94;
int4 uStack_90;
int4 local_8c;
int1 local_88 [64];
int1 local_48 [64];
param_1[6] = 0;
param_1[7] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
MatrixTranslate(in_stack_00000010 & 0xffffffff ^ _DAT_002a8120,
in_stack_00000010 >> 0x20 ^ _DAT_002a8120,0,local_48);
local_94 = 0;
uStack_90 = 0;
local_8c = 0x3f800000;
local_a0 = 0x3f800000;
local_a8 = 0;
MatrixRotate(0,local_88);
MatrixScale(local_e8);
MatrixTranslate(local_128);
MatrixMultiply(local_1e8);
MatrixMultiply(local_1a8);
MatrixMultiply(local_168);
memcpy(param_1,local_168,0x40);
return param_1;
}
|
|
2,646 | GetCameraMatrix2D | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rcore.c | Matrix GetCameraMatrix2D(Camera2D camera)
{
Matrix matTransform = { 0 };
// The camera in world-space is set by
// 1. Move it to target
// 2. Rotate by -rotation and scale by (1/zoom)
// When setting higher scale, it's more intuitive for the world to become bigger (= camera become smaller),
// not for the camera getting bigger, hence the invert. Same deal with rotation
// 3. Move it by (-offset);
// Offset defines target transform relative to screen, but since we're effectively "moving" screen (camera)
// we need to do it into opposite direction (inverse transform)
// Having camera transform in world-space, inverse of it gives the modelview transform
// Since (A*B*C)' = C'*B'*A', the modelview is
// 1. Move to offset
// 2. Rotate and Scale
// 3. Move by -target
Matrix matOrigin = MatrixTranslate(-camera.target.x, -camera.target.y, 0.0f);
Matrix matRotation = MatrixRotate((Vector3){ 0.0f, 0.0f, 1.0f }, camera.rotation*DEG2RAD);
Matrix matScale = MatrixScale(camera.zoom, camera.zoom, 1.0f);
Matrix matTranslation = MatrixTranslate(camera.offset.x, camera.offset.y, 0.0f);
matTransform = MatrixMultiply(MatrixMultiply(matOrigin, MatrixMultiply(matScale, matRotation)), matTranslation);
return matTransform;
} | O2 | c | GetCameraMatrix2D:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movq %rdi, %rbx
movaps 0x538ab(%rip), %xmm0 # 0xb5140
movss 0x228(%rsp), %xmm1
movss 0x22c(%rsp), %xmm2
movss 0x57ded(%rip), %xmm3 # 0xb969c
movlps %xmm3, 0xc0(%rsp)
andl $0x0, 0xc8(%rsp)
xorps %xmm0, %xmm1
xorps %xmm0, %xmm2
movss %xmm1, 0xcc(%rsp)
movsd 0x5810a(%rip), %xmm0 # 0xb99e0
movsd %xmm0, 0xd0(%rsp)
andl $0x0, 0xd8(%rsp)
movss %xmm2, 0xdc(%rsp)
andq $0x0, 0xe0(%rsp)
movl $0x3f800000, %ebp # imm = 0x3F800000
movl %ebp, 0xe8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xec(%rsp)
movl %ebp, 0xfc(%rsp)
movss 0x230(%rsp), %xmm2
mulss 0x61ba8(%rip), %xmm2 # 0xc34d0
leaq 0x1c0(%rsp), %r14
movss 0x57d64(%rip), %xmm1 # 0xb969c
movq %r14, %rdi
callq 0x588f0
movss 0x234(%rsp), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, 0x114(%rsp)
andq $0x0, 0x134(%rsp)
movups %xmm1, 0x124(%rsp)
movups %xmm1, 0x104(%rsp)
xorps %xmm3, %xmm3
movss %xmm0, 0x100(%rsp)
movss %xmm0, 0x114(%rsp)
movl %ebp, 0x128(%rsp)
movss 0x220(%rsp), %xmm0
movss 0x224(%rsp), %xmm1
movss 0x57cf9(%rip), %xmm2 # 0xb969c
movlps %xmm2, 0x80(%rsp)
andl $0x0, 0x88(%rsp)
movss %xmm0, 0x8c(%rsp)
movsd 0x5801c(%rip), %xmm0 # 0xb99e0
movsd %xmm0, 0x90(%rsp)
andl $0x0, 0x98(%rsp)
movss %xmm1, 0x9c(%rsp)
andq $0x0, 0xa0(%rsp)
movl %ebp, 0x13c(%rsp)
movl %ebp, 0xa8(%rsp)
movups %xmm3, 0xac(%rsp)
movl %ebp, 0xbc(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x70(%rsp)
movups %xmm2, 0x60(%rsp)
movups %xmm1, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups 0x100(%rsp), %xmm0
movups 0x110(%rsp), %xmm1
movups 0x120(%rsp), %xmm2
movups 0x130(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x140(%rsp), %r14
movq %r14, %rdi
callq 0x58792
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x70(%rsp)
movups %xmm2, 0x60(%rsp)
movups %xmm1, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups 0xc0(%rsp), %xmm0
movups 0xd0(%rsp), %xmm1
movups 0xe0(%rsp), %xmm2
movups 0xf0(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x180(%rsp), %r14
movq %r14, %rdi
callq 0x58792
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups 0xa0(%rsp), %xmm2
movups 0xb0(%rsp), %xmm3
movups %xmm3, 0x70(%rsp)
movups %xmm2, 0x60(%rsp)
movups %xmm1, 0x50(%rsp)
movups %xmm0, 0x40(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x58792
movq %rbx, %rax
addq $0x200, %rsp # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
| GetCameraMatrix2D:
push rbp
push r14
push rbx
sub rsp, 200h
mov rbx, rdi
movaps xmm0, cs:xmmword_B5140
movss xmm1, [rsp+218h+arg_8]
movss xmm2, [rsp+218h+arg_C]
movss xmm3, cs:dword_B969C
movlps qword ptr [rsp+218h+var_158], xmm3
and dword ptr [rsp+218h+var_158+8], 0
xorps xmm1, xmm0
xorps xmm2, xmm0
movss dword ptr [rsp+218h+var_158+0Ch], xmm1
movsd xmm0, qword ptr cs:xmmword_B99E0
movsd qword ptr [rsp+218h+var_148], xmm0
and dword ptr [rsp+218h+var_148+8], 0
movss dword ptr [rsp+218h+var_148+0Ch], xmm2
and qword ptr [rsp+218h+var_138], 0
mov ebp, 3F800000h
mov dword ptr [rsp+218h+var_138+8], ebp
xorps xmm0, xmm0
movups [rsp+218h+var_138+0Ch], xmm0
mov [rsp+218h+var_11C], ebp
movss xmm2, [rsp+218h+arg_10]
mulss xmm2, cs:dword_C34D0
lea r14, [rsp+218h+var_58]
movss xmm1, cs:dword_B969C
mov rdi, r14
call MatrixRotate
movss xmm0, [rsp+218h+arg_14]
xorps xmm1, xmm1
movups [rsp+218h+var_104], xmm1
and [rsp+218h+var_E4], 0
movups [rsp+218h+var_F4], xmm1
movups [rsp+218h+var_118+4], xmm1
xorps xmm3, xmm3
movss dword ptr [rsp+218h+var_118], xmm0
movss dword ptr [rsp+218h+var_104], xmm0
mov dword ptr [rsp+218h+var_F4+4], ebp
movss xmm0, [rsp+218h+arg_0]
movss xmm1, [rsp+218h+arg_4]
movss xmm2, cs:dword_B969C
movlps qword ptr [rsp+218h+var_198], xmm2
and dword ptr [rsp+218h+var_198+8], 0
movss dword ptr [rsp+218h+var_198+0Ch], xmm0
movsd xmm0, qword ptr cs:xmmword_B99E0
movsd qword ptr [rsp+218h+var_188], xmm0
and dword ptr [rsp+218h+var_188+8], 0
movss dword ptr [rsp+218h+var_188+0Ch], xmm1
and qword ptr [rsp+218h+var_178], 0
mov [rsp+218h+var_DC], ebp
mov dword ptr [rsp+218h+var_178+8], ebp
movups [rsp+218h+var_178+0Ch], xmm3
mov [rsp+218h+var_15C], ebp
movups xmm0, xmmword ptr [r14]
movups xmm1, xmmword ptr [r14+10h]
movups xmm2, xmmword ptr [r14+20h]
movups xmm3, xmmword ptr [r14+30h]
movups [rsp+218h+var_1A8], xmm3
movups [rsp+218h+var_1B8], xmm2
movups [rsp+218h+var_1C8], xmm1
movups [rsp+218h+var_1D8], xmm0
movups xmm0, [rsp+218h+var_118]
movups xmm1, xmmword ptr [rsp+110h]
movups xmm2, [rsp+218h+var_104+0Ch]
movups xmm3, [rsp+218h+var_F4+0Ch]
movups [rsp+218h+var_1E8], xmm3
movups [rsp+218h+var_1F8], xmm2
movups [rsp+218h+var_208], xmm1
movups [rsp+218h+var_218], xmm0
lea r14, [rsp+218h+var_D8]
mov rdi, r14
call MatrixMultiply
movups xmm0, xmmword ptr [r14]
movups xmm1, xmmword ptr [r14+10h]
movups xmm2, xmmword ptr [r14+20h]
movups xmm3, xmmword ptr [r14+30h]
movups [rsp+218h+var_1A8], xmm3
movups [rsp+218h+var_1B8], xmm2
movups [rsp+218h+var_1C8], xmm1
movups [rsp+218h+var_1D8], xmm0
movups xmm0, [rsp+218h+var_158]
movups xmm1, [rsp+218h+var_148]
movups xmm2, [rsp+218h+var_138]
movups xmm3, xmmword ptr [rsp+0F0h]
movups [rsp+218h+var_1E8], xmm3
movups [rsp+218h+var_1F8], xmm2
movups [rsp+218h+var_208], xmm1
movups [rsp+218h+var_218], xmm0
lea r14, [rsp+218h+var_98]
mov rdi, r14
call MatrixMultiply
movups xmm0, [rsp+218h+var_198]
movups xmm1, [rsp+218h+var_188]
movups xmm2, [rsp+218h+var_178]
movups xmm3, xmmword ptr [rsp+0B0h]
movups [rsp+218h+var_1A8], xmm3
movups [rsp+218h+var_1B8], xmm2
movups [rsp+218h+var_1C8], xmm1
movups [rsp+218h+var_1D8], xmm0
movups xmm0, xmmword ptr [r14]
movups xmm1, xmmword ptr [r14+10h]
movups xmm2, xmmword ptr [r14+20h]
movups xmm3, xmmword ptr [r14+30h]
movups [rsp+218h+var_1E8], xmm3
movups [rsp+218h+var_1F8], xmm2
movups [rsp+218h+var_208], xmm1
movups [rsp+218h+var_218], xmm0
mov rdi, rbx
call MatrixMultiply
mov rax, rbx
add rsp, 200h
pop rbx
pop r14
pop rbp
retn
| __m128 * GetCameraMatrix2D(
__m128 *a1,
long long a2,
double a3,
double a4,
double a5,
double a6,
double a7,
double a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14,
long long a15,
long long a16,
long long a17)
{
__m128 v17; // xmm2
long long v18; // rdx
long long v19; // rcx
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
long long v24; // rdx
long long v25; // rcx
long long v26; // r8
long long v27; // r9
__m128 v28; // xmm4
__m128 v29; // xmm5
long long v30; // rdx
long long v31; // rcx
long long v32; // r8
long long v33; // r9
__m128 v34; // xmm4
__m128 v35; // xmm5
double v37; // [rsp+80h] [rbp-198h] BYREF
int v38; // [rsp+88h] [rbp-190h]
int v39; // [rsp+8Ch] [rbp-18Ch]
long long v40; // [rsp+90h] [rbp-188h]
int v41; // [rsp+98h] [rbp-180h]
int v42; // [rsp+9Ch] [rbp-17Ch]
_BYTE v43[28]; // [rsp+A0h] [rbp-178h]
int v44; // [rsp+BCh] [rbp-15Ch]
__m128 v45; // [rsp+C0h] [rbp-158h] BYREF
__m128 v46; // [rsp+D0h] [rbp-148h]
__m256i v47; // [rsp+E0h] [rbp-138h]
_BYTE v48[64]; // [rsp+100h] [rbp-118h] BYREF
__m128 v49[4]; // [rsp+140h] [rbp-D8h] BYREF
__m128 v50[4]; // [rsp+180h] [rbp-98h] BYREF
_BYTE v51[88]; // [rsp+1C0h] [rbp-58h] BYREF
_mm_storel_ps((double *)v45.m128_u64, (__m128)0x3F800000u);
v45.m128_i32[2] = 0;
v45.m128_f32[3] = -*(float *)&a16;
v46.m128_u64[0] = 0x3F80000000000000LL;
v46.m128_i32[2] = 0;
v46.m128_f32[3] = -*((float *)&a16 + 1);
v47.m256i_i64[0] = 0LL;
v47.m256i_i32[2] = 1065353216;
*(_OWORD *)((char *)&v47.m256i_u64[1] + 4) = 0LL;
v47.m256i_i32[7] = 1065353216;
v17 = (__m128)(unsigned int)a17;
v17.m128_f32[0] = *(float *)&a17 * 0.017453292;
MatrixRotate((long long)v51, (__m128)0LL, (__m128)0x3F800000u, v17);
memset(&v48[20], 0, 40);
*(_OWORD *)&v48[4] = 0LL;
*(_DWORD *)v48 = HIDWORD(a17);
*(_DWORD *)&v48[20] = HIDWORD(a17);
*(_DWORD *)&v48[40] = 1065353216;
_mm_storel_ps(&v37, (__m128)0x3F800000u);
v38 = 0;
v39 = a15;
v40 = 0x3F80000000000000LL;
v41 = 0;
v42 = HIDWORD(a15);
*(_QWORD *)v43 = 0LL;
*(_DWORD *)&v48[60] = 1065353216;
*(_DWORD *)&v43[8] = 1065353216;
*(_OWORD *)&v43[12] = 0LL;
v44 = 1065353216;
MatrixMultiply(
v49,
a2,
v18,
v19,
v20,
v21,
*(__m128 *)v48,
*(__m128 *)&v48[16],
*(__m128 *)&v48[32],
*(__m128 *)&v48[48],
v22,
v23,
a9,
a10);
MatrixMultiply(
v50,
a2,
v24,
v25,
v26,
v27,
v45,
v46,
*(__m128 *)v47.m256i_i8,
*(__m128 *)&v47.m256i_u64[2],
v28,
v29,
a9,
a10);
MatrixMultiply(a1, a2, v30, v31, v32, v33, v50[0], v50[1], v50[2], v50[3], v34, v35, a9, a10);
return a1;
}
| GetCameraMatrix2D:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x200
MOV RBX,RDI
MOVAPS XMM0,xmmword ptr [0x001b5140]
MOVSS XMM1,dword ptr [RSP + 0x228]
MOVSS XMM2,dword ptr [RSP + 0x22c]
MOVSS XMM3,dword ptr [0x001b969c]
MOVLPS qword ptr [RSP + 0xc0],XMM3
AND dword ptr [RSP + 0xc8],0x0
XORPS XMM1,XMM0
XORPS XMM2,XMM0
MOVSS dword ptr [RSP + 0xcc],XMM1
MOVSD XMM0,qword ptr [0x001b99e0]
MOVSD qword ptr [RSP + 0xd0],XMM0
AND dword ptr [RSP + 0xd8],0x0
MOVSS dword ptr [RSP + 0xdc],XMM2
AND qword ptr [RSP + 0xe0],0x0
MOV EBP,0x3f800000
MOV dword ptr [RSP + 0xe8],EBP
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0xec],XMM0
MOV dword ptr [RSP + 0xfc],EBP
MOVSS XMM2,dword ptr [RSP + 0x230]
MULSS XMM2,dword ptr [0x001c34d0]
LEA R14,[RSP + 0x1c0]
MOVSS XMM1,dword ptr [0x001b969c]
MOV RDI,R14
CALL 0x001588f0
MOVSS XMM0,dword ptr [RSP + 0x234]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RSP + 0x114],XMM1
AND qword ptr [RSP + 0x134],0x0
MOVUPS xmmword ptr [RSP + 0x124],XMM1
MOVUPS xmmword ptr [RSP + 0x104],XMM1
XORPS XMM3,XMM3
MOVSS dword ptr [RSP + 0x100],XMM0
MOVSS dword ptr [RSP + 0x114],XMM0
MOV dword ptr [RSP + 0x128],EBP
MOVSS XMM0,dword ptr [RSP + 0x220]
MOVSS XMM1,dword ptr [RSP + 0x224]
MOVSS XMM2,dword ptr [0x001b969c]
MOVLPS qword ptr [RSP + 0x80],XMM2
AND dword ptr [RSP + 0x88],0x0
MOVSS dword ptr [RSP + 0x8c],XMM0
MOVSD XMM0,qword ptr [0x001b99e0]
MOVSD qword ptr [RSP + 0x90],XMM0
AND dword ptr [RSP + 0x98],0x0
MOVSS dword ptr [RSP + 0x9c],XMM1
AND qword ptr [RSP + 0xa0],0x0
MOV dword ptr [RSP + 0x13c],EBP
MOV dword ptr [RSP + 0xa8],EBP
MOVUPS xmmword ptr [RSP + 0xac],XMM3
MOV dword ptr [RSP + 0xbc],EBP
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS XMM1,xmmword ptr [R14 + 0x10]
MOVUPS XMM2,xmmword ptr [R14 + 0x20]
MOVUPS XMM3,xmmword ptr [R14 + 0x30]
MOVUPS xmmword ptr [RSP + 0x70],XMM3
MOVUPS xmmword ptr [RSP + 0x60],XMM2
MOVUPS xmmword ptr [RSP + 0x50],XMM1
MOVUPS xmmword ptr [RSP + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0x100]
MOVUPS XMM1,xmmword ptr [RSP + 0x110]
MOVUPS XMM2,xmmword ptr [RSP + 0x120]
MOVUPS XMM3,xmmword ptr [RSP + 0x130]
MOVUPS xmmword ptr [RSP + 0x30],XMM3
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[RSP + 0x140]
MOV RDI,R14
CALL 0x00158792
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS XMM1,xmmword ptr [R14 + 0x10]
MOVUPS XMM2,xmmword ptr [R14 + 0x20]
MOVUPS XMM3,xmmword ptr [R14 + 0x30]
MOVUPS xmmword ptr [RSP + 0x70],XMM3
MOVUPS xmmword ptr [RSP + 0x60],XMM2
MOVUPS xmmword ptr [RSP + 0x50],XMM1
MOVUPS xmmword ptr [RSP + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [RSP + 0xc0]
MOVUPS XMM1,xmmword ptr [RSP + 0xd0]
MOVUPS XMM2,xmmword ptr [RSP + 0xe0]
MOVUPS XMM3,xmmword ptr [RSP + 0xf0]
MOVUPS xmmword ptr [RSP + 0x30],XMM3
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[RSP + 0x180]
MOV RDI,R14
CALL 0x00158792
MOVUPS XMM0,xmmword ptr [RSP + 0x80]
MOVUPS XMM1,xmmword ptr [RSP + 0x90]
MOVUPS XMM2,xmmword ptr [RSP + 0xa0]
MOVUPS XMM3,xmmword ptr [RSP + 0xb0]
MOVUPS xmmword ptr [RSP + 0x70],XMM3
MOVUPS xmmword ptr [RSP + 0x60],XMM2
MOVUPS xmmword ptr [RSP + 0x50],XMM1
MOVUPS xmmword ptr [RSP + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [R14]
MOVUPS XMM1,xmmword ptr [R14 + 0x10]
MOVUPS XMM2,xmmword ptr [R14 + 0x20]
MOVUPS XMM3,xmmword ptr [R14 + 0x30]
MOVUPS xmmword ptr [RSP + 0x30],XMM3
MOVUPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS xmmword ptr [RSP + 0x10],XMM1
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
CALL 0x00158792
MOV RAX,RBX
ADD RSP,0x200
POP RBX
POP R14
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 GetCameraMatrix2D(int8 param_1)
{
float in_stack_00000018;
int1 local_d8 [64];
int1 local_98 [64];
int1 local_58 [64];
MatrixRotate(0,DAT_001b969c,in_stack_00000018 * DAT_001c34d0,local_58);
MatrixMultiply(local_d8);
MatrixMultiply(local_98);
MatrixMultiply(param_1);
return param_1;
}
|
|
2,647 | 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>::at<char const (&) [10], 0>(char const (&) [10]) const | llama.cpp/common/json.hpp | const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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>::at<char const (&) [10], 0>(char const (&) [10]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xafb4d
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xafb37
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20f30
testl %eax, %eax
je 0xafb2c
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xafb0d
jmp 0xafb2f
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xafbab
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20630
movq %rax, %rbx
movq %r14, %rdi
callq 0x89b04
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x6a3e3(%rip), %rsi # 0x119f52
leaq 0x20(%rsp), %rdi
callq 0x7f081
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0xbb52c
xorl %ebp, %ebp
leaq 0xaf4a6(%rip), %rsi # 0x15f040
leaq -0x3a1cd(%rip), %rdx # 0x759d4
movq %rbx, %rdi
callq 0x20a30
jmp 0xafc24
movl $0x20, %edi
callq 0x20630
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x20660
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x27fa8
leaq 0x6a388(%rip), %rsi # 0x119f68
leaq 0x6a387(%rip), %rcx # 0x119f6e
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x7f109
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xd05a4
xorl %ebp, %ebp
leaq 0xaf3ab(%rip), %rsi # 0x15efc0
leaq -0x3a248(%rip), %rdx # 0x759d4
movq %rbx, %rdi
callq 0x20a30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc42
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20170
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xafc8d
movq 0x10(%rsp), %rsi
jmp 0xafc85
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xafc97
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20170
jmp 0xafc97
jmp 0xafc94
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc8d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0xafc97
jmp 0xafc9f
movq %rax, %r14
movq %rbx, %rdi
callq 0x20ed0
movq %r14, %rdi
callq 0x20ad0
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; void *
push r15; int
push r14; __int64
push r12; int
push rbx; void *
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_AFB4D
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_AFB37
loc_AFB0D:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_AFB2C
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_AFB0D
jmp short loc_AFB2F
loc_AFB2C:
mov rax, rbx
loc_AFB2F:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_AFB37:
cmp rax, rbx
jz short loc_AFBAB
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_AFB4D:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_AFC24
loc_AFBAB:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_AFC24:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AFC42
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AFC42:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_AFC8D
mov rsi, [rsp+68h+var_58]
jmp short loc_AFC85
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_AFC97
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_AFC97
jmp short loc_AFC94
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AFC8D
mov rsi, [rsp+68h+var_38]
loc_AFC85:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AFC8D:
test bpl, bpl
jnz short loc_AFC97
jmp short loc_AFC9F
loc_AFC94:
mov r14, rax
loc_AFC97:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_AFC9F:
mov rdi, r14
call __Unwind_Resume
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001afb4d
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001afb37
LAB_001afb0d:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120f30
TEST EAX,EAX
JZ 0x001afb2c
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001afb0d
JMP 0x001afb2f
LAB_001afb2c:
MOV RAX,RBX
LAB_001afb2f:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001afb37:
CMP RAX,RBX
JZ 0x001afbab
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001afb4d:
MOV EDI,0x20
CALL 0x00120630
MOV RBX,RAX
MOV RDI,R14
CALL 0x00189b04
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001afb68:
LEA RSI,[0x219f52]
LEA RDI,[RSP + 0x20]
CALL 0x0017f081
MOV BPL,0x1
LAB_001afb7c:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x001bb52c
XOR EBP,EBP
LEA RSI,[0x25f040]
LEA RDX,[0x1759d4]
MOV RDI,RBX
CALL 0x00120a30
LAB_001afbab:
MOV EDI,0x20
CALL 0x00120630
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x00120660
LEA RDX,[RAX + R15*0x1]
LAB_001afbce:
MOV RDI,RSP
MOV RSI,R15
CALL 0x00127fa8
LAB_001afbd9:
LEA RSI,[0x219f68]
LEA RCX,[0x219f6e]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0017f109
MOV BPL,0x1
LAB_001afbf7:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001d05a4
XOR EBP,EBP
LEA RSI,[0x25efc0]
LEA RDX,[0x1759d4]
MOV RDI,RBX
CALL 0x00120a30
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*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) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001afb68 to 001afb78 has its CatchHandler @ 001afc94 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001afb7c to 001afba8 has its CatchHandler @ 001afc6f */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001afbce to 001afbd8 has its CatchHandler @ 001afc6d */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001afbd9 to 001afbf3 has its CatchHandler @ 001afc52 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001afbf7 to 001afc23 has its CatchHandler @ 001afc24 */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
|
||
2,648 | 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>::type_name() const | monkey531[P]llama/common/json.hpp | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
case value_t::string:
return "string";
case value_t::boolean:
return "boolean";
case value_t::binary:
return "binary";
case value_t::discarded:
return "discarded";
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
default:
return "number";
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::type_name() const:
movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x3e134
leaq 0x6b1b4(%rip), %rcx # 0xa92e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x6d6f3(%rip), %rax # 0xab82e
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv:
movzx eax, byte ptr [rdi]
cmp rax, 9
ja short loc_3E134
lea rcx, unk_A92E0
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_3E134:
lea rax, aNumber; "number"
retn
| const char * nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(
unsigned __int8 *a1)
{
unsigned long long v1; // rax
v1 = *a1;
if ( v1 > 9 )
return "number";
else
return (char *)dword_A92E0 + dword_A92E0[v1];
}
| type_name:
MOVZX EAX,byte ptr [RDI]
CMP RAX,0x9
JA 0x0013e134
LEA RCX,[0x1a92e0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_0013e134:
LEA RAX,[0x1ab82e]
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>::type_name() const */
char * __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>
::type_name(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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)
{
if ((ulong)(byte)*this < 10) {
return &DAT_001a92e0 + *(int *)(&DAT_001a92e0 + (ulong)(byte)*this * 4);
}
return "number";
}
|
|
2,649 | LefDefParser::lefiGeometries::addPolygonIter(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMisc.cpp | void
lefiGeometries::addPolygonIter(int colorMask)
{
int i;
int lim;
lefiGeomPolygonIter *p = (lefiGeomPolygonIter*) lefMalloc(sizeof(lefiGeomPolygonIter));
lim = p->numPoints = numPoints_;
if (lim > 0) {
p->x = (double*) lefMalloc(sizeof(double) * lim);
p->y = (double*) lefMalloc(sizeof(double) * lim);
for (i = 0; i < lim; i++) {
p->x[i] = x_[i];
p->y[i] = y_[i];
}
} else {
p->x = 0;
p->y = 0;
}
p->xStart = xStart_;
p->yStart = yStart_;
p->xStep = xStep_;
p->yStep = yStep_;
p->colorMask = colorMask;
add((void*) p, lefiGeomPolygonIterE);
} | O3 | cpp | LefDefParser::lefiGeometries::addPolygonIter(int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x40, %edi
callq 0x24985
movq %rax, %r14
movslq 0x18(%rbx), %r12
movl %r12d, (%rax)
testq %r12, %r12
jle 0x113e8
leaq (,%r12,8), %r15
movq %r15, %rdi
callq 0x24985
movq %rax, 0x8(%r14)
movq %r15, %rdi
callq 0x24985
movq %rax, 0x10(%r14)
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rdx
movq 0x8(%r14), %rsi
xorl %edi, %edi
movsd (%rcx,%rdi,8), %xmm0
movsd %xmm0, (%rsi,%rdi,8)
movsd (%rdx,%rdi,8), %xmm0
movsd %xmm0, (%rax,%rdi,8)
incq %rdi
cmpq %rdi, %r12
jne 0x113ca
jmp 0x113f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups 0x30(%rbx), %xmm0
movups %xmm0, 0x18(%r14)
movups 0x40(%rbx), %xmm0
movups %xmm0, 0x28(%r14)
movl %ebp, 0x38(%r14)
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10e9e
| _ZN12LefDefParser14lefiGeometries14addPolygonIterEi:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, esi
mov rbx, rdi
mov edi, offset dword_40; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r14, rax
movsxd r12, dword ptr [rbx+18h]
mov [rax], r12d
test r12, r12
jle short loc_113E8
lea r15, ds:0[r12*8]
mov rdi, r15; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [r14+8], rax
mov rdi, r15; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov [r14+10h], rax
mov rcx, [rbx+20h]
mov rdx, [rbx+28h]
mov rsi, [r14+8]
xor edi, edi
loc_113CA:
movsd xmm0, qword ptr [rcx+rdi*8]
movsd qword ptr [rsi+rdi*8], xmm0
movsd xmm0, qword ptr [rdx+rdi*8]
movsd qword ptr [rax+rdi*8], xmm0
inc rdi
cmp r12, rdi
jnz short loc_113CA
jmp short loc_113F0
loc_113E8:
xorps xmm0, xmm0
movups xmmword ptr [r14+8], xmm0
loc_113F0:
movups xmm0, xmmword ptr [rbx+30h]
movups xmmword ptr [r14+18h], xmm0
movups xmm0, xmmword ptr [rbx+40h]
movups xmmword ptr [r14+28h], xmm0
mov [r14+38h], ebp
mov rdi, rbx
mov rsi, r14
mov edx, 0Bh
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _ZN12LefDefParser14lefiGeometries3addEPvNS_12lefiGeomEnumE; LefDefParser::lefiGeometries::add(void *,LefDefParser::lefiGeomEnum)
| long long LefDefParser::lefiGeometries::addPolygonIter(
LefDefParser::lefiGeometries *this,
unsigned long long a2)
{
int v2; // ebp
long long v4; // rax
long long v5; // r14
long long v6; // r12
long long v7; // rax
long long v8; // rcx
long long v9; // rdx
long long v10; // rsi
long long i; // rdi
v2 = a2;
v4 = LefDefParser::lefMalloc((LefDefParser *)&dword_40, a2);
v5 = v4;
v6 = *((int *)this + 6);
*(_DWORD *)v4 = v6;
if ( v6 <= 0 )
{
*(_OWORD *)(v4 + 8) = 0LL;
}
else
{
*(_QWORD *)(v4 + 8) = LefDefParser::lefMalloc((LefDefParser *)(8 * v6), a2);
v7 = LefDefParser::lefMalloc((LefDefParser *)(8 * v6), a2);
*(_QWORD *)(v5 + 16) = v7;
v8 = *((_QWORD *)this + 4);
v9 = *((_QWORD *)this + 5);
v10 = *(_QWORD *)(v5 + 8);
for ( i = 0LL; i != v6; ++i )
{
*(_QWORD *)(v10 + 8 * i) = *(_QWORD *)(v8 + 8 * i);
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(v9 + 8 * i);
}
}
*(_OWORD *)(v5 + 24) = *((_OWORD *)this + 3);
*(_OWORD *)(v5 + 40) = *((_OWORD *)this + 4);
*(_DWORD *)(v5 + 56) = v2;
return LefDefParser::lefiGeometries::add((int *)this, (void *)v5, 11);
}
| addPolygonIter:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,ESI
MOV RBX,RDI
MOV EDI,0x40
CALL 0x00124985
MOV R14,RAX
MOVSXD R12,dword ptr [RBX + 0x18]
MOV dword ptr [RAX],R12D
TEST R12,R12
JLE 0x001113e8
LEA R15,[R12*0x8]
MOV RDI,R15
CALL 0x00124985
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R15
CALL 0x00124985
MOV qword ptr [R14 + 0x10],RAX
MOV RCX,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RBX + 0x28]
MOV RSI,qword ptr [R14 + 0x8]
XOR EDI,EDI
LAB_001113ca:
MOVSD XMM0,qword ptr [RCX + RDI*0x8]
MOVSD qword ptr [RSI + RDI*0x8],XMM0
MOVSD XMM0,qword ptr [RDX + RDI*0x8]
MOVSD qword ptr [RAX + RDI*0x8],XMM0
INC RDI
CMP R12,RDI
JNZ 0x001113ca
JMP 0x001113f0
LAB_001113e8:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x8],XMM0
LAB_001113f0:
MOVUPS XMM0,xmmword ptr [RBX + 0x30]
MOVUPS xmmword ptr [R14 + 0x18],XMM0
MOVUPS XMM0,xmmword ptr [RBX + 0x40]
MOVUPS xmmword ptr [R14 + 0x28],XMM0
MOV dword ptr [R14 + 0x38],EBP
MOV RDI,RBX
MOV RSI,R14
MOV EDX,0xb
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00110e9e
|
/* LefDefParser::lefiGeometries::addPolygonIter(int) */
void __thiscall LefDefParser::lefiGeometries::addPolygonIter(lefiGeometries *this,int param_1)
{
long lVar1;
long lVar2;
long lVar3;
int iVar4;
int iVar5;
int iVar6;
int *piVar7;
int8 uVar8;
long lVar9;
int4 in_register_00000034;
ulong uVar10;
long lVar11;
long lVar12;
uVar10 = CONCAT44(in_register_00000034,param_1);
piVar7 = (int *)lefMalloc((LefDefParser *)0x40,uVar10);
lVar12 = (long)*(int *)(this + 0x18);
*piVar7 = *(int *)(this + 0x18);
if (lVar12 < 1) {
piVar7[2] = 0;
piVar7[3] = 0;
piVar7[4] = 0;
piVar7[5] = 0;
}
else {
uVar8 = lefMalloc((LefDefParser *)(lVar12 * 8),uVar10);
*(int8 *)(piVar7 + 2) = uVar8;
lVar9 = lefMalloc((LefDefParser *)(lVar12 * 8),uVar10);
*(long *)(piVar7 + 4) = lVar9;
lVar1 = *(long *)(this + 0x20);
lVar2 = *(long *)(this + 0x28);
lVar3 = *(long *)(piVar7 + 2);
lVar11 = 0;
do {
*(int8 *)(lVar3 + lVar11 * 8) = *(int8 *)(lVar1 + lVar11 * 8);
*(int8 *)(lVar9 + lVar11 * 8) = *(int8 *)(lVar2 + lVar11 * 8);
lVar11 = lVar11 + 1;
} while (lVar12 != lVar11);
}
uVar8 = *(int8 *)(this + 0x38);
*(int8 *)(piVar7 + 6) = *(int8 *)(this + 0x30);
*(int8 *)(piVar7 + 8) = uVar8;
iVar4 = *(int *)(this + 0x44);
iVar5 = *(int *)(this + 0x48);
iVar6 = *(int *)(this + 0x4c);
piVar7[10] = *(int *)(this + 0x40);
piVar7[0xb] = iVar4;
piVar7[0xc] = iVar5;
piVar7[0xd] = iVar6;
piVar7[0xe] = param_1;
add(this,piVar7,0xb);
return;
}
|
|
2,650 | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {} | O2 | cpp | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x6826e
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x692b0
addq $0x40, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3dc06
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x5019e
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x6481c
movq %r14, %rdi
callq 0x23f20
| _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
add rdi, 20h ; ' '
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
call _ZSt11make_sharedIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<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>>>>()
lea rdi, [rbx+30h]
mov rsi, r14
call _ZNSt12__shared_ptrISt8functionIFN5minja5ValueERKSt10shared_ptrINS1_7ContextEERNS1_14ArgumentsValueEEELN9__gnu_cxx12_Lock_policyE2EEC2ERKSE_; std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2> const&)
add rbx, 40h ; '@'
mov rdi, rbx
xor esi, esi
add rsp, 8
pop rbx
pop r14
jmp _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov r14, rax
lea rdi, [rbx+18h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
add rbx, 8
mov rdi, rbx
call _ZNSt12__weak_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__weak_count<(__gnu_cxx::_Lock_policy)2>::~__weak_count()
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::Value(long long a1, _QWORD *a2)
{
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
std::make_shared<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>>>>(a1 + 32);
std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(
(_QWORD *)(a1 + 48),
a2);
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(a1 + 64);
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
ADD RDI,0x20
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0017079a:
CALL 0x0016826e
LAB_0017079f:
LEA RDI,[RBX + 0x30]
MOV RSI,R14
CALL 0x001692b0
ADD RBX,0x40
MOV RDI,RBX
XOR ESI,ESI
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0013dc06
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0017079a to 0017079e has its CatchHandler @ 001707c0 */
std::
make_shared<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>>>>
();
std::
__shared_ptr<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2>
::__shared_ptr((__shared_ptr<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2>
*)(this + 0x30),(__shared_ptr *)param_1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)(this + 0x40));
return;
}
|
|
2,651 | MNN::Slice::Verify(flatbuffers::Verifier&) const | mnn-tts/MNN/schema/current/CaffeOp_generated.h | bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, 4) &&
VerifyOffset(verifier, 6) &&
verifier.VerifyVector(slicePoints()) &&
VerifyField<int8_t>(verifier, 8) &&
verifier.EndTable();
} | O0 | c | MNN::Slice::Verify(flatbuffers::Verifier&) const:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x6d010
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x79134
jmp 0x791dc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x4, %edx
callq 0x6d570
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x7915a
jmp 0x791dc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x6, %edx
callq 0x6d040
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x7917d
jmp 0x791dc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x791f0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6e500
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x791ab
jmp 0x791dc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x8, %edx
callq 0x6d4f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x791ce
jmp 0x791dc
movq 0x18(%rsp), %rdi
callq 0x6d6f0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| _ZNK3MNN5Slice6VerifyERN11flatbuffers8VerifierE:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rdi, [rsp+28h+var_8]; this
mov [rsp+28h+var_20], rdi
mov rsi, [rsp+28h+var_10]; flatbuffers::Verifier *
call _ZNK11flatbuffers5Table16VerifyTableStartERNS_8VerifierE; flatbuffers::Table::VerifyTableStart(flatbuffers::Verifier &)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+28h+var_11], al
jnz short loc_79134
jmp loc_791DC
loc_79134:
mov rdi, [rsp+28h+var_20]
mov rsi, [rsp+28h+var_10]
mov edx, 4
call _ZNK11flatbuffers5Table11VerifyFieldIiEEbRKNS_8VerifierEt; flatbuffers::Table::VerifyField<int>(flatbuffers::Verifier const&,ushort)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+28h+var_11], al
jnz short loc_7915A
jmp loc_791DC
loc_7915A:
mov rdi, [rsp+28h+var_20]; this
mov rsi, [rsp+28h+var_10]; flatbuffers::Verifier *
mov edx, 6; unsigned __int16
call _ZNK11flatbuffers5Table12VerifyOffsetERKNS_8VerifierEt; flatbuffers::Table::VerifyOffset(flatbuffers::Verifier const&,ushort)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+28h+var_11], al
jnz short loc_7917D
jmp short loc_791DC
loc_7917D:
mov rdi, [rsp+28h+var_20]; this
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_28], rax
call _ZNK3MNN5Slice11slicePointsEv; MNN::Slice::slicePoints(void)
mov rdi, [rsp+28h+var_28]
mov rsi, rax
call _ZNK11flatbuffers8Verifier12VerifyVectorIiEEbPKNS_6VectorIT_EE; flatbuffers::Verifier::VerifyVector<int>(flatbuffers::Vector<int> const*)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+28h+var_11], al
jnz short loc_791AB
jmp short loc_791DC
loc_791AB:
mov rdi, [rsp+28h+var_20]
mov rsi, [rsp+28h+var_10]
mov edx, 8
call _ZNK11flatbuffers5Table11VerifyFieldIaEEbRKNS_8VerifierEt; flatbuffers::Table::VerifyField<signed char>(flatbuffers::Verifier const&,ushort)
mov cl, al
xor eax, eax
test cl, 1
mov [rsp+28h+var_11], al
jnz short loc_791CE
jmp short loc_791DC
loc_791CE:
mov rdi, [rsp+28h+var_10]; this
call _ZN11flatbuffers8Verifier8EndTableEv; flatbuffers::Verifier::EndTable(void)
mov [rsp+28h+var_11], al
loc_791DC:
mov al, [rsp+28h+var_11]
and al, 1
add rsp, 28h
retn
| char MNN::Slice::Verify(MNN::Slice *this, flatbuffers::Verifier *a2)
{
unsigned int *v2; // rax
char v4; // [rsp+17h] [rbp-11h]
v4 = 0;
if ( (flatbuffers::Table::VerifyTableStart(this, a2) & 1) != 0 )
{
v4 = 0;
if ( (flatbuffers::Table::VerifyField<int>(this, (long long)a2, 4u) & 1) != 0 )
{
v4 = 0;
if ( flatbuffers::Table::VerifyOffset(this, a2, 6u) )
{
v2 = (unsigned int *)MNN::Slice::slicePoints(this);
v4 = 0;
if ( (flatbuffers::Verifier::VerifyVector<int>(a2, v2) & 1) != 0 )
{
v4 = 0;
if ( (flatbuffers::Table::VerifyField<signed char>(this, (long long)a2, 8u) & 1) != 0 )
v4 = flatbuffers::Verifier::EndTable(a2);
}
}
}
}
return v4 & 1;
}
| Verify:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RDI,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0016d010
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x17],AL
JNZ 0x00179134
JMP 0x001791dc
LAB_00179134:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,0x4
CALL 0x0016d570
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x17],AL
JNZ 0x0017915a
JMP 0x001791dc
LAB_0017915a:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,0x6
CALL 0x0016d040
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x17],AL
JNZ 0x0017917d
JMP 0x001791dc
LAB_0017917d:
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
CALL 0x001791f0
MOV RDI,qword ptr [RSP]
MOV RSI,RAX
CALL 0x0016e500
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x17],AL
JNZ 0x001791ab
JMP 0x001791dc
LAB_001791ab:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,0x8
CALL 0x0016d4f0
MOV CL,AL
XOR EAX,EAX
TEST CL,0x1
MOV byte ptr [RSP + 0x17],AL
JNZ 0x001791ce
JMP 0x001791dc
LAB_001791ce:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0016d6f0
MOV byte ptr [RSP + 0x17],AL
LAB_001791dc:
MOV AL,byte ptr [RSP + 0x17]
AND AL,0x1
ADD RSP,0x28
RET
|
/* MNN::Slice::Verify(flatbuffers::Verifier&) const */
ulong __thiscall MNN::Slice::Verify(Slice *this,Verifier *param_1)
{
bool bVar1;
uint uVar2;
Vector *pVVar3;
int8 uVar4;
int1 local_11;
uVar2 = flatbuffers::Table::VerifyTableStart((Table *)this,param_1);
uVar4 = 0;
local_11 = 0;
if ((uVar2 & 1) != 0) {
bVar1 = flatbuffers::Table::VerifyField<int>((Table *)this,param_1,4);
uVar4 = 0;
local_11 = 0;
if (bVar1) {
uVar2 = flatbuffers::Table::VerifyOffset((Table *)this,param_1,6);
uVar4 = 0;
local_11 = 0;
if ((uVar2 & 1) != 0) {
pVVar3 = (Vector *)slicePoints(this);
bVar1 = flatbuffers::Verifier::VerifyVector<int>(param_1,pVVar3);
uVar4 = 0;
local_11 = 0;
if (bVar1) {
bVar1 = flatbuffers::Table::VerifyField<signed_char>((Table *)this,param_1,8);
uVar4 = 0;
local_11 = 0;
if (bVar1) {
uVar4 = flatbuffers::Verifier::EndTable(param_1);
local_11 = (int1)uVar4;
}
}
}
}
}
return CONCAT71((int7)((ulong)uVar4 >> 8),local_11) & 0xffffffffffffff01;
}
|
|
2,652 | strmake_root | eloqsql/mysys/my_alloc.c | char *strmake_root(MEM_ROOT *root, const char *str, size_t len)
{
char *pos;
if ((pos=alloc_root(root,len+1)))
{
if (len)
memcpy(pos,str,len);
pos[len]=0;
}
return pos;
} | O0 | c | strmake_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x33ac0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x343c3
cmpq $0x0, -0x18(%rbp)
je 0x343b7
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24230
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| strmake_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
add rsi, 1
call alloc_root
mov [rbp+var_20], rax
cmp rax, 0
jz short loc_343C3
cmp [rbp+var_18], 0
jz short loc_343B7
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _memcpy
loc_343B7:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov byte ptr [rax+rcx], 0
loc_343C3:
mov rax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| char * strmake_root(_QWORD **a1, long long a2, long long a3)
{
char *v4; // [rsp+0h] [rbp-20h]
v4 = alloc_root(a1, a3 + 1);
if ( v4 )
{
if ( a3 )
memcpy(v4, a2, a3);
v4[a3] = 0;
}
return v4;
}
| strmake_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x1
CALL 0x00133ac0
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x001343c3
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001343b7
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00124230
LAB_001343b7:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_001343c3:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
void * strmake_root(int8 param_1,void *param_2,size_t param_3)
{
void *__dest;
__dest = (void *)alloc_root(param_1,param_3 + 1);
if (__dest != (void *)0x0) {
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
|
|
2,653 | strmake_root | eloqsql/mysys/my_alloc.c | char *strmake_root(MEM_ROOT *root, const char *str, size_t len)
{
char *pos;
if ((pos=alloc_root(root,len+1)))
{
if (len)
memcpy(pos,str,len);
pos[len]=0;
}
return pos;
} | O3 | c | strmake_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1(%rdx), %rsi
callq 0x2dc17
movq %rax, %r15
testq %rax, %rax
je 0x2e012
testq %rbx, %rbx
je 0x2e00d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24250
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| strmake_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r14, rsi
lea rsi, [rdx+1]
call alloc_root
mov r15, rax
test rax, rax
jz short loc_2E012
test rbx, rbx
jz short loc_2E00D
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call _memcpy
loc_2E00D:
mov byte ptr [r15+rbx], 0
loc_2E012:
mov rax, r15
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| char * strmake_root(long long a1, long long a2, long long a3)
{
char *v4; // rax
char *v5; // r15
v4 = alloc_root(a1, a3 + 1);
v5 = v4;
if ( v4 )
{
if ( a3 )
memcpy(v4, a2, a3);
v5[a3] = 0;
}
return v5;
}
| strmake_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
LEA RSI,[RDX + 0x1]
CALL 0x0012dc17
MOV R15,RAX
TEST RAX,RAX
JZ 0x0012e012
TEST RBX,RBX
JZ 0x0012e00d
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00124250
LAB_0012e00d:
MOV byte ptr [R15 + RBX*0x1],0x0
LAB_0012e012:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void * strmake_root(int8 param_1,void *param_2,size_t param_3)
{
void *__dest;
__dest = (void *)alloc_root(param_1,param_3 + 1);
if (__dest != (void *)0x0) {
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
|
|
2,654 | my_strnxfrm_8bit_bin | eloqsql/strings/ctype-bin.c | static size_t
my_strnxfrm_8bit_bin(CHARSET_INFO *cs,
uchar * dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
set_if_smaller(srclen, dstlen);
set_if_smaller(srclen, nweights);
if (srclen && dst != src)
memcpy(dst, src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, dst, dst + srclen, dst + dstlen,
(uint)(nweights - srclen), flags, 0);
} | O3 | c | my_strnxfrm_8bit_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl 0x10(%rbp), %r9d
cmpq %rdx, %r13
cmovaeq %rdx, %r13
movl %ecx, %eax
cmpq %rax, %r13
cmovaeq %rax, %r13
testq %r13, %r13
sete %al
cmpq %r8, %rsi
sete %cl
orb %al, %cl
jne 0xb5392
movq %r12, %rdi
movq %r8, %rsi
movq %r13, %rdx
callq 0x2a0a0
movl 0x10(%rbp), %r9d
leaq (%r12,%r13), %rdx
addq %r12, %r14
subl %r13d, %ebx
movl $0x0, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movl %ebx, %r8d
callq 0xbd708
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strnxfrm_8bit_bin:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r9
mov ebx, ecx
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov r9d, [rbp+arg_0]
cmp r13, rdx
cmovnb r13, rdx
mov eax, ecx
cmp r13, rax
cmovnb r13, rax
test r13, r13
setz al
cmp rsi, r8
setz cl
or cl, al
jnz short loc_B5392
mov rdi, r12
mov rsi, r8
mov rdx, r13
call _memcpy
mov r9d, [rbp+arg_0]
loc_B5392:
lea rdx, [r12+r13]
add r14, r12
sub ebx, r13d
mov [rsp+30h+var_30], 0
mov rdi, r15
mov rsi, r12
mov rcx, r14
mov r8d, ebx
call my_strxfrm_pad_desc_and_reverse
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strnxfrm_8bit_bin(
int a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
int a7)
{
int v9; // r14d
int v10; // r9d
v9 = a3;
v10 = a7;
if ( a6 >= a3 )
a6 = a3;
if ( a6 >= a4 )
a6 = a4;
if ( a6 != 0 && a2 != a5 )
{
memcpy(a2, a5, a6);
v10 = a7;
}
return my_strxfrm_pad_desc_and_reverse(a1, a2, (int)a2 + (int)a6, (int)a2 + v9, a4 - (unsigned int)a6, v10, 0);
}
| my_strnxfrm_8bit_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R9
MOV EBX,ECX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV R9D,dword ptr [RBP + 0x10]
CMP R13,RDX
CMOVNC R13,RDX
MOV EAX,ECX
CMP R13,RAX
CMOVNC R13,RAX
TEST R13,R13
SETZ AL
CMP RSI,R8
SETZ CL
OR CL,AL
JNZ 0x001b5392
MOV RDI,R12
MOV RSI,R8
MOV RDX,R13
CALL 0x0012a0a0
MOV R9D,dword ptr [RBP + 0x10]
LAB_001b5392:
LEA RDX,[R12 + R13*0x1]
ADD R14,R12
SUB EBX,R13D
MOV dword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R12
MOV RCX,R14
MOV R8D,EBX
CALL 0x001bd708
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void my_strnxfrm_8bit_bin
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 in_RAX;
uint uVar1;
uVar1 = (uint)((ulong)in_RAX >> 0x20);
if (param_3 <= param_6) {
param_6 = param_3;
}
if (param_4 <= param_6) {
param_6 = (ulong)param_4;
}
if (param_2 != param_5 && param_6 != 0) {
memcpy(param_2,param_5,param_6);
}
my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + param_6,param_3 + (long)param_2,param_4 - (int)param_6,
param_7,(ulong)uVar1 << 0x20);
return;
}
|
|
2,655 | ftxui::(anonymous namespace)::InputBase::HandleArrowLeft() | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/input.cpp | bool HandleArrowLeft() {
if (cursor_position() == 0) {
return false;
}
cursor_position() = GlyphPrevious(content(), cursor_position());
return true;
} | O3 | cpp | ftxui::(anonymous namespace)::InputBase::HandleArrowLeft():
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xf8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2c5ba
movl (%rax), %ebp
testl %ebp, %ebp
je 0x2b834
addq $0x28, %r14
movq %r14, %rdi
callq 0x2c188
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c5ba
movslq (%rax), %rsi
movq %r14, %rdi
callq 0x3ab2e
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c5ba
movl %r14d, (%rax)
testl %ebp, %ebp
setne %al
popq %rbx
popq %r14
popq %rbp
retq
| _ZN5ftxui12_GLOBAL__N_19InputBase15HandleArrowLeftEv:
push rbp
push r14
push rbx
mov r14, rdi
lea rbx, [rdi+0F8h]
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
mov ebp, [rax]
test ebp, ebp
jz short loc_2B834
add r14, 28h ; '('
mov rdi, r14
call _ZN5ftxui3RefINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE7AddressEv; ftxui::Ref<std::string>::Address(void)
mov r14, rax
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
movsxd rsi, dword ptr [rax]
mov rdi, r14
call _ZN5ftxui13GlyphPreviousERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; ftxui::GlyphPrevious(std::string const&,ulong)
mov r14, rax
mov rdi, rbx
call _ZN5ftxui3RefIiE7AddressEv; ftxui::Ref<int>::Address(void)
mov [rax], r14d
loc_2B834:
test ebp, ebp
setnz al
pop rbx
pop r14
pop rbp
retn
| bool ftxui::`anonymous namespace'::InputBase::HandleArrowLeft(ftxui::_anonymous_namespace_::InputBase *this)
{
char *v1; // rbx
int v2; // ebp
long long v3; // r14
int *v4; // rax
v1 = (char *)this + 248;
v2 = *(_DWORD *)ftxui::Ref<int>::Address((char *)this + 248);
if ( v2 )
{
v3 = ftxui::Ref<std::string>::Address((char *)this + 40);
v4 = (int *)ftxui::Ref<int>::Address(v1);
LODWORD(v3) = ftxui::GlyphPrevious(v3, *v4);
*(_DWORD *)ftxui::Ref<int>::Address(v1) = v3;
}
return v2 != 0;
}
| HandleArrowLeft:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDI
LEA RBX,[RDI + 0xf8]
MOV RDI,RBX
CALL 0x0012c5ba
MOV EBP,dword ptr [RAX]
TEST EBP,EBP
JZ 0x0012b834
ADD R14,0x28
MOV RDI,R14
CALL 0x0012c188
MOV R14,RAX
MOV RDI,RBX
CALL 0x0012c5ba
MOVSXD RSI,dword ptr [RAX]
MOV RDI,R14
CALL 0x0013ab2e
MOV R14,RAX
MOV RDI,RBX
CALL 0x0012c5ba
MOV dword ptr [RAX],R14D
LAB_0012b834:
TEST EBP,EBP
SETNZ AL
POP RBX
POP R14
POP RBP
RET
|
/* ftxui::(anonymous namespace)::InputBase::HandleArrowLeft() */
bool __thiscall ftxui::(anonymous_namespace)::InputBase::HandleArrowLeft(InputBase *this)
{
Ref<int> *this_00;
int iVar1;
int *piVar2;
string *psVar3;
int4 uVar4;
int4 *puVar5;
this_00 = (Ref<int> *)(this + 0xf8);
piVar2 = (int *)Ref<int>::Address(this_00);
iVar1 = *piVar2;
if (iVar1 != 0) {
psVar3 = (string *)
Ref<std::__cxx11::string>::Address((Ref<std::__cxx11::string> *)(this + 0x28));
piVar2 = (int *)Ref<int>::Address(this_00);
uVar4 = GlyphPrevious(psVar3,(long)*piVar2);
puVar5 = (int4 *)Ref<int>::Address(this_00);
*puVar5 = uVar4;
}
return iVar1 != 0;
}
|
|
2,656 | httplib::detail::parse_multipart_boundary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | hkr04[P]cpp-mcp/common/httplib.h | inline bool parse_multipart_boundary(const std::string &content_type,
std::string &boundary) {
auto boundary_keyword = "boundary=";
auto pos = content_type.find(boundary_keyword);
if (pos == std::string::npos) { return false; }
auto end = content_type.find(';', pos);
auto beg = pos + strlen(boundary_keyword);
boundary = trim_double_quotes_copy(content_type.substr(beg, end - beg));
return !boundary.empty();
} | O2 | c | httplib::detail::parse_multipart_boundary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1beb2(%rip), %rsi # 0x4c58f
xorl %r12d, %r12d
xorl %edx, %edx
callq 0xabd0
cmpq $-0x1, %rax
je 0x30753
movq %rax, %r15
pushq $0x3b
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0xa830
addq $0x9, %r15
subq %r15, %rax
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0xa6f0
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x30ac4
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7a0
movq %r14, %rdi
callq 0xac20
leaq 0x8(%rsp), %rdi
callq 0xac20
cmpq $0x0, 0x8(%rbx)
setne %r12b
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xac20
movq %rbx, %rdi
callq 0xaac0
nop
| _ZN7httplib6detail24parse_multipart_boundaryERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS6_:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
lea rsi, aMultipartByter+16h; "boundary="
xor r12d, r12d
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_30753
mov r15, rax
push 3Bh ; ';'
pop rsi
mov rdi, r14
mov rdx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
add r15, 9
sub rax, r15
lea r12, [rsp+68h+var_60]
mov rdi, r12
mov rsi, r14
mov rdx, r15
mov rcx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rdi, [rsp+68h+var_40]
mov rsi, r12
call _ZN7httplib6detail23trim_double_quotes_copyERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; httplib::detail::trim_double_quotes_copy(std::string const&)
lea r14, [rsp+68h+var_40]
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
cmp qword ptr [rbx+8], 0
setnz r12b
loc_30753:
mov eax, r12d
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| long long httplib::detail::parse_multipart_boundary(long long a1, long long a2)
{
_BYTE *v2; // r12
long long v3; // rax
long long v4; // r15
long long v5; // rax
_BYTE v7[32]; // [rsp+8h] [rbp-60h] BYREF
_BYTE v8[64]; // [rsp+28h] [rbp-40h] BYREF
LODWORD(v2) = 0;
v3 = std::string::find(a1, "boundary=", 0LL);
if ( v3 != -1 )
{
v4 = v3;
v5 = std::string::find(a1, 59LL, v3);
v2 = v7;
std::string::substr(v7, a1, v4 + 9, v5 - (v4 + 9));
httplib::detail::trim_double_quotes_copy(v8, v7);
std::string::operator=(a2, v8);
std::string::~string(v8);
std::string::~string(v7);
LOBYTE(v2) = *(_QWORD *)(a2 + 8) != 0LL;
}
return (unsigned int)v2;
}
| parse_multipart_boundary:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
LEA RSI,[0x14c58f]
XOR R12D,R12D
XOR EDX,EDX
CALL 0x0010abd0
CMP RAX,-0x1
JZ 0x00130753
MOV R15,RAX
PUSH 0x3b
POP RSI
MOV RDI,R14
MOV RDX,RAX
CALL 0x0010a830
ADD R15,0x9
SUB RAX,R15
LEA R12,[RSP + 0x8]
MOV RDI,R12
MOV RSI,R14
MOV RDX,R15
MOV RCX,RAX
CALL 0x0010a6f0
LAB_0013071b:
LEA RDI,[RSP + 0x28]
MOV RSI,R12
CALL 0x00130ac4
LAB_00130728:
LEA R14,[RSP + 0x28]
MOV RDI,RBX
MOV RSI,R14
CALL 0x0010a7a0
MOV RDI,R14
CALL 0x0010ac20
LEA RDI,[RSP + 0x8]
CALL 0x0010ac20
CMP qword ptr [RBX + 0x8],0x0
SETNZ R12B
LAB_00130753:
MOV EAX,R12D
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* httplib::detail::parse_multipart_boundary(std::__cxx11::string const&, std::__cxx11::string&) */
ulong httplib::detail::parse_multipart_boundary(string *param_1,string *param_2)
{
long lVar1;
ulong uVar2;
string local_60 [32];
detail local_40 [32];
uVar2 = 0;
lVar1 = std::__cxx11::string::find((char *)param_1,0x14c58f);
if (lVar1 != -1) {
std::__cxx11::string::find((char)param_1,0x3b);
std::__cxx11::string::substr((ulong)local_60,(ulong)param_1);
/* try { // try from 0013071b to 00130727 has its CatchHandler @ 00130762 */
trim_double_quotes_copy(local_40,local_60);
std::__cxx11::string::operator=(param_2,(string *)local_40);
std::__cxx11::string::~string((string *)local_40);
std::__cxx11::string::~string(local_60);
uVar2 = CONCAT71((int7)((ulong)local_60 >> 8),*(long *)(param_2 + 8) != 0);
}
return uVar2 & 0xffffffff;
}
|
|
2,657 | google::protobuf::internal::UnknownFieldParserHelper::ParseGroup(unsigned int, char const*, google::protobuf::internal::ParseContext*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/unknown_field_set.cc | const char* ParseGroup(uint32_t num, const char* ptr, ParseContext* ctx) {
UnknownFieldParserHelper child(unknown_->AddGroup(num));
return ctx->ParseGroup(&child, ptr, num * 8 + 3);
} | O3 | cpp | google::protobuf::internal::UnknownFieldParserHelper::ParseGroup(unsigned int, char const*, google::protobuf::internal::ParseContext*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq (%rdi), %rdi
callq 0xa3274
movq %rax, (%rsp)
movl 0x58(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
testl %eax, %eax
jle 0xa3f58
leal 0x3(,%r15,8), %ebp
incl 0x5c(%rbx)
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa385d
movq 0x58(%rbx), %xmm0
paddd 0xc25af(%rip), %xmm0 # 0x1664f0
movq %xmm0, 0x58(%rbx)
xorl %ecx, %ecx
cmpl %ebp, 0x50(%rbx)
movl $0x0, 0x50(%rbx)
cmoveq %rax, %rcx
jmp 0xa3f5a
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ZN6google8protobuf8internal24UnknownFieldParserHelper10ParseGroupEjPKcPNS1_12ParseContextE:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15d, esi
mov rdi, [rdi]; this
call _ZN6google8protobuf15UnknownFieldSet8AddGroupEi; google::protobuf::UnknownFieldSet::AddGroup(int)
mov [rsp+28h+var_28], rax
mov eax, [rbx+58h]
lea ecx, [rax-1]
mov [rbx+58h], ecx
test eax, eax
jle short loc_A3F58
lea ebp, ds:3[r15*8]
inc dword ptr [rbx+5Ch]
mov rdi, rsp
mov rsi, r14
mov rdx, rbx
call _ZN6google8protobuf8internal16WireFormatParserINS1_24UnknownFieldParserHelperEEEPKcRT_S5_PNS1_12ParseContextE; google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>(google::protobuf::internal::UnknownFieldParserHelper &,char const*,google::protobuf::internal::ParseContext *)
movq xmm0, qword ptr [rbx+58h]
paddd xmm0, cs:xmmword_1664F0
movq qword ptr [rbx+58h], xmm0
xor ecx, ecx
cmp [rbx+50h], ebp
mov dword ptr [rbx+50h], 0
cmovz rcx, rax
jmp short loc_A3F5A
loc_A3F58:
xor ecx, ecx
loc_A3F5A:
mov rax, rcx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| google::protobuf::internal * google::protobuf::internal::UnknownFieldParserHelper::ParseGroup(
google::protobuf::UnknownFieldSet **this,
unsigned int a2,
google::protobuf::internal *a3,
google::protobuf::internal::ParseContext *a4)
{
long long v4; // rax
int v7; // eax
google::protobuf::internal *v8; // rax
long long v9; // rcx
bool v10; // zf
long long v12[5]; // [rsp+0h] [rbp-28h] BYREF
v12[0] = v4;
v12[0] = google::protobuf::UnknownFieldSet::AddGroup(*this, a2);
v7 = *((_DWORD *)a4 + 22);
*((_DWORD *)a4 + 22) = v7 - 1;
if ( v7 <= 0 )
return 0LL;
++*((_DWORD *)a4 + 23);
v8 = google::protobuf::internal::WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>(
(long long)v12,
a3,
a4);
*((_QWORD *)a4 + 11) = _mm_add_epi32(_mm_loadl_epi64((const __m128i *)((char *)a4 + 88)), (__m128i)xmmword_1664F0).m128i_u64[0];
v9 = 0LL;
v10 = *((_DWORD *)a4 + 20) == 8 * a2 + 3;
*((_DWORD *)a4 + 20) = 0;
if ( v10 )
return v8;
return (google::protobuf::internal *)v9;
}
| ParseGroup:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15D,ESI
MOV RDI,qword ptr [RDI]
CALL 0x001a3274
MOV qword ptr [RSP],RAX
MOV EAX,dword ptr [RBX + 0x58]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX + 0x58],ECX
TEST EAX,EAX
JLE 0x001a3f58
LEA EBP,[0x3 + R15*0x8]
INC dword ptr [RBX + 0x5c]
MOV RDI,RSP
MOV RSI,R14
MOV RDX,RBX
CALL 0x001a385d
MOVQ XMM0,qword ptr [RBX + 0x58]
PADDD XMM0,xmmword ptr [0x002664f0]
MOVQ qword ptr [RBX + 0x58],XMM0
XOR ECX,ECX
CMP dword ptr [RBX + 0x50],EBP
MOV dword ptr [RBX + 0x50],0x0
CMOVZ RCX,RAX
JMP 0x001a3f5a
LAB_001a3f58:
XOR ECX,ECX
LAB_001a3f5a:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* google::protobuf::internal::UnknownFieldParserHelper::ParseGroup(unsigned int, char const*,
google::protobuf::internal::ParseContext*) */
char * __thiscall
google::protobuf::internal::UnknownFieldParserHelper::ParseGroup
(UnknownFieldParserHelper *this,uint param_1,char *param_2,ParseContext *param_3)
{
int iVar1;
char *pcVar2;
char *pcVar3;
int8 local_28;
local_28 = UnknownFieldSet::AddGroup(*(UnknownFieldSet **)this,param_1);
iVar1 = *(int *)(param_3 + 0x58);
*(int *)(param_3 + 0x58) = iVar1 + -1;
if (iVar1 < 1) {
pcVar3 = (char *)0x0;
}
else {
*(int *)(param_3 + 0x5c) = *(int *)(param_3 + 0x5c) + 1;
pcVar2 = WireFormatParser<google::protobuf::internal::UnknownFieldParserHelper>
((UnknownFieldParserHelper *)&local_28,param_2,param_3);
*(ulong *)(param_3 + 0x58) =
CONCAT44((int)((ulong)*(int8 *)(param_3 + 0x58) >> 0x20) + _UNK_002664f4,
(int)*(int8 *)(param_3 + 0x58) + _DAT_002664f0);
iVar1 = *(int *)(param_3 + 0x50);
*(int4 *)(param_3 + 0x50) = 0;
pcVar3 = (char *)0x0;
if (iVar1 == param_1 * 8 + 3) {
pcVar3 = pcVar2;
}
}
return pcVar3;
}
|
|
2,658 | my_strntoull_8bit | eloqsql/strings/ctype-simple.c | ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O3 | c | my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x5a2d5
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x5a2d5
incq %r10
cmpq %r11, %r10
jb 0x5a2c2
cmpq %r11, %r10
je 0x5a3bd
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movslq %ecx, %rbx
movq $-0x1, %rax
xorl %edx, %edx
movq %rbx, -0x38(%rbp)
divq %rbx
xorl %r12d, %r12d
cmpq %r11, %r10
je 0x5a39a
movq %rdi, -0x30(%rbp)
movq %r10, %r14
xorl %r15d, %r15d
movq %r15, %rdi
movl %r12d, %r13d
movb (%r14), %r12b
leal -0x30(%r12), %ebx
cmpb $0xa, %bl
jb 0x5a349
leal -0x41(%r12), %ebx
cmpb $0x19, %bl
ja 0x5a338
addb $-0x37, %r12b
jmp 0x5a346
leal -0x61(%r12), %ebx
cmpb $0x19, %bl
ja 0x5a388
addb $-0x57, %r12b
movl %r12d, %ebx
movzbl %bl, %ebx
cmpl %ecx, %ebx
jge 0x5a388
movl $0x1, %r12d
cmpq %rax, %rdi
jbe 0x5a360
movq %rdi, %r15
jmp 0x5a377
jne 0x5a369
movq %rax, %r15
cmpl %edx, %ebx
ja 0x5a377
imulq -0x38(%rbp), %rdi
movl %ebx, %r15d
addq %rdi, %r15
movl %r13d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x5a315
movq %r15, %rdi
movq %r11, %r14
movl %r12d, %r13d
testl %r13d, %r13d
sete %al
movq %rdi, %r12
movq %r14, %r11
movq -0x30(%rbp), %rdi
jmp 0x5a39c
movb $0x1, %al
cmpq %r10, %r11
je 0x5a3bd
testq %r8, %r8
je 0x5a3a9
movq %r11, (%r8)
testb %al, %al
je 0x5a3d0
movq %r12, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r12, %rax
jmp 0x5a3de
movl $0x21, (%r9)
testq %r8, %r8
je 0x5a3cc
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0x5a3de
movl $0x22, (%r9)
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strntoull_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_5A2D5
mov rax, [rdi+40h]
mov r10, rsi
loc_5A2C2:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_5A2D5
inc r10
cmp r10, r11
jb short loc_5A2C2
loc_5A2D5:
cmp r10, r11
jz loc_5A3BD
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
movsxd rbx, ecx
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_38], rbx
div rbx
xor r12d, r12d
cmp r10, r11
jz loc_5A39A
mov [rbp+var_30], rdi
mov r14, r10
xor r15d, r15d
loc_5A315:
mov rdi, r15
mov r13d, r12d
mov r12b, [r14]
lea ebx, [r12-30h]
cmp bl, 0Ah
jb short loc_5A349
lea ebx, [r12-41h]
cmp bl, 19h
ja short loc_5A338
add r12b, 0C9h
jmp short loc_5A346
loc_5A338:
lea ebx, [r12-61h]
cmp bl, 19h
ja short loc_5A388
add r12b, 0A9h
loc_5A346:
mov ebx, r12d
loc_5A349:
movzx ebx, bl
cmp ebx, ecx
jge short loc_5A388
mov r12d, 1
cmp rdi, rax
jbe short loc_5A360
mov r15, rdi
jmp short loc_5A377
loc_5A360:
jnz short loc_5A369
mov r15, rax
cmp ebx, edx
ja short loc_5A377
loc_5A369:
imul rdi, [rbp+var_38]
mov r15d, ebx
add r15, rdi
mov r12d, r13d
loc_5A377:
inc r14
cmp r14, r11
jnz short loc_5A315
mov rdi, r15
mov r14, r11
mov r13d, r12d
loc_5A388:
test r13d, r13d
setz al
mov r12, rdi
mov r11, r14
mov rdi, [rbp+var_30]
jmp short loc_5A39C
loc_5A39A:
mov al, 1
loc_5A39C:
cmp r11, r10
jz short loc_5A3BD
test r8, r8
jz short loc_5A3A9
mov [r8], r11
loc_5A3A9:
test al, al
jz short loc_5A3D0
mov rax, r12
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r12
jmp short loc_5A3DE
loc_5A3BD:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_5A3CC
mov [r8], rsi
loc_5A3CC:
xor eax, eax
jmp short loc_5A3DE
loc_5A3D0:
mov dword ptr [r9], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
loc_5A3DE:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strntoull_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned long long v10; // rax
unsigned long long v11; // r12
unsigned __int8 *v12; // r14
unsigned long long v13; // r15
unsigned long long v14; // rdi
int v15; // r13d
unsigned __int8 v16; // r12
unsigned __int8 v17; // bl
unsigned __int8 v18; // r12
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+8h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_30;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0LL;
while ( 1 )
{
v14 = v13;
v15 = v11;
v16 = *v12;
v17 = *v12 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v13 = a4 * v14 + v17;
LODWORD(v11) = v15;
}
}
if ( ++v12 == v6 )
{
v14 = v13;
v12 = &a2[a3];
v15 = v11;
break;
}
}
v19 = v15 == 0;
v11 = v14;
v6 = v12;
v8 = v21;
}
if ( v6 == v9 )
{
LABEL_30:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v6;
if ( v19 )
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return -1LL;
}
}
return result;
}
| my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x0015a2d5
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_0015a2c2:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x0015a2d5
INC R10
CMP R10,R11
JC 0x0015a2c2
LAB_0015a2d5:
CMP R10,R11
JZ 0x0015a3bd
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOVSXD RBX,ECX
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x38],RBX
DIV RBX
XOR R12D,R12D
CMP R10,R11
JZ 0x0015a39a
MOV qword ptr [RBP + -0x30],RDI
MOV R14,R10
XOR R15D,R15D
LAB_0015a315:
MOV RDI,R15
MOV R13D,R12D
MOV R12B,byte ptr [R14]
LEA EBX,[R12 + -0x30]
CMP BL,0xa
JC 0x0015a349
LEA EBX,[R12 + -0x41]
CMP BL,0x19
JA 0x0015a338
ADD R12B,0xc9
JMP 0x0015a346
LAB_0015a338:
LEA EBX,[R12 + -0x61]
CMP BL,0x19
JA 0x0015a388
ADD R12B,0xa9
LAB_0015a346:
MOV EBX,R12D
LAB_0015a349:
MOVZX EBX,BL
CMP EBX,ECX
JGE 0x0015a388
MOV R12D,0x1
CMP RDI,RAX
JBE 0x0015a360
MOV R15,RDI
JMP 0x0015a377
LAB_0015a360:
JNZ 0x0015a369
MOV R15,RAX
CMP EBX,EDX
JA 0x0015a377
LAB_0015a369:
IMUL RDI,qword ptr [RBP + -0x38]
MOV R15D,EBX
ADD R15,RDI
MOV R12D,R13D
LAB_0015a377:
INC R14
CMP R14,R11
JNZ 0x0015a315
MOV RDI,R15
MOV R14,R11
MOV R13D,R12D
LAB_0015a388:
TEST R13D,R13D
SETZ AL
MOV R12,RDI
MOV R11,R14
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0015a39c
LAB_0015a39a:
MOV AL,0x1
LAB_0015a39c:
CMP R11,R10
JZ 0x0015a3bd
TEST R8,R8
JZ 0x0015a3a9
MOV qword ptr [R8],R11
LAB_0015a3a9:
TEST AL,AL
JZ 0x0015a3d0
MOV RAX,R12
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R12
JMP 0x0015a3de
LAB_0015a3bd:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x0015a3cc
MOV qword ptr [R8],RSI
LAB_0015a3cc:
XOR EAX,EAX
JMP 0x0015a3de
LAB_0015a3d0:
MOV dword ptr [R9],0x22
MOV RAX,-0x1
LAB_0015a3de:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
ulong uVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
byte *pbVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
int iVar13;
byte *pbVar14;
bool bVar15;
*param_6 = 0;
pbVar9 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar9);
}
if (pbVar8 != pbVar9) {
bVar1 = *pbVar8;
pbVar8 = pbVar8 + ((bVar1 - 0x2b & 0xfd) == 0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)param_4;
auVar4 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar6 = SUB168(auVar4 / auVar3,0);
uVar7 = 0;
if (pbVar8 == pbVar9) {
bVar15 = true;
}
else {
uVar11 = uVar7;
pbVar14 = pbVar8;
uVar7 = 0;
do {
iVar13 = (int)uVar11;
bVar2 = *pbVar14;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_0015a388;
bVar10 = bVar2 + 0xa9;
}
}
if (param_4 <= (int)(uint)bVar10) goto LAB_0015a388;
uVar12 = 1;
uVar5 = uVar7;
if ((uVar7 <= uVar6) &&
((uVar7 != uVar6 || (uVar5 = uVar6, (uint)bVar10 <= SUB164(auVar4 % auVar3,0))))) {
uVar12 = uVar11;
uVar5 = (ulong)bVar10 + uVar7 * (long)param_4;
}
uVar7 = uVar5;
pbVar14 = pbVar14 + 1;
uVar11 = uVar12;
} while (pbVar14 != pbVar9);
iVar13 = (int)uVar12;
pbVar14 = pbVar9;
LAB_0015a388:
pbVar9 = pbVar14;
bVar15 = iVar13 == 0;
}
if (pbVar9 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar9;
}
if (bVar15) {
if (bVar1 == 0x2d) {
return -uVar7;
}
return uVar7;
}
*param_6 = 0x22;
return 0xffffffffffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
|
|
2,659 | my_mb_wc_utf8mb4_no_range | eloqsql/strings/ctype-utf8.c | static int
my_mb_wc_utf8mb4_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!IS_CONTINUATION_BYTE(s[1]))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_utf8mb4_no_range:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xcf3f8
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0xcf3ff
xorl %eax, %eax
cmpb $-0x3e, %cl
jae 0xcf401
popq %rbp
retq
cmpb $-0x21, %cl
ja 0xcf424
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
cmpb $0x3f, %dl
ja 0xcf3ff
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0xcf3f3
cmpb $-0x11, %cl
ja 0xcf470
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0xcf3ff
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0xcf3ff
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
testb %r9b, %r8b
jne 0xcf3ff
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0xcf3f3
cmpb $-0xc, %cl
ja 0xcf3ff
movzbl 0x1(%rsi), %r8d
cmpb $-0x41, %r8b
jg 0xcf3ff
movzbl 0x2(%rsi), %edx
cmpb $-0x41, %dl
jg 0xcf3ff
movzbl 0x3(%rsi), %esi
cmpb $-0x41, %sil
jg 0xcf3ff
cmpl $0xf0, %ecx
sete %r9b
cmpb $-0x70, %r8b
setb %r10b
testb %r10b, %r9b
jne 0xcf3ff
cmpl $0xf4, %ecx
sete %r9b
cmpb $-0x70, %r8b
setae %r10b
testb %r10b, %r9b
jne 0xcf3ff
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r8d
shll $0xc, %r8d
orl %ecx, %r8d
andl $0x3f, %edx
shll $0x6, %edx
orl %r8d, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x4, %eax
jmp 0xcf46b
| my_mb_wc_utf8mb4_no_range:
push rbp
mov rbp, rsp
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_CF3F8
mov eax, 1
loc_CF3F3:
mov [rdi], rcx
jmp short loc_CF3FF
loc_CF3F8:
xor eax, eax
cmp cl, 0C2h
jnb short loc_CF401
loc_CF3FF:
pop rbp
retn
loc_CF401:
cmp cl, 0DFh
ja short loc_CF424
movzx edx, byte ptr [rsi+1]
xor edx, 80h
cmp dl, 3Fh ; '?'
ja short loc_CF3FF
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_CF3F3
loc_CF424:
cmp cl, 0EFh
ja short loc_CF470
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_CF3FF
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_CF3FF
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
test r8b, r9b
jnz short loc_CF3FF
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
loc_CF46B:
mov rcx, rsi
jmp short loc_CF3F3
loc_CF470:
cmp cl, 0F4h
ja short loc_CF3FF
movzx r8d, byte ptr [rsi+1]
cmp r8b, 0BFh
jg loc_CF3FF
movzx edx, byte ptr [rsi+2]
cmp dl, 0BFh
jg loc_CF3FF
movzx esi, byte ptr [rsi+3]
cmp sil, 0BFh
jg loc_CF3FF
cmp ecx, 0F0h
setz r9b
cmp r8b, 90h
setb r10b
test r9b, r10b
jnz loc_CF3FF
cmp ecx, 0F4h
setz r9b
cmp r8b, 90h
setnb r10b
test r9b, r10b
jnz loc_CF3FF
and ecx, 7
shl ecx, 12h
and r8d, 3Fh
shl r8d, 0Ch
or r8d, ecx
and edx, 3Fh
shl edx, 6
or edx, r8d
and esi, 3Fh
or rsi, rdx
mov eax, 4
jmp loc_CF46B
| long long my_mb_wc_utf8mb4_no_range(unsigned long long *a1, unsigned __int8 *a2)
{
unsigned long long v2; // rcx
long long result; // rax
char v4; // dl
char v5; // si
unsigned long long v6; // rsi
char v7; // r8
char v8; // dl
char v9; // si
v2 = *a2;
if ( (v2 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_3:
*a1 = v2;
return result;
}
result = 0LL;
if ( (unsigned __int8)v2 >= 0xC2u )
{
if ( (unsigned __int8)v2 > 0xDFu )
{
if ( (unsigned __int8)v2 > 0xEFu )
{
if ( (unsigned __int8)v2 > 0xF4u )
return result;
v7 = a2[1];
if ( v7 > -65 )
return result;
v8 = a2[2];
if ( v8 > -65 )
return result;
v9 = a2[3];
if ( v9 > -65
|| (unsigned __int8)v7 < 0x90u && (_DWORD)v2 == 240
|| (unsigned __int8)v7 >= 0x90u && (_DWORD)v2 == 244 )
{
return result;
}
v6 = ((v2 & 7) << 18) | ((unsigned __int8)(v7 & 0x3F) << 12) | ((unsigned __int8)(v8 & 0x3F) << 6) | v9 & 0x3F;
result = 4LL;
}
else
{
v4 = a2[1];
if ( v4 > -65 )
return result;
v5 = a2[2];
if ( v5 > -65 || (unsigned __int8)v4 < 0xA0u && (_DWORD)v2 == 224 )
return result;
v6 = (unsigned __int16)((_WORD)v2 << 12) | ((unsigned __int8)(v4 & 0x3F) << 6) | (unsigned long long)(v5 & 0x3F);
result = 3LL;
}
v2 = v6;
goto LABEL_3;
}
if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v2 = a2[1] ^ 0x80 | ((unsigned __int8)(v2 & 0x1F) << 6);
result = 2LL;
goto LABEL_3;
}
}
return result;
}
| my_mb_wc_utf8mb4_no_range:
PUSH RBP
MOV RBP,RSP
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x001cf3f8
MOV EAX,0x1
LAB_001cf3f3:
MOV qword ptr [RDI],RCX
JMP 0x001cf3ff
LAB_001cf3f8:
XOR EAX,EAX
CMP CL,0xc2
JNC 0x001cf401
LAB_001cf3ff:
POP RBP
RET
LAB_001cf401:
CMP CL,0xdf
JA 0x001cf424
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
CMP DL,0x3f
JA 0x001cf3ff
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x001cf3f3
LAB_001cf424:
CMP CL,0xef
JA 0x001cf470
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cf3ff
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x001cf3ff
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
TEST R8B,R9B
JNZ 0x001cf3ff
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
LAB_001cf46b:
MOV RCX,RSI
JMP 0x001cf3f3
LAB_001cf470:
CMP CL,0xf4
JA 0x001cf3ff
MOVZX R8D,byte ptr [RSI + 0x1]
CMP R8B,0xbf
JG 0x001cf3ff
MOVZX EDX,byte ptr [RSI + 0x2]
CMP DL,0xbf
JG 0x001cf3ff
MOVZX ESI,byte ptr [RSI + 0x3]
CMP SIL,0xbf
JG 0x001cf3ff
CMP ECX,0xf0
SETZ R9B
CMP R8B,0x90
SETC R10B
TEST R9B,R10B
JNZ 0x001cf3ff
CMP ECX,0xf4
SETZ R9B
CMP R8B,0x90
SETNC R10B
TEST R9B,R10B
JNZ 0x001cf3ff
AND ECX,0x7
SHL ECX,0x12
AND R8D,0x3f
SHL R8D,0xc
OR R8D,ECX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,R8D
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x4
JMP 0x001cf46b
|
int8 my_mb_wc_utf8mb4_no_range(ulong *param_1,byte *param_2)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
bVar1 = *param_2;
uVar5 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (bVar1 < 0xc2) {
return 0;
}
uVar4 = (uint)bVar1;
if (bVar1 < 0xe0) {
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar5 = (ulong)((uVar4 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
}
else {
if (bVar1 < 0xf0) {
bVar2 = param_2[1];
if (-0x41 < (char)bVar2) {
return 0;
}
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (uVar4 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc;
uVar3 = 3;
}
else {
if (0xf4 < bVar1) {
return 0;
}
bVar1 = param_2[1];
if (-0x41 < (char)bVar1) {
return 0;
}
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (-0x41 < (char)param_2[3]) {
return 0;
}
if (uVar4 == 0xf0 && bVar1 < 0x90) {
return 0;
}
if (uVar4 == 0xf4 && 0x8f < bVar1) {
return 0;
}
uVar4 = param_2[3] & 0x3f |
(param_2[2] & 0x3f) << 6 | (bVar1 & 0x3f) << 0xc | (uVar4 & 7) << 0x12;
uVar3 = 4;
}
uVar5 = (ulong)uVar4;
}
}
else {
uVar3 = 1;
}
*param_1 = uVar5;
return uVar3;
}
|
|
2,660 | rtree_get_next | eloqsql/storage/myisam/rt_index.c | int rtree_get_next(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root= info->s->state.key_root[keynr];
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if (root == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
if (!info->buff_used && !info->page_changed)
{
uint k_len = keyinfo->keylength - info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(info->int_keypos) */
uchar *key = info->buff + *(int*)info->int_keypos + k_len +
info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(key) */
uchar *after_key = key + k_len + info->s->base.rec_reflength;
info->lastpos = _mi_dpos(info, 0, after_key);
info->lastkey_length = k_len + info->s->base.rec_reflength;
memcpy(info->lastkey, key, k_len + info->s->base.rec_reflength);
*(uint*)info->int_keypos = (uint) (key - info->buff);
if (after_key >= info->int_maxpos)
{
info->buff_used = 1;
}
return 0;
}
return rtree_get_req(info, keyinfo, key_length, root, 0);
} | O3 | c | rtree_get_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x98(%rax), %rdx
movl %esi, %ecx
movq (%rdx,%rcx,8), %rdx
cmpq $-0x1, %rdx
je 0x8a97b
movq %rdi, %rbx
imulq $0x70, %rcx, %rsi
addq 0x218(%rax), %rsi
cmpb $0x0, 0x33d(%rdi)
jne 0x8a963
cmpb $0x0, 0x33c(%rbx)
je 0x8a99e
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8a68f
callq 0xa2412
movl $0x89, (%rax)
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x12(%rsi), %r12d
movl 0x178(%rax), %r14d
subl %r14d, %r12d
movq 0x128(%rbx), %rax
movslq (%rax), %r13
addq 0x100(%rbx), %r13
addq %r14, %r13
addq %r12, %r13
addq %r12, %r14
addq %r13, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x84e7d
movq %rax, 0x170(%rbx)
movq (%rbx), %rax
movq 0x108(%rbx), %rdi
movl 0x178(%rax), %ecx
addl %r12d, %ecx
movl %ecx, 0x1d8(%rbx)
addl 0x178(%rax), %r12d
movq %r13, %rsi
movq %r12, %rdx
callq 0x29080
subl 0x100(%rbx), %r13d
movq 0x128(%rbx), %rax
movl %r13d, (%rax)
cmpq 0x130(%rbx), %r14
jb 0x8a98c
movb $0x1, 0x33d(%rbx)
jmp 0x8a98c
| rtree_get_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rax, [rdi]
mov rdx, [rax+98h]
mov ecx, esi
mov rdx, [rdx+rcx*8]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_8A97B
mov rbx, rdi
imul rsi, rcx, 70h ; 'p'
add rsi, [rax+218h]
cmp byte ptr [rdi+33Dh], 0
jnz short loc_8A963
cmp byte ptr [rbx+33Ch], 0
jz short loc_8A99E
loc_8A963:
mov rdi, rbx
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rtree_get_req
loc_8A97B:
call _my_thread_var
mov dword ptr [rax], 89h
mov r15d, 0FFFFFFFFh
loc_8A98C:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8A99E:
movzx r12d, word ptr [rsi+12h]
mov r14d, [rax+178h]
sub r12d, r14d
mov rax, [rbx+128h]
movsxd r13, dword ptr [rax]
add r13, [rbx+100h]
add r13, r14
add r13, r12
add r14, r12
add r14, r13
xor r15d, r15d
mov rdi, rbx
xor esi, esi
mov rdx, r14
call _mi_dpos
mov [rbx+170h], rax
mov rax, [rbx]
mov rdi, [rbx+108h]
mov ecx, [rax+178h]
add ecx, r12d
mov [rbx+1D8h], ecx
add r12d, [rax+178h]
mov rsi, r13
mov rdx, r12
call _memcpy
sub r13d, [rbx+100h]
mov rax, [rbx+128h]
mov [rax], r13d
cmp r14, [rbx+130h]
jb loc_8A98C
mov byte ptr [rbx+33Dh], 1
jmp loc_8A98C
| long long rtree_get_next(long long *a1, unsigned int a2)
{
long long v2; // rax
long long v3; // rdx
long long v5; // rsi
unsigned int v7; // r15d
long long v8; // r14
long long v9; // r12
long long v10; // r13
unsigned long long v11; // r14
long long v12; // rax
long long v13; // rdi
v2 = *a1;
v3 = *(_QWORD *)(*(_QWORD *)(*a1 + 152) + 8LL * a2);
if ( v3 == -1 )
{
*(_DWORD *)my_thread_var(a1) = 137;
return (unsigned int)-1;
}
else
{
v5 = *(_QWORD *)(v2 + 536) + 112LL * a2;
if ( *((_BYTE *)a1 + 829) || *((_BYTE *)a1 + 828) )
return rtree_get_req(a1, v5, v3, 0LL);
v8 = *(unsigned int *)(v2 + 376);
v9 = *(unsigned __int16 *)(v5 + 18) - (unsigned int)v8;
v10 = v9 + v8 + a1[32] + *(int *)a1[37];
v11 = v10 + v9 + v8;
v7 = 0;
a1[46] = mi_dpos(a1, 0, v11);
v12 = *a1;
v13 = a1[33];
*((_DWORD *)a1 + 118) = v9 + *(_DWORD *)(*a1 + 376);
memcpy(v13, v10, (unsigned int)(*(_DWORD *)(v12 + 376) + v9));
*(_DWORD *)a1[37] = v10 - *((_DWORD *)a1 + 64);
if ( v11 >= a1[38] )
*((_BYTE *)a1 + 829) = 1;
}
return v7;
}
| rtree_get_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RAX + 0x98]
MOV ECX,ESI
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP RDX,-0x1
JZ 0x0018a97b
MOV RBX,RDI
IMUL RSI,RCX,0x70
ADD RSI,qword ptr [RAX + 0x218]
CMP byte ptr [RDI + 0x33d],0x0
JNZ 0x0018a963
CMP byte ptr [RBX + 0x33c],0x0
JZ 0x0018a99e
LAB_0018a963:
MOV RDI,RBX
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018a68f
LAB_0018a97b:
CALL 0x001a2412
MOV dword ptr [RAX],0x89
MOV R15D,0xffffffff
LAB_0018a98c:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018a99e:
MOVZX R12D,word ptr [RSI + 0x12]
MOV R14D,dword ptr [RAX + 0x178]
SUB R12D,R14D
MOV RAX,qword ptr [RBX + 0x128]
MOVSXD R13,dword ptr [RAX]
ADD R13,qword ptr [RBX + 0x100]
ADD R13,R14
ADD R13,R12
ADD R14,R12
ADD R14,R13
XOR R15D,R15D
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R14
CALL 0x00184e7d
MOV qword ptr [RBX + 0x170],RAX
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RBX + 0x108]
MOV ECX,dword ptr [RAX + 0x178]
ADD ECX,R12D
MOV dword ptr [RBX + 0x1d8],ECX
ADD R12D,dword ptr [RAX + 0x178]
MOV RSI,R13
MOV RDX,R12
CALL 0x00129080
SUB R13D,dword ptr [RBX + 0x100]
MOV RAX,qword ptr [RBX + 0x128]
MOV dword ptr [RAX],R13D
CMP R14,qword ptr [RBX + 0x130]
JC 0x0018a98c
MOV byte ptr [RBX + 0x33d],0x1
JMP 0x0018a98c
|
int8 rtree_get_next(long *param_1,ulong param_2)
{
uint uVar1;
long lVar2;
int8 uVar3;
int4 *puVar4;
long lVar5;
long lVar6;
uint uVar7;
void *__src;
ulong uVar8;
lVar5 = *param_1;
lVar2 = *(long *)(*(long *)(lVar5 + 0x98) + (param_2 & 0xffffffff) * 8);
if (lVar2 == -1) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x89;
uVar3 = 0xffffffff;
}
else {
lVar6 = (param_2 & 0xffffffff) * 0x70 + *(long *)(lVar5 + 0x218);
if ((*(char *)((long)param_1 + 0x33d) != '\0') || (*(char *)((long)param_1 + 0x33c) != '\0')) {
uVar3 = rtree_get_req(param_1,lVar6,lVar2,0);
return uVar3;
}
uVar1 = *(uint *)(lVar5 + 0x178);
uVar7 = *(ushort *)(lVar6 + 0x12) - uVar1;
__src = (void *)((long)*(int *)param_1[0x25] + param_1[0x20] + (ulong)uVar1 + (ulong)uVar7);
uVar8 = (ulong)uVar1 + (ulong)uVar7 + (long)__src;
uVar3 = 0;
lVar5 = _mi_dpos(param_1,0,uVar8);
param_1[0x2e] = lVar5;
*(uint *)(param_1 + 0x3b) = *(int *)(*param_1 + 0x178) + uVar7;
memcpy((void *)param_1[0x21],__src,(ulong)(uVar7 + *(int *)(*param_1 + 0x178)));
*(int *)param_1[0x25] = (int)__src - (int)param_1[0x20];
if ((ulong)param_1[0x26] <= uVar8) {
*(int1 *)((long)param_1 + 0x33d) = 1;
}
}
return uVar3;
}
|
|
2,661 | LefDefParser::defiIOTiming::setDriveCell(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiIOTiming.cpp | void defiIOTiming::setDriveCell(const char* name) {
int len = strlen(name) + 1;
if (driveCellLength_ < len) {
if (driveCell_) free(driveCell_);
driveCell_ = (char*) malloc(len);
driveCellLength_ = len;
}
strcpy(driveCell_, defData->DEFCASE(name));
hasDriveCell_ = 1;
} | O3 | cpp | LefDefParser::defiIOTiming::setDriveCell(char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x60d0
movq %rax, %r15
incl %r15d
movsbl 0x48(%rbx), %eax
movq 0x40(%rbx), %r12
cmpl %eax, %r15d
jle 0x1143b
testq %r12, %r12
je 0x11428
movq %r12, %rdi
callq 0x6220
movslq %r15d, %rdi
callq 0x6270
movq %rax, %r12
movq %rax, 0x40(%rbx)
movb %r15b, 0x48(%rbx)
movq 0xa8(%rbx), %rdi
movq %r14, %rsi
callq 0x18aa0
movq %r12, %rdi
movq %rax, %rsi
callq 0x6190
movb $0x1, 0x4e(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN12LefDefParser12defiIOTiming12setDriveCellEPKc:
push r15
push r14
push r12
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _strlen
mov r15, rax
inc r15d
movsx eax, byte ptr [rbx+48h]
mov r12, [rbx+40h]
cmp r15d, eax
jle short loc_1143B
test r12, r12
jz short loc_11428
mov rdi, r12
call _free
loc_11428:
movsxd rdi, r15d
call _malloc
mov r12, rax
mov [rbx+40h], rax
mov [rbx+48h], r15b
loc_1143B:
mov rdi, [rbx+0A8h]; this
mov rsi, r14; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r12
mov rsi, rax
call _strcpy
mov byte ptr [rbx+4Eh], 1
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long LefDefParser::defiIOTiming::setDriveCell(LefDefParser::defiIOTiming *this, const char *a2)
{
int v2; // r15d
long long v3; // r12
long long v4; // rax
long long result; // rax
v2 = strlen(a2) + 1;
v3 = *((_QWORD *)this + 8);
if ( v2 > *((char *)this + 72) )
{
if ( v3 )
free(*((_QWORD *)this + 8));
v3 = malloc(v2);
*((_QWORD *)this + 8) = v3;
*((_BYTE *)this + 72) = v2;
}
v4 = LefDefParser::defrData::DEFCASE(*((LefDefParser::defrData **)this + 21), a2);
result = strcpy(v3, v4);
*((_BYTE *)this + 78) = 1;
return result;
}
| setDriveCell:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001060d0
MOV R15,RAX
INC R15D
MOVSX EAX,byte ptr [RBX + 0x48]
MOV R12,qword ptr [RBX + 0x40]
CMP R15D,EAX
JLE 0x0011143b
TEST R12,R12
JZ 0x00111428
MOV RDI,R12
CALL 0x00106220
LAB_00111428:
MOVSXD RDI,R15D
CALL 0x00106270
MOV R12,RAX
MOV qword ptr [RBX + 0x40],RAX
MOV byte ptr [RBX + 0x48],R15B
LAB_0011143b:
MOV RDI,qword ptr [RBX + 0xa8]
MOV RSI,R14
CALL 0x00118aa0
MOV RDI,R12
MOV RSI,RAX
CALL 0x00106190
MOV byte ptr [RBX + 0x4e],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::defiIOTiming::setDriveCell(char const*) */
void __thiscall LefDefParser::defiIOTiming::setDriveCell(defiIOTiming *this,char *param_1)
{
size_t sVar1;
char *__dest;
char *__src;
int iVar2;
sVar1 = strlen(param_1);
iVar2 = (int)sVar1 + 1;
__dest = *(char **)(this + 0x40);
if ((char)this[0x48] < iVar2) {
if (__dest != (char *)0x0) {
free(__dest);
}
__dest = (char *)malloc((long)iVar2);
*(char **)(this + 0x40) = __dest;
this[0x48] = SUB41(iVar2,0);
}
__src = (char *)defrData::DEFCASE(*(defrData **)(this + 0xa8),param_1);
strcpy(__dest,__src);
this[0x4e] = (defiIOTiming)0x1;
return;
}
|
|
2,662 | js_proxy_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_proxy_constructor(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue target, handler;
JSValue obj;
JSProxyData *s;
target = argv[0];
handler = argv[1];
if (JS_VALUE_GET_TAG(target) != JS_TAG_OBJECT ||
JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
if (JS_IsException(obj))
return obj;
s = js_malloc(ctx, sizeof(JSProxyData));
if (!s) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
s->target = js_dup(target);
s->handler = js_dup(handler);
s->is_func = JS_IsFunction(ctx, target);
s->is_revoked = FALSE;
JS_SetOpaqueInternal(obj, s);
JS_SetConstructorBit(ctx, obj, JS_IsConstructor(ctx, target));
return obj;
} | O0 | c | js_proxy_constructor:
subq $0xc8, %rsp
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movl %ecx, 0x9c(%rsp)
movq %r8, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x80(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x78(%rsp)
movq 0x88(%rsp), %rax
cmpl $-0x1, %eax
jne 0x528ce
movq 0x78(%rsp), %rax
cmpl $-0x1, %eax
je 0x528f0
movq 0xa0(%rsp), %rdi
callq 0x2f5a0
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
jmp 0x52adb
movq 0xa0(%rsp), %rdi
movl $0x0, 0x38(%rsp)
movq $0x2, 0x40(%rsp)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movl $0x30, %ecx
callq 0x29ea0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x5296e
movq 0x60(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xc0(%rsp)
jmp 0x52adb
movq 0xa0(%rsp), %rdi
movl $0x28, %esi
callq 0x21cb0
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x529c0
movq 0xa0(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x23c90
movl $0x0, 0xb8(%rsp)
movq $0x6, 0xc0(%rsp)
jmp 0x52adb
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x216d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x216d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x2e510
movb %al, %cl
movq 0x58(%rsp), %rax
movb %cl, 0x20(%rax)
movq 0x58(%rsp), %rax
movb $0x0, 0x21(%rax)
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x2a9a0
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x380f0
movq 0x10(%rsp), %rdi
movl %eax, %ecx
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x38140
movq 0x60(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq 0xc0(%rsp), %rdx
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
| js_proxy_constructor:
sub rsp, 0C8h
mov [rsp+0C8h+var_20], rsi
mov [rsp+0C8h+var_18], rdx
mov [rsp+0C8h+var_28], rdi
mov [rsp+0C8h+var_2C], ecx
mov [rsp+0C8h+var_38], r8
mov rax, [rsp+0C8h+var_38]
mov rcx, [rax]
mov [rsp+0C8h+var_48], rcx
mov rax, [rax+8]
mov [rsp+0C8h+var_40], rax
mov rax, [rsp+0C8h+var_38]
mov rcx, [rax+10h]
mov [rsp+0C8h+var_58], rcx
mov rax, [rax+18h]
mov [rsp+0C8h+var_50], rax
mov rax, [rsp+0C8h+var_40]
cmp eax, 0FFFFFFFFh
jnz short loc_528CE
mov rax, [rsp+0C8h+var_50]
cmp eax, 0FFFFFFFFh
jz short loc_528F0
loc_528CE:
mov rdi, [rsp+0C8h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+0C8h+var_10], rax
mov [rsp+0C8h+var_8], rdx
jmp loc_52ADB
loc_528F0:
mov rdi, [rsp+0C8h+var_28]
mov dword ptr [rsp+0C8h+var_90], 0
mov [rsp+0C8h+var_88], 2
mov rsi, [rsp+0C8h+var_90]
mov rdx, [rsp+0C8h+var_88]
mov ecx, 30h ; '0'
call JS_NewObjectProtoClass
mov [rsp+0C8h+var_80], rax
mov [rsp+0C8h+var_78], rdx
mov rax, [rsp+0C8h+var_80]
mov [rsp+0C8h+var_68], rax
mov rax, [rsp+0C8h+var_78]
mov [rsp+0C8h+var_60], rax
mov rdi, [rsp+0C8h+var_68]
mov rsi, [rsp+0C8h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_5296E
mov rax, [rsp+0C8h+var_68]
mov [rsp+0C8h+var_10], rax
mov rax, [rsp+0C8h+var_60]
mov [rsp+0C8h+var_8], rax
jmp loc_52ADB
loc_5296E:
mov rdi, [rsp+0C8h+var_28]
mov esi, 28h ; '('
call js_malloc
mov [rsp+0C8h+var_70], rax
cmp [rsp+0C8h+var_70], 0
jnz short loc_529C0
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_68]
mov rdx, [rsp+0C8h+var_60]
call JS_FreeValue
mov dword ptr [rsp+0C8h+var_10], 0
mov [rsp+0C8h+var_8], 6
jmp loc_52ADB
loc_529C0:
mov rax, [rsp+0C8h+var_70]
mov [rsp+0C8h+var_C8], rax
mov rdi, [rsp+0C8h+var_48]
mov rsi, [rsp+0C8h+var_40]
call js_dup
mov rcx, rax
mov rax, [rsp+0C8h+var_C8]
mov [rsp+0C8h+var_A0], rcx
mov [rsp+0C8h+var_98], rdx
mov rcx, [rsp+0C8h+var_A0]
mov [rax], rcx
mov rcx, [rsp+0C8h+var_98]
mov [rax+8], rcx
mov rax, [rsp+0C8h+var_70]
mov [rsp+0C8h+var_C0], rax
mov rdi, [rsp+0C8h+var_58]
mov rsi, [rsp+0C8h+var_50]
call js_dup
mov rcx, rax
mov rax, [rsp+0C8h+var_C0]
mov [rsp+0C8h+var_B0], rcx
mov [rsp+0C8h+var_A8], rdx
mov rcx, [rsp+0C8h+var_B0]
mov [rax+10h], rcx
mov rcx, [rsp+0C8h+var_A8]
mov [rax+18h], rcx
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
call JS_IsFunction
mov cl, al
mov rax, [rsp+0C8h+var_70]
mov [rax+20h], cl
mov rax, [rsp+0C8h+var_70]
mov byte ptr [rax+21h], 0
mov rdx, [rsp+0C8h+var_70]
mov rdi, [rsp+0C8h+var_68]
mov rsi, [rsp+0C8h+var_60]
call JS_SetOpaqueInternal
mov rax, [rsp+0C8h+var_28]
mov [rsp+0C8h+var_B8], rax
mov rdi, [rsp+0C8h+var_28]
mov rsi, [rsp+0C8h+var_48]
mov rdx, [rsp+0C8h+var_40]
call JS_IsConstructor
mov rdi, [rsp+0C8h+var_B8]
mov ecx, eax
mov rsi, [rsp+0C8h+var_68]
mov rdx, [rsp+0C8h+var_60]
call JS_SetConstructorBit
mov rax, [rsp+0C8h+var_68]
mov [rsp+0C8h+var_10], rax
mov rax, [rsp+0C8h+var_60]
mov [rsp+0C8h+var_8], rax
loc_52ADB:
mov rax, [rsp+0C8h+var_10]
mov rdx, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| long long js_proxy_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
char IsConstructor; // al
long long v19; // [rsp+38h] [rbp-90h]
long long v20; // [rsp+48h] [rbp-80h]
long long v21; // [rsp+58h] [rbp-70h]
long long v22; // [rsp+68h] [rbp-60h]
_DWORD *v23; // [rsp+70h] [rbp-58h]
_DWORD *v24; // [rsp+80h] [rbp-48h]
long long v25; // [rsp+B8h] [rbp-10h]
v24 = *(_DWORD **)a13;
v23 = *(_DWORD **)(a13 + 16);
if ( (unsigned int)*(_QWORD *)(a13 + 8) != -1 || (unsigned int)*(_QWORD *)(a13 + 24) != -1 )
return JS_ThrowTypeErrorNotAnObject(a1, a4, a5, a6, a7, a8, a9, a10, a11, a2, a3, *(_QWORD *)(a13 + 16), a13, a14);
LODWORD(v19) = 0;
v20 = JS_NewObjectProtoClass(a1, v19, 2LL, 0x30u);
v22 = v14;
if ( JS_IsException_1(v20, v14) )
return v20;
v21 = js_malloc(a1, 40LL);
if ( v21 )
{
*(_QWORD *)v21 = js_dup(v24, 0xFFFFFFFF);
*(_QWORD *)(v21 + 8) = v15;
*(_QWORD *)(v21 + 16) = js_dup(v23, 0xFFFFFFFF);
*(_QWORD *)(v21 + 24) = v16;
*(_BYTE *)(v21 + 32) = JS_IsFunction(a1, (long long)v24, -1);
*(_BYTE *)(v21 + 33) = 0;
JS_SetOpaqueInternal(v20, v22, v21);
IsConstructor = JS_IsConstructor(a1, (long long)v24, -1);
JS_SetConstructorBit(a1, v20, v22, IsConstructor);
return v20;
}
else
{
JS_FreeValue(a1, v20, v22);
LODWORD(v25) = 0;
}
return v25;
}
| js_proxy_constructor:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0xa0],RDI
MOV dword ptr [RSP + 0x9c],ECX
MOV qword ptr [RSP + 0x90],R8
MOV RAX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x80],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x70],RCX
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x88]
CMP EAX,-0x1
JNZ 0x001528ce
MOV RAX,qword ptr [RSP + 0x78]
CMP EAX,-0x1
JZ 0x001528f0
LAB_001528ce:
MOV RDI,qword ptr [RSP + 0xa0]
CALL 0x0012f5a0
MOV qword ptr [RSP + 0xb8],RAX
MOV qword ptr [RSP + 0xc0],RDX
JMP 0x00152adb
LAB_001528f0:
MOV RDI,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x2
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
MOV ECX,0x30
CALL 0x00129ea0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0015296e
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x00152adb
LAB_0015296e:
MOV RDI,qword ptr [RSP + 0xa0]
MOV ESI,0x28
CALL 0x00121cb0
MOV qword ptr [RSP + 0x58],RAX
CMP qword ptr [RSP + 0x58],0x0
JNZ 0x001529c0
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00123c90
MOV dword ptr [RSP + 0xb8],0x0
MOV qword ptr [RSP + 0xc0],0x6
JMP 0x00152adb
LAB_001529c0:
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x001216d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RDX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x001216d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x0012e510
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x58]
MOV byte ptr [RAX + 0x20],CL
MOV RAX,qword ptr [RSP + 0x58]
MOV byte ptr [RAX + 0x21],0x0
MOV RDX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x0012a9a0
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x001380f0
MOV RDI,qword ptr [RSP + 0x10]
MOV ECX,EAX
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
CALL 0x00138140
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xc0],RAX
LAB_00152adb:
MOV RAX,qword ptr [RSP + 0xb8]
MOV RDX,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
int1 [16] js_proxy_constructor(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int8 uVar4;
int1 uVar5;
int iVar6;
int4 uVar7;
int8 uVar8;
int1 (*pauVar9) [16];
int8 *in_R8;
int1 auVar10 [16];
uint uStack_8c;
int4 local_10;
int4 uStack_c;
int8 local_8;
uVar7 = uStack_c;
uVar1 = *in_R8;
uVar2 = in_R8[1];
uVar3 = in_R8[2];
uVar4 = in_R8[3];
if (((int)uVar2 == -1) && ((int)uVar4 == -1)) {
auVar10 = JS_NewObjectProtoClass(param_1,(ulong)uStack_8c << 0x20,2,0x30);
local_8 = auVar10._8_8_;
uVar8 = auVar10._0_8_;
iVar6 = JS_IsException(uVar8,local_8);
local_10 = auVar10._0_4_;
uStack_c = auVar10._4_4_;
if (iVar6 == 0) {
pauVar9 = (int1 (*) [16])js_malloc(param_1,0x28);
if (pauVar9 == (int1 (*) [16])0x0) {
JS_FreeValue(param_1,uVar8,local_8);
local_10 = 0;
local_8 = 6;
uStack_c = uVar7;
}
else {
auVar10 = js_dup(uVar1,uVar2);
*pauVar9 = auVar10;
auVar10 = js_dup(uVar3,uVar4);
pauVar9[1] = auVar10;
uVar5 = JS_IsFunction(param_1,uVar1,uVar2);
pauVar9[2][0] = uVar5;
pauVar9[2][1] = 0;
JS_SetOpaqueInternal(uVar8,local_8,pauVar9);
uVar7 = JS_IsConstructor(param_1,uVar1,uVar2);
JS_SetConstructorBit(param_1,uVar8,local_8,uVar7);
}
}
}
else {
auVar10 = JS_ThrowTypeErrorNotAnObject(param_1);
local_8 = auVar10._8_8_;
local_10 = auVar10._0_4_;
uStack_c = auVar10._4_4_;
}
auVar10._4_4_ = uStack_c;
auVar10._0_4_ = local_10;
auVar10._8_8_ = local_8;
return auVar10;
}
|
|
2,663 | js_proxy_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_proxy_constructor(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue target, handler;
JSValue obj;
JSProxyData *s;
target = argv[0];
handler = argv[1];
if (JS_VALUE_GET_TAG(target) != JS_TAG_OBJECT ||
JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
if (JS_IsException(obj))
return obj;
s = js_malloc(ctx, sizeof(JSProxyData));
if (!s) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
s->target = js_dup(target);
s->handler = js_dup(handler);
s->is_func = JS_IsFunction(ctx, target);
s->is_revoked = FALSE;
JS_SetOpaqueInternal(obj, s);
JS_SetConstructorBit(ctx, obj, JS_IsConstructor(ctx, target));
return obj;
} | O1 | c | js_proxy_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq 0x8(%r8), %r12
movq 0x18(%r8), %r13
movl %r13d, %eax
notl %eax
movl %r12d, %ebp
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
xorq %rbp, %rcx
orq %rcx, %rax
je 0x35a03
leaq 0x69638(%rip), %rsi # 0x9f025
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %r14d
xorl %ecx, %ecx
jmp 0x35a47
movq (%r8), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%r8), %rax
movq %rax, 0x18(%rsp)
movl $0x2, %edx
movq %r15, %rdi
xorl %esi, %esi
movl $0x30, %ecx
callq 0x20f05
movq %rax, %rbx
movq %rdx, %r14
movl %r14d, %eax
cmpq $0x6, %rax
jne 0x35a5e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rbx, %rcx
andq %rax, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x10(%rsp)
movl $0x28, %esi
movq %r15, %rdi
callq 0xede6
testq %rax, %rax
je 0x35ac9
movq 0x20(%rsp), %rsi
incl (%rsi)
movq %rsi, (%rax)
movq %r12, 0x8(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
incl (%rax)
movq %rax, 0x10(%rcx)
movq %r13, 0x18(%rcx)
movq %rcx, %r13
movq %r15, %rdi
movq %rsi, %r15
movq %r12, %rdx
callq 0x22dbe
movb %al, 0x20(%r13)
movb $0x0, 0x21(%r13)
movq %r13, 0x30(%rbx)
movq %r15, 0x8(%rsp)
cmpl $-0x1, %ebp
jne 0x35ae5
movq 0x8(%rsp), %rax
movb 0x5(%rax), %al
andb $0x10, %al
jmp 0x35ae7
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1d8c6
movl $0x6, %r14d
xorl %ebx, %ebx
jmp 0x359ff
xorl %eax, %eax
movq %rbx, 0x8(%rsp)
cmpl $-0x1, 0x10(%rsp)
jne 0x35a37
movq 0x8(%rsp), %rcx
movb 0x5(%rcx), %dl
andb $-0x11, %dl
orb %al, %dl
movb %dl, 0x5(%rcx)
jmp 0x35a37
| js_proxy_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdi
mov r12, [r8+8]
mov r13, [r8+18h]
mov eax, r13d
not eax
mov ebp, r12d
mov ecx, 0FFFFFFFFh
xor rcx, rbp
or rax, rcx
jz short loc_35A03
lea rsi, aOperandPrototy+20h; "not an object"
xor ebx, ebx
mov rdi, r15
xor eax, eax
call JS_ThrowTypeError
mov r14d, 6
loc_359FF:
xor ecx, ecx
jmp short loc_35A47
loc_35A03:
mov rax, [r8]
mov [rsp+58h+var_38], rax
mov rax, [r8+10h]
mov [rsp+58h+var_40], rax
mov edx, 2
mov rdi, r15
xor esi, esi
mov ecx, 30h ; '0'
call JS_NewObjectProtoClass
mov rbx, rax
mov r14, rdx
mov eax, r14d
cmp rax, 6
jnz short loc_35A5E
loc_35A37:
mov rax, 0FFFFFFFF00000000h
mov rcx, rbx
and rcx, rax
loc_35A47:
mov eax, ebx
or rax, rcx
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_35A5E:
mov [rsp+58h+var_48], rax
mov esi, 28h ; '('
mov rdi, r15
call js_malloc
test rax, rax
jz short loc_35AC9
mov rsi, [rsp+58h+var_38]
inc dword ptr [rsi]
mov [rax], rsi
mov [rax+8], r12
mov rcx, rax
mov rax, [rsp+58h+var_40]
inc dword ptr [rax]
mov [rcx+10h], rax
mov [rcx+18h], r13
mov r13, rcx
mov rdi, r15
mov r15, rsi
mov rdx, r12
call JS_IsFunction
mov [r13+20h], al
mov byte ptr [r13+21h], 0
mov [rbx+30h], r13
mov [rsp+58h+var_50], r15
cmp ebp, 0FFFFFFFFh
jnz short loc_35AE5
mov rax, [rsp+58h+var_50]
mov al, [rax+5]
and al, 10h
jmp short loc_35AE7
loc_35AC9:
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov r14d, 6
xor ebx, ebx
jmp loc_359FF
loc_35AE5:
xor eax, eax
loc_35AE7:
mov [rsp+58h+var_50], rbx
cmp dword ptr [rsp+58h+var_48], 0FFFFFFFFh
jnz loc_35A37
mov rcx, [rsp+58h+var_50]
mov dl, [rcx+5]
and dl, 0EFh
or dl, al
mov [rcx+5], dl
jmp loc_35A37
| unsigned long long js_proxy_constructor(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long *a13,
long long a14)
{
long long v14; // r12
long long v15; // r13
long long v16; // rbx
unsigned long long v17; // rcx
long long v18; // rdx
long long v19; // r14
long long v21; // rax
long long v22; // r13
char v23; // al
char v24; // [rsp+0h] [rbp-58h]
int v25; // [rsp+10h] [rbp-48h]
_DWORD *v26; // [rsp+18h] [rbp-40h]
long long v27; // [rsp+20h] [rbp-38h]
v14 = a13[1];
v15 = a13[3];
if ( !((unsigned int)v14 ^ 0xFFFFFFFFLL | (unsigned int)~*((_DWORD *)a13 + 6)) )
{
v27 = *a13;
v26 = (_DWORD *)a13[2];
v16 = JS_NewObjectProtoClass(a1, 0LL, 2, 0x30u);
v19 = v18;
if ( (unsigned int)v18 != 6LL )
{
v25 = v18;
v21 = js_malloc(a1, 40LL);
if ( !v21 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v16, v19);
LODWORD(v16) = 0;
goto LABEL_3;
}
++*(_DWORD *)v27;
*(_QWORD *)v21 = v27;
*(_QWORD *)(v21 + 8) = v14;
++*v26;
*(_QWORD *)(v21 + 16) = v26;
*(_QWORD *)(v21 + 24) = v15;
v22 = v21;
*(_BYTE *)(v21 + 32) = JS_IsFunction(a1, v27, v14);
*(_BYTE *)(v22 + 33) = 0;
*(_QWORD *)(v16 + 48) = v22;
if ( (_DWORD)v14 == -1 )
v23 = *(_BYTE *)(v27 + 5) & 0x10;
else
v23 = 0;
if ( v25 == -1 )
*(_BYTE *)(v16 + 5) = v23 | *(_BYTE *)(v16 + 5) & 0xEF;
}
v17 = v16 & 0xFFFFFFFF00000000LL;
return v17 | (unsigned int)v16;
}
LODWORD(v16) = 0;
JS_ThrowTypeError(
a1,
(long long)"not an object",
a11,
(unsigned int)v14 ^ 0xFFFFFFFFLL,
(long long)a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
v24);
LABEL_3:
v17 = 0LL;
return v17 | (unsigned int)v16;
}
| |||
2,664 | js_proxy_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_proxy_constructor(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue target, handler;
JSValue obj;
JSProxyData *s;
target = argv[0];
handler = argv[1];
if (JS_VALUE_GET_TAG(target) != JS_TAG_OBJECT ||
JS_VALUE_GET_TAG(handler) != JS_TAG_OBJECT)
return JS_ThrowTypeErrorNotAnObject(ctx);
obj = JS_NewObjectProtoClass(ctx, JS_NULL, JS_CLASS_PROXY);
if (JS_IsException(obj))
return obj;
s = js_malloc(ctx, sizeof(JSProxyData));
if (!s) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
s->target = js_dup(target);
s->handler = js_dup(handler);
s->is_func = JS_IsFunction(ctx, target);
s->is_revoked = FALSE;
JS_SetOpaqueInternal(obj, s);
JS_SetConstructorBit(ctx, obj, JS_IsConstructor(ctx, target));
return obj;
} | O2 | c | js_proxy_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movq 0x8(%r8), %r13
movl %r13d, %eax
notl %eax
movq 0x18(%r8), %r12
movl %r12d, %ecx
notl %ecx
orl %eax, %ecx
je 0x2f262
movq %r15, %rdi
callq 0x1d5e1
pushq $0x6
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
jmp 0x2f30a
movq (%r8), %rbp
movq 0x10(%r8), %rax
movq %rax, 0x10(%rsp)
pushq $0x2
popq %rdx
pushq $0x30
popq %rcx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1b069
movq %rax, %r14
movq %rdx, %rbx
movl %ebx, %eax
cmpq $0x6, %rax
je 0x2f2fa
movq %rax, (%rsp)
movq %rbp, 0x8(%rsp)
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x17214
testq %rax, %rax
je 0x2f322
movq %rax, %rbp
movq 0x8(%rsp), %rcx
incl (%rcx)
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movq 0x10(%rsp), %rax
incl (%rax)
movq %rax, 0x10(%rbp)
movq %r12, 0x18(%rbp)
movq %r15, %rdi
movq %rcx, %r15
movq %rcx, %rsi
movq %r13, %rdx
callq 0x1ce7d
movb %al, 0x20(%rbp)
movb $0x0, 0x21(%rbp)
movq %rbp, 0x30(%r14)
cmpl $-0x1, (%rsp)
jne 0x2f2fa
movb 0x5(%r15), %al
andb $0x10, %al
movb 0x5(%r14), %cl
andb $-0x11, %cl
orb %al, %cl
movb %cl, 0x5(%r14)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r14, %rcx
andq %rax, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1801e
jmp 0x2f255
| js_proxy_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rdi
mov r13, [r8+8]
mov eax, r13d
not eax
mov r12, [r8+18h]
mov ecx, r12d
not ecx
or ecx, eax
jz short loc_2F262
mov rdi, r15
call JS_ThrowTypeErrorNotAnObject
loc_2F255:
push 6
pop rbx
xor r14d, r14d
xor ecx, ecx
jmp loc_2F30A
loc_2F262:
mov rbp, [r8]
mov rax, [r8+10h]
mov [rsp+48h+var_38], rax
push 2
pop rdx
push 30h ; '0'
pop rcx
mov rdi, r15
xor esi, esi
call JS_NewObjectProtoClass
mov r14, rax
mov rbx, rdx
mov eax, ebx
cmp rax, 6
jz short loc_2F2FA
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_40], rbp
push 28h ; '('
pop rsi
mov rdi, r15
call js_malloc
test rax, rax
jz short loc_2F322
mov rbp, rax
mov rcx, [rsp+48h+var_40]
inc dword ptr [rcx]
mov [rax], rcx
mov [rax+8], r13
mov rax, [rsp+48h+var_38]
inc dword ptr [rax]
mov [rbp+10h], rax
mov [rbp+18h], r12
mov rdi, r15
mov r15, rcx
mov rsi, rcx
mov rdx, r13
call JS_IsFunction
mov [rbp+20h], al
mov byte ptr [rbp+21h], 0
mov [r14+30h], rbp
cmp dword ptr [rsp+48h+var_48], 0FFFFFFFFh
jnz short loc_2F2FA
mov al, [r15+5]
and al, 10h
mov cl, [r14+5]
and cl, 0EFh
or cl, al
mov [r14+5], cl
loc_2F2FA:
mov rax, 0FFFFFFFF00000000h
mov rcx, r14
and rcx, rax
loc_2F30A:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2F322:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
jmp loc_2F255
| unsigned long long js_proxy_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
_QWORD *a13,
long long a14)
{
long long v14; // r13
int v15; // eax
long long v16; // r12
long long v17; // r14
unsigned long long v18; // rcx
long long v19; // rbp
long long v20; // rdx
long long v21; // rbx
long long v22; // rax
long long v23; // rbp
char v25; // [rsp+0h] [rbp-48h]
int v26; // [rsp+0h] [rbp-48h]
long long v27; // [rsp+8h] [rbp-40h]
_DWORD *v28; // [rsp+10h] [rbp-38h]
v14 = a13[1];
v15 = ~*((_DWORD *)a13 + 2);
v16 = a13[3];
if ( !(v15 | ~(_DWORD)v16) )
{
v19 = *a13;
v28 = (_DWORD *)a13[2];
v17 = JS_NewObjectProtoClass(a1, 0LL, 2, 0x30u);
v21 = v20;
if ( (unsigned int)v20 != 6LL )
{
v26 = v20;
v27 = v19;
v22 = js_malloc(a1, 40LL);
if ( !v22 )
{
JS_FreeValue(a1, v17, v21);
goto LABEL_3;
}
v23 = v22;
++*(_DWORD *)v27;
*(_QWORD *)v22 = v27;
*(_QWORD *)(v22 + 8) = v14;
++*v28;
*(_QWORD *)(v22 + 16) = v28;
*(_QWORD *)(v22 + 24) = v16;
*(_BYTE *)(v22 + 32) = JS_IsFunction(a1, v27, v14);
*(_BYTE *)(v23 + 33) = 0;
*(_QWORD *)(v17 + 48) = v23;
if ( v26 == -1 )
*(_BYTE *)(v17 + 5) = *(_BYTE *)(v27 + 5) & 0x10 | *(_BYTE *)(v17 + 5) & 0xEF;
}
v18 = v17 & 0xFFFFFFFF00000000LL;
return v18 | (unsigned int)v17;
}
JS_ThrowTypeErrorNotAnObject(
a1,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a2,
a3,
v15 | ~(unsigned int)a13[3],
(long long)a13,
a14,
v25);
LABEL_3:
LODWORD(v17) = 0;
v18 = 0LL;
return v18 | (unsigned int)v17;
}
| js_proxy_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDI
MOV R13,qword ptr [R8 + 0x8]
MOV EAX,R13D
NOT EAX
MOV R12,qword ptr [R8 + 0x18]
MOV ECX,R12D
NOT ECX
OR ECX,EAX
JZ 0x0012f262
MOV RDI,R15
CALL 0x0011d5e1
LAB_0012f255:
PUSH 0x6
POP RBX
XOR R14D,R14D
XOR ECX,ECX
JMP 0x0012f30a
LAB_0012f262:
MOV RBP,qword ptr [R8]
MOV RAX,qword ptr [R8 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
PUSH 0x2
POP RDX
PUSH 0x30
POP RCX
MOV RDI,R15
XOR ESI,ESI
CALL 0x0011b069
MOV R14,RAX
MOV RBX,RDX
MOV EAX,EBX
CMP RAX,0x6
JZ 0x0012f2fa
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RBP
PUSH 0x28
POP RSI
MOV RDI,R15
CALL 0x00117214
TEST RAX,RAX
JZ 0x0012f322
MOV RBP,RAX
MOV RCX,qword ptr [RSP + 0x8]
INC dword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],R13
MOV RAX,qword ptr [RSP + 0x10]
INC dword ptr [RAX]
MOV qword ptr [RBP + 0x10],RAX
MOV qword ptr [RBP + 0x18],R12
MOV RDI,R15
MOV R15,RCX
MOV RSI,RCX
MOV RDX,R13
CALL 0x0011ce7d
MOV byte ptr [RBP + 0x20],AL
MOV byte ptr [RBP + 0x21],0x0
MOV qword ptr [R14 + 0x30],RBP
CMP dword ptr [RSP],-0x1
JNZ 0x0012f2fa
MOV AL,byte ptr [R15 + 0x5]
AND AL,0x10
MOV CL,byte ptr [R14 + 0x5]
AND CL,0xef
OR CL,AL
MOV byte ptr [R14 + 0x5],CL
LAB_0012f2fa:
MOV RAX,-0x100000000
MOV RCX,R14
AND RCX,RAX
LAB_0012f30a:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012f322:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011801e
JMP 0x0012f255
|
int1 [16] js_proxy_constructor(int8 param_1)
{
int8 uVar1;
int8 uVar2;
int *piVar3;
int *piVar4;
int1 uVar5;
int8 *puVar6;
ulong uVar7;
int8 *in_R8;
int1 auVar8 [16];
int1 auVar9 [16];
int local_48;
uVar1 = in_R8[1];
uVar2 = in_R8[3];
if ((int)uVar2 == -1 && (int)uVar1 == -1) {
piVar3 = (int *)*in_R8;
piVar4 = (int *)in_R8[2];
auVar8 = JS_NewObjectProtoClass(param_1,0,2,0x30);
uVar7 = auVar8._0_8_;
if ((auVar8._8_8_ & 0xffffffff) != 6) {
puVar6 = (int8 *)js_malloc(param_1,0x28);
if (puVar6 == (int8 *)0x0) {
JS_FreeValue(param_1,uVar7,auVar8._8_8_);
goto LAB_0012f255;
}
*piVar3 = *piVar3 + 1;
*puVar6 = piVar3;
puVar6[1] = uVar1;
*piVar4 = *piVar4 + 1;
puVar6[2] = piVar4;
puVar6[3] = uVar2;
uVar5 = JS_IsFunction(param_1,piVar3,uVar1);
*(int1 *)(puVar6 + 4) = uVar5;
*(int1 *)((long)puVar6 + 0x21) = 0;
*(int8 **)(uVar7 + 0x30) = puVar6;
local_48 = auVar8._8_4_;
if (local_48 == -1) {
*(byte *)(uVar7 + 5) = *(byte *)(uVar7 + 5) & 0xef | *(byte *)((long)piVar3 + 5) & 0x10;
}
}
uVar7 = uVar7 & 0xffffffff00000000;
}
else {
JS_ThrowTypeErrorNotAnObject(param_1);
LAB_0012f255:
auVar8 = ZEXT816(6) << 0x40;
uVar7 = 0;
}
auVar9._0_8_ = auVar8._0_8_ & 0xffffffff | uVar7;
auVar9._8_8_ = auVar8._8_8_;
return auVar9;
}
|
|
2,665 | translateState | untodesu[P]riteg/build_O0/_deps/glfw-src/src/x11_window.c | static int translateState(int state)
{
int mods = 0;
if (state & ShiftMask)
mods |= GLFW_MOD_SHIFT;
if (state & ControlMask)
mods |= GLFW_MOD_CONTROL;
if (state & Mod1Mask)
mods |= GLFW_MOD_ALT;
if (state & Mod4Mask)
mods |= GLFW_MOD_SUPER;
if (state & LockMask)
mods |= GLFW_MOD_CAPS_LOCK;
if (state & Mod2Mask)
mods |= GLFW_MOD_NUM_LOCK;
return mods;
} | O0 | c | translateState:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x360f2
movl -0x8(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x36106
movl -0x8(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x3611a
movl -0x8(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x3612e
movl -0x8(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x36142
movl -0x8(%rbp), %eax
orl $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x36156
movl -0x8(%rbp), %eax
orl $0x20, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| translateState:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], 0
mov eax, [rbp+var_4]
and eax, 1
cmp eax, 0
jz short loc_360F2
mov eax, [rbp+var_8]
or eax, 1
mov [rbp+var_8], eax
loc_360F2:
mov eax, [rbp+var_4]
and eax, 4
cmp eax, 0
jz short loc_36106
mov eax, [rbp+var_8]
or eax, 2
mov [rbp+var_8], eax
loc_36106:
mov eax, [rbp+var_4]
and eax, 8
cmp eax, 0
jz short loc_3611A
mov eax, [rbp+var_8]
or eax, 4
mov [rbp+var_8], eax
loc_3611A:
mov eax, [rbp+var_4]
and eax, 40h
cmp eax, 0
jz short loc_3612E
mov eax, [rbp+var_8]
or eax, 8
mov [rbp+var_8], eax
loc_3612E:
mov eax, [rbp+var_4]
and eax, 2
cmp eax, 0
jz short loc_36142
mov eax, [rbp+var_8]
or eax, 10h
mov [rbp+var_8], eax
loc_36142:
mov eax, [rbp+var_4]
and eax, 10h
cmp eax, 0
jz short loc_36156
mov eax, [rbp+var_8]
or eax, 20h
mov [rbp+var_8], eax
loc_36156:
mov eax, [rbp+var_8]
pop rbp
retn
| long long translateState(char a1)
{
unsigned int v2; // [rsp+0h] [rbp-8h]
v2 = (a1 & 1) != 0;
if ( (a1 & 4) != 0 )
v2 |= 2u;
if ( (a1 & 8) != 0 )
v2 |= 4u;
if ( (a1 & 0x40) != 0 )
v2 |= 8u;
if ( (a1 & 2) != 0 )
v2 |= 0x10u;
if ( (a1 & 0x10) != 0 )
v2 |= 0x20u;
return v2;
}
| translateState:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001360f2
MOV EAX,dword ptr [RBP + -0x8]
OR EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
LAB_001360f2:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x4
CMP EAX,0x0
JZ 0x00136106
MOV EAX,dword ptr [RBP + -0x8]
OR EAX,0x2
MOV dword ptr [RBP + -0x8],EAX
LAB_00136106:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0013611a
MOV EAX,dword ptr [RBP + -0x8]
OR EAX,0x4
MOV dword ptr [RBP + -0x8],EAX
LAB_0013611a:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x40
CMP EAX,0x0
JZ 0x0013612e
MOV EAX,dword ptr [RBP + -0x8]
OR EAX,0x8
MOV dword ptr [RBP + -0x8],EAX
LAB_0013612e:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00136142
MOV EAX,dword ptr [RBP + -0x8]
OR EAX,0x10
MOV dword ptr [RBP + -0x8],EAX
LAB_00136142:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00136156
MOV EAX,dword ptr [RBP + -0x8]
OR EAX,0x20
MOV dword ptr [RBP + -0x8],EAX
LAB_00136156:
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
byte translateState(uint param_1)
{
byte bVar1;
bVar1 = (param_1 & 1) != 0;
if ((param_1 & 4) != 0) {
bVar1 = bVar1 | 2;
}
if ((param_1 & 8) != 0) {
bVar1 = bVar1 | 4;
}
if ((param_1 & 0x40) != 0) {
bVar1 = bVar1 | 8;
}
if ((param_1 & 2) != 0) {
bVar1 = bVar1 | 0x10;
}
if ((param_1 & 0x10) != 0) {
bVar1 = bVar1 | 0x20;
}
return bVar1;
}
|
|
2,666 | mju_muscleBias | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_misc.c | mjtNum mju_muscleBias(mjtNum len, const mjtNum lengthrange[2],
mjtNum acc0, const mjtNum prm[9]) {
// unpack parameters
mjtNum range[2] = {prm[0], prm[1]};
mjtNum force = prm[2];
mjtNum scale = prm[3];
mjtNum lmax = prm[5];
mjtNum fpmax = prm[7];
// scale force if negative
if (force < 0) {
force = scale / mjMAX(mjMINVAL, acc0);
}
// optimum length
mjtNum L0 = (lengthrange[1]-lengthrange[0]) / mjMAX(mjMINVAL, range[1]-range[0]);
// normalized length
mjtNum L = range[0] + (len-lengthrange[0]) / mjMAX(mjMINVAL, L0);
// half-quadratic to (L0+lmax)/2, linear beyond
mjtNum b = 0.5*(1+lmax);
if (L <= 1) {
return 0;
} else if (L <= b) {
mjtNum x = (L-1) / mjMAX(mjMINVAL, b-1);
return -force*fpmax*0.5*x*x;
} else {
mjtNum x = (L-b) / mjMAX(mjMINVAL, b-1);
return -force*fpmax*(0.5 + x);
}
} | O3 | c | mju_muscleBias:
vmovapd %xmm0, %xmm2
vmovsd (%rsi), %xmm4
vmovsd 0x8(%rsi), %xmm5
vmovsd 0x10(%rsi), %xmm3
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm3, %xmm0
jbe 0x9de94
vmovsd 0x18(%rsi), %xmm3
vmovsd 0x11ed1c(%rip), %xmm6 # 0x1bcba8
vmaxsd %xmm1, %xmm6, %xmm1
vdivsd %xmm1, %xmm3, %xmm3
vmovsd (%rdi), %xmm1
vmovsd 0x8(%rdi), %xmm6
vsubsd %xmm1, %xmm6, %xmm6
vsubsd %xmm4, %xmm5, %xmm7
vmovsd 0x11ecfb(%rip), %xmm5 # 0x1bcba8
vmaxsd %xmm7, %xmm5, %xmm7
vdivsd %xmm7, %xmm6, %xmm6
vsubsd %xmm1, %xmm2, %xmm1
vmaxsd %xmm6, %xmm5, %xmm2
vdivsd %xmm2, %xmm1, %xmm1
vaddsd %xmm1, %xmm4, %xmm1
vmovsd 0x11ed03(%rip), %xmm2 # 0x1bcbd0
vucomisd %xmm1, %xmm2
jae 0x9df17
vaddsd 0x28(%rsi), %xmm2, %xmm0
vmulsd 0x11ecd8(%rip), %xmm0, %xmm4 # 0x1bcbb8
vucomisd %xmm1, %xmm4
vaddsd 0x11ecd4(%rip), %xmm4, %xmm0 # 0x1bcbc0
vmaxsd %xmm0, %xmm5, %xmm0
vmovddup 0x11eca8(%rip), %xmm2 # xmm2 = mem[0,0]
vxorpd %xmm2, %xmm3, %xmm2
vmulsd 0x38(%rsi), %xmm2, %xmm2
jae 0x9df18
vsubsd %xmm4, %xmm1, %xmm1
vdivsd %xmm0, %xmm1, %xmm0
vaddsd 0x11eca5(%rip), %xmm0, %xmm0 # 0x1bcbb8
vmulsd %xmm0, %xmm2, %xmm0
retq
vaddsd 0x11eca0(%rip), %xmm1, %xmm1 # 0x1bcbc0
vdivsd %xmm0, %xmm1, %xmm0
vmulsd 0x11ec8c(%rip), %xmm2, %xmm1 # 0x1bcbb8
vmulsd %xmm0, %xmm1, %xmm1
vmulsd %xmm1, %xmm0, %xmm0
retq
| mju_muscleBias:
vmovapd xmm2, xmm0
vmovsd xmm4, qword ptr [rsi]
vmovsd xmm5, qword ptr [rsi+8]
vmovsd xmm3, qword ptr [rsi+10h]
vxorpd xmm0, xmm0, xmm0
vucomisd xmm0, xmm3
jbe short loc_9DE94
vmovsd xmm3, qword ptr [rsi+18h]
vmovsd xmm6, cs:qword_1BCBA8
vmaxsd xmm1, xmm6, xmm1
vdivsd xmm3, xmm3, xmm1
loc_9DE94:
vmovsd xmm1, qword ptr [rdi]
vmovsd xmm6, qword ptr [rdi+8]
vsubsd xmm6, xmm6, xmm1
vsubsd xmm7, xmm5, xmm4
vmovsd xmm5, cs:qword_1BCBA8
vmaxsd xmm7, xmm5, xmm7
vdivsd xmm6, xmm6, xmm7
vsubsd xmm1, xmm2, xmm1
vmaxsd xmm2, xmm5, xmm6
vdivsd xmm1, xmm1, xmm2
vaddsd xmm1, xmm4, xmm1
vmovsd xmm2, cs:qword_1BCBD0
vucomisd xmm2, xmm1
jnb short locret_9DF17
vaddsd xmm0, xmm2, qword ptr [rsi+28h]
vmulsd xmm4, xmm0, cs:qword_1BCBB8
vucomisd xmm4, xmm1
vaddsd xmm0, xmm4, cs:qword_1BCBC0
vmaxsd xmm0, xmm5, xmm0
vmovddup xmm2, cs:qword_1BCBA0
vxorpd xmm2, xmm3, xmm2
vmulsd xmm2, xmm2, qword ptr [rsi+38h]
jnb short loc_9DF18
vsubsd xmm1, xmm1, xmm4
vdivsd xmm0, xmm1, xmm0
vaddsd xmm0, xmm0, cs:qword_1BCBB8
vmulsd xmm0, xmm2, xmm0
locret_9DF17:
retn
loc_9DF18:
vaddsd xmm1, xmm1, cs:qword_1BCBC0
vdivsd xmm0, xmm1, xmm0
vmulsd xmm1, xmm2, cs:qword_1BCBB8
vmulsd xmm1, xmm1, xmm0
vmulsd xmm0, xmm0, xmm1
retn
| __int128 __usercall mju_muscleBias@<xmm0>(long long _RDI@<rdi>, long long _RSI@<rsi>, __m128 _XMM0@<xmm0>)
{
char v3; // cf
char v4; // zf
__int128 result; // xmm0
__asm
{
vmovapd xmm2, xmm0
vmovsd xmm4, qword ptr [rsi]
vmovsd xmm5, qword ptr [rsi+8]
vmovsd xmm3, qword ptr [rsi+10h]
vxorpd xmm0, xmm0, xmm0
vucomisd xmm0, xmm3
}
if ( !(v3 | v4) )
{
__asm
{
vmovsd xmm3, qword ptr [rsi+18h]
vmovsd xmm6, cs:qword_1BCBA8
vmaxsd xmm1, xmm6, xmm1
vdivsd xmm3, xmm3, xmm1
}
}
__asm
{
vmovsd xmm1, qword ptr [rdi]
vmovsd xmm6, qword ptr [rdi+8]
vsubsd xmm6, xmm6, xmm1
vsubsd xmm7, xmm5, xmm4
vmovsd xmm5, cs:qword_1BCBA8
vmaxsd xmm7, xmm5, xmm7
vdivsd xmm6, xmm6, xmm7
vsubsd xmm1, xmm2, xmm1
vmaxsd xmm2, xmm5, xmm6
vdivsd xmm1, xmm1, xmm2
vaddsd xmm1, xmm4, xmm1
vmovsd xmm2, cs:qword_1BCBD0
vucomisd xmm2, xmm1
}
if ( v3 )
{
__asm
{
vaddsd xmm0, xmm2, qword ptr [rsi+28h]
vmulsd xmm4, xmm0, cs:qword_1BCBB8
vucomisd xmm4, xmm1
vaddsd xmm0, xmm4, cs:qword_1BCBC0
vmaxsd xmm0, xmm5, xmm0
vmovddup xmm2, cs:qword_1BCBA0
vxorpd xmm2, xmm3, xmm2
vmulsd xmm2, xmm2, qword ptr [rsi+38h]
vsubsd xmm1, xmm1, xmm4
vdivsd xmm0, xmm1, xmm0
vaddsd xmm0, xmm0, cs:qword_1BCBB8
vmulsd xmm0, xmm2, xmm0
}
}
return result;
}
| mju_muscleBias:
VMOVAPD XMM2,XMM0
VMOVSD XMM4,qword ptr [RSI]
VMOVSD XMM5,qword ptr [RSI + 0x8]
VMOVSD XMM3,qword ptr [RSI + 0x10]
VXORPD XMM0,XMM0,XMM0
VUCOMISD XMM0,XMM3
JBE 0x0019de94
VMOVSD XMM3,qword ptr [RSI + 0x18]
VMOVSD XMM6,qword ptr [0x002bcba8]
VMAXSD XMM1,XMM6,XMM1
VDIVSD XMM3,XMM3,XMM1
LAB_0019de94:
VMOVSD XMM1,qword ptr [RDI]
VMOVSD XMM6,qword ptr [RDI + 0x8]
VSUBSD XMM6,XMM6,XMM1
VSUBSD XMM7,XMM5,XMM4
VMOVSD XMM5,qword ptr [0x002bcba8]
VMAXSD XMM7,XMM5,XMM7
VDIVSD XMM6,XMM6,XMM7
VSUBSD XMM1,XMM2,XMM1
VMAXSD XMM2,XMM5,XMM6
VDIVSD XMM1,XMM1,XMM2
VADDSD XMM1,XMM4,XMM1
VMOVSD XMM2,qword ptr [0x002bcbd0]
VUCOMISD XMM2,XMM1
JNC 0x0019df17
VADDSD XMM0,XMM2,qword ptr [RSI + 0x28]
VMULSD XMM4,XMM0,qword ptr [0x002bcbb8]
VUCOMISD XMM4,XMM1
VADDSD XMM0,XMM4,qword ptr [0x002bcbc0]
VMAXSD XMM0,XMM5,XMM0
VMOVDDUP XMM2,qword ptr [0x002bcba0]
VXORPD XMM2,XMM3,XMM2
VMULSD XMM2,XMM2,qword ptr [RSI + 0x38]
JNC 0x0019df18
VSUBSD XMM1,XMM1,XMM4
VDIVSD XMM0,XMM1,XMM0
VADDSD XMM0,XMM0,qword ptr [0x002bcbb8]
VMULSD XMM0,XMM2,XMM0
LAB_0019df17:
RET
LAB_0019df18:
VADDSD XMM1,XMM1,qword ptr [0x002bcbc0]
VDIVSD XMM0,XMM1,XMM0
VMULSD XMM1,XMM2,qword ptr [0x002bcbb8]
VMULSD XMM1,XMM1,XMM0
VMULSD XMM0,XMM0,XMM1
RET
|
double mju_muscleBias(double param_1,double *param_2,double *param_3)
{
double dVar1;
double dVar2;
double dVar3;
int1 auVar4 [16];
int1 in_ZMM1 [64];
double dVar5;
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
dVar5 = param_3[2];
dVar3 = 0.0;
if (dVar5 < 0.0) {
auVar7._8_8_ = 0;
auVar7._0_8_ = DAT_002bcba8;
auVar7 = vmaxsd_avx(auVar7,in_ZMM1._0_16_);
dVar5 = param_3[3] / auVar7._0_8_;
}
auVar6._8_8_ = 0;
auVar6._0_8_ = DAT_002bcba8;
auVar9._8_8_ = 0;
auVar9._0_8_ = param_3[1] - *param_3;
auVar7 = vmaxsd_avx(auVar6,auVar9);
auVar8._0_8_ = (param_2[1] - *param_2) / auVar7._0_8_;
auVar8._8_8_ = 0;
auVar7 = vmaxsd_avx(auVar6,auVar8);
dVar1 = *param_3 + (param_1 - *param_2) / auVar7._0_8_;
if (DAT_002bcbd0 < dVar1) {
dVar2 = (DAT_002bcbd0 + param_3[5]) * DAT_002bcbb8;
auVar4._8_8_ = 0;
auVar4._0_8_ = dVar2 + DAT_002bcbc0;
auVar7 = vmaxsd_avx(auVar6,auVar4);
dVar3 = (double)((ulong)dVar5 ^ DAT_002bcba0) * param_3[7];
if (dVar1 <= dVar2) {
dVar5 = (dVar1 + DAT_002bcbc0) / auVar7._0_8_;
return dVar5 * dVar3 * DAT_002bcbb8 * dVar5;
}
dVar3 = dVar3 * ((dVar1 - dVar2) / auVar7._0_8_ + DAT_002bcbb8);
}
return dVar3;
}
|
|
2,667 | testing::UnitTest::current_test_suite() const | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_suite();
} | O1 | cpp | testing::UnitTest::current_test_suite() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x370dc
movq 0x40(%rbx), %rax
movq 0x1d8(%rax), %rbx
movq %r14, %rdi
callq 0x3717a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x326a4
nop
| _ZNK7testing8UnitTest18current_test_suiteEv:
push r14
push rbx
push rax
mov rbx, rdi
lea r14, [rdi+8]
mov rdi, r14; this
call _ZN7testing8internal9MutexBase4LockEv; testing::internal::MutexBase::Lock(void)
mov rax, [rbx+40h]
mov rbx, [rax+1D8h]
mov rdi, r14; this
call _ZN7testing8internal9MutexBase6UnlockEv; testing::internal::MutexBase::Unlock(void)
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
mov rdi, rax
call __clang_call_terminate
| long long testing::UnitTest::current_test_suite(testing::UnitTest *this)
{
long long v1; // rbx
testing::internal::MutexBase::Lock((testing::UnitTest *)((char *)this + 8));
v1 = *(_QWORD *)(*((_QWORD *)this + 8) + 472LL);
testing::internal::MutexBase::Unlock((testing::UnitTest *)((char *)this + 8));
return v1;
}
| current_test_suite:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[RDI + 0x8]
MOV RDI,R14
CALL 0x001370dc
MOV RAX,qword ptr [RBX + 0x40]
MOV RBX,qword ptr [RAX + 0x1d8]
LAB_0012dd3e:
MOV RDI,R14
CALL 0x0013717a
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* testing::UnitTest::current_test_suite() const */
int8 __thiscall testing::UnitTest::current_test_suite(UnitTest *this)
{
int8 uVar1;
internal::MutexBase::Lock((MutexBase *)(this + 8));
uVar1 = *(int8 *)(*(long *)(this + 0x40) + 0x1d8);
/* try { // try from 0012dd3e to 0012dd45 has its CatchHandler @ 0012dd51 */
internal::MutexBase::Unlock((MutexBase *)(this + 8));
return uVar1;
}
|
|
2,668 | OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessAtVertex(float, int, float const*) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/sdc/crease.cpp | float
Crease::SubdivideEdgeSharpnessAtVertex(float edgeSharpness,
int incEdgeCountAtVertex,
float const * incEdgeSharpness) const {
if (IsUniform() || (incEdgeCountAtVertex < 2)) {
return decrementSharpness(edgeSharpness);
}
if (IsSmooth(edgeSharpness)) return Crease::SHARPNESS_SMOOTH;
if (IsInfinite(edgeSharpness)) return Crease::SHARPNESS_INFINITE;
float sharpSum = 0.0f;
int sharpCount = 0;
for (int i = 0; i < incEdgeCountAtVertex; ++i) {
if (IsSemiSharp(incEdgeSharpness[i])) {
sharpCount ++;
sharpSum += incEdgeSharpness[i];
}
}
if (sharpCount > 1) {
// Chaikin rule is 3/4 original sharpness + 1/4 average of the others
float avgSharpnessAtVertex = (sharpSum - edgeSharpness) / (float)(sharpCount - 1);
edgeSharpness = (0.75f * edgeSharpness) + (0.25f * avgSharpnessAtVertex);
}
edgeSharpness -= 1.0f;
return IsSharp(edgeSharpness) ? edgeSharpness : Crease::SHARPNESS_SMOOTH;
} | O1 | cpp | OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessAtVertex(float, int, float const*) const:
cmpl $0x2, %esi
jl 0x3d395
cmpb $0x0, 0x2(%rdi)
je 0x3d395
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x3d401
movss 0x74cbd(%rip), %xmm1 # 0xb2004
ucomiss %xmm1, %xmm0
jae 0x3d401
testl %esi, %esi
jle 0x3d3c0
movl %esi, %ecx
xorps %xmm1, %xmm1
xorl %esi, %esi
movss 0x74ca1(%rip), %xmm2 # 0xb2004
xorl %eax, %eax
movss (%rdx,%rsi,4), %xmm3
movaps %xmm3, %xmm4
cmpltps %xmm2, %xmm4
xorps %xmm5, %xmm5
cmpltps %xmm3, %xmm5
andps %xmm4, %xmm5
movd %xmm5, %edi
testb $0x1, %dil
je 0x3d389
addss %xmm3, %xmm1
subl %edi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3d365
jmp 0x3d3c5
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x3d401
movss 0x74c5f(%rip), %xmm1 # 0xb2004
ucomiss %xmm1, %xmm0
jae 0x3d401
ucomiss 0x74c4f(%rip), %xmm0 # 0xb2000
xorps %xmm1, %xmm1
jbe 0x3d401
addss 0x74c52(%rip), %xmm0 # 0xb2010
jmp 0x3d3fe
xorl %eax, %eax
xorps %xmm1, %xmm1
cmpl $0x1, %eax
jle 0x3d3ef
decl %eax
xorps %xmm2, %xmm2
cvtsi2ss %eax, %xmm2
subss %xmm0, %xmm1
divss %xmm2, %xmm1
mulss 0x74c25(%rip), %xmm1 # 0xb2008
mulss 0x74c21(%rip), %xmm0 # 0xb200c
addss %xmm1, %xmm0
addss 0x74c19(%rip), %xmm0 # 0xb2010
xorps %xmm1, %xmm1
maxss %xmm1, %xmm0
movaps %xmm0, %xmm1
movaps %xmm1, %xmm0
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Sdc6Crease30SubdivideEdgeSharpnessAtVertexEfiPKf:
cmp esi, 2
jl short loc_3D395
cmp byte ptr [rdi+2], 0
jz short loc_3D395
xorps xmm1, xmm1
ucomiss xmm1, xmm0
jnb loc_3D401
movss xmm1, cs:dword_B2004
ucomiss xmm0, xmm1
jnb loc_3D401
test esi, esi
jle short loc_3D3C0
mov ecx, esi
xorps xmm1, xmm1
xor esi, esi
movss xmm2, cs:dword_B2004
xor eax, eax
loc_3D365:
movss xmm3, dword ptr [rdx+rsi*4]
movaps xmm4, xmm3
cmpltps xmm4, xmm2
xorps xmm5, xmm5
cmpltps xmm5, xmm3
andps xmm5, xmm4
movd edi, xmm5
test dil, 1
jz short loc_3D389
addss xmm1, xmm3
loc_3D389:
sub eax, edi
inc rsi
cmp rcx, rsi
jnz short loc_3D365
jmp short loc_3D3C5
loc_3D395:
xorps xmm1, xmm1
ucomiss xmm1, xmm0
jnb short loc_3D401
movss xmm1, cs:dword_B2004
ucomiss xmm0, xmm1
jnb short loc_3D401
ucomiss xmm0, cs:dword_B2000
xorps xmm1, xmm1
jbe short loc_3D401
addss xmm0, cs:dword_B2010
jmp short loc_3D3FE
loc_3D3C0:
xor eax, eax
xorps xmm1, xmm1
loc_3D3C5:
cmp eax, 1
jle short loc_3D3EF
dec eax
xorps xmm2, xmm2
cvtsi2ss xmm2, eax
subss xmm1, xmm0
divss xmm1, xmm2
mulss xmm1, cs:dword_B2008
mulss xmm0, cs:dword_B200C
addss xmm0, xmm1
loc_3D3EF:
addss xmm0, cs:dword_B2010
xorps xmm1, xmm1
maxss xmm0, xmm1
loc_3D3FE:
movaps xmm1, xmm0
loc_3D401:
movaps xmm0, xmm1
retn
| __m128 OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessAtVertex(
OpenSubdiv::v3_6_0::Sdc::Crease *this,
__m128 a2,
int a3,
const float *a4)
{
__int128 v4; // xmm1
long long v5; // rcx
float v6; // xmm1_4
long long v7; // rsi
int v8; // eax
__m128 v9; // xmm3
int v10; // edi
if ( a3 >= 2 && *((_BYTE *)this + 2) )
{
v4 = 0LL;
if ( a2.m128_f32[0] > 0.0 )
{
v4 = 0x41200000u;
if ( a2.m128_f32[0] < 10.0 )
{
v5 = (unsigned int)a3;
v6 = 0.0;
v7 = 0LL;
v8 = 0;
do
{
v9 = (__m128)LODWORD(a4[v7]);
v10 = _mm_cvtsi128_si32((__m128i)_mm_and_ps(
_mm_cmplt_ps((__m128)0LL, v9),
_mm_cmplt_ps(v9, (__m128)0x41200000u)));
if ( (v10 & 1) != 0 )
v6 = v6 + v9.m128_f32[0];
v8 -= v10;
++v7;
}
while ( v5 != v7 );
if ( v8 > 1 )
a2.m128_f32[0] = (float)(a2.m128_f32[0] * 0.75)
+ (float)((float)((float)(v6 - a2.m128_f32[0]) / (float)(v8 - 1)) * 0.25);
a2.m128_f32[0] = fmaxf(a2.m128_f32[0] + -1.0, 0.0);
return a2;
}
}
}
else
{
v4 = 0LL;
if ( a2.m128_f32[0] > 0.0 )
{
v4 = 0x41200000u;
if ( a2.m128_f32[0] < 10.0 )
{
v4 = 0LL;
if ( a2.m128_f32[0] > 1.0 )
{
a2.m128_f32[0] = a2.m128_f32[0] + -1.0;
return a2;
}
}
}
}
return (__m128)v4;
}
| SubdivideEdgeSharpnessAtVertex:
CMP ESI,0x2
JL 0x0013d395
CMP byte ptr [RDI + 0x2],0x0
JZ 0x0013d395
XORPS XMM1,XMM1
UCOMISS XMM1,XMM0
JNC 0x0013d401
MOVSS XMM1,dword ptr [0x001b2004]
UCOMISS XMM0,XMM1
JNC 0x0013d401
TEST ESI,ESI
JLE 0x0013d3c0
MOV ECX,ESI
XORPS XMM1,XMM1
XOR ESI,ESI
MOVSS XMM2,dword ptr [0x001b2004]
XOR EAX,EAX
LAB_0013d365:
MOVSS XMM3,dword ptr [RDX + RSI*0x4]
MOVAPS XMM4,XMM3
CMPLTPS XMM4,XMM2
XORPS XMM5,XMM5
CMPLTPS XMM5,XMM3
ANDPS XMM5,XMM4
MOVD EDI,XMM5
TEST DIL,0x1
JZ 0x0013d389
ADDSS XMM1,XMM3
LAB_0013d389:
SUB EAX,EDI
INC RSI
CMP RCX,RSI
JNZ 0x0013d365
JMP 0x0013d3c5
LAB_0013d395:
XORPS XMM1,XMM1
UCOMISS XMM1,XMM0
JNC 0x0013d401
MOVSS XMM1,dword ptr [0x001b2004]
UCOMISS XMM0,XMM1
JNC 0x0013d401
UCOMISS XMM0,dword ptr [0x001b2000]
XORPS XMM1,XMM1
JBE 0x0013d401
ADDSS XMM0,dword ptr [0x001b2010]
JMP 0x0013d3fe
LAB_0013d3c0:
XOR EAX,EAX
XORPS XMM1,XMM1
LAB_0013d3c5:
CMP EAX,0x1
JLE 0x0013d3ef
DEC EAX
XORPS XMM2,XMM2
CVTSI2SS XMM2,EAX
SUBSS XMM1,XMM0
DIVSS XMM1,XMM2
MULSS XMM1,dword ptr [0x001b2008]
MULSS XMM0,dword ptr [0x001b200c]
ADDSS XMM0,XMM1
LAB_0013d3ef:
ADDSS XMM0,dword ptr [0x001b2010]
XORPS XMM1,XMM1
MAXSS XMM0,XMM1
LAB_0013d3fe:
MOVAPS XMM1,XMM0
LAB_0013d401:
MOVAPS XMM0,XMM1
RET
|
/* OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessAtVertex(float, int, float const*) const
*/
int8 __thiscall
OpenSubdiv::v3_6_0::Sdc::Crease::SubdivideEdgeSharpnessAtVertex
(Crease *this,float param_1,int param_2,float *param_3)
{
float fVar1;
uint uVar2;
int iVar3;
ulong uVar4;
int4 in_XMM0_Db;
float fVar5;
int4 uVar6;
if ((param_2 < 2) || (this[2] == (Crease)0x0)) {
fVar5 = 0.0;
uVar6 = 0;
if ((0.0 < param_1) && (fVar5 = DAT_001b2004, uVar6 = 0, param_1 < DAT_001b2004)) {
fVar5 = 0.0;
uVar6 = 0;
if (DAT_001b2000 < param_1) {
fVar5 = param_1 + DAT_001b2010;
uVar6 = in_XMM0_Db;
}
}
}
else {
fVar5 = 0.0;
uVar6 = 0;
if ((0.0 < param_1) && (fVar5 = DAT_001b2004, uVar6 = 0, param_1 < DAT_001b2004)) {
if (param_2 < 1) {
iVar3 = 0;
fVar5 = 0.0;
}
else {
fVar5 = 0.0;
uVar4 = 0;
iVar3 = 0;
do {
fVar1 = param_3[uVar4];
uVar2 = (uint)(0.0 < fVar1 && fVar1 < DAT_001b2004);
if ((-uVar2 & 1) != 0) {
fVar5 = fVar5 + fVar1;
}
iVar3 = iVar3 + uVar2;
uVar4 = uVar4 + 1;
} while ((uint)param_2 != uVar4);
}
if (1 < iVar3) {
param_1 = param_1 * DAT_001b200c + ((fVar5 - param_1) / (float)(iVar3 + -1)) * DAT_001b2008;
}
fVar5 = param_1 + DAT_001b2010;
uVar6 = in_XMM0_Db;
if (fVar5 <= 0.0) {
fVar5 = 0.0;
}
}
}
return CONCAT44(uVar6,fVar5);
}
|
|
2,669 | my_caseup_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_str_8bit(CHARSET_INFO * cs,char *str)
{
register const uchar *map= cs->to_upper;
char *str_orig= str;
while ((*str= (char) map[(uchar) *str]) != 0)
str++;
return (size_t) (str - str_orig);
} | O0 | c | my_caseup_str_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %al
movq -0x10(%rbp), %rcx
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0xa215a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa2130
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
| my_caseup_str_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+50h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
loc_A2130:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov al, [rax+rcx]
mov rcx, [rbp+var_10]
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_A215A
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_A2130
loc_A215A:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_20]
sub rax, rcx
pop rbp
retn
| _BYTE * my_caseup_str_8bit(long long a1, _BYTE *a2)
{
char v2; // al
long long v4; // [rsp+8h] [rbp-18h]
_BYTE *v5; // [rsp+10h] [rbp-10h]
v5 = a2;
v4 = *(_QWORD *)(a1 + 80);
while ( 1 )
{
v2 = *(_BYTE *)(v4 + (unsigned __int8)*v5);
*v5 = v2;
if ( !v2 )
break;
++v5;
}
return (_BYTE *)(v5 - a2);
}
| my_caseup_str_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x50]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LAB_001a2130:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001a215a
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001a2130
LAB_001a215a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
POP RBP
RET
|
long my_caseup_str_8bit(long param_1,byte *param_2)
{
byte bVar1;
long lVar2;
byte *local_18;
lVar2 = *(long *)(param_1 + 0x50);
local_18 = param_2;
while (bVar1 = *(byte *)(lVar2 + (ulong)*local_18), *local_18 = bVar1, bVar1 != 0) {
local_18 = local_18 + 1;
}
return (long)local_18 - (long)param_2;
}
|
|
2,670 | _JS_AtomToValue | bluesky950520[P]quickjs/quickjs.c | static JSValue __JS_AtomToValue(JSContext *ctx, JSAtom atom, BOOL force_string)
{
char buf[ATOM_GET_STR_BUF_SIZE];
if (__JS_AtomIsTaggedInt(atom)) {
size_t len = u32toa(buf, __JS_AtomToUInt32(atom));
return js_new_string8_len(ctx, buf, len);
} else {
JSRuntime *rt = ctx->rt;
JSAtomStruct *p;
assert(atom < rt->atom_size);
p = rt->atom_array[atom];
if (p->atom_type == JS_ATOM_TYPE_STRING) {
goto ret_string;
} else if (force_string) {
if (p->len == 0 && p->is_wide_char != 0) {
/* no description string */
p = rt->atom_array[JS_ATOM_empty_string];
}
ret_string:
return js_dup(JS_MKPTR(JS_TAG_STRING, p));
} else {
return js_dup(JS_MKPTR(JS_TAG_SYMBOL, p));
}
}
} | O1 | c | _JS_AtomToValue:
movq 0x18(%rdi), %rax
movq 0x68(%rax), %rcx
movq 0x5c0(%rcx), %rax
movq 0x4(%rax), %rdx
movq %rdx, %rsi
shrq $0x3e, %rsi
cmpl $0x1, %esi
sete %sil
negl %edx
setno %dl
orb %sil, %dl
jne 0x730a6
movq 0x178(%rcx), %rax
incl (%rax)
movq $-0x7, %rdx
retq
| js_iterator_proto_get_toStringTag:
mov rax, [rdi+18h]
mov rcx, [rax+68h]
mov rax, [rcx+5C0h]
mov rdx, [rax+4]
mov rsi, rdx
shr rsi, 3Eh
cmp esi, 1
setz sil
neg edx
setno dl
or dl, sil
jnz short loc_730A6
mov rax, [rcx+178h]
loc_730A6:
inc dword ptr [rax]
mov rdx, 0FFFFFFFFFFFFFFF9h
retn
| long long js_iterator_proto_get_toStringTag(long long a1)
{
long long v1; // rcx
long long result; // rax
v1 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL);
result = *(_QWORD *)(v1 + 1472);
if ( !((*(_QWORD *)(result + 4) >> 62 == 1) | !__OFSUB__(-(int)*(_QWORD *)(result + 4), 1)) )
result = *(_QWORD *)(v1 + 376);
++*(_DWORD *)result;
return result;
}
| js_iterator_proto_get_toStringTag:
MOV RAX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RCX + 0x5c0]
MOV RDX,qword ptr [RAX + 0x4]
MOV RSI,RDX
SHR RSI,0x3e
CMP ESI,0x1
SETZ SIL
NEG EDX
SETNO DL
OR DL,SIL
JNZ 0x001730a6
MOV RAX,qword ptr [RCX + 0x178]
LAB_001730a6:
INC dword ptr [RAX]
MOV RDX,-0x7
RET
|
/* WARNING: Removing unreachable block (ram,0x0017309f) */
void js_iterator_proto_get_toStringTag(long param_1)
{
int *piVar1;
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + 0x5c0);
*piVar1 = *piVar1 + 1;
return;
}
|
|
2,671 | _JS_AtomToValue | bluesky950520[P]quickjs/quickjs.c | static JSValue __JS_AtomToValue(JSContext *ctx, JSAtom atom, BOOL force_string)
{
char buf[ATOM_GET_STR_BUF_SIZE];
if (__JS_AtomIsTaggedInt(atom)) {
size_t len = u32toa(buf, __JS_AtomToUInt32(atom));
return js_new_string8_len(ctx, buf, len);
} else {
JSRuntime *rt = ctx->rt;
JSAtomStruct *p;
assert(atom < rt->atom_size);
p = rt->atom_array[atom];
if (p->atom_type == JS_ATOM_TYPE_STRING) {
goto ret_string;
} else if (force_string) {
if (p->len == 0 && p->is_wide_char != 0) {
/* no description string */
p = rt->atom_array[JS_ATOM_empty_string];
}
ret_string:
return js_dup(JS_MKPTR(JS_TAG_STRING, p));
} else {
return js_dup(JS_MKPTR(JS_TAG_SYMBOL, p));
}
}
} | O2 | c | _JS_AtomToValue:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
testl %esi, %esi
js 0x1a964
movq 0x18(%rbx), %rax
movq 0x68(%rax), %rcx
movl %esi, %eax
movq (%rcx,%rax,8), %rax
movq 0x4(%rax), %rsi
movq %rsi, %rdi
shrq $0x3e, %rdi
cmpl $0x1, %edi
je 0x1a95d
testl %edx, %edx
je 0x1a98a
negl %esi
jno 0x1a95d
movq 0x178(%rcx), %rax
incl (%rax)
pushq $-0x7
popq %rdx
jmp 0x1a982
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %rsp, %r14
movq %r14, %rdi
callq 0x16482
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1a4e8
addq $0x48, %rsp
popq %rbx
popq %r14
retq
incl (%rax)
pushq $-0x8
jmp 0x1a961
| __JS_AtomToValue:
push r14
push rbx
sub rsp, 48h
mov rbx, rdi
test esi, esi
js short loc_1A964
mov rax, [rbx+18h]
mov rcx, [rax+68h]
mov eax, esi
mov rax, [rcx+rax*8]
mov rsi, [rax+4]
mov rdi, rsi
shr rdi, 3Eh
cmp edi, 1
jz short loc_1A95D
test edx, edx
jz short loc_1A98A
neg esi
jno short loc_1A95D
mov rax, [rcx+178h]
loc_1A95D:
inc dword ptr [rax]
push 0FFFFFFFFFFFFFFF9h
loc_1A961:
pop rdx
jmp short loc_1A982
loc_1A964:
and esi, 7FFFFFFFh
mov r14, rsp
mov rdi, r14
call u32toa
mov rdi, rbx
mov rsi, r14
mov edx, eax
call js_new_string8_len
loc_1A982:
add rsp, 48h
pop rbx
pop r14
retn
loc_1A98A:
inc dword ptr [rax]
push 0FFFFFFFFFFFFFFF8h
jmp short loc_1A961
| long long _JS_AtomToValue(long long a1, int a2, int a3)
{
long long v3; // rcx
long long result; // rax
unsigned long long v5; // rsi
unsigned int v6; // eax
_BYTE v7[88]; // [rsp+0h] [rbp-58h] BYREF
if ( a2 < 0 )
{
v6 = u32toa(v7, a2 & 0x7FFFFFFF);
return js_new_string8_len(a1, (long long)v7, v6);
}
else
{
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL);
result = *(_QWORD *)(v3 + 8LL * (unsigned int)a2);
v5 = *(_QWORD *)(result + 4);
if ( v5 >> 62 == 1 )
{
LABEL_6:
++*(_DWORD *)result;
return result;
}
if ( a3 )
{
if ( __OFSUB__(-(int)v5, 1) )
result = *(_QWORD *)(v3 + 376);
goto LABEL_6;
}
++*(_DWORD *)result;
}
return result;
}
| __JS_AtomToValue:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
TEST ESI,ESI
JS 0x0011a964
MOV RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RAX + 0x68]
MOV EAX,ESI
MOV RAX,qword ptr [RCX + RAX*0x8]
MOV RSI,qword ptr [RAX + 0x4]
MOV RDI,RSI
SHR RDI,0x3e
CMP EDI,0x1
JZ 0x0011a95d
TEST EDX,EDX
JZ 0x0011a98a
NEG ESI
JNO 0x0011a95d
MOV RAX,qword ptr [RCX + 0x178]
LAB_0011a95d:
INC dword ptr [RAX]
PUSH -0x7
LAB_0011a961:
POP RDX
JMP 0x0011a982
LAB_0011a964:
AND ESI,0x7fffffff
MOV R14,RSP
MOV RDI,R14
CALL 0x00116482
MOV RDI,RBX
MOV RSI,R14
MOV EDX,EAX
CALL 0x0011a4e8
LAB_0011a982:
ADD RSP,0x48
POP RBX
POP R14
RET
LAB_0011a98a:
INC dword ptr [RAX]
PUSH -0x8
JMP 0x0011a961
|
/* WARNING: Removing unreachable block (ram,0x0011a956) */
void __JS_AtomToValue(long param_1,uint param_2,int param_3)
{
int *piVar1;
int4 uVar2;
int1 auStack_58 [72];
if ((int)param_2 < 0) {
uVar2 = u32toa(auStack_58,param_2 & 0x7fffffff);
js_new_string8_len(param_1,auStack_58,uVar2);
}
else {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_2 * 8);
if (((uint)((ulong)*(int8 *)(piVar1 + 1) >> 0x3e) == 1) || (param_3 != 0)) {
*piVar1 = *piVar1 + 1;
}
else {
*piVar1 = *piVar1 + 1;
}
}
return;
}
|
|
2,672 | uf_varchar2 | eloqsql/storage/myisam/mi_packrec.c | static void uf_varchar2(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end __attribute__((unused)))
{
if (get_bit(bit_buff))
to[0]=to[1]=0; /* Zero lengths */
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
int2store(to,length);
decode_bytes(rec,bit_buff,to+2,to+2+length);
}
} | O3 | c | uf_varchar2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x83927
movl (%r14), %r13d
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %r13d
jae 0x83944
movw $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x821c9
movl $0x1f, 0x4(%r14)
movl (%r14), %r13d
movl $0x1f, %eax
testl %r13d, %r13d
js 0x83913
movl 0x1c(%r15), %r12d
movl %eax, %ecx
subl %r12d, %ecx
jae 0x83989
subl %eax, %r12d
movl %eax, %eax
leaq 0x5df35(%rip), %rcx # 0xe1890
andl (%rcx,%rax,4), %r13d
movl %r12d, %ecx
shll %cl, %r13d
movq %r14, %rdi
callq 0x821c9
movl $0x20, %eax
subl %r12d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r12d
movl %r12d, %ecx
shrl %cl, %eax
addl %eax, %r13d
jmp 0x8399f
movl %ecx, 0x4(%r14)
shrl %cl, %r13d
movl 0x1c(%r15), %eax
leaq 0x5def5(%rip), %rcx # 0xe1890
andl (%rcx,%rax,4), %r13d
movl %r13d, %eax
movw %r13w, (%rbx)
leaq (%rbx,%rax), %rcx
addq $0x2, %rcx
addq $0x2, %rbx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x82aba
| uf_varchar2_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_83927
mov r13d, [r14]
dec eax
mov [r14+4], eax
bt r13d, eax
jnb short loc_83944
loc_83913:
mov word ptr [rbx], 0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_83927:
mov rdi, r14
call fill_buffer_0
mov dword ptr [r14+4], 1Fh
mov r13d, [r14]
mov eax, 1Fh
test r13d, r13d
js short loc_83913
loc_83944:
mov r12d, [r15+1Ch]
mov ecx, eax
sub ecx, r12d
jnb short loc_83989
sub r12d, eax
mov eax, eax
lea rcx, mask_0
and r13d, [rcx+rax*4]
mov ecx, r12d
shl r13d, cl
mov rdi, r14
call fill_buffer_0
mov eax, 20h ; ' '
sub eax, r12d
mov [r14+4], eax
mov eax, [r14]
neg r12d
mov ecx, r12d
shr eax, cl
add r13d, eax
jmp short loc_8399F
loc_83989:
mov [r14+4], ecx
shr r13d, cl
mov eax, [r15+1Ch]
lea rcx, mask_0
and r13d, [rcx+rax*4]
loc_8399F:
mov eax, r13d
mov [rbx], r13w
lea rcx, [rbx+rax]
add rcx, 2
add rbx, 2
mov rdi, r15
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes_0
| long long uf_varchar2_0(long long a1, unsigned int *a2, long long a3)
{
unsigned int v4; // eax
unsigned int v5; // r13d
long long result; // rax
unsigned int v7; // r12d
unsigned int v8; // ecx
int v9; // r12d
int v10; // r13d
unsigned int v11; // r13d
v4 = a2[1];
if ( v4 )
{
v5 = *a2;
result = v4 - 1;
a2[1] = result;
if ( _bittest((const int *)&v5, result) )
{
LABEL_3:
*(_WORD *)a3 = 0;
return result;
}
}
else
{
fill_buffer_0((long long)a2);
a2[1] = 31;
v5 = *a2;
result = 31LL;
if ( (*a2 & 0x80000000) != 0 )
goto LABEL_3;
}
v7 = *(_DWORD *)(a1 + 28);
v8 = result - v7;
if ( (unsigned int)result >= v7 )
{
a2[1] = v8;
v11 = mask_0[*(unsigned int *)(a1 + 28)] & (v5 >> v8);
}
else
{
v9 = v7 - result;
v10 = (mask_0[(unsigned int)result] & v5) << v9;
fill_buffer_0((long long)a2);
a2[1] = 32 - v9;
v11 = (*a2 >> -(char)v9) + v10;
}
*(_WORD *)a3 = v11;
return (long long)decode_bytes_0(a1, (long long)a2, (_BYTE *)(a3 + 2), (_BYTE *)(a3 + v11 + 2));
}
| uf_varchar2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x00183927
MOV R13D,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT R13D,EAX
JNC 0x00183944
LAB_00183913:
MOV word ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00183927:
MOV RDI,R14
CALL 0x001821c9
MOV dword ptr [R14 + 0x4],0x1f
MOV R13D,dword ptr [R14]
MOV EAX,0x1f
TEST R13D,R13D
JS 0x00183913
LAB_00183944:
MOV R12D,dword ptr [R15 + 0x1c]
MOV ECX,EAX
SUB ECX,R12D
JNC 0x00183989
SUB R12D,EAX
MOV EAX,EAX
LEA RCX,[0x1e1890]
AND R13D,dword ptr [RCX + RAX*0x4]
MOV ECX,R12D
SHL R13D,CL
MOV RDI,R14
CALL 0x001821c9
MOV EAX,0x20
SUB EAX,R12D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R12D
MOV ECX,R12D
SHR EAX,CL
ADD R13D,EAX
JMP 0x0018399f
LAB_00183989:
MOV dword ptr [R14 + 0x4],ECX
SHR R13D,CL
MOV EAX,dword ptr [R15 + 0x1c]
LEA RCX,[0x1e1890]
AND R13D,dword ptr [RCX + RAX*0x4]
LAB_0018399f:
MOV EAX,R13D
MOV word ptr [RBX],R13W
LEA RCX,[RBX + RAX*0x1]
ADD RCX,0x2
ADD RBX,0x2
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00182aba
|
void uf_varchar2(long param_1,uint *param_2,int2 *param_3)
{
uint uVar1;
uint uVar2;
uint uVar3;
byte bVar4;
uint uVar5;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar5 = *param_2;
uVar3 = 0x1f;
if (-1 < (int)uVar5) goto LAB_00183944;
}
else {
uVar5 = *param_2;
uVar3 = param_2[1] - 1;
param_2[1] = uVar3;
if ((uVar5 >> (uVar3 & 0x1f) & 1) == 0) {
LAB_00183944:
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar3 < uVar1) {
uVar2 = (&mask)[uVar3];
bVar4 = (byte)(uVar1 - uVar3);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar3);
uVar5 = ((uVar5 & uVar2) << (bVar4 & 0x1f)) + (*param_2 >> (-bVar4 & 0x1f));
}
else {
param_2[1] = uVar3 - uVar1;
uVar5 = uVar5 >> ((byte)(uVar3 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
*param_3 = (short)uVar5;
decode_bytes(param_1,param_2,param_3 + 1,(long)param_3 + (ulong)uVar5 + 2);
return;
}
}
*param_3 = 0;
return;
}
|
|
2,673 | minja::Context::~Context() | monkey531[P]llama/common/minja.hpp | virtual ~Context() {} | O1 | cpp | minja::Context::~Context():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8143e(%rip), %rax # 0xf4150
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x72d27
callq 0x32b80
leaq 0x58(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x52814
movq %r14, %rdi
callq 0x5f2cc
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x72d4b
callq 0x32b80
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x72d59
callq 0x32b80
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x72d67
callq 0x32b80
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x72d9c
movq 0x82221(%rip), %rax # 0xf4f98
cmpb $0x0, (%rax)
je 0x72d87
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x72d91
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x72d9c
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x72dd8
movq 0x821ec(%rip), %rax # 0xf4f98
cmpb $0x0, (%rax)
je 0x72dbc
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x72dc6
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x72dd8
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja7ContextD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5minja7ContextE; `vtable for'minja::Context
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+70h]
test rdi, rdi
jz short loc_72D27
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72D27:
lea r14, [rbx+58h]
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 rdi, [rbx+50h]
test rdi, rdi
jz short loc_72D4B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72D4B:
mov rdi, [rbx+40h]
test rdi, rdi
jz short loc_72D59
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72D59:
mov rdi, [rbx+30h]
test rdi, rdi
jz short loc_72D67
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_72D67:
mov rdi, [rbx+20h]
test rdi, rdi
jz short loc_72D9C
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_72D87
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_72D91
loc_72D87:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_72D91:
cmp eax, 1
jnz short loc_72D9C
mov rax, [rdi]
call qword ptr [rax+18h]
loc_72D9C:
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_72DD8
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_72DBC
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_72DC6
loc_72DBC:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_72DC6:
cmp eax, 1
jnz short loc_72DD8
mov rax, [rdi]
add rsp, 8
pop rbx
pop r14
jmp qword ptr [rax+18h]
loc_72DD8:
add rsp, 8
pop rbx
pop r14
retn
| void minja::Context::~Context(minja::Context *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
volatile signed __int32 *v4; // rdi
volatile signed __int32 *v5; // rdi
volatile signed __int32 *v6; // rdi
signed __int32 v7; // eax
volatile signed __int32 *v8; // rdi
signed __int32 v9; // eax
*(_QWORD *)this = &`vtable for'minja::Context + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 14);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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 *)this + 88);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)this + 11);
v3 = (volatile signed __int32 *)*((_QWORD *)this + 10);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
v4 = (volatile signed __int32 *)*((_QWORD *)this + 8);
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v4);
v5 = (volatile signed __int32 *)*((_QWORD *)this + 6);
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v5);
v6 = (volatile signed __int32 *)*((_QWORD *)this + 4);
if ( v6 )
{
if ( _libc_single_threaded )
{
v7 = *((_DWORD *)v6 + 3);
*((_DWORD *)v6 + 3) = v7 - 1;
}
else
{
v7 = _InterlockedExchangeAdd(v6 + 3, 0xFFFFFFFF);
}
if ( v7 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v6 + 24LL))(v6, 0LL);
}
v8 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v8 )
{
if ( _libc_single_threaded )
{
v9 = *((_DWORD *)v8 + 3);
*((_DWORD *)v8 + 3) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd(v8 + 3, 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(volatile signed __int32 *, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
}
| ~Context:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x1f4150]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x70]
TEST RDI,RDI
JZ 0x00172d27
CALL 0x00132b80
LAB_00172d27:
LEA R14,[RBX + 0x58]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00152814
MOV RDI,R14
CALL 0x0015f2cc
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x00172d4b
CALL 0x00132b80
LAB_00172d4b:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x00172d59
CALL 0x00132b80
LAB_00172d59:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x00172d67
CALL 0x00132b80
LAB_00172d67:
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JZ 0x00172d9c
MOV RAX,qword ptr [0x001f4f98]
CMP byte ptr [RAX],0x0
JZ 0x00172d87
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00172d91
LAB_00172d87:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00172d91:
CMP EAX,0x1
JNZ 0x00172d9c
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00172d9c:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00172dd8
MOV RAX,qword ptr [0x001f4f98]
CMP byte ptr [RAX],0x0
JZ 0x00172dbc
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00172dc6
LAB_00172dbc:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00172dc6:
CMP EAX,0x1
JNZ 0x00172dd8
MOV RAX,qword ptr [RDI]
ADD RSP,0x8
POP RBX
POP R14
JMP qword ptr [RAX + 0x18]
LAB_00172dd8:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Context::~Context() */
void __thiscall minja::Context::~Context(Context *this)
{
int *piVar1;
long *plVar2;
int iVar3;
*(int ***)this = &PTR__Context_001f4160;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x70) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x70));
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(this + 0x58),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 *)(this + 0x58));
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x50) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x50));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x40) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x40));
}
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x30) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x30));
}
plVar2 = *(long **)(this + 0x20);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_001f4f98 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*plVar2 + 0x18))();
}
}
plVar2 = *(long **)(this + 0x10);
if (plVar2 != (long *)0x0) {
if (*PTR___libc_single_threaded_001f4f98 == '\0') {
LOCK();
piVar1 = (int *)((long)plVar2 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)plVar2 + 0xc);
*(int *)((long)plVar2 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
/* WARNING: Could not recover jumptable at 0x00172dd5. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(*plVar2 + 0x18))();
return;
}
}
return;
}
|
|
2,674 | Transaction_state_tracker::add_trx_state(THD*, unsigned int) | eloqsql/sql/session_tracker.cc | void Transaction_state_tracker::add_trx_state(THD *thd, uint add)
{
if ((!m_enabled) || (thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
return;
if (add == TX_EXPLICIT)
{
/* Always send characteristic item (if tracked), always replace state. */
tx_changed |= TX_CHG_CHISTICS;
tx_curr_state = TX_EXPLICIT;
}
/*
If we're not in an implicit or explicit transaction, but
autocommit==0 and tables are accessed, we flag "implicit transaction."
*/
else if (!(tx_curr_state & (TX_EXPLICIT|TX_IMPLICIT)) &&
(thd->variables.option_bits & OPTION_NOT_AUTOCOMMIT) &&
(add &
(TX_READ_TRX | TX_READ_UNSAFE | TX_WRITE_TRX | TX_WRITE_UNSAFE)))
tx_curr_state |= TX_IMPLICIT;
/*
Only flag state when in transaction or LOCK TABLES is added.
*/
if ((tx_curr_state & (TX_EXPLICIT | TX_IMPLICIT)) ||
(add & TX_LOCKED_TABLES))
tx_curr_state |= add;
update_change_flags(thd);
} | O0 | cpp | Transaction_state_tracker::add_trx_state(THD*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x8(%rax)
je 0x8e3373
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8e3378
jmp 0x8e340a
cmpl $0x1, -0x14(%rbp)
jne 0x8e3394
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xc(%rax)
movl $0x1, 0x10(%rax)
jmp 0x8e33d4
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x8e33d2
movq -0x10(%rbp), %rax
movq 0x8a8(%rax), %rax
andq $0x80000, %rax # imm = 0x80000
cmpq $0x0, %rax
je 0x8e33d2
movl -0x14(%rbp), %eax
andl $0x3c, %eax
cmpl $0x0, %eax
je 0x8e33d2
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x10(%rax)
jmp 0x8e33d4
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x8e33f0
movl -0x14(%rbp), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
je 0x8e33fd
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8e3a00
addq $0x20, %rsp
popq %rbp
retq
| _ZN25Transaction_state_tracker13add_trx_stateEP3THDj:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
test byte ptr [rax+8], 1
jz short loc_8E3373
mov rax, [rbp+var_10]
mov eax, [rax+128h]
and eax, 1
cmp eax, 0
jz short loc_8E3378
loc_8E3373:
jmp loc_8E340A
loc_8E3378:
cmp [rbp+var_14], 1
jnz short loc_8E3394
mov rax, [rbp+var_20]
mov ecx, [rax+0Ch]
or ecx, 2
mov [rax+0Ch], ecx
mov dword ptr [rax+10h], 1
jmp short loc_8E33D4
loc_8E3394:
mov rax, [rbp+var_20]
mov eax, [rax+10h]
and eax, 3
cmp eax, 0
jnz short loc_8E33D2
mov rax, [rbp+var_10]
mov rax, [rax+8A8h]
and rax, 80000h
cmp rax, 0
jz short loc_8E33D2
mov eax, [rbp+var_14]
and eax, 3Ch
cmp eax, 0
jz short loc_8E33D2
mov rax, [rbp+var_20]
mov ecx, [rax+10h]
or ecx, 2
mov [rax+10h], ecx
loc_8E33D2:
jmp short $+2
loc_8E33D4:
mov rax, [rbp+var_20]
mov eax, [rax+10h]
and eax, 3
cmp eax, 0
jnz short loc_8E33F0
mov eax, [rbp+var_14]
and eax, 200h
cmp eax, 0
jz short loc_8E33FD
loc_8E33F0:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_14]
or ecx, [rax+10h]
mov [rax+10h], ecx
loc_8E33FD:
mov rdi, [rbp+var_20]; this
mov rsi, [rbp+var_10]; THD *
call _ZN25Transaction_state_tracker19update_change_flagsEP3THD; Transaction_state_tracker::update_change_flags(THD *)
loc_8E340A:
add rsp, 20h
pop rbp
retn
| long long Transaction_state_tracker::add_trx_state(Transaction_state_tracker *this, THD *a2, int a3)
{
long long result; // rax
result = (long long)this;
if ( (*((_BYTE *)this + 8) & 1) != 0 )
{
result = *((_DWORD *)a2 + 74) & 1;
if ( !(_DWORD)result )
{
if ( a3 == 1 )
{
*((_DWORD *)this + 3) |= 2u;
*((_DWORD *)this + 4) = 1;
}
else if ( (*((_DWORD *)this + 4) & 3) == 0 && (*((_QWORD *)a2 + 277) & 0x80000LL) != 0 && (a3 & 0x3C) != 0 )
{
*((_DWORD *)this + 4) |= 2u;
}
if ( (*((_DWORD *)this + 4) & 3) != 0 || (a3 & 0x200) != 0 )
*((_DWORD *)this + 4) |= a3;
return Transaction_state_tracker::update_change_flags(this, a2);
}
}
return result;
}
| __cxx_global_var_init.2:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x271579c]
MOV ESI,0x4
CALL 0x008fd530
POP RBP
RET
|
void __cxx_global_var_init_2(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_TIME_ONLY,4);
return;
}
|
|
2,675 | minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::ArgumentsExpression&&) | monkey531[P]llama/common/minja.hpp | CallExpr(const Location & location, std::shared_ptr<Expression> && obj, ArgumentsExpression && a)
: Expression(location), object(std::move(obj)), args(std::move(a)) {} | O2 | cpp | minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::ArgumentsExpression&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x7ed62
leaq 0x94b32(%rip), %rax # 0x11f8c0
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x28(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x20(%r15)
andq $0x0, (%r14)
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x87c38
| _ZN5minja8CallExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEEONS_19ArgumentsExpressionE:
push r15
push r14
push rbx
mov rbx, rcx
mov r14, rdx
mov r15, rdi
call _ZN5minja10ExpressionC2ERKNS_8LocationE; minja::Expression::Expression(minja::Location const&)
lea rax, _ZTVN5minja8CallExprE; `vtable for'minja::CallExpr
add rax, 10h
mov [r15], rax
and qword ptr [r15+28h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+20h], xmm0
and qword ptr [r14], 0
add r15, 30h ; '0'
mov rdi, r15
mov rsi, rbx
pop rbx
pop r14
pop r15
jmp _ZN5minja19ArgumentsExpressionC2EOS0_; minja::ArgumentsExpression::ArgumentsExpression(minja::ArgumentsExpression&&)
| long long minja::CallExpr::CallExpr(long long a1, _QWORD *a2, __int128 *a3, long long a4)
{
__int128 v6; // xmm0
minja::Expression::Expression((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::CallExpr + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v6;
*(_QWORD *)a3 = 0LL;
return minja::ArgumentsExpression::ArgumentsExpression(a1 + 48, a4);
}
| CallExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
CALL 0x0017ed62
LEA RAX,[0x21f8c0]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
AND qword ptr [R14],0x0
ADD R15,0x30
MOV RDI,R15
MOV RSI,RBX
POP RBX
POP R14
POP R15
JMP 0x00187c38
|
/* minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
minja::ArgumentsExpression&&) */
void __thiscall
minja::CallExpr::CallExpr
(CallExpr *this,Location *param_1,shared_ptr *param_2,ArgumentsExpression *param_3)
{
int8 uVar1;
Expression::Expression((Expression *)this,param_1);
*(int ***)this = &PTR_do_evaluate_0021f8d0;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
ArgumentsExpression::ArgumentsExpression((ArgumentsExpression *)(this + 0x30),param_3);
return;
}
|
|
2,676 | JS_IsEqual | bluesky950520[P]quickjs/quickjs.c | static JSValue js_dup(JSValue v)
{
if (JS_VALUE_HAS_REF_COUNT(v)) {
JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
p->ref_count++;
}
return v;
} | O2 | c | JS_IsEqual:
cmpl $-0x9, %edx
jb 0x3691e
incl (%rsi)
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %r8d
jb 0x36935
incl (%rcx)
leaq 0x20(%rsp), %rbx
movq %rcx, -0x10(%rbx)
movq %r8, -0x8(%rbx)
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3695e
negl %eax
sbbl %ebp, %ebp
orl -0x20(%rbx), %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
| JS_IsEqual:
cmp edx, 0FFFFFFF7h
jb short loc_3691E
inc dword ptr [rsi]
loc_3691E:
push rbp
push rbx
sub rsp, 28h
mov [rsp+38h+var_38], rsi
mov [rsp+38h+var_30], rdx
cmp r8d, 0FFFFFFF7h
jb short loc_36935
inc dword ptr [rcx]
loc_36935:
lea rbx, [rsp+38h+var_18]
mov [rbx-10h], rcx
mov [rbx-8], r8
xor ebp, ebp
mov rsi, rbx
xor edx, edx
call js_eq_slow
neg eax
sbb ebp, ebp
or ebp, [rbx-20h]
mov eax, ebp
add rsp, 28h
pop rbx
pop rbp
retn
| long long JS_IsEqual(long long a1, _DWORD *a2, unsigned int a3, _DWORD *a4, unsigned int a5)
{
_BYTE v6[24]; // [rsp+20h] [rbp-18h] BYREF
if ( a3 >= 0xFFFFFFF7 )
++*a2;
if ( a5 >= 0xFFFFFFF7 )
++*a4;
return (unsigned int)js_eq_slow(a1, v6, 0LL) != 0 ? -1 : (unsigned int)a2;
}
| JS_IsEqual:
CMP EDX,-0x9
JC 0x0013691e
INC dword ptr [RSI]
LAB_0013691e:
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP],RSI
MOV qword ptr [RSP + 0x8],RDX
CMP R8D,-0x9
JC 0x00136935
INC dword ptr [RCX]
LAB_00136935:
LEA RBX,[RSP + 0x20]
MOV qword ptr [RBX + -0x10],RCX
MOV qword ptr [RBX + -0x8],R8
XOR EBP,EBP
MOV RSI,RBX
XOR EDX,EDX
CALL 0x0013695e
NEG EAX
SBB EBP,EBP
OR EBP,dword ptr [RBX + -0x20]
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP RBP
RET
|
uint JS_IsEqual(int8 param_1,int *param_2,uint param_3,int *param_4,uint param_5)
{
int iVar1;
uint local_38;
int1 local_18 [8];
if (0xfffffff6 < param_3) {
*param_2 = *param_2 + 1;
}
if (0xfffffff6 < param_5) {
*param_4 = *param_4 + 1;
}
iVar1 = js_eq_slow(param_1,local_18,0);
local_38 = (uint)param_2;
return -(uint)(iVar1 != 0) | local_38;
}
|
|
2,677 | translog_get_last_page_addr | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_get_last_page_addr(TRANSLOG_ADDRESS *addr,
my_bool *last_page_ok,
my_bool no_errors)
{
char path[FN_REFLEN];
uint32 rec_offset;
my_off_t file_size;
uint32 file_no= LSN_FILE_NO(*addr);
TRANSLOG_FILE *file;
#ifndef DBUG_OFF
char buff[21];
#endif
DBUG_ENTER("translog_get_last_page_addr");
if (likely((file= get_logfile_by_number(file_no)) != NULL))
{
/*
This function used only during initialization of loghandler or in
scanner (which mean we need read that part of the log), so the
requested log file have to be opened and can't be freed after
returning pointer on it (file_size).
*/
file_size= mysql_file_seek(file->handler.file, 0, SEEK_END, MYF(0));
}
else
{
/*
This branch is used only during very early initialization
when files are not opened.
*/
File fd;
if ((fd= mysql_file_open(key_file_translog,
translog_filename_by_fileno(file_no, path),
O_RDONLY | O_CLOEXEC, (no_errors ? MYF(0) : MYF(MY_WME)))) < 0)
{
my_errno= errno;
DBUG_PRINT("error", ("Error %d during opening file #%d",
errno, file_no));
DBUG_RETURN(1);
}
file_size= mysql_file_seek(fd, 0, SEEK_END, MYF(0));
mysql_file_close(fd, MYF(0));
}
DBUG_PRINT("info", ("File size: %s", llstr(file_size, buff)));
if (file_size == MY_FILEPOS_ERROR)
DBUG_RETURN(1);
DBUG_ASSERT(file_size < 0xffffffffULL);
if (((uint32)file_size) > TRANSLOG_PAGE_SIZE)
{
rec_offset= (((((uint32)file_size) / TRANSLOG_PAGE_SIZE) - 1) *
TRANSLOG_PAGE_SIZE);
*last_page_ok= (((uint32)file_size) == rec_offset + TRANSLOG_PAGE_SIZE);
}
else
{
*last_page_ok= 0;
rec_offset= 0;
}
*addr= MAKE_LSN(file_no, rec_offset);
DBUG_PRINT("info", ("Last page: 0x%lx ok: %d", (ulong) rec_offset,
*last_page_ok));
DBUG_RETURN(0);
} | O3 | c | translog_get_last_page_addr:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp # imm = 0x218
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %r13
movq %r13, %r12
shrq $0x20, %r12
movl %r12d, %edi
callq 0x6f8ee
testq %rax, %rax
je 0x6aee2
movl 0x18(%rax), %r15d
leaq 0x328c0e(%rip), %rax # 0x393a58
movq (%rax), %rax
leaq -0x230(%rbp), %rdi
movl %r15d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x6af11
movl %r15d, %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xab33c
movq %rax, %rcx
cmpq $-0x1, %rcx
je 0x6aebf
movl $0xffffe000, %edx # imm = 0xFFFFE000
movl %ecx, %eax
andl %edx, %eax
addl %eax, %edx
cmpl %ecx, %eax
sete %sil
xorl %eax, %eax
cmpl $0x2001, %ecx # imm = 0x2001
setae %cl
cmovbl %eax, %edx
andb %sil, %cl
movb %cl, (%r14)
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rcx, %r13
orq %rdx, %r13
movq %r13, (%rbx)
jmp 0x6aec1
movb $0x1, %al
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x6af2f
addq $0x218, %rsp # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %r15b, %edx
leaq -0x230(%rbp), %rsi
leaq -0x238(%rbp), %rcx
movl %r12d, %edi
callq 0x2da89
movl %eax, %ecx
movb $0x1, %al
testb $0x1, %cl
je 0x6aec1
movq -0x238(%rbp), %rcx
jmp 0x6ae7f
leaq -0x238(%rbp), %r12
movq %rax, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x2da2c
movq (%r12), %rcx
jmp 0x6ae7f
callq 0x2a250
| translog_get_last_page_addr:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 218h
mov r15d, edx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13, [rdi]
mov r12, r13
shr r12, 20h
mov edi, r12d
call get_logfile_by_number
test rax, rax
jz loc_6AEE2
mov r15d, [rax+18h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_230]
mov esi, r15d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_6AF11
mov edi, r15d
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
mov rcx, rax
loc_6AE7F:
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz short loc_6AEBF
mov edx, 0FFFFE000h
mov eax, ecx
and eax, edx
add edx, eax
cmp eax, ecx
setz sil
xor eax, eax
cmp ecx, 2001h
setnb cl
cmovb edx, eax
and cl, sil
mov [r14], cl
mov rcx, 0FFFFFFFF00000000h
and r13, rcx
or r13, rdx
mov [rbx], r13
jmp short loc_6AEC1
loc_6AEBF:
mov al, 1
loc_6AEC1:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_6AF2F
add rsp, 218h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6AEE2:
movzx edx, r15b
lea rsi, [rbp+var_230]
lea rcx, [rbp+var_238]
mov edi, r12d
call translog_get_last_page_addr_cold_2
mov ecx, eax
mov al, 1
test cl, 1
jz short loc_6AEC1
mov rcx, [rbp+var_238]
jmp loc_6AE7F
loc_6AF11:
lea r12, [rbp+var_238]
mov rdi, rax
mov esi, r15d
mov rdx, r12
call translog_get_last_page_addr_cold_1
mov rcx, [r12]
jmp loc_6AE7F
loc_6AF2F:
call ___stack_chk_fail
| char translog_get_last_page_addr(unsigned long long *a1, bool *a2, char a3)
{
unsigned long long v4; // r13
unsigned long long v5; // r12
long long logfile_by_number; // rax
unsigned int v7; // r15d
long long v8; // rax
long long v9; // rcx
long long v10; // rdx
char result; // al
char last_page_addr_cold_2; // cl
long long v13; // [rsp+8h] [rbp-238h] BYREF
_BYTE v14[512]; // [rsp+10h] [rbp-230h] BYREF
unsigned long long v15; // [rsp+210h] [rbp-30h]
v15 = __readfsqword(0x28u);
v4 = *a1;
v5 = HIDWORD(*a1);
logfile_by_number = get_logfile_by_number(HIDWORD(*a1));
if ( logfile_by_number )
{
v7 = *(_DWORD *)(logfile_by_number + 24);
v8 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v14, v7, 8LL);
if ( v8 )
{
translog_get_last_page_addr_cold_1(v8, v7, &v13);
v9 = v13;
}
else
{
v9 = my_seek(v7, 0LL, 2LL, 0LL);
}
}
else
{
last_page_addr_cold_2 = translog_get_last_page_addr_cold_2((unsigned int)v5, (long long)v14, a3, &v13);
result = 1;
if ( (last_page_addr_cold_2 & 1) == 0 )
return result;
v9 = v13;
}
if ( v9 == -1 )
return 1;
v10 = ((unsigned int)v9 & 0xFFFFE000) - 0x2000;
result = 0;
if ( (unsigned int)v9 < 0x2001 )
v10 = 0LL;
*a2 = (v9 & 0xFFFFE000) == (_DWORD)v9 && (unsigned int)v9 >= 0x2001;
*a1 = v10 | v4 & 0xFFFFFFFF00000000LL;
return result;
}
| translog_get_last_page_addr:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x218
MOV R15D,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13,qword ptr [RDI]
MOV R12,R13
SHR R12,0x20
MOV EDI,R12D
CALL 0x0016f8ee
TEST RAX,RAX
JZ 0x0016aee2
MOV R15D,dword ptr [RAX + 0x18]
LEA RAX,[0x493a58]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x230]
MOV ESI,R15D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0016af11
MOV EDI,R15D
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x001ab33c
MOV RCX,RAX
LAB_0016ae7f:
CMP RCX,-0x1
JZ 0x0016aebf
MOV EDX,0xffffe000
MOV EAX,ECX
AND EAX,EDX
ADD EDX,EAX
CMP EAX,ECX
SETZ SIL
XOR EAX,EAX
CMP ECX,0x2001
SETNC CL
CMOVC EDX,EAX
AND CL,SIL
MOV byte ptr [R14],CL
MOV RCX,-0x100000000
AND R13,RCX
OR R13,RDX
MOV qword ptr [RBX],R13
JMP 0x0016aec1
LAB_0016aebf:
MOV AL,0x1
LAB_0016aec1:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0016af2f
ADD RSP,0x218
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016aee2:
MOVZX EDX,R15B
LEA RSI,[RBP + -0x230]
LEA RCX,[RBP + -0x238]
MOV EDI,R12D
CALL 0x0012da89
MOV ECX,EAX
MOV AL,0x1
TEST CL,0x1
JZ 0x0016aec1
MOV RCX,qword ptr [RBP + -0x238]
JMP 0x0016ae7f
LAB_0016af11:
LEA R12,[RBP + -0x238]
MOV RDI,RAX
MOV ESI,R15D
MOV RDX,R12
CALL 0x0012da2c
MOV RCX,qword ptr [R12]
JMP 0x0016ae7f
LAB_0016af2f:
CALL 0x0012a250
|
int8 translog_get_last_page_addr(ulong *param_1,int8 param_2,int1 param_3)
{
int4 uVar1;
ulong uVar2;
uint uVar3;
long lVar4;
int8 uVar5;
uint uVar6;
ulong uVar7;
long in_FS_OFFSET;
long local_240;
int1 local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = *param_1;
uVar7 = uVar2 >> 0x20;
lVar4 = get_logfile_by_number(uVar7);
if (lVar4 == 0) {
uVar7 = translog_get_last_page_addr_cold_2(uVar7,local_238,param_3,&local_240);
uVar5 = 1;
if ((uVar7 & 1) == 0) goto LAB_0016aec1;
}
else {
uVar1 = *(int4 *)(lVar4 + 0x18);
lVar4 = (**(code **)(PSI_server + 0x158))(local_238,uVar1,8);
if (lVar4 == 0) {
local_240 = my_seek(uVar1,0,2,0);
}
else {
translog_get_last_page_addr_cold_1(lVar4,uVar1,&local_240);
}
}
if (local_240 == -1) {
uVar5 = 1;
}
else {
uVar6 = (uint)local_240;
uVar5 = 0;
uVar3 = (uVar6 & 0xffffe000) - 0x2000;
if (0x2000 >= uVar6) {
uVar3 = 0;
}
*(bool *)param_2 = 0x2000 < uVar6 && (uVar6 & 0xffffe000) == uVar6;
*param_1 = uVar2 & 0xffffffff00000000 | (ulong)uVar3;
}
LAB_0016aec1:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar5;
}
|
|
2,678 | minja::Parser::parseValueExpression()::'lambda'()::operator()() const | monkey531[P]llama/common/./minja.hpp | std::shared_ptr<Expression> parseValueExpression() {
auto parseValue = [&]() -> std::shared_ptr<Expression> {
auto location = get_location();
auto constant = parseConstant();
if (constant) return std::make_shared<LiteralExpr>(location, *constant);
static std::regex null_regex(R"(null\b)");
if (!consumeToken(null_regex).empty()) return std::make_shared<LiteralExpr>(location, Value());
auto identifier = parseIdentifier();
if (identifier) return identifier;
auto braced = parseBracedExpressionOrArray();
if (braced) return braced;
auto array = parseArray();
if (array) return array;
auto dictionary = parseDictionary();
if (dictionary) return dictionary;
throw std::runtime_error("Expected value expression");
};
auto value = parseValue();
while (it != end && consumeSpaces() && peekSymbols({ "[", "." })) {
if (!consumeToken("[").empty()) {
std::shared_ptr<Expression> index;
if (!consumeToken(":").empty()) {
auto slice_end = parseExpression();
index = std::make_shared<SliceExpr>(slice_end->location, nullptr, std::move(slice_end));
} else {
auto slice_start = parseExpression();
if (!consumeToken(":").empty()) {
consumeSpaces();
if (peekSymbols({ "]" })) {
index = std::make_shared<SliceExpr>(slice_start->location, std::move(slice_start), nullptr);
} else {
auto slice_end = parseExpression();
index = std::make_shared<SliceExpr>(slice_start->location, std::move(slice_start), std::move(slice_end));
}
} else {
index = std::move(slice_start);
}
}
if (!index) throw std::runtime_error("Empty index in subscript");
if (consumeToken("]").empty()) throw std::runtime_error("Expected closing bracket in subscript");
value = std::make_shared<SubscriptExpr>(value->location, std::move(value), std::move(index));
} else if (!consumeToken(".").empty()) {
auto identifier = parseIdentifier();
if (!identifier) throw std::runtime_error("Expected identifier in subscript");
consumeSpaces();
if (peekSymbols({ "(" })) {
auto callParams = parseCallArgs();
value = std::make_shared<MethodCallExpr>(identifier->location, std::move(value), std::move(identifier), std::move(callParams));
} else {
auto key = std::make_shared<LiteralExpr>(identifier->location, Value(identifier->get_name()));
value = std::make_shared<SubscriptExpr>(identifier->location, std::move(value), std::move(key));
}
}
consumeSpaces();
}
if (peekSymbols({ "(" })) {
auto location = get_location();
auto callParams = parseCallArgs();
value = std::make_shared<CallExpr>(location, std::move(value), std::move(callParams));
}
return value;
} | O3 | cpp | minja::Parser::parseValueExpression()::'lambda'()::operator()() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq (%r14), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0x41b49
movq 0xae465(%rip), %rcx # 0xeffa0
cmpb $0x0, (%rcx)
je 0x41b45
incl 0x8(%rax)
jmp 0x41b49
lock
incl 0x8(%rax)
movq 0x20(%r14), %rax
subq 0x10(%r14), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x425fe
movq 0x40(%rsp), %r8
testq %r8, %r8
je 0x41bc2
leaq 0x58(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x50(%rsp), %rsi
movq %rsp, %rdx
leaq 0x28(%rsp), %rcx
callq 0x4f258
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x41ba3
callq 0x2f80e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x41bb2
callq 0x2f80e
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb 0xaf338(%rip), %al # 0xf0f00
testb %al, %al
je 0x41dc6
leaq 0xaf309(%rip), %rdx # 0xf0ee0
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x2fd6a
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0x41c08
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x186a0
testq %r15, %r15
je 0x41cee
leaq 0x90(%rsp), %r14
xorl %r15d, %r15d
movq %r15, 0x8(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%r14)
movaps %xmm0, -0x30(%r14)
movaps %xmm0, -0x20(%r14)
movaps %xmm0, -0x10(%r14)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
movq %r14, %rdi
movl $0x1, %esi
callq 0x3d970
leaq 0x8(%rsp), %rdi
movq %r15, -0x8(%rdi)
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x5611a
movaps (%rsp), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movups %xmm0, (%rbx)
movq %rax, (%rsp)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d970
movq %r14, %rdi
callq 0x4a5c0
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x41cab
callq 0x2f80e
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x41cba
callq 0x2f80e
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x41cc9
callq 0x2f80e
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x41b94
movq 0xae2c2(%rip), %rax # 0xeffa0
cmpb $0x0, (%rax)
je 0x41d16
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x41d20
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x303fe
movq 0x50(%rsp), %rax
testq %rax, %rax
je 0x41d34
movq %rax, (%rbx)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rbx)
jmp 0x41b94
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x41b94
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x41b94
movq %rsp, %rdi
movq %r14, %rsi
callq 0x42996
movq (%rsp), %rax
testq %rax, %rax
je 0x41d56
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
jmp 0x41dae
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x42ef6
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x41d7b
movq %rax, (%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rbx)
jmp 0x41d9f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4351c
cmpq $0x0, (%rbx)
je 0x41e1d
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x41d9f
callq 0x2f80e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x41dae
callq 0x2f80e
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x41b94
callq 0x2f80e
jmp 0x41b94
leaq 0xaf133(%rip), %rdi # 0xf0f00
callq 0x18be0
testl %eax, %eax
je 0x41bd0
leaq 0xaf0ff(%rip), %rdi # 0xf0ee0
leaq 0x7560d(%rip), %rsi # 0xb73f5
movl $0x10, %edx
callq 0x2f87e
leaq -0x12513(%rip), %rdi # 0x2f8e6
leaq 0xaf0e0(%rip), %rsi # 0xf0ee0
leaq 0xae891(%rip), %rdx # 0xf0698
callq 0x185d0
leaq 0xaf0ed(%rip), %rdi # 0xf0f00
callq 0x18450
jmp 0x41bd0
movl $0x10, %edi
callq 0x18360
movq %rax, %r15
leaq 0x755cb(%rip), %rsi # 0xb73fc
movq %rax, %rdi
callq 0x18270
movq 0xae1b0(%rip), %rsi # 0xefff0
movq 0xae139(%rip), %rdx # 0xeff80
movq %r15, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0xaf0a7(%rip), %rdi # 0xf0f00
callq 0x18440
jmp 0x41ed2
movq %rax, %r14
jmp 0x41e70
movq %rax, %r14
movq %r15, %rdi
callq 0x18500
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x41e83
callq 0x2f80e
jmp 0x41e83
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x41e97
callq 0x2f80e
jmp 0x41e97
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x41eab
callq 0x2f80e
jmp 0x41eab
movq %rax, %r14
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x41ed2
callq 0x2f80e
jmp 0x41ed2
jmp 0x41ecf
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x3d8e4
jmp 0x41ed2
jmp 0x41ecf
movq %rax, %r14
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x41ee6
callq 0x2f80e
jmp 0x41ee6
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x41ef5
callq 0x2f80e
movq %r14, %rdi
callq 0x18b90
nop
| _ZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEv:
push r15
push r14
push rbx
sub rsp, 0A0h
mov rbx, rdi
mov r14, [rsi]
mov rax, [r14]
mov [rsp+0B8h+var_90], rax
mov rax, [r14+8]
mov [rsp+0B8h+var_88], rax
test rax, rax
jz short loc_41B49
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_41B45
inc dword ptr [rax+8]
jmp short loc_41B49
loc_41B45:
lock inc dword ptr [rax+8]
loc_41B49:
mov rax, [r14+20h]
sub rax, [r14+10h]
mov [rsp+0B8h+var_80], rax
lea rdi, [rsp+0B8h+var_78]; this
mov rsi, r14
call _ZN5minja6Parser13parseConstantEv; minja::Parser::parseConstant(void)
mov r8, [rsp+0B8h+var_78]
test r8, r8
jz short loc_41BC2
lea rdi, [rsp+0B8h+var_68+8]
mov qword ptr [rdi-8], 0
lea rsi, [rsp+0B8h+var_68]
mov rdx, rsp
lea rcx, [rsp+0B8h+var_90]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5minja11LiteralExprESaIS5_EJRNS4_8LocationERNS4_5ValueEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::LiteralExpr,std::allocator<minja::LiteralExpr>,minja::Location &,minja::Value &>(minja::LiteralExpr *&,std::_Sp_alloc_shared_tag<std::allocator<minja::LiteralExpr>>,minja::Location &,minja::Value &)
movaps xmm0, [rsp+0B8h+var_68]
movups xmmword ptr [rbx], xmm0
loc_41B94:
mov rdi, [rsp+0B8h+var_70]
test rdi, rdi
jz short loc_41BA3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41BA3:
mov rdi, [rsp+0B8h+var_88]
test rdi, rdi
jz short loc_41BB2
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41BB2:
mov rax, rbx
add rsp, 0A0h
pop rbx
pop r14
pop r15
retn
loc_41BC2:
mov al, cs:_ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; `guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex
test al, al
jz loc_41DC6
loc_41BD0:
lea rdx, _ZZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex
lea rdi, [rsp+0B8h+var_68]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+0B8h+var_58]
mov rdi, [rax-10h]; void *
mov r15, [rax-8]
cmp rdi, rax
jz short loc_41C08
mov rsi, [rsp+0B8h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_41C08:
test r15, r15
jz loc_41CEE
lea r14, [rsp+0B8h+var_28]
xor r15d, r15d
mov [r14+8], r15
xorps xmm0, xmm0
movaps xmmword ptr [r14-40h], xmm0
movaps xmmword ptr [r14-30h], xmm0
movaps xmmword ptr [r14-20h], xmm0
movaps xmmword ptr [r14-10h], xmm0
mov byte ptr [r14], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
lea rdi, [rsp+0B8h+var_B0]
mov [rdi-8], r15
mov rsi, rsp
lea rdx, [rsp+0B8h+var_A0]
lea rcx, [rsp+0B8h+var_90]
lea r8, [rsp+0B8h+var_68]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5minja11LiteralExprESaIS5_EJRNS4_8LocationENS4_5ValueEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::LiteralExpr,std::allocator<minja::LiteralExpr>,minja::Location &,minja::Value>(minja::LiteralExpr *&,std::_Sp_alloc_shared_tag<std::allocator<minja::LiteralExpr>>,minja::Location &,minja::Value &&)
movaps xmm0, xmmword ptr [rsp]
xor eax, eax
mov [rsp+0B8h+var_B0], rax
movups xmmword ptr [rbx], xmm0
mov [rsp+0B8h+var_B8], rax
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 rdi, [rsp+0B8h+var_30]
test rdi, rdi
jz short loc_41CAB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41CAB:
mov rdi, [rsp+0B8h+var_40]
test rdi, rdi
jz short loc_41CBA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41CBA:
mov rdi, [rsp+0B8h+var_50]
test rdi, rdi
jz short loc_41CC9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41CC9:
mov rdi, qword ptr [rsp+0B8h+var_68+8]
test rdi, rdi
jz loc_41B94
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_41D16
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_41D20
loc_41CEE:
lea rdi, [rsp+0B8h+var_68]; this
mov rsi, r14
call _ZN5minja6Parser15parseIdentifierEv; minja::Parser::parseIdentifier(void)
mov rax, qword ptr [rsp+0B8h+var_68]
test rax, rax
jz short loc_41D34
mov [rbx], rax
mov rax, qword ptr [rsp+0B8h+var_68+8]
mov [rbx+8], rax
jmp loc_41B94
loc_41D16:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_41D20:
cmp eax, 1
jnz loc_41B94
mov rax, [rdi]
call qword ptr [rax+18h]
jmp loc_41B94
loc_41D34:
mov rdi, rsp; this
mov rsi, r14
call _ZN5minja6Parser28parseBracedExpressionOrArrayEv; minja::Parser::parseBracedExpressionOrArray(void)
mov rax, [rsp+0B8h+var_B8]
test rax, rax
jz short loc_41D56
mov [rbx], rax
mov rax, [rsp+0B8h+var_B0]
mov [rbx+8], rax
jmp short loc_41DAE
loc_41D56:
lea rdi, [rsp+0B8h+var_A0]; this
mov rsi, r14
call _ZN5minja6Parser10parseArrayEv; minja::Parser::parseArray(void)
mov rax, [rsp+0B8h+var_A0]
test rax, rax
jz short loc_41D7B
mov [rbx], rax
mov rax, [rsp+0B8h+var_98]
mov [rbx+8], rax
jmp short loc_41D9F
loc_41D7B:
mov rdi, rbx; this
mov rsi, r14
call _ZN5minja6Parser15parseDictionaryEv; minja::Parser::parseDictionary(void)
cmp qword ptr [rbx], 0
jz loc_41E1D
mov rdi, [rsp+0B8h+var_98]
test rdi, rdi
jz short loc_41D9F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41D9F:
mov rdi, [rsp+0B8h+var_B0]
test rdi, rdi
jz short loc_41DAE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41DAE:
mov rdi, qword ptr [rsp+0B8h+var_68+8]
test rdi, rdi
jz loc_41B94
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp loc_41B94
loc_41DC6:
lea rdi, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_41BD0
lea rdi, _ZZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex
lea rsi, aNullB; "null\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_41BD0
loc_41E1D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedValueE; "Expected value expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
mov r14, rax
lea rdi, _ZGVZZN5minja6Parser20parseValueExpressionEvENKUlvE_clEvE10null_regexB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_41ED2
mov r14, rax
jmp short loc_41E70
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
loc_41E70:
mov rdi, [rbx+8]
test rdi, rdi
jz short loc_41E83
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_41E83
mov r14, rax
loc_41E83:
mov rdi, [rsp+0B8h+var_98]
test rdi, rdi
jz short loc_41E97
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_41E97
mov r14, rax
loc_41E97:
mov rdi, [rsp+0B8h+var_B0]
test rdi, rdi
jz short loc_41EAB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_41EAB
mov r14, rax
loc_41EAB:
mov rdi, qword ptr [rsp+0B8h+var_68+8]
test rdi, rdi
jz short loc_41ED2
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_41ED2
jmp short loc_41ECF
mov r14, rax
lea rdi, [rsp+0B8h+var_68]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_41ED2
jmp short $+2
loc_41ECF:
mov r14, rax
loc_41ED2:
mov rdi, [rsp+0B8h+var_70]
test rdi, rdi
jz short loc_41EE6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_41EE6
mov r14, rax
loc_41EE6:
mov rdi, [rsp+0B8h+var_88]
test rdi, rdi
jz short loc_41EF5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_41EF5:
mov rdi, r14
call __Unwind_Resume
| minja::Parser * minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator()(
minja::Parser *this,
long long **a2)
{
long long *v3; // r14
volatile signed __int32 *v4; // rax
long long v6; // r15
__int128 v7; // xmm0
long long v8; // rdi
signed __int32 v9; // eax
std::runtime_error *exception; // r15
__int128 v11; // [rsp+0h] [rbp-B8h] BYREF
long long v12; // [rsp+18h] [rbp-A0h] BYREF
volatile signed __int32 *v13; // [rsp+20h] [rbp-98h]
long long v14; // [rsp+28h] [rbp-90h] BYREF
volatile signed __int32 *v15; // [rsp+30h] [rbp-88h]
long long v16; // [rsp+38h] [rbp-80h]
long long v17; // [rsp+40h] [rbp-78h] BYREF
volatile signed __int32 *v18; // [rsp+48h] [rbp-70h]
__int128 v19; // [rsp+50h] [rbp-68h] BYREF
__int128 v20; // [rsp+60h] [rbp-58h] BYREF
__int128 v21; // [rsp+70h] [rbp-48h]
__int128 v22; // [rsp+80h] [rbp-38h]
char v23[8]; // [rsp+90h] [rbp-28h] BYREF
long long v24; // [rsp+98h] [rbp-20h]
v3 = *a2;
v14 = **a2;
v4 = (volatile signed __int32 *)v3[1];
v15 = v4;
if ( v4 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v4 + 2);
else
_InterlockedIncrement(v4 + 2);
}
v16 = v3[4] - v3[2];
minja::Parser::parseConstant((minja::Parser *)&v17);
if ( v17 )
{
*(_QWORD *)&v19 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::LiteralExpr,std::allocator<minja::LiteralExpr>,minja::Location &,minja::Value &>(
(char *)&v19 + 8,
&v19,
&v11,
&v14);
*(_OWORD *)this = v19;
}
else
{
if ( !(_BYTE)`guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11],
"null\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)&v19,
(long long)v3,
(long long)&minja::Parser::parseValueExpression(void)::{lambda(void)#1}::operator() const(void)::null_regex[abi:cxx11],
1u);
v6 = *((_QWORD *)&v19 + 1);
if ( (__int128 *)v19 != &v20 )
operator delete((void *)v19, v20 + 1);
if ( v6 )
{
v24 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23[0] = 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>::assert_invariant(v23);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v23);
*(_QWORD *)&v11 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::LiteralExpr,std::allocator<minja::LiteralExpr>,minja::Location &,minja::Value>(
(char *)&v11 + 8,
&v11,
&v12,
&v14,
&v19);
v7 = v11;
*((_QWORD *)&v11 + 1) = 0LL;
*(_OWORD *)this = v7;
*(_QWORD *)&v11 = 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(v23);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v23);
if ( *((_QWORD *)&v22 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v22 + 1));
if ( *((_QWORD *)&v21 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v21 + 1));
if ( *((_QWORD *)&v20 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v20 + 1));
v8 = *((_QWORD *)&v19 + 1);
if ( *((_QWORD *)&v19 + 1) )
{
if ( _libc_single_threaded )
{
v9 = *(_DWORD *)(*((_QWORD *)&v19 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v19 + 1) + 12LL) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v19 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
}
else
{
minja::Parser::parseIdentifier((minja::Parser *)&v19, v3);
if ( (_QWORD)v19 )
{
*(_OWORD *)this = v19;
}
else
{
minja::Parser::parseBracedExpressionOrArray((minja::Parser *)&v11);
if ( (_QWORD)v11 )
{
*(_OWORD *)this = v11;
}
else
{
minja::Parser::parseArray((minja::Parser *)&v12);
if ( v12 )
{
*(_QWORD *)this = v12;
*((_QWORD *)this + 1) = v13;
}
else
{
minja::Parser::parseDictionary(this);
if ( !*(_QWORD *)this )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected value expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v13 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v13);
}
if ( *((_QWORD *)&v11 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v11 + 1));
}
if ( *((_QWORD *)&v19 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v19 + 1));
}
}
}
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
return this;
}
| operator():
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa0
MOV RBX,RDI
MOV R14,qword ptr [RSI]
MOV RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x30],RAX
TEST RAX,RAX
JZ 0x00141b49
MOV RCX,qword ptr [0x001effa0]
CMP byte ptr [RCX],0x0
JZ 0x00141b45
INC dword ptr [RAX + 0x8]
JMP 0x00141b49
LAB_00141b45:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00141b49:
MOV RAX,qword ptr [R14 + 0x20]
SUB RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RSP + 0x38],RAX
LAB_00141b56:
LEA RDI,[RSP + 0x40]
MOV RSI,R14
CALL 0x001425fe
MOV R8,qword ptr [RSP + 0x40]
TEST R8,R8
JZ 0x00141bc2
LEA RDI,[RSP + 0x58]
MOV qword ptr [RDI + -0x8],0x0
LAB_00141b7a:
LEA RSI,[RSP + 0x50]
MOV RDX,RSP
LEA RCX,[RSP + 0x28]
CALL 0x0014f258
MOVAPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RBX],XMM0
LAB_00141b94:
MOV RDI,qword ptr [RSP + 0x48]
TEST RDI,RDI
JZ 0x00141ba3
CALL 0x0012f80e
LAB_00141ba3:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x00141bb2
CALL 0x0012f80e
LAB_00141bb2:
MOV RAX,RBX
ADD RSP,0xa0
POP RBX
POP R14
POP R15
RET
LAB_00141bc2:
MOV AL,byte ptr [0x001f0f00]
TEST AL,AL
JZ 0x00141dc6
LAB_00141bd0:
LEA RDX,[0x1f0ee0]
LEA RDI,[RSP + 0x50]
MOV RSI,R14
MOV ECX,0x1
CALL 0x0012fd6a
LEA RAX,[RSP + 0x60]
MOV RDI,qword ptr [RAX + -0x10]
MOV R15,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x00141c08
MOV RSI,qword ptr [RSP + 0x60]
INC RSI
CALL 0x001186a0
LAB_00141c08:
TEST R15,R15
JZ 0x00141cee
LEA R14,[RSP + 0x90]
XOR R15D,R15D
MOV qword ptr [R14 + 0x8],R15
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14 + -0x40],XMM0
MOVAPS xmmword ptr [R14 + -0x30],XMM0
MOVAPS xmmword ptr [R14 + -0x20],XMM0
MOVAPS xmmword ptr [R14 + -0x10],XMM0
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013d970
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI + -0x8],R15
LAB_00141c5e:
MOV RSI,RSP
LEA RDX,[RSP + 0x18]
LEA RCX,[RSP + 0x28]
LEA R8,[RSP + 0x50]
CALL 0x0015611a
MOVAPS XMM0,xmmword ptr [RSP]
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RSP],RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d970
MOV RDI,R14
CALL 0x0014a5c0
MOV RDI,qword ptr [RSP + 0x88]
TEST RDI,RDI
JZ 0x00141cab
CALL 0x0012f80e
LAB_00141cab:
MOV RDI,qword ptr [RSP + 0x78]
TEST RDI,RDI
JZ 0x00141cba
CALL 0x0012f80e
LAB_00141cba:
MOV RDI,qword ptr [RSP + 0x68]
TEST RDI,RDI
JZ 0x00141cc9
CALL 0x0012f80e
LAB_00141cc9:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x00141b94
MOV RAX,qword ptr [0x001effa0]
CMP byte ptr [RAX],0x0
JZ 0x00141d16
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00141d20
LAB_00141cee:
LEA RDI,[RSP + 0x50]
MOV RSI,R14
CALL 0x001303fe
LAB_00141cfb:
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x00141d34
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RBX + 0x8],RAX
JMP 0x00141b94
LAB_00141d16:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00141d20:
CMP EAX,0x1
JNZ 0x00141b94
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
JMP 0x00141b94
LAB_00141d34:
MOV RDI,RSP
MOV RSI,R14
CALL 0x00142996
MOV RAX,qword ptr [RSP]
TEST RAX,RAX
JZ 0x00141d56
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x8],RAX
JMP 0x00141dae
LAB_00141d56:
LEA RDI,[RSP + 0x18]
MOV RSI,R14
CALL 0x00142ef6
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x00141d7b
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RBX + 0x8],RAX
JMP 0x00141d9f
LAB_00141d7b:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014351c
CMP qword ptr [RBX],0x0
JZ 0x00141e1d
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00141d9f
CALL 0x0012f80e
LAB_00141d9f:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00141dae
CALL 0x0012f80e
LAB_00141dae:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x00141b94
CALL 0x0012f80e
JMP 0x00141b94
LAB_00141dc6:
LEA RDI,[0x1f0f00]
CALL 0x00118be0
TEST EAX,EAX
JZ 0x00141bd0
LAB_00141dda:
LEA RDI,[0x1f0ee0]
LEA RSI,[0x1b73f5]
MOV EDX,0x10
CALL 0x0012f87e
LAB_00141df2:
LEA RDI,[0x12f8e6]
LEA RSI,[0x1f0ee0]
LEA RDX,[0x1f0698]
CALL 0x001185d0
LEA RDI,[0x1f0f00]
CALL 0x00118450
JMP 0x00141bd0
LAB_00141e1d:
MOV EDI,0x10
CALL 0x00118360
MOV R15,RAX
LAB_00141e2a:
LEA RSI,[0x1b73fc]
MOV RDI,RAX
CALL 0x00118270
LAB_00141e39:
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,R15
CALL 0x00118b30
|
/* minja::Parser::parseValueExpression()::{lambda()#1}::TEMPNAMEPLACEHOLDERVALUE() const */
_lambda___1_ * __thiscall
minja::Parser::parseValueExpression()::{lambda()#1}::operator()(_lambda___1_ *this)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Var1;
int8 *puVar2;
int iVar3;
runtime_error *this_00;
long *in_RSI;
bool bVar4;
long local_b8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *ap_Stack_b0 [2];
long local_a0;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
int8 local_90;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_88;
long local_80;
long local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_70;
long *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_60;
long local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_50;
int8 local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_40;
int8 local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *p_Stack_30;
data local_28 [8];
int8 local_20;
puVar2 = (int8 *)*in_RSI;
local_90 = *puVar2;
local_88 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)puVar2[1];
if (local_88 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001effa0 == '\0') {
LOCK();
*(int *)(local_88 + 8) = *(int *)(local_88 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_88 + 8) = *(int *)(local_88 + 8) + 1;
}
}
local_80 = puVar2[4] - puVar2[2];
/* try { // try from 00141b56 to 00141b62 has its CatchHandler @ 00141ee3 */
parseConstant();
if (local_78 == 0) {
if (operator()()::null_regex_abi_cxx11_ == '\0') {
iVar3 = __cxa_guard_acquire(&operator()()::null_regex_abi_cxx11_);
if (iVar3 != 0) {
/* try { // try from 00141dda to 00141df1 has its CatchHandler @ 00141e4f */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
operator()()::null_regex_abi_cxx11_,"null\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
operator()()::null_regex_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&operator()()::null_regex_abi_cxx11_);
}
}
/* try { // try from 00141bd0 to 00141be8 has its CatchHandler @ 00141ecd */
consumeToken(&local_68,puVar2,operator()()::null_regex_abi_cxx11_,1);
p_Var1 = p_Stack_60;
if (local_68 != &local_58) {
operator_delete(local_68,local_58 + 1);
}
if (p_Var1 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
/* try { // try from 00141cee to 00141cfa has its CatchHandler @ 00141ebc */
parseIdentifier();
if (local_68 == (long *)0x0) {
/* try { // try from 00141d34 to 00141d3e has its CatchHandler @ 00141ea8 */
parseBracedExpressionOrArray();
if (local_b8 == 0) {
/* try { // try from 00141d56 to 00141d62 has its CatchHandler @ 00141e94 */
parseArray();
if (local_a0 == 0) {
/* try { // try from 00141d7b to 00141d85 has its CatchHandler @ 00141e80 */
parseDictionary();
if (*(long *)this == 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00141e2a to 00141e38 has its CatchHandler @ 00141e65 */
std::runtime_error::runtime_error(this_00,"Expected value expression");
/* try { // try from 00141e39 to 00141e4e has its CatchHandler @ 00141e60 */
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
}
else {
*(long *)this = local_a0;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 8) = local_98;
}
if (ap_Stack_b0[0] != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(ap_Stack_b0[0]);
}
}
else {
*(long *)this = local_b8;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 8) = ap_Stack_b0[0];
}
if (p_Stack_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_60);
}
}
else {
*(long **)this = local_68;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 8) = p_Stack_60;
}
}
else {
local_20 = 0;
local_68 = (long *)0x0;
p_Stack_60 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_58 = 0;
p_Stack_50 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_48 = 0;
p_Stack_40 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_38 = 0;
p_Stack_30 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
local_28[0] = (data)0x0;
bVar4 = SUB81(local_28,0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar4);
local_b8 = 0;
/* try { // try from 00141c5e to 00141c74 has its CatchHandler @ 00141ebe */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<minja::LiteralExpr,std::allocator<minja::LiteralExpr>,minja::Location&,minja::Value>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)ap_Stack_b0,&local_b8,&local_a0,
&local_90,&local_68);
p_Var1 = ap_Stack_b0[0];
ap_Stack_b0[0] = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0;
*(long *)this = local_b8;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 8) = p_Var1;
local_b8 = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
if (p_Stack_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_30);
}
if (p_Stack_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_40);
}
if (p_Stack_50 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(p_Stack_50);
}
if (p_Stack_60 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_001effa0 == '\0') {
LOCK();
p_Var1 = p_Stack_60 + 0xc;
iVar3 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)(p_Stack_60 + 0xc);
*(int *)(p_Stack_60 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*(long *)p_Stack_60 + 0x18))();
}
}
}
}
else {
local_68 = (long *)0x0;
/* try { // try from 00141b7a to 00141b8b has its CatchHandler @ 00141ecf */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<minja::LiteralExpr,std::allocator<minja::LiteralExpr>,minja::Location&,minja::Value&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&p_Stack_60,&local_68,&local_b8,
&local_90);
*(long **)this = local_68;
*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 8) = p_Stack_60;
}
if (local_70 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_70);
}
if (local_88 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_88);
}
return this;
}
|
|
2,679 | my_fopen | eloqsql/mysys/my_fopen.c | FILE *my_fopen(const char *filename, int flags, myf MyFlags)
{
FILE *fd;
char type[10];
DBUG_ENTER("my_fopen");
DBUG_PRINT("my",("Name: '%s' flags: %d MyFlags: %lu",
filename, flags, MyFlags));
make_ftype(type,flags);
#ifdef _WIN32
fd= my_win_fopen(filename, type);
#else
fd= fopen(filename, type);
#endif
if (fd != 0)
{
/*
The test works if MY_NFILE < 128. The problem is that fileno() is char
on some OS (SUNOS). Actually the filename save isn't that important
so we can ignore if this doesn't work.
*/
int filedesc= my_fileno(fd);
if ((uint)filedesc >= my_file_limit)
{
statistic_increment(my_stream_opened,&THR_LOCK_open);
DBUG_RETURN(fd); /* safeguard */
}
my_file_info[filedesc].name= my_strdup(key_memory_my_file_info, filename, MyFlags);
statistic_increment(my_stream_opened, &THR_LOCK_open);
statistic_increment(my_file_total_opened, &THR_LOCK_open);
my_file_info[filedesc].type= STREAM_BY_FOPEN;
DBUG_PRINT("exit",("stream: %p", fd));
DBUG_RETURN(fd);
}
else
my_errno=errno;
DBUG_PRINT("error",("Got error %d on open",my_errno));
if (MyFlags & (MY_FFNF | MY_FAE | MY_WME))
my_error((flags & O_RDONLY) ? EE_FILENOTFOUND : EE_CANTCREATEFILE,
MYF(ME_BELL), filename, my_errno);
DBUG_RETURN((FILE*) 0);
} | O0 | c | my_fopen:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
jmp 0x83122
leaq -0x12(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x832b0
movq -0x28(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x29430
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x83214
movq -0x40(%rbp), %rdi
callq 0x83810
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
leaq 0x1c2fa0(%rip), %rcx # 0x246100
cmpl (%rcx), %eax
jb 0x83189
leaq 0x3832e5(%rip), %rax # 0x406450
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x3832d7(%rip), %rax # 0x406450
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8327f
leaq 0x383814(%rip), %rax # 0x4069a4
movl (%rax), %edi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x8adb0
movq %rax, %rcx
leaq 0x1c2f5f(%rip), %rax # 0x246108
movq (%rax), %rax
movslq -0x44(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
leaq 0x38328f(%rip), %rax # 0x406450
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x383281(%rip), %rax # 0x406450
movq %rcx, (%rax)
leaq 0x383287(%rip), %rax # 0x406460
movq (%rax), %rcx
addq $0x1, %rcx
leaq 0x383279(%rip), %rax # 0x406460
movq %rcx, (%rax)
leaq 0x1c2f17(%rip), %rax # 0x246108
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x3, 0x8(%rax)
jmp 0x83208
jmp 0x8320a
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8327f
callq 0x29040
movl (%rax), %eax
movl %eax, -0x48(%rbp)
callq 0x8d620
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x8322a
jmp 0x8322c
movq -0x38(%rbp), %rax
andq $0x19, %rax
cmpq $0x0, %rax
je 0x83275
movl -0x2c(%rbp), %edx
andl $0x0, %edx
movl $0x1, %eax
movl $0x1d, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x8d620
movl -0x54(%rbp), %edi
movq -0x50(%rbp), %rdx
movl (%rax), %ecx
movl $0x4, %esi
movb $0x0, %al
callq 0x82bd0
jmp 0x83277
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x832a3
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
callq 0x29420
nopl (%rax,%rax)
| my_fopen:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
jmp short $+2
loc_83122:
lea rdi, [rbp+var_12]
mov esi, [rbp+var_2C]
call make_ftype
mov rdi, [rbp+var_28]
lea rsi, [rbp+var_12]
call _fopen64
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
jz loc_83214
mov rdi, [rbp+var_40]
call my_fileno
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
lea rcx, my_file_limit
cmp eax, [rcx]
jb short loc_83189
lea rax, my_stream_opened
mov rcx, [rax]
add rcx, 1
lea rax, my_stream_opened
mov [rax], rcx
mov rax, [rbp+var_40]
mov [rbp+var_20], rax
jmp loc_8327F
loc_83189:
lea rax, key_memory_my_file_info
mov edi, [rax]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call my_strdup
mov rcx, rax
lea rax, my_file_info
mov rax, [rax]
movsxd rdx, [rbp+var_44]
shl rdx, 4
add rax, rdx
mov [rax], rcx
lea rax, my_stream_opened
mov rcx, [rax]
add rcx, 1
lea rax, my_stream_opened
mov [rax], rcx
lea rax, my_file_total_opened
mov rcx, [rax]
add rcx, 1
lea rax, my_file_total_opened
mov [rax], rcx
lea rax, my_file_info
mov rax, [rax]
movsxd rcx, [rbp+var_44]
shl rcx, 4
add rax, rcx
mov dword ptr [rax+8], 3
jmp short $+2
loc_83208:
jmp short $+2
loc_8320A:
mov rax, [rbp+var_40]
mov [rbp+var_20], rax
jmp short loc_8327F
loc_83214:
call ___errno_location
mov eax, [rax]
mov [rbp+var_48], eax
call _my_thread_var
mov ecx, [rbp+var_48]
mov [rax], ecx
jmp short $+2
loc_8322A:
jmp short $+2
loc_8322C:
mov rax, [rbp+var_38]
and rax, 19h
cmp rax, 0
jz short loc_83275
mov edx, [rbp+var_2C]
and edx, 0
mov eax, 1
mov ecx, 1Dh
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_54], eax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
call _my_thread_var
mov edi, [rbp+var_54]
mov rdx, [rbp+var_50]
mov ecx, [rax]
mov esi, 4
mov al, 0
call my_error
loc_83275:
jmp short $+2
loc_83277:
mov [rbp+var_20], 0
loc_8327F:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_832A3
mov rax, [rbp+var_60]
add rsp, 60h
pop rbp
retn
loc_832A3:
call ___stack_chk_fail
| long long my_fopen(long long a1, unsigned int a2, long long a3)
{
unsigned int *v3; // rax
int v5; // [rsp+18h] [rbp-48h]
unsigned int v6; // [rsp+1Ch] [rbp-44h]
long long v7; // [rsp+20h] [rbp-40h]
char v10[10]; // [rsp+4Eh] [rbp-12h] BYREF
unsigned long long v11; // [rsp+58h] [rbp-8h]
v11 = __readfsqword(0x28u);
make_ftype(v10, a2);
v7 = fopen64(a1, v10);
if ( v7 )
{
v6 = my_fileno(v7);
if ( v6 < my_file_limit )
{
*((_QWORD *)my_file_info + 2 * (int)v6) = my_strdup(key_memory_my_file_info, a1, a3);
++my_stream_opened;
++my_file_total_opened;
*((_DWORD *)my_file_info + 4 * (int)v6 + 2) = 3;
}
else
{
++my_stream_opened;
}
return v7;
}
else
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, v10) = v5;
if ( (a3 & 0x19) != 0 )
{
v3 = (unsigned int *)my_thread_var(a1, v10);
my_error(1u, 4LL, a1, *v3);
}
return 0LL;
}
}
| my_fopen:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
JMP 0x00183122
LAB_00183122:
LEA RDI,[RBP + -0x12]
MOV ESI,dword ptr [RBP + -0x2c]
CALL 0x001832b0
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x12]
CALL 0x00129430
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
JZ 0x00183214
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00183810
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
LEA RCX,[0x346100]
CMP EAX,dword ptr [RCX]
JC 0x00183189
LEA RAX,[0x506450]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x506450]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0018327f
LAB_00183189:
LEA RAX,[0x5069a4]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x0018adb0
MOV RCX,RAX
LEA RAX,[0x346108]
MOV RAX,qword ptr [RAX]
MOVSXD RDX,dword ptr [RBP + -0x44]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LEA RAX,[0x506450]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x506450]
MOV qword ptr [RAX],RCX
LEA RAX,[0x506460]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
LEA RAX,[0x506460]
MOV qword ptr [RAX],RCX
LEA RAX,[0x346108]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RBP + -0x44]
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RAX + 0x8],0x3
JMP 0x00183208
LAB_00183208:
JMP 0x0018320a
LAB_0018320a:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0018327f
LAB_00183214:
CALL 0x00129040
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
CALL 0x0018d620
MOV ECX,dword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
JMP 0x0018322a
LAB_0018322a:
JMP 0x0018322c
LAB_0018322c:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x19
CMP RAX,0x0
JZ 0x00183275
MOV EDX,dword ptr [RBP + -0x2c]
AND EDX,0x0
MOV EAX,0x1
MOV ECX,0x1d
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
CALL 0x0018d620
MOV EDI,dword ptr [RBP + -0x54]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RAX]
MOV ESI,0x4
MOV AL,0x0
CALL 0x00182bd0
LAB_00183275:
JMP 0x00183277
LAB_00183277:
MOV qword ptr [RBP + -0x20],0x0
LAB_0018327f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001832a3
MOV RAX,qword ptr [RBP + -0x60]
ADD RSP,0x60
POP RBP
RET
LAB_001832a3:
CALL 0x00129420
|
/* WARNING: Removing unreachable block (ram,0x0018324d) */
FILE * my_fopen(char *param_1,int4 param_2,ulong param_3)
{
int iVar1;
uint uVar2;
int8 uVar3;
int *piVar4;
int4 *puVar5;
long in_FS_OFFSET;
FILE *local_28;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
make_ftype(local_1a,param_2);
local_28 = fopen64(param_1,local_1a);
if (local_28 == (FILE *)0x0) {
piVar4 = __errno_location();
iVar1 = *piVar4;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if ((param_3 & 0x19) != 0) {
puVar5 = (int4 *)_my_thread_var();
my_error(1,4,param_1,*puVar5);
}
local_28 = (FILE *)0x0;
}
else {
uVar2 = my_fileno(local_28);
if (uVar2 < my_file_limit) {
uVar3 = my_strdup(key_memory_my_file_info,param_1,param_3);
*(int8 *)(my_file_info + (long)(int)uVar2 * 0x10) = uVar3;
my_stream_opened = my_stream_opened + 1;
my_file_total_opened = my_file_total_opened + 1;
*(int4 *)(my_file_info + (long)(int)uVar2 * 0x10 + 8) = 3;
}
else {
my_stream_opened = my_stream_opened + 1;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_28;
}
|
|
2,680 | arena_reset | tsotchke[P]eshkol/src/core/memory/arena.c | void arena_reset(Arena* arena) {
assert(arena != NULL);
// Reset all blocks
Block* block = arena->first;
while (block) {
block->used = 0;
block = block->next;
}
// Reset arena stats
arena->total_used = 0;
arena->allocation_count = 0;
} | O0 | c | arena_reset:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4915
jmp 0x4934
leaq 0x4757(%rip), %rdi # 0x9073
leaq 0x5e7a(%rip), %rsi # 0xa79d
movl $0xab, %edx
leaq 0x5f73(%rip), %rcx # 0xa8a2
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4960
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4940
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
| arena_reset:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
cmp [rbp+var_8], 0
jz short loc_4915
jmp short loc_4934
loc_4915:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0ABh
lea rcx, aVoidArenaReset; "void arena_reset(Arena *)"
call ___assert_fail
loc_4934:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_10], rax
loc_4940:
cmp [rbp+var_10], 0
jz short loc_4960
mov rax, [rbp+var_10]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_10], rax
jmp short loc_4940
loc_4960:
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+18h], 0
add rsp, 10h
pop rbp
retn
| _QWORD * arena_reset(_QWORD *a1)
{
_QWORD *result; // rax
_QWORD *i; // [rsp+0h] [rbp-10h]
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
171LL,
"void arena_reset(Arena *)");
for ( i = (_QWORD *)a1[1]; i; i = (_QWORD *)*i )
i[2] = 0LL;
a1[2] = 0LL;
result = a1;
a1[3] = 0LL;
return result;
}
| arena_reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00104915
JMP 0x00104934
LAB_00104915:
LEA RDI,[0x109073]
LEA RSI,[0x10a79d]
MOV EDX,0xab
LEA RCX,[0x10a8a2]
CALL 0x00101080
LAB_00104934:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_00104940:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00104960
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00104940
LAB_00104960:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],0x0
ADD RSP,0x10
POP RBP
RET
|
void arena_reset(long param_1)
{
int8 *local_18;
if (param_1 != 0) {
for (local_18 = *(int8 **)(param_1 + 8); local_18 != (int8 *)0x0;
local_18 = (int8 *)*local_18) {
local_18[2] = 0;
}
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
0xab,"void arena_reset(Arena *)");
}
|
|
2,681 | arena_reset | tsotchke[P]eshkol/src/core/memory/arena.c | void arena_reset(Arena* arena) {
assert(arena != NULL);
// Reset all blocks
Block* block = arena->first;
while (block) {
block->used = 0;
block = block->next;
}
// Reset arena stats
arena->total_used = 0;
arena->allocation_count = 0;
} | O1 | c | arena_reset:
pushq %rax
testq %rdi, %rdi
je 0x4147
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x413e
movq $0x0, 0x10(%rax)
movq (%rax), %rax
jmp 0x412c
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
popq %rax
retq
leaq 0x2eda(%rip), %rdi # 0x7028
leaq 0x461f(%rip), %rsi # 0x8774
leaq 0x471d(%rip), %rcx # 0x8879
movl $0xab, %edx
callq 0x1090
| arena_reset:
push rax
test rdi, rdi
jz short loc_4147
mov rax, [rdi+8]
loc_412C:
test rax, rax
jz short loc_413E
mov qword ptr [rax+10h], 0
mov rax, [rax]
jmp short loc_412C
loc_413E:
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
pop rax
retn
loc_4147:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidArenaReset; "void arena_reset(Arena *)"
mov edx, 0ABh
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> arena_reset(long long a1)
{
_QWORD *i; // rax
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
171LL,
"void arena_reset(Arena *)");
for ( i = *(_QWORD **)(a1 + 8); i; i = (_QWORD *)*i )
i[2] = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
}
| arena_reset:
PUSH RAX
TEST RDI,RDI
JZ 0x00104147
MOV RAX,qword ptr [RDI + 0x8]
LAB_0010412c:
TEST RAX,RAX
JZ 0x0010413e
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RAX]
JMP 0x0010412c
LAB_0010413e:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
POP RAX
RET
LAB_00104147:
LEA RDI,[0x107028]
LEA RSI,[0x108774]
LEA RCX,[0x108879]
MOV EDX,0xab
CALL 0x00101090
|
int8 arena_reset(long param_1)
{
int8 in_RAX;
int8 *puVar1;
if (param_1 != 0) {
for (puVar1 = *(int8 **)(param_1 + 8); puVar1 != (int8 *)0x0;
puVar1 = (int8 *)*puVar1) {
puVar1[2] = 0;
}
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
return in_RAX;
}
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
0xab,"void arena_reset(Arena *)");
}
|
|
2,682 | arena_reset | tsotchke[P]eshkol/src/core/memory/arena.c | void arena_reset(Arena* arena) {
assert(arena != NULL);
// Reset all blocks
Block* block = arena->first;
while (block) {
block->used = 0;
block = block->next;
}
// Reset arena stats
arena->total_used = 0;
arena->allocation_count = 0;
} | O3 | c | arena_reset:
pushq %rax
testq %rdi, %rdi
je 0x4157
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x414e
movq $0x0, 0x10(%rax)
movq (%rax), %rax
jmp 0x413c
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
popq %rax
retq
leaq 0x2eca(%rip), %rdi # 0x7028
leaq 0x462b(%rip), %rsi # 0x8790
leaq 0x4729(%rip), %rcx # 0x8895
movl $0xab, %edx
callq 0x1090
| arena_reset:
push rax
test rdi, rdi
jz short loc_4157
mov rax, [rdi+8]
loc_413C:
test rax, rax
jz short loc_414E
mov qword ptr [rax+10h], 0
mov rax, [rax]
jmp short loc_413C
loc_414E:
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
pop rax
retn
loc_4157:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidArenaReset; "void arena_reset(Arena *)"
mov edx, 0ABh
call ___assert_fail
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> arena_reset(long long a1)
{
_QWORD *i; // rax
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
171LL,
"void arena_reset(Arena *)");
for ( i = *(_QWORD **)(a1 + 8); i; i = (_QWORD *)*i )
i[2] = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
}
| arena_reset:
PUSH RAX
TEST RDI,RDI
JZ 0x00104157
MOV RAX,qword ptr [RDI + 0x8]
LAB_0010413c:
TEST RAX,RAX
JZ 0x0010414e
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RAX]
JMP 0x0010413c
LAB_0010414e:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
POP RAX
RET
LAB_00104157:
LEA RDI,[0x107028]
LEA RSI,[0x108790]
LEA RCX,[0x108895]
MOV EDX,0xab
CALL 0x00101090
|
int8 arena_reset(long param_1)
{
int8 in_RAX;
int8 *puVar1;
if (param_1 != 0) {
for (puVar1 = *(int8 **)(param_1 + 8); puVar1 != (int8 *)0x0;
puVar1 = (int8 *)*puVar1) {
puVar1[2] = 0;
}
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
return in_RAX;
}
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/memory/arena.c",
0xab,"void arena_reset(Arena *)");
}
|
|
2,683 | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::emplace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> emplace(const key_type& key, T&& t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(key, std::forward<T>(t));
return {std::prev(this->end()), true};
} | O3 | cpp | nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::emplace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %r15
cmpq %r15, %rbx
je 0x5ea86
movq (%r12), %r13
movq 0x8(%r12), %rbp
cmpq %rbp, 0x8(%rbx)
jne 0x5ea7d
testq %rbp, %rbp
je 0x5eaa1
movq (%rbx), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1a920
testl %eax, %eax
je 0x5eaa1
addq $0x30, %rbx
cmpq %r15, %rbx
jne 0x5ea60
movq %r14, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x5eab6
movq 0x8(%r14), %rbx
addq $-0x30, %rbx
movb $0x1, %dl
jmp 0x5eaa3
xorl %edx, %edx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
mov r15, [rdi+8]
cmp rbx, r15
jz short loc_5EA86
mov r13, [r12]
mov rbp, [r12+8]
loc_5EA60:
cmp [rbx+8], rbp
jnz short loc_5EA7D
test rbp, rbp
jz short loc_5EAA1
mov rdi, [rbx]
mov rsi, r13
mov rdx, rbp
call _bcmp
test eax, eax
jz short loc_5EAA1
loc_5EA7D:
add rbx, 30h ; '0'
cmp rbx, r15
jnz short loc_5EA60
loc_5EA86:
mov rdi, r14
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE12emplace_backIJRS7_SF_EEERSG_DpOT_; 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>>>::emplace_back<std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFD0h
mov dl, 1
jmp short loc_5EAA3
loc_5EAA1:
xor edx, edx
loc_5EAA3:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
_QWORD *a1,
long long *a2,
long long a3)
{
_QWORD *v3; // rbx
_QWORD *v4; // r15
long long v5; // r13
long long v6; // rbp
v3 = (_QWORD *)*a1;
v4 = (_QWORD *)a1[1];
if ( (_QWORD *)*a1 == v4 )
{
LABEL_7:
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::emplace_back<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>>(
a1,
a2,
a3);
return a1[1] - 48LL;
}
else
{
v5 = *a2;
v6 = a2[1];
while ( v3[1] != v6 || v6 && (unsigned int)bcmp(*v3, v5) )
{
v3 += 6;
if ( v3 == v4 )
goto LABEL_7;
}
}
return (long long)v3;
}
| emplace:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
MOV R15,qword ptr [RDI + 0x8]
CMP RBX,R15
JZ 0x0015ea86
MOV R13,qword ptr [R12]
MOV RBP,qword ptr [R12 + 0x8]
LAB_0015ea60:
CMP qword ptr [RBX + 0x8],RBP
JNZ 0x0015ea7d
TEST RBP,RBP
JZ 0x0015eaa1
MOV RDI,qword ptr [RBX]
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011a920
TEST EAX,EAX
JZ 0x0015eaa1
LAB_0015ea7d:
ADD RBX,0x30
CMP RBX,R15
JNZ 0x0015ea60
LAB_0015ea86:
MOV RDI,R14
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0015eab6
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x30
MOV DL,0x1
JMP 0x0015eaa3
LAB_0015eaa1:
XOR EDX,EDX
LAB_0015eaa3:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::string const,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > > >::emplace(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>&&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this,string *param_1,basic_json *param_2)
{
int8 *puVar1;
void *__s2;
size_t __n;
int iVar2;
int8 extraout_RDX;
int8 uVar3;
int8 *puVar4;
int1 auVar5 [16];
puVar4 = *(int8 **)this;
puVar1 = *(int8 **)(this + 8);
if (puVar4 != puVar1) {
__s2 = *(void **)param_1;
__n = *(size_t *)(param_1 + 8);
do {
if (puVar4[1] == __n) {
if (__n != 0) {
iVar2 = bcmp((void *)*puVar4,__s2,__n);
if (iVar2 != 0) goto LAB_0015ea7d;
}
uVar3 = 0;
goto LAB_0015eaa3;
}
LAB_0015ea7d:
puVar4 = puVar4 + 6;
} while (puVar4 != puVar1);
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::
emplace_back<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<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)this,param_1,param_2);
puVar4 = (int8 *)(*(long *)(this + 8) + -0x30);
uVar3 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0015eaa3:
auVar5._8_8_ = uVar3;
auVar5._0_8_ = puVar4;
return auVar5;
}
|
|
2,684 | PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024, PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex>>, 2>::deallocate(PFS_mutex*) | eloqsql/storage/perfschema/pfs_buffer_container.h | void deallocate(value_type *safe_pfs)
{
/*
One issue here is that we do not know which partition
the record belongs to.
Each record points to the parent page,
and each page points to the parent buffer,
so using static_deallocate here,
which will find the correct partition by itself.
*/
B::static_deallocate(safe_pfs);
} | O0 | c | PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024, PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex>>, 2>::deallocate(PFS_mutex*):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42a40
addq $0x10, %rsp
popq %rbp
retq
nop
| _ZN41PFS_partitioned_buffer_scalable_containerI29PFS_buffer_scalable_containerI9PFS_mutexLi1024ELi1024E24PFS_buffer_default_arrayIS1_E28PFS_buffer_default_allocatorIS1_EELi2EE10deallocateEPS1_:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_10]
call _ZN29PFS_buffer_scalable_containerI9PFS_mutexLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE17static_deallocateEPS0_; PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>::static_deallocate(PFS_mutex*)
add rsp, 10h
pop rbp
retn
| long long PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>::deallocate(
long long a1,
long long a2)
{
return PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>::static_deallocate(a2);
}
| deallocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00142a40
ADD RSP,0x10
POP RBP
RET
|
/* PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex, 1024, 1024,
PFS_buffer_default_array<PFS_mutex>, PFS_buffer_default_allocator<PFS_mutex> >,
2>::deallocate(PFS_mutex*) */
void __thiscall
PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>
::deallocate(PFS_partitioned_buffer_scalable_container<PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>,2>
*this,PFS_mutex *param_1)
{
PFS_buffer_scalable_container<PFS_mutex,1024,1024,PFS_buffer_default_array<PFS_mutex>,PFS_buffer_default_allocator<PFS_mutex>>
::static_deallocate(param_1);
return;
}
|
|
2,685 | LefDefParser::lefwStartBeginext(char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwStartBeginext(const char *name)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState == LEFW_BEGINEXT_START ||
lefwState == LEFW_BEGINEXT)
return LEFW_BAD_ORDER;
if (!name || name == 0 || *name == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) "BEGINEXT \"%s\"", name);
// \n will be added later
else
fprintf(lefwFile, "BEGINEXT \"%s\"", name);
lefwState = LEFW_BEGINEXT_START;
lefwLines++;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwStartBeginext(char const*):
pushq %rbx
movq %rdi, %rdx
leaq 0x6b1cf(%rip), %rax # 0x8d0f0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x21f75
leaq 0x6b414(%rip), %rcx # 0x8d344
movl $0x2, %eax
cmpl $0x0, (%rcx)
je 0x21f7a
leaq 0x6b3ff(%rip), %rbx # 0x8d340
movl (%rbx), %ecx
cmpl $0x3, %ecx
je 0x21f7a
cmpl $0x14, %ecx
je 0x21f7a
movl $0x3, %eax
testq %rdx, %rdx
je 0x21f7a
cmpb $0x0, (%rdx)
je 0x21f7a
cmpb $0x1, 0x6b479(%rip) # 0x8d3dc
jne 0x21f7c
leaq 0x3a9f0(%rip), %rsi # 0x5c95c
xorl %eax, %eax
callq 0x55afd
jmp 0x21f8a
movl $0x1, %eax
popq %rbx
retq
leaq 0x3a9d9(%rip), %rsi # 0x5c95c
xorl %eax, %eax
callq 0x22e0
movl $0x3, (%rbx)
leaq 0x6b3a5(%rip), %rax # 0x8d33c
incl (%rax)
xorl %eax, %eax
jmp 0x21f7a
| _ZN12LefDefParser17lefwStartBeginextEPKc:
push rbx
mov rdx, rdi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_21F75
lea rcx, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
mov eax, 2
cmp dword ptr [rcx], 0
jz short loc_21F7A
lea rbx, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov ecx, [rbx]
cmp ecx, 3
jz short loc_21F7A
cmp ecx, 14h
jz short loc_21F7A
mov eax, 3
test rdx, rdx
jz short loc_21F7A
cmp byte ptr [rdx], 0
jz short loc_21F7A
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_21F7C
lea rsi, aBeginextS_0; "BEGINEXT \"%s\""
xor eax, eax
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_21F8A
loc_21F75:
mov eax, 1
loc_21F7A:
pop rbx
retn
loc_21F7C:
lea rsi, aBeginextS_0; "BEGINEXT \"%s\""
xor eax, eax
call _fprintf
loc_21F8A:
mov dword ptr [rbx], 3
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
xor eax, eax
jmp short loc_21F7A
| long long LefDefParser::lefwStartBeginext(
LefDefParser *this,
const char *a2,
long long 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 != 3 && LefDefParser::lefwState != 20 )
{
result = 3LL;
if ( this )
{
if ( *(_BYTE *)this )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)"BEGINEXT \"%s\"",
(_DWORD)this,
LefDefParser::lefwState,
a5,
a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "BEGINEXT \"%s\"", (const char *)this);
LefDefParser::lefwState = 3;
++LefDefParser::lefwLines;
return 0LL;
}
}
}
}
return result;
}
| lefwStartBeginext:
PUSH RBX
MOV RDX,RDI
LEA RAX,[0x18d0f0]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00121f75
LEA RCX,[0x18d344]
MOV EAX,0x2
CMP dword ptr [RCX],0x0
JZ 0x00121f7a
LEA RBX,[0x18d340]
MOV ECX,dword ptr [RBX]
CMP ECX,0x3
JZ 0x00121f7a
CMP ECX,0x14
JZ 0x00121f7a
MOV EAX,0x3
TEST RDX,RDX
JZ 0x00121f7a
CMP byte ptr [RDX],0x0
JZ 0x00121f7a
CMP byte ptr [0x0018d3dc],0x1
JNZ 0x00121f7c
LEA RSI,[0x15c95c]
XOR EAX,EAX
CALL 0x00155afd
JMP 0x00121f8a
LAB_00121f75:
MOV EAX,0x1
LAB_00121f7a:
POP RBX
RET
LAB_00121f7c:
LEA RSI,[0x15c95c]
XOR EAX,EAX
CALL 0x001022e0
LAB_00121f8a:
MOV dword ptr [RBX],0x3
LEA RAX,[0x18d33c]
INC dword ptr [RAX]
XOR EAX,EAX
JMP 0x00121f7a
|
/* LefDefParser::lefwStartBeginext(char const*) */
int8 LefDefParser::lefwStartBeginext(char *param_1)
{
int8 uVar1;
if (lefwFile == (_IO_FILE *)0x0) {
uVar1 = 1;
}
else {
uVar1 = 2;
if (lefwDidInit != 0) {
if ((((lefwState != 3) && (lefwState != 0x14)) && (uVar1 = 3, param_1 != (char *)0x0)) &&
(*param_1 != '\0')) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile,"BEGINEXT \"%s\"");
}
else {
fprintf(lefwFile,"BEGINEXT \"%s\"");
}
lefwState = 3;
lefwLines = lefwLines + 1;
uVar1 = 0;
}
}
}
return uVar1;
}
|
|
2,686 | js_error_get_prepareStackTrace | bluesky950520[P]quickjs/quickjs.c | static JSValue js_error_get_prepareStackTrace(JSContext *ctx, JSValue this_val)
{
JSValue val;
val = JS_ToObject(ctx, this_val);
if (JS_IsException(val))
return val;
JS_FreeValue(ctx, val);
return js_dup(ctx->error_prepare_stack);
} | O1 | c | js_error_get_prepareStackTrace:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x26ddd
cmpl $0x6, %edx
je 0x71e50
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x1d8c6
movq 0x128(%rbx), %rax
movq 0x130(%rbx), %rdx
movq %rax, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x71e50
movq 0x8(%rsp), %rcx
incl (%rcx)
addq $0x10, %rsp
popq %rbx
retq
| js_error_get_prepareStackTrace:
push rbx
sub rsp, 10h
mov rbx, rdi
call JS_ToObject
cmp edx, 6
jz short loc_71E50
mov rdi, [rbx+18h]
mov rsi, rax
call JS_FreeValueRT
mov rax, [rbx+128h]
mov rdx, [rbx+130h]
mov [rsp+18h+var_10], rax
cmp edx, 0FFFFFFF7h
jb short loc_71E50
mov rcx, [rsp+18h+var_10]
inc dword ptr [rcx]
loc_71E50:
add rsp, 10h
pop rbx
retn
| _DWORD * js_error_get_prepareStackTrace(
long long *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *result; // rax
long long v15; // rdx
result = JS_ToObject((long long)a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( (_DWORD)v15 != 6 )
{
JS_FreeValueRT(a1[3], result, v15);
result = (_DWORD *)a1[37];
if ( (unsigned int)a1[38] >= 0xFFFFFFF7 )
++*(_DWORD *)a1[37];
}
return result;
}
| |||
2,687 | js_error_get_prepareStackTrace | bluesky950520[P]quickjs/quickjs.c | static JSValue js_error_get_prepareStackTrace(JSContext *ctx, JSValue this_val)
{
JSValue val;
val = JS_ToObject(ctx, this_val);
if (JS_IsException(val))
return val;
JS_FreeValue(ctx, val);
return js_dup(ctx->error_prepare_stack);
} | O2 | c | js_error_get_prepareStackTrace:
pushq %rbx
movq %rdi, %rbx
callq 0x20b92
cmpl $0x6, %edx
je 0x5ffaf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
movq 0x128(%rbx), %rax
movq 0x130(%rbx), %rdx
cmpl $-0x9, %edx
jb 0x5ffaf
incl (%rax)
popq %rbx
retq
| js_error_get_prepareStackTrace:
push rbx
mov rbx, rdi
call JS_ToObject
cmp edx, 6
jz short loc_5FFAF
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
mov rax, [rbx+128h]
mov rdx, [rbx+130h]
cmp edx, 0FFFFFFF7h
jb short loc_5FFAF
inc dword ptr [rax]
loc_5FFAF:
pop rbx
retn
| _DWORD * js_error_get_prepareStackTrace(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *result; // rax
long long v15; // rdx
result = (_DWORD *)JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( (_DWORD)v15 != 6 )
{
JS_FreeValue(a1, (long long)result, v15);
result = *(_DWORD **)(a1 + 296);
if ( (unsigned int)*(_QWORD *)(a1 + 304) >= 0xFFFFFFF7 )
++*result;
}
return result;
}
| js_error_get_prepareStackTrace:
PUSH RBX
MOV RBX,RDI
CALL 0x00120b92
CMP EDX,0x6
JZ 0x0015ffaf
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
MOV RAX,qword ptr [RBX + 0x128]
MOV RDX,qword ptr [RBX + 0x130]
CMP EDX,-0x9
JC 0x0015ffaf
INC dword ptr [RAX]
LAB_0015ffaf:
POP RBX
RET
|
void js_error_get_prepareStackTrace(long param_1)
{
int1 auVar1 [12];
auVar1 = JS_ToObject();
if (auVar1._8_4_ != 6) {
JS_FreeValue(param_1,auVar1._0_8_);
if (0xfffffff6 < (uint)*(int8 *)(param_1 + 0x130)) {
**(int **)(param_1 + 0x128) = **(int **)(param_1 + 0x128) + 1;
}
}
return;
}
|
|
2,688 | mthd_my_send_cmd | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int
mthd_my_send_cmd(MYSQL *mysql,enum enum_server_command command, const char *arg,
size_t length, my_bool skip_check, void *opt_arg)
{
NET *net= &mysql->net;
int result= -1;
if (mysql->net.pvio == 0)
{
/* Do reconnect if possible */
if (mariadb_reconnect(mysql))
return(1);
}
if (mysql->status != MYSQL_STATUS_READY ||
mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
goto end;
}
if (IS_CONNHDLR_ACTIVE(mysql))
{
result= mysql->extension->conn_hdlr->plugin->set_connection(mysql, command, arg, length, skip_check, opt_arg);
if (result== -1)
return(result);
}
CLEAR_CLIENT_ERROR(mysql);
if (command == COM_QUERY ||
command == COM_STMT_PREPARE)
{
if ((mysql->options.client_flag & CLIENT_LOCAL_FILES) &&
mysql->options.extension && mysql->extension->auto_local_infile == WAIT_FOR_QUERY &&
arg && (*arg == 'l' || *arg == 'L'))
{
if (strncasecmp(arg, "load", 4) == 0)
mysql->extension->auto_local_infile= ACCEPT_FILE_REQUEST;
}
}
mysql->info=0;
mysql->affected_rows= ~(unsigned long long) 0;
ma_net_clear(net); /* Clear receive buffer */
if (!arg)
arg="";
if (net->extension->multi_status== COM_MULTI_ENABLED)
{
return net_add_multi_command(net, command, (const uchar *)arg, length);
}
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
{
my_set_error(mysql, CR_NET_PACKET_TOO_LARGE, SQLSTATE_UNKNOWN, 0);
goto end;
}
end_server(mysql);
if (mariadb_reconnect(mysql))
goto end;
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
goto end;
}
}
result=0;
if (net->extension->multi_status > COM_MULTI_OFF)
skip_check= 1;
if (!skip_check)
{
result= ((mysql->packet_length=ma_net_safe_read(mysql)) == packet_error ?
1 : 0);
}
end:
return(result);
} | O0 | c | mthd_my_send_cmd:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x16638
movq -0x10(%rbp), %rdi
callq 0x16a00
cmpb $0x0, %al
je 0x16636
movl $0x1, -0x4(%rbp)
jmp 0x169f1
jmp 0x16638
movq -0x10(%rbp), %rax
cmpl $0x0, 0x488(%rax)
jne 0x16657
movq -0x10(%rbp), %rax
movl 0x380(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x166c1
jmp 0x16659
movq -0x10(%rbp), %rax
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x49867(%rip), %rax # 0x5fee0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x4984d(%rip), %rax # 0x5fef0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
jmp 0x169eb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x16728
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x16728
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %r8b
movq -0x38(%rbp), %r9
movsbl %r8b, %r8d
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x16726
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x169f1
jmp 0x16728
jmp 0x1672a
movq -0x10(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x3515f(%rip), %rsi # 0x4b8a9
callq 0x133c0
movq -0x10(%rbp), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x1677a
movq -0x10(%rbp), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x1677c
cmpl $0x3, -0x14(%rbp)
je 0x1678c
cmpl $0x16, -0x14(%rbp)
jne 0x16811
movq -0x10(%rbp), %rax
movq 0x3a8(%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x1680f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x1680f
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movsbl 0x78(%rax), %eax
cmpl $0x1, %eax
jne 0x1680f
cmpq $0x0, -0x20(%rbp)
je 0x1680f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0x167e4
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x1680f
movq -0x20(%rbp), %rdi
leaq 0x350c0(%rip), %rsi # 0x4b8af
movl $0x4, %edx
callq 0x13570
cmpl $0x0, %eax
jne 0x1680d
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movb $0x2, 0x78(%rax)
jmp 0x1680f
jmp 0x16811
movq -0x10(%rbp), %rax
movq $0x0, 0x2e0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x338(%rax)
movq -0x40(%rbp), %rdi
callq 0x45c60
cmpq $0x0, -0x20(%rbp)
jne 0x1684a
leaq 0x34e5d(%rip), %rax # 0x4b6a3
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x2, (%rax)
jne 0x16879
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movzbl %al, %esi
callq 0x46cb0
movl %eax, -0x4(%rbp)
jmp 0x169f1
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x51(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x168a0
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x168ad
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdx
movb -0x51(%rbp), %al
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x46400
cmpl $0x0, %eax
je 0x1699c
movq -0x40(%rbp), %rax
cmpl $0x481, 0x90(%rax) # imm = 0x481
jne 0x16903
movq -0x10(%rbp), %rdi
leaq 0x495f5(%rip), %rax # 0x5fee0
movq (%rax), %rdx
movl $0x7e4, %esi # imm = 0x7E4
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x16150
jmp 0x169eb
movq -0x10(%rbp), %rdi
callq 0x16100
movq -0x10(%rbp), %rdi
callq 0x16a00
cmpb $0x0, %al
je 0x1691e
jmp 0x169eb
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x71(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16948
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x16958
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x46400
cmpl $0x0, %eax
je 0x1699a
movq -0x10(%rbp), %rdi
leaq 0x4955b(%rip), %rax # 0x5fee0
movq (%rax), %rdx
movl $0x7d6, %esi # imm = 0x7D6
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x16150
jmp 0x169eb
jmp 0x1699c
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x0, (%rax)
jbe 0x169b7
movb $0x1, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x169e9
movq -0x10(%rbp), %rdi
callq 0x15e40
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, 0x358(%rax)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x44(%rbp)
jmp 0x169eb
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| mthd_my_send_cmd:
push rbp
mov rbp, rsp
sub rsp, 90h
mov al, r8b
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_29], al
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov [rbp+var_44], 0FFFFFFFFh
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_16638
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_16636
mov [rbp+var_4], 1
jmp loc_169F1
loc_16636:
jmp short $+2
loc_16638:
mov rax, [rbp+var_10]
cmp dword ptr [rax+488h], 0
jnz short loc_16657
mov rax, [rbp+var_10]
mov eax, [rax+380h]
and eax, 8
cmp eax, 0
jz short loc_166C1
loc_16657:
jmp short $+2
loc_16659:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_10]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
jmp loc_169EB
loc_166C1:
mov rax, [rbp+var_10]
cmp qword ptr [rax+4F0h], 0
jz short loc_16728
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_16728
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8b, [rbp+var_29]
mov r9, [rbp+var_38]
movsx r8d, r8b
call rax
mov [rbp+var_44], eax
cmp [rbp+var_44], 0FFFFFFFFh
jnz short loc_16726
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
jmp loc_169F1
loc_16726:
jmp short $+2
loc_16728:
jmp short $+2
loc_1672A:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 0
mov rdi, [rbp+var_10]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+2A0h], 0
jz short loc_1677A
mov rax, [rbp+var_10]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_1677A:
jmp short $+2
loc_1677C:
cmp [rbp+var_14], 3
jz short loc_1678C
cmp [rbp+var_14], 16h
jnz loc_16811
loc_1678C:
mov rax, [rbp+var_10]
mov rax, [rax+3A8h]
and rax, 80h
cmp rax, 0
jz short loc_1680F
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_1680F
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
movsx eax, byte ptr [rax+78h]
cmp eax, 1
jnz short loc_1680F
cmp [rbp+var_20], 0
jz short loc_1680F
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jz short loc_167E4
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 4Ch ; 'L'
jnz short loc_1680F
loc_167E4:
mov rdi, [rbp+var_20]
lea rsi, aLoad; "load"
mov edx, 4
call _strncasecmp
cmp eax, 0
jnz short loc_1680D
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov byte ptr [rax+78h], 2
loc_1680D:
jmp short $+2
loc_1680F:
jmp short $+2
loc_16811:
mov rax, [rbp+var_10]
mov qword ptr [rax+2E0h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+338h], 0FFFFFFFFFFFFFFFFh
mov rdi, [rbp+var_40]
call ma_net_clear
cmp [rbp+var_20], 0
jnz short loc_1684A
lea rax, aExecuteTestWit+29h; ""
mov [rbp+var_20], rax
loc_1684A:
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 2
jnz short loc_16879
mov rdi, [rbp+var_40]
mov eax, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
movzx esi, al
call net_add_multi_command
mov [rbp+var_4], eax
jmp loc_169F1
loc_16879:
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov eax, [rbp+var_14]
mov [rbp+var_51], al
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
cmp [rbp+var_28], 0
jz short loc_168A0
mov rax, [rbp+var_28]
mov [rbp+var_68], rax
jmp short loc_168AD
loc_168A0:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_68], rax
loc_168AD:
mov rdx, [rbp+var_50]
mov al, [rbp+var_51]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_68]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz loc_1699C
mov rax, [rbp+var_40]
cmp dword ptr [rax+90h], 481h
jnz short loc_16903
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7E4h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp loc_169EB
loc_16903:
mov rdi, [rbp+var_10]
call end_server
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_1691E
jmp loc_169EB
loc_1691E:
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov eax, [rbp+var_14]
mov [rbp+var_71], al
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
cmp [rbp+var_28], 0
jz short loc_16948
mov rax, [rbp+var_28]
mov [rbp+var_88], rax
jmp short loc_16958
loc_16948:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_88], rax
loc_16958:
mov rdx, [rbp+var_70]
mov al, [rbp+var_71]
mov rdi, [rbp+var_80]
mov rcx, [rbp+var_88]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz short loc_1699A
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D6h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp short loc_169EB
loc_1699A:
jmp short $+2
loc_1699C:
mov [rbp+var_44], 0
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 0
jbe short loc_169B7
mov [rbp+var_29], 1
loc_169B7:
cmp [rbp+var_29], 0
jnz short loc_169E9
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov rdx, rax
mov rax, [rbp+var_10]
mov [rax+358h], rdx
mov esi, 0FFFFFFFFh
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovz eax, ecx
mov [rbp+var_44], eax
loc_169E9:
jmp short $+2
loc_169EB:
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
loc_169F1:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long mthd_my_send_cmd(long long a1, long long a2, char *a3, long long a4, char a5, long long a6)
{
long long v6; // rdx
long long v7; // rcx
int v8; // r8d
int v9; // r9d
long long v10; // rdx
long long v12; // [rsp+8h] [rbp-88h]
long long v13; // [rsp+28h] [rbp-68h]
unsigned int v14; // [rsp+4Ch] [rbp-44h]
v14 = -1;
if ( *(_QWORD *)a1 || !(unsigned __int8)mariadb_reconnect(a1) )
{
if ( *(_DWORD *)(a1 + 1160) || (*(_DWORD *)(a1 + 896) & 8) != 0 )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[14], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return v14;
}
if ( *(_QWORD *)(a1 + 1264) )
{
if ( **(_QWORD **)(a1 + 1264) )
{
v14 = (*(long long ( **)(long long, _QWORD, char *, long long, _QWORD, long long))(***(_QWORD ***)(a1 + 1264)
+ 112LL))(
a1,
(unsigned int)a2,
a3,
a4,
(unsigned int)a5,
a6);
if ( v14 == -1 )
return (unsigned int)-1;
}
}
*(_DWORD *)(a1 + 144) = 0;
strcpy(a1 + 663, "00000");
*(_BYTE *)(a1 + 151) = 0;
if ( *(_QWORD *)(a1 + 672) )
*(_DWORD *)(*(_QWORD *)(a1 + 672) + 4LL) = 0;
if ( ((_DWORD)a2 == 3 || (_DWORD)a2 == 22)
&& (*(_QWORD *)(a1 + 936) & 0x80LL) != 0
&& *(_QWORD *)(a1 + 1152)
&& *(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) == 1
&& a3
&& (*a3 == 108 || *a3 == 76)
&& !(unsigned int)strncasecmp(a3, "load", 4LL) )
{
*(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) = 2;
}
*(_QWORD *)(a1 + 736) = 0LL;
*(_QWORD *)(a1 + 824) = -1LL;
ma_net_clear(a1);
if ( !a3 )
a3 = "";
if ( **(_DWORD **)(a1 + 672) == 2 )
return (unsigned int)net_add_multi_command(a1, (unsigned __int8)a2, a3, a4);
if ( a4 )
v13 = a4;
else
v13 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v13, 0LL) )
{
if ( *(_DWORD *)(a1 + 144) == 1153 )
{
my_set_error(a1, 0x7E4u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
end_server((_QWORD *)a1);
if ( (unsigned __int8)mariadb_reconnect(a1) )
return v14;
if ( a4 )
v12 = a4;
else
v12 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v12, 0LL) )
{
my_set_error(a1, 0x7D6u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
}
v14 = 0;
if ( **(_DWORD **)(a1 + 672) )
a5 = 1;
if ( !a5 )
{
v10 = ma_net_safe_read(a1, a2, v6, v7, v8, v9);
*(_QWORD *)(a1 + 856) = v10;
return v10 == 0xFFFFFFFFLL;
}
return v14;
}
return 1;
}
| mthd_my_send_cmd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AL,R8B
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x44],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00116638
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00116a00
CMP AL,0x0
JZ 0x00116636
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001169f1
LAB_00116636:
JMP 0x00116638
LAB_00116638:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x488],0x0
JNZ 0x00116657
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x380]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001166c1
LAB_00116657:
JMP 0x00116659
LAB_00116659:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x15fee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x15fef0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
JMP 0x001169eb
LAB_001166c1:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00116728
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00116728
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8B,byte ptr [RBP + -0x29]
MOV R9,qword ptr [RBP + -0x38]
MOVSX R8D,R8B
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP dword ptr [RBP + -0x44],-0x1
JNZ 0x00116726
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001169f1
LAB_00116726:
JMP 0x00116728
LAB_00116728:
JMP 0x0011672a
LAB_0011672a:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RSI,[0x14b8a9]
CALL 0x001133c0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x0011677a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_0011677a:
JMP 0x0011677c
LAB_0011677c:
CMP dword ptr [RBP + -0x14],0x3
JZ 0x0011678c
CMP dword ptr [RBP + -0x14],0x16
JNZ 0x00116811
LAB_0011678c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3a8]
AND RAX,0x80
CMP RAX,0x0
JZ 0x0011680f
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0011680f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOVSX EAX,byte ptr [RAX + 0x78]
CMP EAX,0x1
JNZ 0x0011680f
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0011680f
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JZ 0x001167e4
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x4c
JNZ 0x0011680f
LAB_001167e4:
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[0x14b8af]
MOV EDX,0x4
CALL 0x00113570
CMP EAX,0x0
JNZ 0x0011680d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV byte ptr [RAX + 0x78],0x2
LAB_0011680d:
JMP 0x0011680f
LAB_0011680f:
JMP 0x00116811
LAB_00116811:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2e0],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x338],-0x1
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00145c60
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0011684a
LEA RAX,[0x14b6a3]
MOV qword ptr [RBP + -0x20],RAX
LAB_0011684a:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x00116879
MOV RDI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ESI,AL
CALL 0x00146cb0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001169f1
LAB_00116879:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001168a0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001168ad
LAB_001168a0:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x68],RAX
LAB_001168ad:
MOV RDX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RBP + -0x51]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x00146400
CMP EAX,0x0
JZ 0x0011699c
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x90],0x481
JNZ 0x00116903
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15fee0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7e4
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00116150
JMP 0x001169eb
LAB_00116903:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00116100
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00116a00
CMP AL,0x0
JZ 0x0011691e
JMP 0x001169eb
LAB_0011691e:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x71],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00116948
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00116958
LAB_00116948:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x88],RAX
LAB_00116958:
MOV RDX,qword ptr [RBP + -0x70]
MOV AL,byte ptr [RBP + -0x71]
MOV RDI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x00146400
CMP EAX,0x0
JZ 0x0011699a
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15fee0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d6
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00116150
JMP 0x001169eb
LAB_0011699a:
JMP 0x0011699c
LAB_0011699c:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x0
JBE 0x001169b7
MOV byte ptr [RBP + -0x29],0x1
LAB_001169b7:
CMP byte ptr [RBP + -0x29],0x0
JNZ 0x001169e9
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00115e40
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x358],RDX
MOV ESI,0xffffffff
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVZ EAX,ECX
MOV dword ptr [RBP + -0x44],EAX
LAB_001169e9:
JMP 0x001169eb
LAB_001169eb:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
LAB_001169f1:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
uint mthd_my_send_cmd(long *param_1,uint param_2,char *param_3,size_t param_4,char param_5,
int8 param_6)
{
char cVar1;
int iVar2;
uint uVar3;
long lVar4;
size_t local_90;
size_t local_70;
uint local_4c;
char local_31;
char *local_28;
local_4c = 0xffffffff;
if ((*param_1 == 0) && (cVar1 = mariadb_reconnect(param_1), cVar1 != '\0')) {
return 1;
}
if (((int)param_1[0x91] != 0) || ((*(uint *)(param_1 + 0x70) & 8) != 0)) {
*(int4 *)(param_1 + 0x12) = 0x7de;
strncpy((char *)((long)param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)((long)param_1 + 0x29c) = 0;
strncpy((char *)((long)param_1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_0015ff60,0x1ff);
*(int1 *)((long)param_1 + 0x296) = 0;
return 0xffffffff;
}
if (((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) &&
(local_4c = (**(code **)(**(long **)param_1[0x9e] + 0x70))
(param_1,param_2,param_3,param_4,(int)param_5,param_6),
local_4c == 0xffffffff)) {
return 0xffffffff;
}
*(int4 *)(param_1 + 0x12) = 0;
strcpy((char *)((long)param_1 + 0x297),"00000");
*(int1 *)((long)param_1 + 0x97) = 0;
if (param_1[0x54] != 0) {
*(int4 *)(param_1[0x54] + 4) = 0;
}
if (((((param_2 == 3) || (param_2 == 0x16)) &&
(((param_1[0x75] & 0x80U) != 0 &&
((param_1[0x90] != 0 && (*(char *)(param_1[0x9e] + 0x78) == '\x01')))))) &&
(param_3 != (char *)0x0)) &&
(((*param_3 == 'l' || (*param_3 == 'L')) && (iVar2 = strncasecmp(param_3,"load",4), iVar2 == 0)
))) {
*(int1 *)(param_1[0x9e] + 0x78) = 2;
}
param_1[0x5c] = 0;
param_1[0x67] = -1;
ma_net_clear(param_1);
local_28 = param_3;
if (param_3 == (char *)0x0) {
local_28 = "";
}
if (*(int *)param_1[0x54] != 2) {
local_70 = param_4;
if (param_4 == 0) {
local_70 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_70,0);
if (iVar2 != 0) {
if ((int)param_1[0x12] == 0x481) {
my_set_error(param_1,0x7e4,SQLSTATE_UNKNOWN,0);
return local_4c;
}
end_server(param_1);
cVar1 = mariadb_reconnect(param_1);
if (cVar1 != '\0') {
return local_4c;
}
local_90 = param_4;
if (param_4 == 0) {
local_90 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_90,0);
if (iVar2 != 0) {
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
return local_4c;
}
}
local_4c = 0;
local_31 = param_5;
if (*(int *)param_1[0x54] != 0) {
local_31 = '\x01';
}
if (local_31 == '\0') {
lVar4 = ma_net_safe_read(param_1);
param_1[0x6b] = lVar4;
local_4c = (uint)(lVar4 == 0xffffffff);
}
return local_4c;
}
uVar3 = net_add_multi_command(param_1,param_2 & 0xff,local_28,param_4);
return uVar3;
}
|
|
2,689 | ma_write_abort_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_write_abort_block_record(MARIA_HA *info)
{
my_bool res= 0;
MARIA_BITMAP_BLOCKS *blocks= &info->cur_row.insert_blocks;
MARIA_BITMAP_BLOCK *block, *end;
LSN lsn= LSN_IMPOSSIBLE;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_write_abort_block_record");
_ma_bitmap_lock(share); /* Lock bitmap from other insert threads */
if (delete_head_or_tail(info,
ma_recordpos_to_page(info->cur_row.lastpos),
ma_recordpos_to_dir_entry(info->cur_row.lastpos), 1,
0))
res= 1;
for (block= blocks->block + 1, end= block + blocks->count - 1; block < end;
block++)
{
if (block->used & BLOCKUSED_USED)
{
if (block->used & BLOCKUSED_TAIL)
{
/*
block->page_count is set to the tail directory entry number in
write_block_record()
*/
if (delete_head_or_tail(info, block->page,
block->page_count & ~TAIL_BIT,
0, 0))
res= 1;
}
else
{
if (free_full_page_range(info, block->page, block->page_count))
res= 1;
}
}
}
_ma_bitmap_unlock(share);
if (share->now_transactional)
{
/*
Write clr to mark end of aborted row insert.
The above delete_head_or_tail() calls will only log redo, not undo.
The undo just before the row insert is stored in row->orig_undo_lsn.
When applying undo's, we can skip all undo records between current
lsn and row->orig_undo_lsn as logically things are as before the
attempted insert.
*/
if (_ma_write_clr(info, info->cur_row.orig_undo_lsn,
LOGREC_UNDO_ROW_INSERT,
share->calc_checksum != 0,
(ha_checksum) 0 - info->cur_row.checksum,
&lsn, (void*) 0))
res= 1;
}
_ma_unpin_all_pages_and_finalize_row(info, lsn);
DBUG_RETURN(res);
} | O0 | c | ma_write_abort_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x43590
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x77200
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x77220
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x76e60
cmpb $0x0, %al
je 0x76d15
movb $0x1, -0x9(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $-0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x76dcf
movq -0x20(%rbp), %rax
movzbl 0x14(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x76dbc
movq -0x20(%rbp), %rax
movzbl 0x14(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x76d99
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
andl $0xffff7fff, %edx # imm = 0xFFFF7FFF
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x76e60
cmpb $0x0, %al
je 0x76d97
movb $0x1, -0x9(%rbp)
jmp 0x76dba
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x77240
cmpb $0x0, %al
je 0x76db8
movb $0x1, -0x9(%rbp)
jmp 0x76dba
jmp 0x76dbc
jmp 0x76dbe
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x76d3e
movq -0x38(%rbp), %rdi
callq 0x43660
movq -0x38(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x76e3b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rsi
movq -0x38(%rbp), %rax
cmpq $0x0, 0x6a8(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x8(%rbp), %rcx
xorl %r8d, %r8d
subl 0xb0(%rcx), %r8d
movl $0x12, %edx
leaq -0x30(%rbp), %r9
xorl %ecx, %ecx
movsbl %al, %ecx
movq $0x0, (%rsp)
callq 0x713d0
cmpb $0x0, %al
je 0x76e39
movb $0x1, -0x9(%rbp)
jmp 0x76e3b
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x77470
movb -0x9(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_write_abort_block_record:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_9], 0
mov rax, [rbp+var_8]
add rax, 80h
mov [rbp+var_18], rax
mov [rbp+var_30], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]
call _ma_bitmap_lock
mov rax, [rbp+var_8]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rdi, [rax+98h]
call ma_recordpos_to_page
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rdi, [rax+98h]
call ma_recordpos_to_dir_entry
mov rdi, [rbp+var_48]
mov rsi, [rbp+var_40]
mov edx, eax
mov ecx, 1
xor r8d, r8d
call delete_head_or_tail
cmp al, 0
jz short loc_76D15
mov [rbp+var_9], 1
loc_76D15:
mov rax, [rbp+var_18]
mov rax, [rax]
add rax, 18h
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov ecx, [rcx+8]
imul rcx, 18h
add rax, rcx
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_28], rax
loc_76D3E:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jnb loc_76DCF
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+14h]
and eax, 1
cmp eax, 0
jz short loc_76DBC
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+14h]
and eax, 4
cmp eax, 0
jz short loc_76D99
mov rdi, [rbp+var_8]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
and edx, 0FFFF7FFFh
xor r8d, r8d
mov ecx, r8d
call delete_head_or_tail
cmp al, 0
jz short loc_76D97
mov [rbp+var_9], 1
loc_76D97:
jmp short loc_76DBA
loc_76D99:
mov rdi, [rbp+var_8]
mov rax, [rbp+var_20]
mov rsi, [rax]
mov rax, [rbp+var_20]
mov edx, [rax+8]
call free_full_page_range
cmp al, 0
jz short loc_76DB8
mov [rbp+var_9], 1
loc_76DB8:
jmp short $+2
loc_76DBA:
jmp short $+2
loc_76DBC:
jmp short $+2
loc_76DBE:
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
jmp loc_76D3E
loc_76DCF:
mov rdi, [rbp+var_38]
call _ma_bitmap_unlock
mov rax, [rbp+var_38]
cmp byte ptr [rax+7E7h], 0
jz short loc_76E3B
mov rdi, [rbp+var_8]
mov rax, [rbp+var_8]
mov rsi, [rax+0B8h]
mov rax, [rbp+var_38]
cmp qword ptr [rax+6A8h], 0
setnz al
and al, 1
movzx eax, al
mov rcx, [rbp+var_8]
xor r8d, r8d
sub r8d, [rcx+0B0h]
mov edx, 12h
lea r9, [rbp+var_30]
xor ecx, ecx
movsx ecx, al
mov [rsp+60h+var_60], 0
call _ma_write_clr
cmp al, 0
jz short loc_76E39
mov [rbp+var_9], 1
loc_76E39:
jmp short $+2
loc_76E3B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
call _ma_unpin_all_pages_and_finalize_row_0
mov al, [rbp+var_9]
mov [rbp+var_49], al
mov al, [rbp+var_49]
add rsp, 60h
pop rbp
retn
| bool ma_write_abort_block_record(long long a1)
{
unsigned int v1; // eax
long long v3; // [rsp+20h] [rbp-40h]
long long v4; // [rsp+28h] [rbp-38h]
long long v5; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v6; // [rsp+38h] [rbp-28h]
unsigned long long v7; // [rsp+40h] [rbp-20h]
long long v8; // [rsp+48h] [rbp-18h]
bool v9; // [rsp+57h] [rbp-9h]
long long *v10; // [rsp+58h] [rbp-8h]
v10 = (long long *)a1;
v8 = a1 + 128;
v5 = 0LL;
v4 = *(_QWORD *)a1;
ma_bitmap_lock(*(_QWORD *)a1);
v3 = ma_recordpos_to_page(*(_QWORD *)(a1 + 152));
v1 = ma_recordpos_to_dir_entry(*(_QWORD *)(a1 + 152));
v9 = (unsigned __int8)delete_head_or_tail(a1, v3, v1, 1LL, 0LL) != 0;
v7 = *(_QWORD *)(a1 + 128) + 24LL;
v6 = 24LL * *(unsigned int *)(a1 + 136) + v7 - 24;
while ( v7 < v6 )
{
if ( (*(_BYTE *)(v7 + 20) & 1) != 0 )
{
if ( (*(_BYTE *)(v7 + 20) & 4) != 0 )
{
if ( (unsigned __int8)delete_head_or_tail(v10, *(_QWORD *)v7, *(_DWORD *)(v7 + 8) & 0xFFFF7FFF, 0LL, 0LL) )
v9 = 1;
}
else if ( (unsigned __int8)free_full_page_range(v10, *(_QWORD *)v7, *(unsigned int *)(v7 + 8)) )
{
v9 = 1;
}
}
v7 += 24LL;
}
ma_bitmap_unlock(v4);
if ( *(_BYTE *)(v4 + 2023)
&& ma_write_clr(v10, v10[23], 18, *(_QWORD *)(v4 + 1704) != 0LL, -*((_DWORD *)v10 + 44), (long long)&v5, 0LL) )
{
v9 = 1;
}
ma_unpin_all_pages_and_finalize_row_0(v10, v5);
return v9;
}
| _ma_write_abort_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x80
MOV qword ptr [RBP + -0x18],RAX
MOV qword ptr [RBP + -0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00143590
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x00177200
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x00177220
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,EAX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x00176e60
CMP AL,0x0
JZ 0x00176d15
MOV byte ptr [RBP + -0x9],0x1
LAB_00176d15:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RCX + 0x8]
IMUL RCX,RCX,0x18
ADD RAX,RCX
ADD RAX,-0x18
MOV qword ptr [RBP + -0x28],RAX
LAB_00176d3e:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x00176dcf
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00176dbc
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x14]
AND EAX,0x4
CMP EAX,0x0
JZ 0x00176d99
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
AND EDX,0xffff7fff
XOR R8D,R8D
MOV ECX,R8D
CALL 0x00176e60
CMP AL,0x0
JZ 0x00176d97
MOV byte ptr [RBP + -0x9],0x1
LAB_00176d97:
JMP 0x00176dba
LAB_00176d99:
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV EDX,dword ptr [RAX + 0x8]
CALL 0x00177240
CMP AL,0x0
JZ 0x00176db8
MOV byte ptr [RBP + -0x9],0x1
LAB_00176db8:
JMP 0x00176dba
LAB_00176dba:
JMP 0x00176dbc
LAB_00176dbc:
JMP 0x00176dbe
LAB_00176dbe:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00176d3e
LAB_00176dcf:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00143660
MOV RAX,qword ptr [RBP + -0x38]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x00176e3b
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x38]
CMP qword ptr [RAX + 0x6a8],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV RCX,qword ptr [RBP + -0x8]
XOR R8D,R8D
SUB R8D,dword ptr [RCX + 0xb0]
MOV EDX,0x12
LEA R9,[RBP + -0x30]
XOR ECX,ECX
MOVSX ECX,AL
MOV qword ptr [RSP],0x0
CALL 0x001713d0
CMP AL,0x0
JZ 0x00176e39
MOV byte ptr [RBP + -0x9],0x1
LAB_00176e39:
JMP 0x00176e3b
LAB_00176e3b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00177470
MOV AL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x49],AL
MOV AL,byte ptr [RBP + -0x49]
ADD RSP,0x60
POP RBP
RET
|
int1 _ma_write_abort_block_record(long *param_1)
{
long lVar1;
long *plVar2;
char cVar3;
int4 uVar4;
int8 uVar5;
int8 local_38;
int8 *local_30;
int8 *local_28;
long *local_20;
int1 local_11;
long *local_10;
local_11 = 0;
local_20 = param_1 + 0x10;
local_38 = 0;
lVar1 = *param_1;
local_10 = param_1;
_ma_bitmap_lock(lVar1);
plVar2 = local_10;
uVar5 = ma_recordpos_to_page(local_10[0x13]);
uVar4 = ma_recordpos_to_dir_entry(local_10[0x13]);
cVar3 = delete_head_or_tail(plVar2,uVar5,uVar4,1,0);
if (cVar3 != '\0') {
local_11 = 1;
}
local_28 = (int8 *)(*local_20 + 0x18);
local_30 = local_28 + (ulong)*(uint *)(local_20 + 1) * 3 + -3;
for (; local_28 < local_30; local_28 = local_28 + 3) {
if ((*(byte *)((long)local_28 + 0x14) & 1) != 0) {
if ((*(byte *)((long)local_28 + 0x14) & 4) == 0) {
cVar3 = free_full_page_range(local_10,*local_28,*(int4 *)(local_28 + 1));
if (cVar3 != '\0') {
local_11 = 1;
}
}
else {
cVar3 = delete_head_or_tail(local_10,*local_28,*(uint *)(local_28 + 1) & 0xffff7fff,0);
if (cVar3 != '\0') {
local_11 = 1;
}
}
}
}
_ma_bitmap_unlock(lVar1);
if ((*(char *)(lVar1 + 0x7e7) != '\0') &&
(cVar3 = _ma_write_clr(local_10,local_10[0x17],0x12,*(long *)(lVar1 + 0x6a8) != 0,
-(int)local_10[0x16],&local_38,0), cVar3 != '\0')) {
local_11 = 1;
}
_ma_unpin_all_pages_and_finalize_row(local_10,local_38);
return local_11;
}
|
|
2,690 | 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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/./json.hpp | bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
} | O1 | 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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4beee
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x4a044
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x497ca
testb %bpl, %bpl
je 0x4a022
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x4a022
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2c4cc
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x4bf28
leaq 0x20(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x487f0
movq %rax, 0x70(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %rbx, %rdi
callq 0x4bfb8
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x18260
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
jmp 0x4a068
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
movq %rbx, %rdi
callq 0x18b90
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_4A044
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_4A022
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_4A022
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
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 rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator[](std::string const&)
lea r14, [rsp+48h+var_28]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov [rbx+70h], rax
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_4A022:
lea rbx, [rsp+48h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_4A044:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea r14, [rsp+48h+var_28]
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()
jmp short loc_4A068
mov rbx, rax
loc_4A068:
lea r14, [rsp+48h+var_38]
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 rdi, rbx
call __Unwind_Resume
| 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>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v5; // [rsp+Bh] [rbp-3Dh] BYREF
int v6; // [rsp+Ch] [rbp-3Ch] BYREF
char v7[16]; // [rsp+10h] [rbp-38h] BYREF
char v8[40]; // [rsp+20h] [rbp-28h] BYREF
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v7);
v6 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v5 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, char *))(a1 + 152))(a1 + 128, &v6, &v5, v7);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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);
v3 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
*(_QWORD *)(a1 + 112) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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=(
v3,
(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>::assert_invariant(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>::data::~data(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>::assert_invariant(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>::data::~data(v7);
return 1;
}
| key:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
CALL 0x0014beee
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x4
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0014a044
LEA RDI,[RBX + 0x80]
LAB_00149fa4:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x001497ca
TEST BPL,BPL
JZ 0x0014a022
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x0014a022
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x20]
CALL 0x0012c4cc
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_00149ff4:
MOV RSI,R14
CALL 0x0014bf28
LEA R14,[RSP + 0x20]
MOV RDI,RAX
MOV RSI,R14
CALL 0x001487f0
MOV qword ptr [RBX + 0x70],RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R14
CALL 0x0014bfb8
LAB_0014a022:
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,RBX
CALL 0x0014bfb8
MOV AL,0x1
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0014a044:
CALL 0x00118260
|
/* 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> >::key(std::__cxx11::string&) */
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>>
::key(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,string *param_1)
{
bool bVar1;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar2;
int8 uVar3;
int1 local_3d;
int4 local_3c;
data local_38 [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_28 [16];
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_38);
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_3d = 4;
if (*(long *)(this + 0x90) != 0) {
/* try { // try from 00149fa4 to 00149fe7 has its CatchHandler @ 0014a065 */
bVar1 = (bool)(**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_3d,local_38);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar1);
if ((bVar1 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 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_28,(basic_json *)(this + 0xa8));
/* try { // try from 00149ff4 to 00149ffb has its CatchHandler @ 0014a049 */
pbVar2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
uVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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=(pbVar2,(data *)local_28);
*(int8 *)(this + 0x70) = uVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_28,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>
::data::~data((data *)local_28);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,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>
::data::~data(local_38);
return 1;
}
/* WARNING: Subroutine does not return */
/* try { // try from 0014a044 to 0014a048 has its CatchHandler @ 0014a065 */
std::__throw_bad_function_call();
}
|
|
2,691 | 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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | monkey531[P]llama/common/./json.hpp | bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
} | O2 | 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>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x455a0
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x4
popq %rdx
movq %r15, %rcx
callq 0x442d6
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x4357a
testb %bpl, %bpl
je 0x43e2c
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x43e2c
leaq 0xa8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2b5c6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x455d8
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x429ca
movq %rax, 0x70(%rbx)
movq %r14, %rdi
callq 0x2b1f0
leaq 0x18(%rsp), %rdi
callq 0x2b1f0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2b1f0
jmp 0x43e55
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2b1f0
movq %rbx, %rdi
callq 0x20b90
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+48h+var_30]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 4
pop rdx
mov rcx, r15
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> &)
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_43E2C
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_43E2C
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_40]
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 rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator[](std::string const&)
lea r14, [rsp+48h+var_40]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov [rbx+70h], rax
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_43E2C:
lea rdi, [rsp+48h+var_30]
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 al, 1
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
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_43E55
mov rbx, rax
loc_43E55:
lea rdi, [rsp+arg_10]
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
| 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>>::key(
_QWORD *a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
_BYTE v5[16]; // [rsp+8h] [rbp-40h] BYREF
_BYTE v6[48]; // [rsp+18h] [rbp-30h] BYREF
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v6);
v2 = 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 + 16,
(a1[2] - a1[1]) >> 3,
4LL,
v6);
std::vector<bool>::push_back((long long)(a1 + 9), v2);
if ( v2 && *(_QWORD *)(a1[2] - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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,
(long long)(a1 + 21));
v3 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(a1[2] - 8LL) + 8LL),
a2);
a1[14] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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=(
v3,
(long long)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>::~basic_json((long long)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>::~basic_json((long long)v6);
return 1;
}
| key:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x18]
MOV RDI,R15
CALL 0x001455a0
LEA RDI,[RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
LAB_00143dc2:
PUSH 0x4
POP RDX
MOV RCX,R15
CALL 0x001442d6
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x0014357a
TEST BPL,BPL
JZ 0x00143e2c
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x00143e2c
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x8]
CALL 0x0012b5c6
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_00143e08:
MOV RSI,R14
CALL 0x001455d8
LAB_00143e10:
LEA R14,[RSP + 0x8]
MOV RDI,RAX
MOV RSI,R14
CALL 0x001429ca
MOV qword ptr [RBX + 0x70],RAX
MOV RDI,R14
CALL 0x0012b1f0
LAB_00143e2c:
LEA RDI,[RSP + 0x18]
CALL 0x0012b1f0
MOV AL,0x1
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
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> >::key(std::__cxx11::string&) */
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>>
::key(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,string *param_1)
{
bool bVar1;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar2;
int8 uVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_40 [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_30 [16];
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_30);
/* try { // try from 00143dc2 to 00143dfb has its CatchHandler @ 00143e52 */
bVar1 = (bool)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()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,
4,local_30);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar1);
if ((bVar1 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 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_40,(basic_json *)(this + 0xa8));
/* try { // try from 00143e08 to 00143e0f has its CatchHandler @ 00143e43 */
pbVar2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
uVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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=(pbVar2,local_40);
*(int8 *)(this + 0x70) = uVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_40);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_30);
return 1;
}
|
|
2,692 | my_message_stderr | eloqsql/mysys/my_mess.c | void my_message_stderr(uint error __attribute__((unused)),
const char *str, myf MyFlags)
{
DBUG_ENTER("my_message_stderr");
DBUG_PRINT("enter",("message: %s",str));
(void) fflush(stdout);
if (MyFlags & (ME_NOTE | ME_ERROR_LOG_ONLY))
DBUG_VOID_RETURN;
if (MyFlags & ME_BELL)
(void) fputc('\007', stderr);
if (my_progname)
{
(void)fputs(my_progname,stderr); (void)fputs(": ",stderr);
}
(void)fputs(str,stderr);
(void)fputc('\n',stderr);
(void)fflush(stderr);
DBUG_VOID_RETURN;
} | O3 | c | my_message_stderr:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x2c926c(%rip), %rax # 0x2effb0
movq (%rax), %rdi
callq 0x24380
testl $0x480, %r14d # imm = 0x480
je 0x26d5a
popq %rbx
popq %r14
popq %rbp
retq
testb $0x4, %r14b
je 0x26d74
movq 0x2c9271(%rip), %rax # 0x2effd8
movq (%rax), %rsi
movl $0x7, %edi
callq 0x243f0
leaq 0x340105(%rip), %rax # 0x366e80
movq (%rax), %rdi
testq %rdi, %rdi
je 0x26d88
callq 0x24620
movq 0x2c9249(%rip), %r14 # 0x2effd8
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x24350
movq (%r14), %rsi
movl $0xa, %edi
callq 0x243f0
movq (%r14), %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x24380
nop
| my_message_stderr:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
test r14d, 480h
jz short loc_26D5A
pop rbx
pop r14
pop rbp
retn
loc_26D5A:
test r14b, 4
jz short loc_26D74
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 7
call _fputc
loc_26D74:
lea rax, my_progname
mov rdi, [rax]
test rdi, rdi
jz short loc_26D88
call my_message_stderr_cold_1
loc_26D88:
mov r14, cs:stderr_ptr
mov rsi, [r14]
mov rdi, rbx
call _fputs
mov rsi, [r14]
mov edi, 0Ah
call _fputc
mov rdi, [r14]
pop rbx
pop r14
pop rbp
jmp _fflush
| long long my_message_stderr(long long a1, long long a2, __int16 a3)
{
long long result; // rax
result = fflush(stdout);
if ( (a3 & 0x480) == 0 )
{
if ( (a3 & 4) != 0 )
fputc(7LL, stderr);
if ( my_progname )
my_message_stderr_cold_1(my_progname);
fputs(a2, stderr);
fputc(10LL, stderr);
return fflush(stderr);
}
return result;
}
| my_message_stderr:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV RAX,qword ptr [0x003effb0]
MOV RDI,qword ptr [RAX]
CALL 0x00124380
TEST R14D,0x480
JZ 0x00126d5a
POP RBX
POP R14
POP RBP
RET
LAB_00126d5a:
TEST R14B,0x4
JZ 0x00126d74
MOV RAX,qword ptr [0x003effd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0x7
CALL 0x001243f0
LAB_00126d74:
LEA RAX,[0x466e80]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00126d88
CALL 0x00124620
LAB_00126d88:
MOV R14,qword ptr [0x003effd8]
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x00124350
MOV RSI,qword ptr [R14]
MOV EDI,0xa
CALL 0x001243f0
MOV RDI,qword ptr [R14]
POP RBX
POP R14
POP RBP
JMP 0x00124380
|
void my_message_stderr(int8 param_1,char *param_2,ulong param_3)
{
int *puVar1;
fflush(*(FILE **)PTR_stdout_003effb0);
if ((param_3 & 0x480) != 0) {
return;
}
if ((param_3 & 4) != 0) {
fputc(7,*(FILE **)PTR_stderr_003effd8);
}
if (my_progname != 0) {
my_message_stderr_cold_1();
}
puVar1 = PTR_stderr_003effd8;
fputs(param_2,*(FILE **)PTR_stderr_003effd8);
fputc(10,*(FILE **)puVar1);
fflush(*(FILE **)puVar1);
return;
}
|
|
2,693 | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | static std::string strip(const std::string & s) {
auto start = s.find_first_not_of(" \t\n\r");
if (start == std::string::npos) return "";
auto end = s.find_last_not_of(" \t\n\r");
return s.substr(start, end - start + 1);
} | O0 | cpp | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x11bb5a(%rip), %rsi # 0x2121c1
xorl %eax, %eax
movl %eax, %edx
callq 0x5afa0
movq %rax, 0x40(%rsp)
cmpq $-0x1, 0x40(%rsp)
jne 0xf66ca
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5b0f0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x116ba4(%rip), %rsi # 0x20d241
callq 0x63270
jmp 0xf66a4
leaq 0x3f(%rsp), %rdi
callq 0x5b560
jmp 0xf6709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x5b560
jmp 0xf6713
movq 0x48(%rsp), %rdi
leaq 0x11baeb(%rip), %rsi # 0x2121c1
movq $-0x1, %rdx
callq 0x5af20
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq 0x40(%rsp), %rcx
addq $0x1, %rcx
callq 0x5b140
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5abf0
nopl (%rax)
| _ZN5minjaL5stripERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 58h
mov [rsp+58h+var_48], rdi
mov rax, rdi
mov [rsp+58h+var_40], rax
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rdi, [rsp+58h+var_10]
lea rsi, asc_2121C1; " \t\n\r"
xor eax, eax
mov edx, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcm; std::string::find_first_not_of(char const*,ulong)
mov [rsp+58h+var_18], rax
cmp [rsp+58h+var_18], 0FFFFFFFFFFFFFFFFh
jnz short loc_F66CA
lea rdi, [rsp+58h+var_19]
mov [rsp+58h+var_50], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_50]
lea rsi, aExampleSpecifi+27h; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_F66A4:
lea rdi, [rsp+58h+var_19]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_F6709
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_37]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_F6713
loc_F66CA:
mov rdi, [rsp+58h+var_10]
lea rsi, asc_2121C1; " \t\n\r"
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcm; std::string::find_last_not_of(char const*,ulong)
mov rdi, [rsp+58h+var_48]
mov [rsp+58h+var_38], rax
mov rsi, [rsp+58h+var_10]
mov rdx, [rsp+58h+var_18]
mov rcx, [rsp+58h+var_38]
sub rcx, [rsp+58h+var_18]
add rcx, 1
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
loc_F6709:
mov rax, [rsp+58h+var_40]
add rsp, 58h
retn
loc_F6713:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long minja::strip(long long a1, long long a2)
{
long long last_not_of; // [rsp+20h] [rbp-38h]
char v4; // [rsp+3Fh] [rbp-19h] BYREF
long long first_not_of; // [rsp+40h] [rbp-18h]
long long v6; // [rsp+48h] [rbp-10h]
long long v7; // [rsp+50h] [rbp-8h]
v7 = a1;
v6 = a2;
first_not_of = std::string::find_first_not_of(a2, " \t\n\r", 0LL);
if ( first_not_of == -1 )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"", (long long)&v4);
std::allocator<char>::~allocator(&v4);
}
else
{
last_not_of = std::string::find_last_not_of(v6, " \t\n\r", -1LL);
std::string::substr(a1, v6, first_not_of, last_not_of - first_not_of + 1);
}
return a1;
}
| strip:
SUB RSP,0x58
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x3121c1]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0015afa0
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],-0x1
JNZ 0x001f66ca
LEA RDI,[RSP + 0x3f]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0015b0f0
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001f6696:
LEA RSI,[0x30d241]
CALL 0x00163270
LAB_001f66a2:
JMP 0x001f66a4
LAB_001f66a4:
LEA RDI,[RSP + 0x3f]
CALL 0x0015b560
JMP 0x001f6709
LAB_001f66ca:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x3121c1]
MOV RDX,-0x1
CALL 0x0015af20
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x20]
SUB RCX,qword ptr [RSP + 0x40]
ADD RCX,0x1
CALL 0x0015b140
LAB_001f6709:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x58
RET
|
/* minja::strip(std::__cxx11::string const&) */
minja * __thiscall minja::strip(minja *this,string *param_1)
{
allocator local_19;
long local_18;
string *local_10;
minja *local_8;
local_10 = param_1;
local_8 = this;
local_18 = std::__cxx11::string::find_first_not_of((char *)param_1,0x3121c1);
if (local_18 == -1) {
std::allocator<char>::allocator();
/* try { // try from 001f6696 to 001f66a1 has its CatchHandler @ 001f66b0 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"",&local_19);
std::allocator<char>::~allocator((allocator<char> *)&local_19);
}
else {
std::__cxx11::string::find_last_not_of((char *)local_10,0x3121c1);
std::__cxx11::string::substr((ulong)this,(ulong)local_10);
}
return this;
}
|
|
2,694 | string_view::operator[](unsigned long) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | char operator[](size_t pos) const {
auto index = _start + pos;
if (index >= _end) {
throw std::out_of_range("string_view index out of range");
}
return _str[_start + pos];
} | O0 | cpp | string_view::operator[](unsigned long) const:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x10(%rcx), %rax
jb 0x1bdbf3
movl $0x10, %edi
callq 0x5a6b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x5899d(%rip), %rsi # 0x216559
callq 0x5a4b0
jmp 0x1bdbc3
movq (%rsp), %rdi
movq 0xe534a(%rip), %rsi # 0x2a2f18
movq 0xe53ab(%rip), %rdx # 0x2a2f80
callq 0x5ab30
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x5af90
jmp 0x1bdc10
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
addq 0x28(%rsp), %rsi
callq 0x5b340
movb (%rax), %al
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5abf0
nopw (%rax,%rax)
| _ZNK11string_viewixEm:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rcx, [rsp+38h+var_8]
mov [rsp+38h+var_30], rcx
mov rax, [rcx+8]
add rax, [rsp+38h+var_10]
mov [rsp+38h+var_18], rax
mov rax, [rsp+38h+var_18]
cmp rax, [rcx+10h]
jb short loc_1BDBF3
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+38h+var_38], rax
lea rsi, aStringViewInde; "string_view index out of range"
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
jmp short $+2
loc_1BDBC3:
mov rdi, [rsp+38h+var_38]; void *
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+38h+var_38]; void *
mov rcx, rax
mov eax, edx
mov [rsp+38h+var_20], rcx
mov [rsp+38h+var_24], eax
call ___cxa_free_exception
jmp short loc_1BDC10
loc_1BDBF3:
mov rax, [rsp+38h+var_30]
mov rdi, [rax]
mov rsi, [rax+8]
add rsi, [rsp+38h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov al, [rax]
add rsp, 38h
retn
loc_1BDC10:
mov rdi, [rsp+38h+var_20]
call __Unwind_Resume
| char string_view::operator[](_QWORD *a1, long long a2)
{
std::out_of_range *exception; // [rsp+0h] [rbp-38h]
if ( (unsigned long long)(a2 + a1[1]) >= a1[2] )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "string_view index out of range");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
return *(_BYTE *)std::string::operator[](*a1, a2 + a1[1]);
}
| construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::__cxx11::string&>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP]
CALL 0x001bde40
ADD RSP,0x18
RET
|
/* void
std::allocator_traits<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> >
>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
std::__cxx11::string&>(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> >&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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::__cxx11::string&) */
void std::
allocator_traits<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>>>
::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::__cxx11::string&>
(allocator *param_1,basic_json *param_2,string *param_3)
{
__gnu_cxx::
new_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>>
::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::__cxx11::string&>
((new_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>>
*)param_1,param_2,param_3);
return;
}
|
|
2,695 | string_view::operator[](unsigned long) const | monkey531[P]llama/common/json-schema-to-grammar.cpp | char operator[](size_t pos) const {
auto index = _start + pos;
if (index >= _end) {
throw std::out_of_range("string_view index out of range");
}
return _str[_start + pos];
} | O2 | cpp | string_view::operator[](unsigned long) const:
pushq %r14
pushq %rbx
pushq %rax
addq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
jae 0x95bbd
movq (%rdi), %rax
movq (%rax), %rax
movb (%rax,%rsi), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %rbx
leaq 0x22fbe(%rip), %rsi # 0xb8b8d
movq %rax, %rdi
callq 0x23110
movq 0x683da(%rip), %rsi # 0xfdfb8
movq 0x683b3(%rip), %rdx # 0xfdf98
movq %rbx, %rdi
callq 0x23f40
movq %rax, %r14
movq %rbx, %rdi
callq 0x236a0
movq %r14, %rdi
callq 0x23fc0
| _ZNK11string_viewixEm:
push r14
push rbx
push rax
add rsi, [rdi+8]
cmp rsi, [rdi+10h]
jnb short loc_95BBD
mov rax, [rdi]
mov rax, [rax]
mov al, [rax+rsi]
add rsp, 8
pop rbx
pop r14
retn
loc_95BBD:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aStringViewInde; "string_view index out of range"
mov rdi, rax; this
call __ZNSt12out_of_rangeC1EPKc; std::out_of_range::out_of_range(char const*)
mov rsi, cs:_ZTISt12out_of_range_ptr; lptinfo
mov rdx, cs:_ZNSt12out_of_rangeD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| char string_view::operator[](long long a1, long long a2)
{
unsigned long long v2; // rsi
std::out_of_range *exception; // rbx
v2 = *(_QWORD *)(a1 + 8) + a2;
if ( v2 >= *(_QWORD *)(a1 + 16) )
{
exception = (std::out_of_range *)__cxa_allocate_exception(0x10uLL);
std::out_of_range::out_of_range(exception, "string_view index out of range");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::out_of_range,
(void (*)(void *))&std::out_of_range::~out_of_range);
}
return *(_BYTE *)(**(_QWORD **)a1 + v2);
}
| operator[]:
PUSH R14
PUSH RBX
PUSH RAX
ADD RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JNC 0x00195bbd
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX + RSI*0x1]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00195bbd:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV RBX,RAX
LAB_00195bc8:
LEA RSI,[0x1b8b8d]
MOV RDI,RAX
CALL 0x00123110
LAB_00195bd7:
MOV RSI,qword ptr [0x001fdfb8]
MOV RDX,qword ptr [0x001fdf98]
MOV RDI,RBX
CALL 0x00123f40
|
/* string_view::operator[](unsigned long) const */
int8 __thiscall string_view::operator[](string_view *this,ulong param_1)
{
out_of_range *this_00;
if (param_1 + *(long *)(this + 8) < *(ulong *)(this + 0x10)) {
return CONCAT71((int7)((ulong)**(long **)this >> 8),
*(int1 *)(**(long **)this + param_1 + *(long *)(this + 8)));
}
this_00 = (out_of_range *)__cxa_allocate_exception(0x10);
/* try { // try from 00195bc8 to 00195bd6 has its CatchHandler @ 00195bed */
std::out_of_range::out_of_range(this_00,"string_view index out of range");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fdfb8,PTR__out_of_range_001fdf98);
}
|
|
2,696 | flux::parser::AssignExpr::clone() const | kvthweatt[P]FluxLang/src/parser/ast.cpp | std::unique_ptr<Expr> AssignExpr::clone() const {
return std::make_unique<AssignExpr>(target->clone(), op, value->clone(), range);
} | O1 | cpp | flux::parser::AssignExpr::clone() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
movq 0x90(%r15), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movl $0x98, %edi
callq 0x6270
movq %rax, %r14
leaq 0x8(%r15), %r8
addq $0x30, %r15
movq 0x8(%rsp), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movq %rax, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x12b70
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xde88
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xdea1
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xdeb3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xdec3
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xdee3
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
callq 0x65e2
jmp 0xdefa
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xdf09
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
jmp 0xdf16
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xdf26
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x6440
| _ZNK4flux6parser10AssignExpr5cloneEv:
push r15
push r14
push rbx
sub rsp, 20h
mov r15, rsi
mov rbx, rdi
mov rsi, [rsi+28h]
mov rax, [rsi]
lea rdi, [rsp+38h+var_30]
call qword ptr [rax+18h]
mov rsi, [r15+90h]
mov rax, [rsi]
mov rdi, rsp
call qword ptr [rax+18h]
mov edi, 98h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea r8, [r15+8]
add r15, 30h ; '0'
mov rax, [rsp+38h+var_30]
lea rsi, [rsp+38h+var_20]
mov [rsi], rax
xor eax, eax
mov [rsp+38h+var_30], rax
mov rdx, [rsp+38h+var_38]
lea rcx, [rsp+38h+var_28]
mov [rcx], rdx
mov [rsp+38h+var_38], rax
mov rdi, r14
mov rdx, r15
call _ZN4flux6parser10AssignExprC2ESt10unique_ptrINS0_4ExprESt14default_deleteIS3_EERKNS_5lexer5TokenES6_RKNS_6common11SourceRangeE; flux::parser::AssignExpr::AssignExpr(std::unique_ptr<flux::parser::Expr>,flux::lexer::Token const&,std::unique_ptr<flux::parser::Expr>,flux::common::SourceRange const&)
mov rdi, [rsp+38h+var_28]
test rdi, rdi
jz short loc_DE88
mov rax, [rdi]
call qword ptr [rax+8]
loc_DE88:
mov [rsp+38h+var_28], 0
mov rdi, [rsp+38h+var_20]
test rdi, rdi
jz short loc_DEA1
mov rax, [rdi]
call qword ptr [rax+8]
loc_DEA1:
mov [rbx], r14
mov rdi, [rsp+38h+var_38]
test rdi, rdi
jz short loc_DEB3
mov rax, [rdi]
call qword ptr [rax+8]
loc_DEB3:
mov rdi, [rsp+38h+var_30]
test rdi, rdi
jz short loc_DEC3
mov rax, [rdi]
call qword ptr [rax+8]
loc_DEC3:
mov rax, rbx
add rsp, 20h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_DEE3
mov rax, [rdi]
call qword ptr [rax+8]
loc_DEE3:
lea rdi, [rsp+arg_8]
lea rsi, [rsp+arg_10]
mov rdx, r14
call _ZNK4flux6parser10AssignExpr5cloneEv_cold_1; flux::parser::AssignExpr::clone(void) [clone]
jmp short loc_DEFA
mov rbx, rax
loc_DEFA:
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_DF09
mov rax, [rdi]
call qword ptr [rax+8]
loc_DF09:
mov qword ptr [rsp+0], 0
jmp short loc_DF16
mov rbx, rax
loc_DF16:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_DF26
mov rax, [rdi]
call qword ptr [rax+8]
loc_DF26:
mov rdi, rbx
call __Unwind_Resume
| flux::parser::AssignExpr * flux::parser::AssignExpr::clone(flux::parser::AssignExpr *this, long long a2)
{
long long v2; // r14
long long v4; // [rsp+0h] [rbp-38h] BYREF
long long v5; // [rsp+8h] [rbp-30h] BYREF
long long v6; // [rsp+10h] [rbp-28h] BYREF
_QWORD v7[4]; // [rsp+18h] [rbp-20h] BYREF
(*(void ( **)(long long *))(**(_QWORD **)(a2 + 40) + 24LL))(&v5);
(*(void ( **)(long long *))(**(_QWORD **)(a2 + 144) + 24LL))(&v4);
v2 = operator new(0x98uLL);
v7[0] = v5;
v5 = 0LL;
v6 = v4;
v4 = 0LL;
flux::parser::AssignExpr::AssignExpr(v2, v7, a2 + 48, &v6, a2 + 8);
if ( v6 )
(*(void ( **)(long long))(*(_QWORD *)v6 + 8LL))(v6);
v6 = 0LL;
if ( v7[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v7[0] + 8LL))(v7[0]);
*(_QWORD *)this = v2;
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
if ( v5 )
(*(void ( **)(long long))(*(_QWORD *)v5 + 8LL))(v5);
return this;
}
| clone:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV R15,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x28]
MOV RAX,qword ptr [RSI]
LEA RDI,[RSP + 0x8]
CALL qword ptr [RAX + 0x18]
MOV RSI,qword ptr [R15 + 0x90]
MOV RAX,qword ptr [RSI]
LAB_0010de2e:
MOV RDI,RSP
CALL qword ptr [RAX + 0x18]
LAB_0010de34:
MOV EDI,0x98
CALL 0x00106270
MOV R14,RAX
LEA R8,[R15 + 0x8]
ADD R15,0x30
MOV RAX,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x18]
MOV qword ptr [RSI],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x8],RAX
MOV RDX,qword ptr [RSP]
LEA RCX,[RSP + 0x10]
MOV qword ptr [RCX],RDX
MOV qword ptr [RSP],RAX
LAB_0010de6d:
MOV RDI,R14
MOV RDX,R15
CALL 0x00112b70
LAB_0010de78:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0010de88
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010de88:
MOV qword ptr [RSP + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x0010dea1
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010dea1:
MOV qword ptr [RBX],R14
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0010deb3
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010deb3:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0010dec3
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010dec3:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R14
POP R15
RET
|
/* flux::parser::AssignExpr::clone() const */
void flux::parser::AssignExpr::clone(void)
{
AssignExpr *pAVar1;
long in_RSI;
int8 *in_RDI;
long *local_38;
long *local_30;
long *local_28;
long *local_20;
(**(code **)(**(long **)(in_RSI + 0x28) + 0x18))(&local_30);
/* try { // try from 0010de2e to 0010de33 has its CatchHandler @ 0010df13 */
(**(code **)(**(long **)(in_RSI + 0x90) + 0x18))(&local_38);
/* try { // try from 0010de34 to 0010de3d has its CatchHandler @ 0010def7 */
pAVar1 = (AssignExpr *)operator_new(0x98);
local_20 = local_30;
local_30 = (long *)0x0;
local_28 = local_38;
local_38 = (long *)0x0;
/* try { // try from 0010de6d to 0010de77 has its CatchHandler @ 0010ded0 */
AssignExpr(pAVar1,&local_20,in_RSI + 0x30,&local_28,in_RSI + 8);
if (local_28 != (long *)0x0) {
(**(code **)(*local_28 + 8))();
}
local_28 = (long *)0x0;
if (local_20 != (long *)0x0) {
(**(code **)(*local_20 + 8))();
}
*in_RDI = pAVar1;
if (local_38 != (long *)0x0) {
(**(code **)(*local_38 + 8))();
}
if (local_30 != (long *)0x0) {
(**(code **)(*local_30 + 8))();
}
return;
}
|
|
2,697 | inline_mysql_mutex_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
} | O0 | c | inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x1ac2a6(%rip), %rax # 0x1d0a60
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x24440
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_mutex_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_mutex_init(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = (*((long long ( **)(_QWORD, _QWORD *))PSI_server[0] + 8))(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
| inline_mysql_mutex_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x2d0a60]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00124440
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
|
|
2,698 | mi_cmp_static_unique | eloqsql/storage/myisam/mi_statrec.c | int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
const uchar *record, my_off_t pos)
{
DBUG_ENTER("_mi_cmp_static_unique");
info->rec_cache.seek_not_done=1; /* We have done a seek */
if (info->s->file_read(info, info->rec_buff, info->s->base.reclength,
pos, MYF(MY_NABP)))
DBUG_RETURN(-1);
DBUG_RETURN(mi_unique_comp(def, record, info->rec_buff,
def->null_are_equal));
} | O0 | c | mi_cmp_static_unique:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x300(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x2e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x120(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x140(%rcx), %rdx
movq -0x28(%rbp), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0xc609e
jmp 0xc6095
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc60c3
jmp 0xc60a0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdx
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %ecx
callq 0xc6c10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _mi_cmp_static_unique:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+300h], 1
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+2E0h]
mov rdi, [rbp+var_10]
mov rcx, [rbp+var_10]
mov rsi, [rcx+120h]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rcx+140h]
mov rcx, [rbp+var_28]
mov r8d, 4
call rax
cmp rax, 0
jz short loc_C609E
jmp short $+2
loc_C6095:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C60C3
loc_C609E:
jmp short $+2
loc_C60A0:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rdx, [rax+120h]
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax+3]
call mi_unique_comp
mov [rbp+var_4], eax
loc_C60C3:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mi_cmp_static_unique(long long a1, long long a2, long long a3, long long a4)
{
*(_DWORD *)(a1 + 768) = 1;
if ( (*(long long ( **)(long long, _QWORD, _QWORD, long long, long long))(*(_QWORD *)a1 + 736LL))(
a1,
*(_QWORD *)(a1 + 288),
*(_QWORD *)(*(_QWORD *)a1 + 320LL),
a4,
4LL) )
{
return (unsigned int)-1;
}
else
{
return (unsigned int)mi_unique_comp(a2, a3, *(_QWORD *)(a1 + 288), (unsigned int)*(char *)(a2 + 3));
}
}
| _mi_cmp_static_unique:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x300],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x2e0]
MOV RDI,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x140]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x001c609e
JMP 0x001c6095
LAB_001c6095:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c60c3
LAB_001c609e:
JMP 0x001c60a0
LAB_001c60a0:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x120]
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX + 0x3]
CALL 0x001c6c10
MOV dword ptr [RBP + -0x4],EAX
LAB_001c60c3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 _mi_cmp_static_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
int4 local_c;
*(int4 *)(param_1 + 0x60) = 1;
lVar1 = (**(code **)(*param_1 + 0x2e0))
(param_1,param_1[0x24],*(int8 *)(*param_1 + 0x140),param_4,4);
if (lVar1 == 0) {
local_c = mi_unique_comp(param_2,param_3,param_1[0x24],(int)*(char *)(param_2 + 3));
}
else {
local_c = 0xffffffff;
}
return local_c;
}
|
|
2,699 | my_casedn_str_mb | eloqsql/strings/ctype-mb.c | size_t my_casedn_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_lower;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
} | O0 | c | my_casedn_str_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x40377
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x40290
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x40355
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x40375
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x40314
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_casedn_str_mb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_40314:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_40377
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+9Ch]
add rdx, rax
call my_ismbchar_0
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_40355
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_40375
loc_40355:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_40375:
jmp short loc_40314
loc_40377:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
add rsp, 30h
pop rbp
retn
| _BYTE * my_casedn_str_mb(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-20h]
unsigned int v4; // [rsp+1Ch] [rbp-14h]
_BYTE *v5; // [rsp+20h] [rbp-10h]
v5 = a2;
v3 = *(_QWORD *)(a1 + 72);
while ( *v5 )
{
v4 = my_ismbchar_0(a1, (long long)v5, (long long)&v5[*(unsigned int *)(a1 + 156)]);
if ( v4 )
{
v5 += v4;
}
else
{
*v5 = *(_BYTE *)(v3 + (unsigned __int8)*v5);
++v5;
}
}
return (_BYTE *)(v5 - a2);
}
| my_casedn_str_mb:
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 RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_00140314:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x00140377
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x9c]
ADD RDX,RAX
CALL 0x00140290
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x00140355
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00140375
LAB_00140355:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_00140375:
JMP 0x00140314
LAB_00140377:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
ADD RSP,0x30
POP RBP
RET
|
long my_casedn_str_mb(long param_1,byte *param_2)
{
long lVar1;
uint uVar2;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_18 = param_2;
while (*local_18 != 0) {
uVar2 = my_ismbchar(param_1,local_18,local_18 + *(uint *)(param_1 + 0x9c));
if (uVar2 == 0) {
*local_18 = *(byte *)(lVar1 + (ulong)*local_18);
local_18 = local_18 + 1;
}
else {
local_18 = local_18 + uVar2;
}
}
return (long)local_18 - (long)param_2;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.