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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
24,500 | 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) | monkey531[P]llama/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 0x91fcd(%rip), %rsi # 0xef554
leaq 0x91fd1(%rip), %rdx # 0xef55f
leaq 0x8(%rsp), %rdi
callq 0x24458
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x5b440
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x6384c
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq %r15, (%rsp)
leaq 0x91f89(%rip), %rdx # 0xef560
leaq 0x9638d(%rip), %r8 # 0xf396b
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r9
callq 0x63743
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5d611
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d62c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d647
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5d65e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq (%r14), %r14
movq 0x88(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5b6ae
leaq 0xce926(%rip), %rax # 0x12bfa0
addq $0x10, %rax
movq %rax, (%rbx)
movq %r14, 0x20(%rbx)
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d6a6
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x1b8e0
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 0x5d753
movq 0x98(%rsp), %rsi
jmp 0x5d746
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5d6f7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d717
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x5d717
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d737
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x5d737
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5d753
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x5d753
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1c030
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_5D611
mov rsi, [rsp+0D8h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D611:
lea rax, [rsp+0D8h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5D62C
mov rsi, [rsp+0D8h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D62C:
lea rax, [rsp+0D8h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5D647
mov rsi, [rsp+0D8h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D647:
mov rdi, [rsp+0D8h+var_D0]; void *
cmp rdi, r12
jz short loc_5D65E
mov rsi, [rsp+0D8h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D65E:
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, _ZTVN8nlohmann16json_abi_v3_11_36detail11parse_errorE; `vtable for'nlohmann::json_abi_v3_11_3::detail::parse_error
add rax, 10h
mov [rbx], rax
mov [rbx+20h], r14
lea rax, [rsp+0D8h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5D6A6
mov rsi, [rsp+0D8h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D6A6:
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_5D753
mov rsi, [rsp+arg_90]
jmp short loc_5D746
mov rbx, rax
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_5D6F7
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D6F7:
lea rax, [rsp+arg_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5D717
mov rsi, [rsp+arg_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5D717
mov rbx, rax
loc_5D717:
lea rax, [rsp+arg_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5D737
mov rsi, [rsp+arg_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5D737
mov rbx, rax
loc_5D737:
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_5D753
mov rsi, [rsp+arg_10]
loc_5D746:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5D753
mov rbx, rax
loc_5D753:
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 = &`vtable for'nlohmann::json_abi_v3_11_3::detail::parse_error + 2;
*((_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_0015d580:
LEA RSI,[0x1ef554]
LEA RDX,[0x1ef55f]
LEA RDI,[RSP + 0x8]
CALL 0x00124458
LAB_0015d598:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x8]
MOV EDX,EBP
CALL 0x0015b440
LAB_0015d5a9:
LEA RDI,[RSP + 0x48]
MOV RSI,R14
CALL 0x0016384c
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
LAB_0015d5cc:
MOV qword ptr [RSP],R15
LEA RDX,[0x1ef560]
LEA R8,[0x1f396b]
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x68]
LEA RCX,[RSP + 0x48]
LEA R9,[RSP + 0x28]
CALL 0x00163743
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x0015d611
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011b8e0
LAB_0015d611:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0015d62c
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x0011b8e0
LAB_0015d62c:
LEA RAX,[RSP + 0x78]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0015d647
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x0011b8e0
LAB_0015d647:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x0015d65e
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8e0
LAB_0015d65e:
MOV R14,qword ptr [R14]
MOV RDX,qword ptr [RSP + 0x88]
LAB_0015d669:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0015b6ae
LAB_0015d673:
LEA RAX,[0x22bfa0]
ADD RAX,0x10
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 0x0015d6a6
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x0011b8e0
LAB_0015d6a6:
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 0015d580 to 0015d597 has its CatchHandler @ 0015d750 */
local_d0[0] = local_c0;
std::__cxx11::string::_M_construct<char_const*>(local_d0,"parse_error","");
/* try { // try from 0015d598 to 0015d5a8 has its CatchHandler @ 0015d734 */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_70,(string *)local_d0,param_2);
/* try { // try from 0015d5a9 to 0015d5b5 has its CatchHandler @ 0015d714 */
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 0015d5cc to 0015d5f9 has its CatchHandler @ 0015d6dd */
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 0015d669 to 0015d672 has its CatchHandler @ 0015d6bb */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,(char *)local_50[0]);
*(int ***)param_1 = &PTR__exception_0022bfb0;
*(int8 *)(param_1 + 0x20) = uVar1;
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return param_1;
}
| |
24,501 | JS_WriteObject2 | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValue obj,
int flags, JSSABTab *psab_tab)
{
BCWriterState ss, *s = &ss;
memset(s, 0, sizeof(*s));
s->ctx = ctx;
s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
s->allow_source = ((flags & JS_WRITE_OBJ_STRIP_SOURCE) == 0);
s->allow_debug = ((flags & JS_WRITE_OBJ_STRIP_DEBUG) == 0);
/* XXX: could use a different version when bytecode is included */
if (s->allow_bytecode)
s->first_atom = JS_ATOM_END;
else
s->first_atom = 1;
js_dbuf_init(ctx, &s->dbuf);
js_object_list_init(&s->object_list);
if (JS_WriteObjectRec(s, obj))
goto fail;
if (JS_WriteObjectAtoms(s))
goto fail;
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
*psize = s->dbuf.size;
if (psab_tab) {
psab_tab->tab = s->sab_tab;
psab_tab->len = s->sab_tab_len;
} else {
js_free(ctx, s->sab_tab);
}
return s->dbuf.buf;
fail:
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
dbuf_free(&s->dbuf);
*psize = 0;
if (psab_tab) {
psab_tab->tab = NULL;
psab_tab->len = 0;
}
return NULL;
} | O1 | c | JS_WriteObject2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, 0x8(%rsp)
movl %r8d, %r12d
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rsp), %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xe350
movq %r15, (%r14)
movl %r12d, %eax
andl $0x1, %eax
movl $0xfc000000, %ecx # imm = 0xFC000000
andl 0x38(%r14), %ecx
movl %r12d, %edx
andl $0x4, %edx
shll $0x6, %edx
movl %r12d, %esi
andl $0x8, %esi
shll $0xd, %esi
orl %edx, %esi
andl $0x30, %r12d
shll $0x14, %r12d
orl %esi, %r12d
orl %ecx, %r12d
orl %eax, %r12d
xorl $0x3000000, %r12d # imm = 0x3000000
testl %eax, %eax
movl $0x1, %eax
movl $0xe0, %ecx
cmovel %eax, %ecx
movl %r12d, 0x38(%r14)
movl %ecx, 0x3c(%r14)
leaq 0x60(%rsp), %r12
movq 0x18(%r15), %rsi
leaq 0x13b1f(%rip), %rdx # 0x45302
movq %r12, %rdi
callq 0x1b32b
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r12)
movups %xmm0, 0x68(%r12)
movq %r14, %rdi
movq 0x8(%rsp), %r14
movq %rbp, %rsi
movq %r13, %rdx
callq 0x31a6a
testl %eax, %eax
jne 0x31983
movq %r15, 0x50(%rsp)
movq %rbx, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rbx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x18(%rax), %rsi
leaq 0x13aaf(%rip), %rdx # 0x45302
movq %r12, %rdi
callq 0x1b32b
movq %r12, %rdi
movl $0x13, %esi
callq 0x1b4d0
movl 0xb0(%rsp), %esi
movq %r12, %rdi
callq 0x45854
cmpl $0x0, 0xb0(%rsp)
jle 0x318f6
xorl %r15d, %r15d
leaq 0x58(%rsp), %r14
leaq 0x14(%rsp), %r13
movq 0xa8(%rsp), %rax
movslq (%rax,%r15,4), %rbp
cmpq $0xdf, %rbp
jle 0x318c8
movq 0x68(%rbx), %rax
movq (%rax,%rbp,8), %rbp
movq 0x4(%rbp), %rsi
shrq $0x3e, %rsi
movq %r12, %rdi
callq 0x1b4d0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x45307
jmp 0x318e6
movq %r12, %rdi
xorl %esi, %esi
callq 0x1b4d0
movl %ebp, 0x14(%rsp)
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1b422
incq %r15
movslq 0xb0(%rsp), %rax
cmpq %rax, %r15
jl 0x3188e
movslq 0x68(%rsp), %r14
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x1b375
movl %eax, %ebp
testl %eax, %eax
je 0x3191e
leaq 0x20(%rsp), %rdi
callq 0x1b62a
jmp 0x31970
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq (%rsi,%r14), %rdi
callq 0xe720
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %r14, %rdx
callq 0xe5b0
addq %r14, 0x28(%rsp)
movq %r12, %rdi
callq 0x1b62a
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq 0x8(%rsp), %r14
movq 0x18(%rsp), %rbx
testl %ebp, %ebp
movq 0x50(%rsp), %r15
je 0x319f2
movq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xd8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x98(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xa8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq %r12, %rdi
callq 0x1b62a
movq $0x0, (%rbx)
testq %r14, %r14
je 0x319de
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xd8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x98(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0xa8(%rsp), %rsi
movq %r15, %rdi
callq 0x1cb99
movq 0x68(%rsp), %rax
movq %rax, (%rbx)
movq 0xb8(%rsp), %rsi
testq %r14, %r14
je 0x31a58
movq %rsi, (%r14)
movslq 0xc0(%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x31a60
movq %r15, %rdi
callq 0x1cb99
movq 0x60(%rsp), %rax
jmp 0x319e0
| JS_WriteObject2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_110], r9
mov r12d, r8d
mov r13, rcx
mov rbp, rdx
mov rbx, rsi
mov r15, rdi
lea r14, [rsp+118h+var_C0]
mov edx, 90h
mov rdi, r14
xor esi, esi
call _memset
mov [r14], r15
mov eax, r12d
and eax, 1
mov ecx, 0FC000000h
and ecx, [r14+38h]
mov edx, r12d
and edx, 4
shl edx, 6
mov esi, r12d
and esi, 8
shl esi, 0Dh
or esi, edx
and r12d, 30h
shl r12d, 14h
or r12d, esi
or r12d, ecx
or r12d, eax
xor r12d, 3000000h
test eax, eax
mov eax, 1
mov ecx, 0E0h
cmovz ecx, eax
mov [r14+38h], r12d
mov [r14+3Ch], ecx
lea r12, [rsp+118h+var_B8]
mov rsi, [r15+18h]
lea rdx, js_dbuf_realloc
mov rdi, r12
call dbuf_init2
xorps xmm0, xmm0
movups xmmword ptr [r12+78h], xmm0
movups xmmword ptr [r12+68h], xmm0
mov rdi, r14
mov r14, [rsp+118h+var_110]
mov rsi, rbp
mov rdx, r13
call JS_WriteObjectRec
test eax, eax
jnz loc_31983
mov [rsp+118h+var_C8], r15
mov [rsp+118h+var_100], rbx
mov rax, [rsp+118h+var_C0]
mov rbx, [rax+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+10h]
movups xmm2, xmmword ptr [r12+20h]
movaps [rsp+118h+var_D8], xmm2
movaps [rsp+118h+var_E8], xmm1
movaps [rsp+118h+var_F8], xmm0
mov rsi, [rax+18h]
lea rdx, js_dbuf_realloc
mov rdi, r12
call dbuf_init2
mov rdi, r12
mov esi, 13h
call dbuf_putc
mov esi, [rsp+118h+var_68]
mov rdi, r12
call dbuf_put_leb128
cmp [rsp+118h+var_68], 0
jle short loc_318F6
xor r15d, r15d
lea r14, [rsp+118h+var_C0]
lea r13, [rsp+118h+var_104]
loc_3188E:
mov rax, [rsp+118h+var_70]
movsxd rbp, dword ptr [rax+r15*4]
cmp rbp, 0DFh
jle short loc_318C8
mov rax, [rbx+68h]
mov rbp, [rax+rbp*8]
mov rsi, [rbp+4]
shr rsi, 3Eh
mov rdi, r12
call dbuf_putc
mov rdi, r14
mov rsi, rbp
call JS_WriteString
jmp short loc_318E6
loc_318C8:
mov rdi, r12
xor esi, esi
call dbuf_putc
mov [rsp+118h+var_104], ebp
mov edx, 4
mov rdi, r12
mov rsi, r13
call dbuf_put
loc_318E6:
inc r15
movsxd rax, [rsp+118h+var_68]
cmp r15, rax
jl short loc_3188E
loc_318F6:
movsxd r14, dword ptr [rsp+118h+var_B0]
lea rdi, [rsp+118h+var_F8]
mov rsi, [rdi+8]
add rsi, r14
call dbuf_realloc
mov ebp, eax
test eax, eax
jz short loc_3191E
lea rdi, [rsp+118h+var_F8]
call dbuf_free
jmp short loc_31970
loc_3191E:
mov rsi, qword ptr [rsp+118h+var_F8]
mov rdx, qword ptr [rsp+118h+var_F8+8]
lea rdi, [rsi+r14]
call _memmove
mov rdi, qword ptr [rsp+118h+var_F8]
mov rsi, [rsp+118h+var_B8]
mov rdx, r14
call _memcpy
add qword ptr [rsp+118h+var_F8+8], r14
mov rdi, r12
call dbuf_free
movaps xmm0, [rsp+118h+var_F8]
movaps xmm1, [rsp+118h+var_E8]
movaps xmm2, [rsp+118h+var_D8]
movups xmmword ptr [r12+20h], xmm2
movups xmmword ptr [r12+10h], xmm1
movups xmmword ptr [r12], xmm0
loc_31970:
mov r14, [rsp+118h+var_110]
mov rbx, [rsp+118h+var_100]
test ebp, ebp
mov r15, [rsp+118h+var_C8]
jz short loc_319F2
loc_31983:
mov rsi, [rsp+118h+var_50]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_40]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_80]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, r15
call js_free
mov rdi, r12
call dbuf_free
mov qword ptr [rbx], 0
test r14, r14
jz short loc_319DE
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
loc_319DE:
xor eax, eax
loc_319E0:
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_319F2:
mov rsi, [rsp+118h+var_50]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_40]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_80]
mov rdi, r15
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, r15
call js_free
mov rax, [rsp+118h+var_B0]
mov [rbx], rax
mov rsi, [rsp+118h+var_60]
test r14, r14
jz short loc_31A58
mov [r14], rsi
movsxd rax, [rsp+118h+var_58]
mov [r14+8], rax
jmp short loc_31A60
loc_31A58:
mov rdi, r15
call js_free
loc_31A60:
mov rax, [rsp+118h+var_B8]
jmp loc_319E0
| long long JS_WriteObject2(long long a1, _QWORD *a2, long long a3, long long a4, char a5, _QWORD *a6)
{
_QWORD *v9; // rbx
long long v10; // r15
int v11; // eax
unsigned int v12; // r12d
int v13; // ecx
_OWORD *v14; // r14
long long v15; // rbx
long long i; // r15
long long v17; // rbp
long long v18; // rbp
long long v19; // r14
int v20; // ebp
int v23; // [rsp+14h] [rbp-104h] BYREF
_QWORD *v24; // [rsp+18h] [rbp-100h]
__int128 v25; // [rsp+20h] [rbp-F8h] BYREF
__int128 v26; // [rsp+30h] [rbp-E8h]
__int128 v27; // [rsp+40h] [rbp-D8h]
long long v28; // [rsp+50h] [rbp-C8h]
long long v29; // [rsp+58h] [rbp-C0h] BYREF
__int128 v30; // [rsp+60h] [rbp-B8h] BYREF
__int128 v31; // [rsp+70h] [rbp-A8h]
__int128 v32; // [rsp+80h] [rbp-98h]
unsigned int v33; // [rsp+90h] [rbp-88h]
int v34; // [rsp+94h] [rbp-84h]
long long v35; // [rsp+98h] [rbp-80h]
long long v36; // [rsp+A8h] [rbp-70h]
int v37; // [rsp+B0h] [rbp-68h]
long long v38; // [rsp+B8h] [rbp-60h]
int v39; // [rsp+C0h] [rbp-58h]
__int128 v40; // [rsp+C8h] [rbp-50h]
__int128 v41; // [rsp+D8h] [rbp-40h]
v9 = a2;
v10 = a1;
memset(&v29, 0LL, 144LL);
v29 = a1;
v11 = a5 & 1;
v12 = (v11 | v33 & 0xFC000000 | ((a5 & 4) << 6) | ((a5 & 8) << 13) | ((a5 & 0x30) << 20)) ^ 0x3000000;
v13 = 224;
if ( !v11 )
v13 = 1;
v33 = v12;
v34 = v13;
dbuf_init2((long long)&v30, *(_QWORD *)(a1 + 24), js_dbuf_realloc);
v41 = 0LL;
v40 = 0LL;
v14 = a6;
if ( (unsigned int)JS_WriteObjectRec(&v29, a3, a4) )
goto LABEL_14;
v28 = a1;
v24 = a2;
v15 = *(_QWORD *)(v29 + 24);
v27 = v32;
v26 = v31;
v25 = v30;
dbuf_init2((long long)&v30, *(_QWORD *)(v29 + 24), js_dbuf_realloc);
dbuf_putc(&v30, 19);
dbuf_put_leb128(&v30, (unsigned int)v37);
if ( v37 > 0 )
{
for ( i = 0LL; i < v37; ++i )
{
v17 = *(int *)(v36 + 4 * i);
if ( v17 <= 223 )
{
dbuf_putc(&v30, 0);
v23 = v17;
dbuf_put(&v30, (long long)&v23, 4LL);
}
else
{
v18 = *(_QWORD *)(*(_QWORD *)(v15 + 104) + 8 * v17);
dbuf_putc(&v30, *(_QWORD *)(v18 + 4) >> 62);
JS_WriteString(&v29, v18);
}
}
}
v19 = SDWORD2(v30);
v20 = dbuf_realloc((long long)&v25, SDWORD2(v30) + *((_QWORD *)&v25 + 1));
if ( v20 )
{
dbuf_free((long long)&v25);
}
else
{
memmove(v25 + v19, v25, *((_QWORD *)&v25 + 1));
memcpy(v25, v30, v19);
*((_QWORD *)&v25 + 1) += v19;
dbuf_free((long long)&v30);
v32 = v27;
v31 = v26;
v30 = v25;
}
v14 = a6;
v9 = v24;
v10 = v28;
if ( v20 )
{
LABEL_14:
js_free(v10, v40);
js_free(v10, v41);
js_free(v10, v35);
js_free(v10, v36);
dbuf_free((long long)&v30);
*v9 = 0LL;
if ( v14 )
*v14 = 0LL;
return 0LL;
}
else
{
js_free(v28, v40);
js_free(v10, v41);
js_free(v10, v35);
js_free(v10, v36);
*v9 = *((_QWORD *)&v30 + 1);
if ( a6 )
{
*a6 = v38;
a6[1] = v39;
}
else
{
js_free(v10, v38);
}
return v30;
}
}
| |||
24,502 | JS_WriteObject2 | bluesky950520[P]quickjs/quickjs.c | uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValue obj,
int flags, JSSABTab *psab_tab)
{
BCWriterState ss, *s = &ss;
memset(s, 0, sizeof(*s));
s->ctx = ctx;
s->allow_bytecode = ((flags & JS_WRITE_OBJ_BYTECODE) != 0);
s->allow_sab = ((flags & JS_WRITE_OBJ_SAB) != 0);
s->allow_reference = ((flags & JS_WRITE_OBJ_REFERENCE) != 0);
s->allow_source = ((flags & JS_WRITE_OBJ_STRIP_SOURCE) == 0);
s->allow_debug = ((flags & JS_WRITE_OBJ_STRIP_DEBUG) == 0);
/* XXX: could use a different version when bytecode is included */
if (s->allow_bytecode)
s->first_atom = JS_ATOM_END;
else
s->first_atom = 1;
js_dbuf_init(ctx, &s->dbuf);
js_object_list_init(&s->object_list);
if (JS_WriteObjectRec(s, obj))
goto fail;
if (JS_WriteObjectAtoms(s))
goto fail;
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
*psize = s->dbuf.size;
if (psab_tab) {
psab_tab->tab = s->sab_tab;
psab_tab->len = s->sab_tab_len;
} else {
js_free(ctx, s->sab_tab);
}
return s->dbuf.buf;
fail:
js_object_list_end(ctx, &s->object_list);
js_free(ctx, s->atom_to_idx);
js_free(ctx, s->idx_to_atom);
dbuf_free(&s->dbuf);
*psize = 0;
if (psab_tab) {
psab_tab->tab = NULL;
psab_tab->len = 0;
}
return NULL;
} | O2 | c | JS_WriteObject2:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %rbx
movl %r8d, %r13d
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
leaq 0x60(%rsp), %r12
movl $0x88, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0xe360
movq %rbp, -0x8(%r12)
movl %r13d, %eax
andl $0x1, %eax
movl %r13d, %ecx
andl $0x4, %ecx
shll $0x6, %ecx
movl %r13d, %edx
andl $0x8, %edx
shll $0xd, %edx
orl %ecx, %edx
andl $0x30, %r13d
shll $0x14, %r13d
orl %edx, %r13d
orl %eax, %r13d
xorl $0x3000000, %r13d # imm = 0x3000000
movl %r13d, 0x30(%r12)
testl %eax, %eax
pushq $0x1
popq %rax
movl $0xe0, %ecx
cmovel %eax, %ecx
movl %ecx, 0x34(%r12)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x29e23
leaq 0xc8(%rsp), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
leaq 0x58(%rsp), %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x29e39
testl %eax, %eax
jne 0x29d04
movq %rbp, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movq %rbx, 0x8(%rsp)
leaq 0x58(%rsp), %rbp
movq (%rbp), %rdi
movq 0x18(%rdi), %rbx
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movaps %xmm2, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %r12, %rsi
callq 0x29e23
pushq $0x13
popq %rsi
movq %r12, %rdi
callq 0x15d33
movl 0x58(%rbp), %esi
movq %r12, %rdi
callq 0x3cf8f
xorl %r13d, %r13d
movslq 0xb0(%rsp), %rax
cmpq %rax, %r13
jge 0x29cc9
movq 0xa8(%rsp), %rax
movslq (%rax,%r13,4), %r14
cmpq $0xdf, %r14
jle 0x29caf
movq 0x68(%rbx), %rax
movq (%rax,%r14,8), %r14
movq 0x4(%r14), %rsi
shrq $0x3e, %rsi
movq %r12, %rdi
callq 0x15d33
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3ceda
jmp 0x29cc4
movq %r12, %rdi
xorl %esi, %esi
callq 0x15d33
movq %r12, %rdi
movl %r14d, %esi
callq 0x3d14f
incq %r13
jmp 0x29c68
movslq 0x68(%rsp), %r14
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x15bdf
testl %eax, %eax
je 0x29d5a
leaq 0x20(%rsp), %rdi
callq 0x15e89
movq 0x8(%rsp), %rbx
movq 0x18(%rsp), %r15
leaq 0xc8(%rsp), %r13
movq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2abca
movq 0x98(%rsp), %rsi
movq %rbp, %rdi
callq 0x1726e
movq 0xa8(%rsp), %rsi
movq %rbp, %rdi
callq 0x1726e
movq %r12, %rdi
callq 0x15e89
andq $0x0, (%r15)
testq %rbx, %rbx
je 0x29d46
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq (%rsi,%r14), %rdi
callq 0xe740
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq %r14, %rdx
callq 0xe5c0
addq %r14, 0x28(%rsp)
movq %r12, %rdi
callq 0x15e89
movaps 0x20(%rsp), %xmm0
movaps 0x30(%rsp), %xmm1
movaps 0x40(%rsp), %xmm2
movups %xmm2, 0x20(%r12)
movups %xmm1, 0x10(%r12)
movups %xmm0, (%r12)
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
leaq 0xc8(%rsp), %rsi
callq 0x2abca
movq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x1726e
movq 0xa8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1726e
movq 0x68(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0xb8(%rsp), %rsi
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
je 0x29e11
movq %rsi, (%rcx)
movslq 0xc0(%rsp), %rax
movq %rax, 0x8(%rcx)
jmp 0x29e19
movq %rbx, %rdi
callq 0x1726e
movq 0x60(%rsp), %rax
jmp 0x29d48
| JS_WriteObject2:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov rbx, r9
mov r13d, r8d
mov [rsp+118h+var_110], rcx
mov r14, rdx
mov r15, rsi
mov rbp, rdi
lea r12, [rsp+118h+var_B8]
mov edx, 88h
mov rdi, r12
xor esi, esi
call _memset
mov [r12-8], rbp
mov eax, r13d
and eax, 1
mov ecx, r13d
and ecx, 4
shl ecx, 6
mov edx, r13d
and edx, 8
shl edx, 0Dh
or edx, ecx
and r13d, 30h
shl r13d, 14h
or r13d, edx
or r13d, eax
xor r13d, 3000000h
mov [r12+30h], r13d
test eax, eax
push 1
pop rax
mov ecx, 0E0h
cmovz ecx, eax
mov [r12+34h], ecx
mov rdi, rbp
mov rsi, r12
call js_dbuf_init
lea r13, [rsp+118h+var_50]
xorps xmm0, xmm0
movups xmmword ptr [r13+10h], xmm0
movups xmmword ptr [r13+0], xmm0
lea rdi, [rsp+118h+var_C0]
mov rsi, r14
mov rdx, [rsp+118h+var_110]
call JS_WriteObjectRec
test eax, eax
jnz loc_29D04
mov [rsp+118h+var_108], rbp
mov [rsp+118h+var_100], r15
mov [rsp+118h+var_110], rbx
lea rbp, [rsp+118h+var_C0]
mov rdi, [rbp+0]
mov rbx, [rdi+18h]
movups xmm0, xmmword ptr [r12]
movups xmm1, xmmword ptr [r12+10h]
movups xmm2, xmmword ptr [r12+20h]
movaps [rsp+118h+var_D8], xmm2
movaps [rsp+118h+var_E8], xmm1
movaps [rsp+118h+var_F8], xmm0
mov rsi, r12
call js_dbuf_init
push 13h
pop rsi
mov rdi, r12
call dbuf_putc
mov esi, [rbp+58h]
mov rdi, r12
call dbuf_put_leb128
xor r13d, r13d
loc_29C68:
movsxd rax, [rsp+118h+var_68]
cmp r13, rax
jge short loc_29CC9
mov rax, [rsp+118h+var_70]
movsxd r14, dword ptr [rax+r13*4]
cmp r14, 0DFh
jle short loc_29CAF
mov rax, [rbx+68h]
mov r14, [rax+r14*8]
mov rsi, [r14+4]
shr rsi, 3Eh
mov rdi, r12
call dbuf_putc
mov rdi, rbp
mov rsi, r14
call JS_WriteString
jmp short loc_29CC4
loc_29CAF:
mov rdi, r12
xor esi, esi
call dbuf_putc
mov rdi, r12
mov esi, r14d
call dbuf_put_u32
loc_29CC4:
inc r13
jmp short loc_29C68
loc_29CC9:
movsxd r14, dword ptr [rsp+118h+var_B0]
lea rdi, [rsp+118h+var_F8]
mov rsi, [rdi+8]
add rsi, r14
call dbuf_realloc
test eax, eax
jz short loc_29D5A
lea rdi, [rsp+118h+var_F8]
call dbuf_free
mov rbx, [rsp+118h+var_110]
mov r15, [rsp+118h+var_100]
lea r13, [rsp+118h+var_50]
mov rbp, [rsp+118h+var_108]
loc_29D04:
mov rdi, rbp
mov rsi, r13
call js_object_list_end
mov rsi, [rsp+118h+var_80]
mov rdi, rbp
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, rbp
call js_free
mov rdi, r12
call dbuf_free
and qword ptr [r15], 0
test rbx, rbx
jz short loc_29D46
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_29D46:
xor eax, eax
loc_29D48:
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_29D5A:
mov rsi, qword ptr [rsp+118h+var_F8]
mov rdx, qword ptr [rsp+118h+var_F8+8]
lea rdi, [rsi+r14]
call _memmove
mov rdi, qword ptr [rsp+118h+var_F8]
mov rsi, [rsp+118h+var_B8]
mov rdx, r14
call _memcpy
add qword ptr [rsp+118h+var_F8+8], r14
mov rdi, r12
call dbuf_free
movaps xmm0, [rsp+118h+var_F8]
movaps xmm1, [rsp+118h+var_E8]
movaps xmm2, [rsp+118h+var_D8]
movups xmmword ptr [r12+20h], xmm2
movups xmmword ptr [r12+10h], xmm1
movups xmmword ptr [r12], xmm0
mov rbx, [rsp+118h+var_108]
mov rdi, rbx
lea rsi, [rsp+118h+var_50]
call js_object_list_end
mov rsi, [rsp+118h+var_80]
mov rdi, rbx
call js_free
mov rsi, [rsp+118h+var_70]
mov rdi, rbx
call js_free
mov rax, [rsp+118h+var_B0]
mov rcx, [rsp+118h+var_100]
mov [rcx], rax
mov rsi, [rsp+118h+var_60]
mov rcx, [rsp+118h+var_110]
test rcx, rcx
jz short loc_29E11
mov [rcx], rsi
movsxd rax, [rsp+118h+var_58]
mov [rcx+8], rax
jmp short loc_29E19
loc_29E11:
mov rdi, rbx
call js_free
loc_29E19:
mov rax, [rsp+118h+var_B8]
jmp loc_29D48
| long long JS_WriteObject2(long long a1, _QWORD *a2, long long a3, long long a4, char a5, _OWORD *a6)
{
long long v9; // rbp
int v10; // ecx
long long v11; // rbx
long long i; // r13
long long v13; // r14
long long v14; // r14
long long v15; // r14
_QWORD *v18; // [rsp+8h] [rbp-110h]
__int128 v19; // [rsp+20h] [rbp-F8h] BYREF
__int128 v20; // [rsp+30h] [rbp-E8h]
__int128 v21; // [rsp+40h] [rbp-D8h]
long long v22; // [rsp+58h] [rbp-C0h] BYREF
__int128 v23; // [rsp+60h] [rbp-B8h] BYREF
__int128 v24; // [rsp+70h] [rbp-A8h]
__int128 v25; // [rsp+80h] [rbp-98h]
int v26; // [rsp+90h] [rbp-88h]
int v27; // [rsp+94h] [rbp-84h]
long long v28; // [rsp+98h] [rbp-80h]
long long v29; // [rsp+A8h] [rbp-70h]
unsigned int v30; // [rsp+B0h] [rbp-68h]
long long v31; // [rsp+B8h] [rbp-60h]
int v32; // [rsp+C0h] [rbp-58h]
_BYTE v33[80]; // [rsp+C8h] [rbp-50h] BYREF
v9 = a1;
memset(&v23, 0LL, 136LL);
v22 = a1;
v26 = (a5 & 1 | ((a5 & 4) << 6) | ((a5 & 8) << 13) | ((a5 & 0x30) << 20)) ^ 0x3000000;
v10 = 224;
if ( (a5 & 1) == 0 )
v10 = 1;
v27 = v10;
js_dbuf_init(a1, &v23);
memset(v33, 0, 32);
if ( !(unsigned int)JS_WriteObjectRec(&v22, a3, a4) )
{
v18 = a6;
v11 = *(_QWORD *)(v22 + 24);
v21 = v25;
v20 = v24;
v19 = v23;
js_dbuf_init(v22, &v23);
dbuf_putc(&v23, 19);
dbuf_put_leb128(&v23, v30);
for ( i = 0LL; i < (int)v30; ++i )
{
v13 = *(int *)(v29 + 4 * i);
if ( v13 <= 223 )
{
dbuf_putc(&v23, 0);
dbuf_put_u32(&v23, (unsigned int)v13);
}
else
{
v14 = *(_QWORD *)(*(_QWORD *)(v11 + 104) + 8 * v13);
dbuf_putc(&v23, *(_QWORD *)(v14 + 4) >> 62);
JS_WriteString(&v22, v14);
}
}
v15 = SDWORD2(v23);
if ( !(unsigned int)dbuf_realloc((long long)&v19, SDWORD2(v23) + *((_QWORD *)&v19 + 1)) )
{
memmove(v19 + v15, v19, *((_QWORD *)&v19 + 1));
memcpy(v19, v23, v15);
*((_QWORD *)&v19 + 1) += v15;
dbuf_free((long long)&v23);
v25 = v21;
v24 = v20;
v23 = v19;
js_object_list_end(a1, v33);
js_free(a1, v28);
js_free(a1, v29);
*a2 = *((_QWORD *)&v23 + 1);
if ( v18 )
{
*v18 = v31;
v18[1] = v32;
}
else
{
js_free(a1, v31);
}
return v23;
}
dbuf_free((long long)&v19);
a6 = v18;
v9 = a1;
}
js_object_list_end(v9, v33);
js_free(v9, v28);
js_free(v9, v29);
dbuf_free((long long)&v23);
*a2 = 0LL;
if ( a6 )
*a6 = 0LL;
return 0LL;
}
| JS_WriteObject2:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV RBX,R9
MOV R13D,R8D
MOV qword ptr [RSP + 0x8],RCX
MOV R14,RDX
MOV R15,RSI
MOV RBP,RDI
LEA R12,[RSP + 0x60]
MOV EDX,0x88
MOV RDI,R12
XOR ESI,ESI
CALL 0x0010e360
MOV qword ptr [R12 + -0x8],RBP
MOV EAX,R13D
AND EAX,0x1
MOV ECX,R13D
AND ECX,0x4
SHL ECX,0x6
MOV EDX,R13D
AND EDX,0x8
SHL EDX,0xd
OR EDX,ECX
AND R13D,0x30
SHL R13D,0x14
OR R13D,EDX
OR R13D,EAX
XOR R13D,0x3000000
MOV dword ptr [R12 + 0x30],R13D
TEST EAX,EAX
PUSH 0x1
POP RAX
MOV ECX,0xe0
CMOVZ ECX,EAX
MOV dword ptr [R12 + 0x34],ECX
MOV RDI,RBP
MOV RSI,R12
CALL 0x00129e23
LEA R13,[RSP + 0xc8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13 + 0x10],XMM0
MOVUPS xmmword ptr [R13],XMM0
LEA RDI,[RSP + 0x58]
MOV RSI,R14
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x00129e39
TEST EAX,EAX
JNZ 0x00129d04
MOV qword ptr [RSP + 0x10],RBP
MOV qword ptr [RSP + 0x18],R15
MOV qword ptr [RSP + 0x8],RBX
LEA RBP,[RSP + 0x58]
MOV RDI,qword ptr [RBP]
MOV RBX,qword ptr [RDI + 0x18]
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS XMM1,xmmword ptr [R12 + 0x10]
MOVUPS XMM2,xmmword ptr [R12 + 0x20]
MOVAPS xmmword ptr [RSP + 0x40],XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RSI,R12
CALL 0x00129e23
PUSH 0x13
POP RSI
MOV RDI,R12
CALL 0x00115d33
MOV ESI,dword ptr [RBP + 0x58]
MOV RDI,R12
CALL 0x0013cf8f
XOR R13D,R13D
LAB_00129c68:
MOVSXD RAX,dword ptr [RSP + 0xb0]
CMP R13,RAX
JGE 0x00129cc9
MOV RAX,qword ptr [RSP + 0xa8]
MOVSXD R14,dword ptr [RAX + R13*0x4]
CMP R14,0xdf
JLE 0x00129caf
MOV RAX,qword ptr [RBX + 0x68]
MOV R14,qword ptr [RAX + R14*0x8]
MOV RSI,qword ptr [R14 + 0x4]
SHR RSI,0x3e
MOV RDI,R12
CALL 0x00115d33
MOV RDI,RBP
MOV RSI,R14
CALL 0x0013ceda
JMP 0x00129cc4
LAB_00129caf:
MOV RDI,R12
XOR ESI,ESI
CALL 0x00115d33
MOV RDI,R12
MOV ESI,R14D
CALL 0x0013d14f
LAB_00129cc4:
INC R13
JMP 0x00129c68
LAB_00129cc9:
MOVSXD R14,dword ptr [RSP + 0x68]
LEA RDI,[RSP + 0x20]
MOV RSI,qword ptr [RDI + 0x8]
ADD RSI,R14
CALL 0x00115bdf
TEST EAX,EAX
JZ 0x00129d5a
LEA RDI,[RSP + 0x20]
CALL 0x00115e89
MOV RBX,qword ptr [RSP + 0x8]
MOV R15,qword ptr [RSP + 0x18]
LEA R13,[RSP + 0xc8]
MOV RBP,qword ptr [RSP + 0x10]
LAB_00129d04:
MOV RDI,RBP
MOV RSI,R13
CALL 0x0012abca
MOV RSI,qword ptr [RSP + 0x98]
MOV RDI,RBP
CALL 0x0011726e
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDI,RBP
CALL 0x0011726e
MOV RDI,R12
CALL 0x00115e89
AND qword ptr [R15],0x0
TEST RBX,RBX
JZ 0x00129d46
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00129d46:
XOR EAX,EAX
LAB_00129d48:
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00129d5a:
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LEA RDI,[RSI + R14*0x1]
CALL 0x0010e740
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,R14
CALL 0x0010e5c0
ADD qword ptr [RSP + 0x28],R14
MOV RDI,R12
CALL 0x00115e89
MOVAPS XMM0,xmmword ptr [RSP + 0x20]
MOVAPS XMM1,xmmword ptr [RSP + 0x30]
MOVAPS XMM2,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [R12 + 0x20],XMM2
MOVUPS xmmword ptr [R12 + 0x10],XMM1
MOVUPS xmmword ptr [R12],XMM0
MOV RBX,qword ptr [RSP + 0x10]
MOV RDI,RBX
LEA RSI,[RSP + 0xc8]
CALL 0x0012abca
MOV RSI,qword ptr [RSP + 0x98]
MOV RDI,RBX
CALL 0x0011726e
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDI,RBX
CALL 0x0011726e
MOV RAX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RCX],RAX
MOV RSI,qword ptr [RSP + 0xb8]
MOV RCX,qword ptr [RSP + 0x8]
TEST RCX,RCX
JZ 0x00129e11
MOV qword ptr [RCX],RSI
MOVSXD RAX,dword ptr [RSP + 0xc0]
MOV qword ptr [RCX + 0x8],RAX
JMP 0x00129e19
LAB_00129e11:
MOV RDI,RBX
CALL 0x0011726e
LAB_00129e19:
MOV RAX,qword ptr [RSP + 0x60]
JMP 0x00129d48
|
int8
JS_WriteObject2(long param_1,int8 *param_2,int8 param_3,int8 param_4,uint param_5,
int8 *param_6)
{
long lVar1;
int iVar2;
long lVar3;
long lVar4;
size_t __n;
int4 local_f8;
int4 uStack_f4;
int8 uStack_f0;
int4 local_e8;
int4 uStack_e4;
int4 uStack_e0;
int4 uStack_dc;
int4 local_d8;
int4 uStack_d4;
int4 uStack_d0;
int4 uStack_cc;
long local_c0;
int4 local_b8;
int4 uStack_b4;
int iStack_b0;
int4 uStack_ac;
int4 local_a8;
int4 uStack_a4;
int4 uStack_a0;
int4 uStack_9c;
int4 local_98;
int4 uStack_94;
int4 uStack_90;
int4 uStack_8c;
uint local_88;
int4 local_84;
int8 local_80;
long local_70;
int local_68;
int8 local_60;
int local_58;
int8 local_50;
int8 uStack_48;
int8 local_40;
int8 uStack_38;
memset(&local_b8,0,0x88);
local_88 = ((param_5 & 0x30) << 0x14 | (param_5 & 8) << 0xd | (param_5 & 4) << 6 | param_5 & 1) ^
0x3000000;
local_84 = 0xe0;
if ((param_5 & 1) == 0) {
local_84 = 1;
}
local_c0 = param_1;
js_dbuf_init(param_1,&local_b8);
local_40 = 0;
uStack_38 = 0;
local_50 = 0;
uStack_48 = 0;
iVar2 = JS_WriteObjectRec(&local_c0,param_3,param_4);
if (iVar2 == 0) {
lVar1 = *(long *)(local_c0 + 0x18);
local_d8 = local_98;
uStack_d4 = uStack_94;
uStack_d0 = uStack_90;
uStack_cc = uStack_8c;
local_e8 = local_a8;
uStack_e4 = uStack_a4;
uStack_e0 = uStack_a0;
uStack_dc = uStack_9c;
local_f8 = local_b8;
uStack_f4 = uStack_b4;
uStack_f0 = CONCAT44(uStack_ac,iStack_b0);
js_dbuf_init(local_c0,&local_b8);
dbuf_putc(&local_b8,0x13);
dbuf_put_leb128(&local_b8,local_68);
for (lVar3 = 0; lVar3 < local_68; lVar3 = lVar3 + 1) {
lVar4 = (long)*(int *)(local_70 + lVar3 * 4);
if (lVar4 < 0xe0) {
dbuf_putc(&local_b8,0);
dbuf_put_u32(&local_b8);
}
else {
dbuf_putc(&local_b8,*(ulong *)(*(long *)(*(long *)(lVar1 + 0x68) + lVar4 * 8) + 4) >> 0x3e);
JS_WriteString(&local_c0);
}
}
__n = (size_t)iStack_b0;
iVar2 = dbuf_realloc(&local_f8,uStack_f0 + __n);
if (iVar2 == 0) {
memmove((void *)((long)CONCAT44(uStack_f4,local_f8) + __n),
(void *)CONCAT44(uStack_f4,local_f8),uStack_f0);
memcpy((void *)CONCAT44(uStack_f4,local_f8),(void *)CONCAT44(uStack_b4,local_b8),__n);
uStack_f0 = uStack_f0 + __n;
dbuf_free(&local_b8);
local_98 = local_d8;
uStack_94 = uStack_d4;
uStack_90 = uStack_d0;
uStack_8c = uStack_cc;
local_a8 = local_e8;
uStack_a4 = uStack_e4;
uStack_a0 = uStack_e0;
uStack_9c = uStack_dc;
local_b8 = local_f8;
uStack_b4 = uStack_f4;
iStack_b0 = (int4)uStack_f0;
uStack_ac = uStack_f0._4_4_;
js_object_list_end(param_1,&local_50);
js_free(param_1,local_80);
js_free(param_1,local_70);
*param_2 = CONCAT44(uStack_ac,iStack_b0);
if (param_6 == (int8 *)0x0) {
js_free(param_1);
}
else {
*param_6 = local_60;
param_6[1] = (long)local_58;
}
return CONCAT44(uStack_b4,local_b8);
}
dbuf_free(&local_f8);
}
js_object_list_end(param_1,&local_50);
js_free(param_1,local_80);
js_free(param_1,local_70);
dbuf_free(&local_b8);
*param_2 = 0;
if (param_6 != (int8 *)0x0) {
*param_6 = 0;
param_6[1] = 0;
}
return 0;
}
| |
24,503 | google::protobuf::UninterpretedOption_NamePart::_InternalParse(char const*, google::protobuf::internal::ParseContext*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | const char* UninterpretedOption_NamePart::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
_Internal::HasBits has_bits{};
while (!ctx->Done(&ptr)) {
uint32_t tag;
ptr = ::_pbi::ReadTag(ptr, &tag);
switch (tag >> 3) {
// required string name_part = 1;
case 1:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
auto str = _internal_mutable_name_part();
ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
CHK_(ptr);
#ifndef NDEBUG
::_pbi::VerifyUTF8(str, "google.protobuf.UninterpretedOption.NamePart.name_part");
#endif // !NDEBUG
} else
goto handle_unusual;
continue;
// required bool is_extension = 2;
case 2:
if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
_Internal::set_has_is_extension(&has_bits);
_impl_.is_extension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
CHK_(ptr);
} else
goto handle_unusual;
continue;
default:
goto handle_unusual;
} // switch
handle_unusual:
if ((tag == 0) || ((tag & 7) == 4)) {
CHK_(ptr);
ctx->SetLastTag(tag);
goto message_done;
}
ptr = UnknownFieldParse(
tag,
_internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
ptr, ctx);
CHK_(ptr != nullptr);
} // while
message_done:
_impl_._has_bits_.Or(has_bits);
return ptr;
failure:
ptr = nullptr;
goto message_done;
#undef CHK_
} | O0 | cpp | google::protobuf::UninterpretedOption_NamePart::_InternalParse(char const*, google::protobuf::internal::ParseContext*):
subq $0x88, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x44(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
movl $0x0, (%rax)
addq $0x4, %rax
cmpq %rcx, %rax
movq %rax, 0x30(%rsp)
jne 0xc8950
jmp 0xc8970
movq 0x48(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd41f0
xorb $-0x1, %al
testb $0x1, %al
jne 0xc898a
jmp 0xc8b47
movq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0xd4220
movq %rax, 0x50(%rsp)
movl 0x40(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0xc89c0
jmp 0xc89b2
movl 0x1c(%rsp), %eax
subl $0x2, %eax
je 0xc8a13
jmp 0xc8a67
movl 0x40(%rsp), %eax
movzbl %al, %eax
cmpl $0xa, %eax
jne 0xc8a0c
movq 0x20(%rsp), %rdi
callq 0xdb990
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x1b4980
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc8a05
jmp 0xc8a0a
jmp 0xc8b69
jmp 0xc8a0e
jmp 0xc8a69
jmp 0xc8970
movl 0x40(%rsp), %eax
movzbl %al, %eax
cmpl $0x10, %eax
jne 0xc8a60
leaq 0x44(%rsp), %rdi
callq 0xdb9f0
leaq 0x50(%rsp), %rdi
callq 0xd72e0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
cmpq $0x0, 0x50(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc8a59
jmp 0xc8a5e
jmp 0xc8b69
jmp 0xc8a62
jmp 0xc8a69
jmp 0xc8970
jmp 0xc8a69
cmpl $0x0, 0x40(%rsp)
je 0xc8a7c
movl 0x40(%rsp), %eax
andl $0x7, %eax
cmpl $0x4, %eax
jne 0xc8aa5
cmpq $0x0, 0x50(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc8a8d
jmp 0xc8a92
jmp 0xc8b69
movq 0x48(%rsp), %rdi
movl 0x40(%rsp), %esi
callq 0xd4350
jmp 0xc8b49
movq 0x20(%rsp), %rax
movl 0x40(%rsp), %ecx
movq %rcx, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xc8b02
movq 0x10(%rsp), %rdi
callq 0x9cd40
addq $0x8, %rax
movq %rax, 0x68(%rsp)
jmp 0xc8b11
movq 0x10(%rsp), %rdi
callq 0xdf250
movq %rax, 0x68(%rsp)
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x163b20
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc8b40
jmp 0xc8b42
jmp 0xc8b69
jmp 0xc8970
jmp 0xc8b49
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0x44(%rsp), %rsi
callq 0xd5090
movq 0x50(%rsp), %rax
addq $0x88, %rsp
retq
movq $0x0, 0x50(%rsp)
jmp 0xc8b49
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf28UninterpretedOption_NamePart14_InternalParseEPKcPNS0_8internal12ParseContextE:
sub rsp, 88h
mov qword ptr [rsp+88h+var_30], rdi; int
mov [rsp+88h+var_38], rsi
mov [rsp+88h+var_40], rdx; int
mov rax, qword ptr [rsp+88h+var_30]
mov qword ptr [rsp+88h+var_68], rax; int
lea rax, [rsp+88h+var_48+4]
mov qword ptr [rsp+88h+var_10], rax; int
mov rax, qword ptr [rsp+88h+var_10]
mov rcx, rax
add rcx, 4
mov qword ptr [rsp+88h+var_60], rcx; int
mov qword ptr [rsp+88h+var_58], rax
loc_C8950:
mov rax, qword ptr [rsp+88h+var_58]
mov rcx, qword ptr [rsp+88h+var_60]
mov dword ptr [rax], 0
add rax, 4
cmp rax, rcx
mov qword ptr [rsp+88h+var_58], rax; int
jnz short loc_C8950
jmp short $+2
loc_C8970:
mov rdi, [rsp+88h+var_40]; this
lea rsi, [rsp+88h+var_38]; char **
call _ZN6google8protobuf8internal12ParseContext4DoneEPPKc; google::protobuf::internal::ParseContext::Done(char const**)
xor al, 0FFh
test al, 1
jnz short loc_C898A
jmp loc_C8B47
loc_C898A:
mov rdi, [rsp+88h+var_38]; this
lea rsi, [rsp+88h+var_48]; char **
xor edx, edx; unsigned int *
call _ZN6google8protobuf8internal7ReadTagEPKcPjj; google::protobuf::internal::ReadTag(char const*,uint *,uint)
mov [rsp+88h+var_38], rax; int
mov eax, dword ptr [rsp+88h+var_48]
shr eax, 3
mov [rsp+88h+var_6C], eax
sub eax, 1
jz short loc_C89C0
jmp short $+2
loc_C89B2:
mov eax, [rsp+88h+var_6C]
sub eax, 2
jz short loc_C8A13
jmp loc_C8A67
loc_C89C0:
mov eax, dword ptr [rsp+88h+var_48]
movzx eax, al
cmp eax, 0Ah
jnz short loc_C8A0C
mov rdi, qword ptr [rsp+88h+var_68]
call _ZN6google8protobuf28UninterpretedOption_NamePart27_internal_mutable_name_partB5cxx11Ev; google::protobuf::UninterpretedOption_NamePart::_internal_mutable_name_part(void)
mov [rsp+88h+var_50], rax
mov rdi, [rsp+88h+var_50]
mov rsi, [rsp+88h+var_38]
mov rdx, [rsp+88h+var_40]
call _ZN6google8protobuf8internal24InlineGreedyStringParserEPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKcPNS1_12ParseContextE; google::protobuf::internal::InlineGreedyStringParser(std::string *,char const*,google::protobuf::internal::ParseContext *)
mov [rsp+88h+var_38], rax
cmp [rsp+88h+var_38], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_C8A05
jmp short loc_C8A0A
loc_C8A05:
jmp loc_C8B69
loc_C8A0A:
jmp short loc_C8A0E
loc_C8A0C:
jmp short loc_C8A69
loc_C8A0E:
jmp loc_C8970
loc_C8A13:
mov eax, dword ptr [rsp+88h+var_48]
movzx eax, al
cmp eax, 10h
jnz short loc_C8A60
lea rdi, [rsp+88h+var_48+4]
call _ZN6google8protobuf28UninterpretedOption_NamePart9_Internal20set_has_is_extensionEPNS0_8internal7HasBitsILm1EEE; google::protobuf::UninterpretedOption_NamePart::_Internal::set_has_is_extension(google::protobuf::internal::HasBits<1ul> *)
lea rdi, [rsp+88h+var_38]; this
call _ZN6google8protobuf8internal12ReadVarint64EPPKc; google::protobuf::internal::ReadVarint64(char const**)
mov rcx, rax
mov rax, qword ptr [rsp+88h+var_68]
cmp rcx, 0
setnz cl
and cl, 1
mov [rax+20h], cl
cmp [rsp+88h+var_38], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_C8A59
jmp short loc_C8A5E
loc_C8A59:
jmp loc_C8B69
loc_C8A5E:
jmp short loc_C8A62
loc_C8A60:
jmp short loc_C8A69
loc_C8A62:
jmp loc_C8970
loc_C8A67:
jmp short $+2
loc_C8A69:
cmp dword ptr [rsp+88h+var_48], 0
jz short loc_C8A7C
mov eax, dword ptr [rsp+88h+var_48]
and eax, 7
cmp eax, 4
jnz short loc_C8AA5
loc_C8A7C:
cmp [rsp+88h+var_38], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_C8A8D
jmp short loc_C8A92
loc_C8A8D:
jmp loc_C8B69
loc_C8A92:
mov rdi, [rsp+88h+var_40]; this
mov esi, dword ptr [rsp+88h+var_48]; unsigned int
call _ZN6google8protobuf8internal18EpsCopyInputStream10SetLastTagEj; google::protobuf::internal::EpsCopyInputStream::SetLastTag(uint)
jmp loc_C8B49
loc_C8AA5:
mov rax, qword ptr [rsp+88h+var_68]
mov ecx, dword ptr [rsp+88h+var_48]; int
mov [rsp+88h+var_80], rcx; int
add rax, 8
mov [rsp+88h+var_28], rax; int
mov rax, [rsp+88h+var_28]
mov [rsp+88h+var_78], rax; void *
mov [rsp+88h+var_18], rax; int
mov rax, [rsp+88h+var_18]
mov [rsp+88h+var_8], rax; __int64
mov rax, [rsp+88h+var_8]
mov rax, [rax]
and rax, 1
cmp rax, 0
jz short loc_C8B02
mov rdi, [rsp+88h+var_78]
call _ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS2_9ContainerINS0_15UnknownFieldSetEEEEEPT_v; google::protobuf::internal::InternalMetadata::PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>(void)
add rax, 8
mov [rsp+88h+var_20], rax
jmp short loc_C8B11
loc_C8B02:
mov rdi, [rsp+88h+var_78]; int
call _ZN6google8protobuf8internal16InternalMetadata27mutable_unknown_fields_slowINS0_15UnknownFieldSetEEEPT_v; google::protobuf::internal::InternalMetadata::mutable_unknown_fields_slow<google::protobuf::UnknownFieldSet>(void)
mov [rsp+88h+var_20], rax
loc_C8B11:
mov rdi, [rsp+88h+var_80]; this
mov rsi, [rsp+88h+var_20]; unsigned __int64
mov rdx, [rsp+88h+var_38]; google::protobuf::UnknownFieldSet *
mov rcx, [rsp+88h+var_40]; char *
call _ZN6google8protobuf8internal17UnknownFieldParseEmPNS0_15UnknownFieldSetEPKcPNS1_12ParseContextE; google::protobuf::internal::UnknownFieldParse(ulong,google::protobuf::UnknownFieldSet *,char const*,google::protobuf::internal::ParseContext *)
mov [rsp+88h+var_38], rax
cmp [rsp+88h+var_38], 0
setnz al
xor al, 0FFh
test al, 1
jnz short loc_C8B40
jmp short loc_C8B42
loc_C8B40:
jmp short loc_C8B69
loc_C8B42:
jmp loc_C8970
loc_C8B47:
jmp short $+2
loc_C8B49:
mov rdi, qword ptr [rsp+88h+var_68]
add rdi, 10h
lea rsi, [rsp+88h+var_48+4]
call _ZN6google8protobuf8internal7HasBitsILm1EE2OrERKS3_; google::protobuf::internal::HasBits<1ul>::Or(google::protobuf::internal::HasBits<1ul> const&)
mov rax, [rsp+88h+var_38]
add rsp, 88h
retn
loc_C8B69:
mov [rsp+88h+var_38], 0
jmp short loc_C8B49
| google::protobuf::internal * google::protobuf::UninterpretedOption_NamePart::_InternalParse(
google::protobuf::UninterpretedOption_NamePart *this,
google::protobuf::internal *a2,
google::protobuf::internal::ParseContext *a3)
{
unsigned int v3; // ecx
int v4; // edx
int v5; // r8d
int v6; // r9d
google::protobuf::internal::ParseContext *v7; // r8
int v9; // [rsp+0h] [rbp-88h]
google::protobuf::internal *v10; // [rsp+8h] [rbp-80h]
_QWORD *v11; // [rsp+10h] [rbp-78h]
int v12; // [rsp+18h] [rbp-70h]
google::protobuf::UninterpretedOption_NamePart *v13; // [rsp+20h] [rbp-68h]
google::protobuf::internal::EpsCopyInputStream **v14; // [rsp+28h] [rbp-60h]
google::protobuf::internal::EpsCopyInputStream **v15; // [rsp+30h] [rbp-58h]
long long v16; // [rsp+38h] [rbp-50h]
char *v17; // [rsp+40h] [rbp-48h] BYREF
google::protobuf::internal::EpsCopyInputStream *v18; // [rsp+48h] [rbp-40h] BYREF
google::protobuf::internal *Tag; // [rsp+50h] [rbp-38h] BYREF
int v20[2]; // [rsp+58h] [rbp-30h]
void *v21; // [rsp+60h] [rbp-28h]
unsigned long long v22; // [rsp+68h] [rbp-20h]
long long v23; // [rsp+70h] [rbp-18h]
int v24[2]; // [rsp+78h] [rbp-10h]
long long v25; // [rsp+80h] [rbp-8h]
*(_QWORD *)v20 = this;
Tag = a2;
v18 = a3;
v13 = this;
*(_QWORD *)v24 = (char *)&v17 + 4;
v14 = &v18;
v15 = (google::protobuf::internal::EpsCopyInputStream **)((char *)&v17 + 4);
do
{
*(_DWORD *)v15 = 0;
v15 = (google::protobuf::internal::EpsCopyInputStream **)((char *)v15 + 4);
}
while ( v15 != &v18 );
while ( (google::protobuf::internal::ParseContext::Done(v18, (const char **)&Tag) & 1) == 0 )
{
Tag = (google::protobuf::internal *)google::protobuf::internal::ReadTag(Tag, (const char *)&v17, 0LL, v3);
if ( (unsigned int)v17 >> 3 == 1 )
{
if ( (unsigned __int8)v17 != 10 )
goto LABEL_14;
v16 = google::protobuf::UninterpretedOption_NamePart::_internal_mutable_name_part[abi:cxx11](v13);
Tag = (google::protobuf::internal *)google::protobuf::internal::InlineGreedyStringParser(v16, Tag, v18);
if ( !Tag )
goto LABEL_24;
}
else if ( (unsigned int)v17 >> 3 == 2 && (unsigned __int8)v17 == 16 )
{
google::protobuf::UninterpretedOption_NamePart::_Internal::set_has_is_extension((char *)&v17 + 4);
*((_BYTE *)v13 + 32) = google::protobuf::internal::ReadVarint64(
(google::protobuf::internal *)&Tag,
(const char **)&v17) != 0;
if ( !Tag )
goto LABEL_24;
}
else
{
LABEL_14:
if ( !(_DWORD)v17 || ((unsigned __int8)v17 & 7) == 4 )
{
if ( Tag )
{
google::protobuf::internal::EpsCopyInputStream::SetLastTag(v18, (unsigned int)v17);
break;
}
LABEL_24:
Tag = 0LL;
break;
}
v10 = (google::protobuf::internal *)(unsigned int)v17;
v21 = (char *)v13 + 8;
v11 = (_QWORD *)((char *)v13 + 8);
v23 = (long long)v13 + 8;
v25 = (long long)v13 + 8;
if ( (*((_QWORD *)v13 + 1) & 1LL) != 0 )
v22 = google::protobuf::internal::InternalMetadata::PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>(v11)
+ 8;
else
v22 = google::protobuf::internal::InternalMetadata::mutable_unknown_fields_slow<google::protobuf::UnknownFieldSet>(
(int)v11,
(int)&v17,
v4,
(int)v17,
v5,
v6,
v9,
(int)v17,
v11,
v12,
(int)v13,
(int)v14,
(int)v15,
v16,
(int)v17,
(int)v18,
(int)Tag,
v20[0],
(int)v21,
v22,
v23,
v24[0],
v25);
Tag = (google::protobuf::internal *)google::protobuf::internal::UnknownFieldParse(
v10,
v22,
Tag,
(const char *)v18,
v7);
if ( !Tag )
goto LABEL_24;
}
}
google::protobuf::internal::HasBits<1ul>::Or((char *)v13 + 16, (char *)&v17 + 4);
return Tag;
}
| _InternalParse:
SUB RSP,0x88
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[RSP + 0x44]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RAX
LAB_001c8950:
MOV RAX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
JNZ 0x001c8950
JMP 0x001c8970
LAB_001c8970:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[RSP + 0x50]
CALL 0x001d41f0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c898a
JMP 0x001c8b47
LAB_001c898a:
MOV RDI,qword ptr [RSP + 0x50]
LEA RSI,[RSP + 0x40]
XOR EDX,EDX
CALL 0x001d4220
MOV qword ptr [RSP + 0x50],RAX
MOV EAX,dword ptr [RSP + 0x40]
SHR EAX,0x3
MOV dword ptr [RSP + 0x1c],EAX
SUB EAX,0x1
JZ 0x001c89c0
JMP 0x001c89b2
LAB_001c89b2:
MOV EAX,dword ptr [RSP + 0x1c]
SUB EAX,0x2
JZ 0x001c8a13
JMP 0x001c8a67
LAB_001c89c0:
MOV EAX,dword ptr [RSP + 0x40]
MOVZX EAX,AL
CMP EAX,0xa
JNZ 0x001c8a0c
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001db990
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x002b4980
MOV qword ptr [RSP + 0x50],RAX
CMP qword ptr [RSP + 0x50],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c8a05
JMP 0x001c8a0a
LAB_001c8a05:
JMP 0x001c8b69
LAB_001c8a0a:
JMP 0x001c8a0e
LAB_001c8a0c:
JMP 0x001c8a69
LAB_001c8a0e:
JMP 0x001c8970
LAB_001c8a13:
MOV EAX,dword ptr [RSP + 0x40]
MOVZX EAX,AL
CMP EAX,0x10
JNZ 0x001c8a60
LEA RDI,[RSP + 0x44]
CALL 0x001db9f0
LEA RDI,[RSP + 0x50]
CALL 0x001d72e0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
CMP RCX,0x0
SETNZ CL
AND CL,0x1
MOV byte ptr [RAX + 0x20],CL
CMP qword ptr [RSP + 0x50],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c8a59
JMP 0x001c8a5e
LAB_001c8a59:
JMP 0x001c8b69
LAB_001c8a5e:
JMP 0x001c8a62
LAB_001c8a60:
JMP 0x001c8a69
LAB_001c8a62:
JMP 0x001c8970
LAB_001c8a67:
JMP 0x001c8a69
LAB_001c8a69:
CMP dword ptr [RSP + 0x40],0x0
JZ 0x001c8a7c
MOV EAX,dword ptr [RSP + 0x40]
AND EAX,0x7
CMP EAX,0x4
JNZ 0x001c8aa5
LAB_001c8a7c:
CMP qword ptr [RSP + 0x50],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c8a8d
JMP 0x001c8a92
LAB_001c8a8d:
JMP 0x001c8b69
LAB_001c8a92:
MOV RDI,qword ptr [RSP + 0x48]
MOV ESI,dword ptr [RSP + 0x40]
CALL 0x001d4350
JMP 0x001c8b49
LAB_001c8aa5:
MOV RAX,qword ptr [RSP + 0x20]
MOV ECX,dword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RCX
ADD RAX,0x8
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV RAX,qword ptr [RAX]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001c8b02
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0019cd40
ADD RAX,0x8
MOV qword ptr [RSP + 0x68],RAX
JMP 0x001c8b11
LAB_001c8b02:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001df250
MOV qword ptr [RSP + 0x68],RAX
LAB_001c8b11:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x48]
CALL 0x00263b20
MOV qword ptr [RSP + 0x50],RAX
CMP qword ptr [RSP + 0x50],0x0
SETNZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c8b40
JMP 0x001c8b42
LAB_001c8b40:
JMP 0x001c8b69
LAB_001c8b42:
JMP 0x001c8970
LAB_001c8b47:
JMP 0x001c8b49
LAB_001c8b49:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x10
LEA RSI,[RSP + 0x44]
CALL 0x001d5090
MOV RAX,qword ptr [RSP + 0x50]
ADD RSP,0x88
RET
LAB_001c8b69:
MOV qword ptr [RSP + 0x50],0x0
JMP 0x001c8b49
|
/* google::protobuf::UninterpretedOption_NamePart::_InternalParse(char const*,
google::protobuf::internal::ParseContext*) */
char * __thiscall
google::protobuf::UninterpretedOption_NamePart::_InternalParse
(UninterpretedOption_NamePart *this,char *param_1,ParseContext *param_2)
{
byte bVar1;
string *psVar2;
long lVar3;
Container *pCVar4;
ulong uVar5;
HasBits *local_58;
uint local_48;
HasBits local_44 [4];
ParseContext *local_40;
char *local_38;
UninterpretedOption_NamePart *local_30;
InternalMetadata *local_28;
UnknownFieldSet *local_20;
InternalMetadata *local_18;
HasBits *local_10;
InternalMetadata *local_8;
local_58 = local_44;
local_40 = param_2;
local_38 = param_1;
local_30 = this;
local_10 = local_58;
do {
*(int4 *)local_58 = 0;
local_58 = local_58 + 4;
} while (local_58 != (HasBits *)&local_40);
do {
while( true ) {
bVar1 = internal::ParseContext::Done(local_40,&local_38);
if (((bVar1 ^ 0xff) & 1) == 0) goto LAB_001c8b49;
local_38 = (char *)internal::ReadTag(local_38,&local_48,0);
if (local_48 >> 3 != 1) break;
if ((local_48 & 0xff) == 10) {
psVar2 = (string *)_internal_mutable_name_part_abi_cxx11_(this);
local_38 = (char *)internal::InlineGreedyStringParser(psVar2,local_38,local_40);
}
else {
LAB_001c8a69:
if ((local_48 == 0) || ((local_48 & 7) == 4)) {
if (local_38 != (char *)0x0) {
internal::EpsCopyInputStream::SetLastTag((EpsCopyInputStream *)local_40,local_48);
goto LAB_001c8b49;
}
goto LAB_001c8b69;
}
uVar5 = (ulong)local_48;
local_28 = (InternalMetadata *)(this + 8);
local_18 = local_28;
local_8 = local_28;
if ((*(ulong *)local_28 & 1) == 0) {
local_20 = internal::InternalMetadata::
mutable_unknown_fields_slow<google::protobuf::UnknownFieldSet>(local_28);
}
else {
pCVar4 = internal::InternalMetadata::
PtrValue<google::protobuf::internal::InternalMetadata::Container<google::protobuf::UnknownFieldSet>>
(local_28);
local_20 = (UnknownFieldSet *)(pCVar4 + 8);
}
local_38 = (char *)internal::UnknownFieldParse(uVar5,local_20,local_38,local_40);
}
if (local_38 == (char *)0x0) goto LAB_001c8b69;
}
if ((local_48 >> 3 != 2) || ((local_48 & 0xff) != 0x10)) goto LAB_001c8a69;
_Internal::set_has_is_extension(local_44);
lVar3 = internal::ReadVarint64(&local_38);
this[0x20] = (UninterpretedOption_NamePart)(lVar3 != 0);
} while (local_38 != (char *)0x0);
LAB_001c8b69:
local_38 = (char *)0x0;
LAB_001c8b49:
internal::HasBits<1ul>::Or((HasBits<1ul> *)(this + 0x10),local_44);
return local_38;
}
| |
24,504 | uf_endspace | eloqsql/storage/maria/ma_packrec.c | static void uf_endspace(MARIA_COLUMNDEF *rec, MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill(end - spaces, spaces, ' ');
} | O3 | c | uf_endspace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movl 0x4(%rsi), %ecx
movl 0x24(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x3aeb1
subl %ecx, %r13d
leaq 0xa62ae(%rip), %rax # 0xe1120
movl (%rax,%rcx,4), %r14d
andl (%r15), %r14d
movl %r13d, %ecx
shll %cl, %r14d
movq %rdi, -0x30(%rbp)
movq %r15, %rdi
movq %rdx, %r12
callq 0x3a694
movq -0x30(%rbp), %rdi
movq %r12, %rdx
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %r14d, %eax
jmp 0x3aeca
movl (%r15), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r15)
shrl %cl, %eax
movl 0x24(%rdi), %ecx
leaq 0xa6259(%rip), %rsi # 0xe1120
andl (%rsi,%rcx,4), %eax
movl %eax, %r13d
leaq (%rdx,%r13), %rax
cmpq %rbx, %rax
jbe 0x3aeed
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
negq %r14
cmpq %rbx, %rax
je 0x3af04
leaq (%rbx,%r14), %rcx
movq %r15, %rsi
callq 0x3a851
addq %r14, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292c0
| uf_endspace:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r15, rsi
mov ecx, [rsi+4]
mov r13d, [rdi+24h]
cmp ecx, r13d
jnb short loc_3AEB1
sub r13d, ecx
lea rax, mask
mov r14d, [rax+rcx*4]
and r14d, [r15]
mov ecx, r13d
shl r14d, cl
mov [rbp+var_30], rdi
mov rdi, r15
mov r12, rdx
call fill_buffer
mov rdi, [rbp+var_30]
mov rdx, r12
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, r14d
jmp short loc_3AECA
loc_3AEB1:
mov eax, [r15]
sub ecx, r13d
mov [r15+4], ecx
shr eax, cl
mov ecx, [rdi+24h]
lea rsi, mask
and eax, [rsi+rcx*4]
loc_3AECA:
mov r13d, eax
lea rax, [rdx+r13]
cmp rax, rbx
jbe short loc_3AEED
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3AEED:
mov r14, r13
neg r14
cmp rax, rbx
jz short loc_3AF04
lea rcx, [rbx+r14]
mov rsi, r15
call decode_bytes
loc_3AF04:
add rbx, r14
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
| unsigned long long uf_endspace(long long a1, unsigned int *a2, _BYTE *a3, unsigned long long a4)
{
long long v5; // rcx
unsigned int v6; // r13d
int v7; // r13d
int v8; // r14d
_BYTE *v9; // r12
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // ecx
long long v13; // r13
unsigned long long result; // rax
v5 = a2[1];
v6 = *(_DWORD *)(a1 + 36);
if ( (unsigned int)v5 >= v6 )
{
v11 = *a2;
v12 = v5 - v6;
a2[1] = v12;
v10 = mask[*(unsigned int *)(a1 + 36)] & (v11 >> v12);
}
else
{
v7 = v6 - v5;
v8 = (*a2 & mask[v5]) << v7;
v9 = a3;
fill_buffer((long long)a2);
a3 = v9;
a2[1] = 32 - v7;
v10 = v8 + (*a2 >> -(char)v7);
}
v13 = v10;
result = (unsigned long long)&a3[v10];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes(a1, (long long)a2, a3, (_BYTE *)(a4 - v13));
return memset(a4 - v13, 32LL, v13);
}
else
{
a2[10] = 1;
}
return result;
}
| uf_endspace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15,RSI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x24]
CMP ECX,R13D
JNC 0x0013aeb1
SUB R13D,ECX
LEA RAX,[0x1e1120]
MOV R14D,dword ptr [RAX + RCX*0x4]
AND R14D,dword ptr [R15]
MOV ECX,R13D
SHL R14D,CL
MOV qword ptr [RBP + -0x30],RDI
MOV RDI,R15
MOV R12,RDX
CALL 0x0013a694
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,R12
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,R14D
JMP 0x0013aeca
LAB_0013aeb1:
MOV EAX,dword ptr [R15]
SUB ECX,R13D
MOV dword ptr [R15 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [RDI + 0x24]
LEA RSI,[0x1e1120]
AND EAX,dword ptr [RSI + RCX*0x4]
LAB_0013aeca:
MOV R13D,EAX
LEA RAX,[RDX + R13*0x1]
CMP RAX,RBX
JBE 0x0013aeed
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013aeed:
MOV R14,R13
NEG R14
CMP RAX,RBX
JZ 0x0013af04
LEA RCX,[RBX + R14*0x1]
MOV RSI,R15
CALL 0x0013a851
LAB_0013af04:
ADD RBX,R14
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292c0
|
void uf_endspace(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
byte bVar5;
ulong __n;
uVar4 = param_2[1];
uVar1 = *(uint *)(param_1 + 0x24);
if (uVar4 < uVar1) {
uVar2 = (&mask)[uVar4];
uVar3 = *param_2;
bVar5 = (byte)(uVar1 - uVar4);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar4);
uVar4 = (*param_2 >> (-bVar5 & 0x1f)) + ((uVar2 & uVar3) << (bVar5 & 0x1f));
}
else {
param_2[1] = uVar4 - uVar1;
uVar4 = *param_2 >> ((byte)(uVar4 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x24)];
}
__n = (ulong)uVar4;
if (param_4 < param_3 + __n) {
param_2[10] = 1;
return;
}
if (param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
memset((void *)(param_4 + -__n),0x20,__n);
return;
}
| |
24,505 | rtree_get_req | eloqsql/storage/myisam/rt_index.c | static int rtree_get_req(MI_INFO *info, MI_KEYDEF *keyinfo, uint key_length,
my_off_t page, int level)
{
uchar *k;
uchar *last;
uint nod_flag;
int res;
uchar *page_buf;
uint k_len;
uint *saved_key = (uint*) (info->rtree_recursion_state) + level;
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
return -1;
if (!_mi_fetch_keypage(info, keyinfo, page, DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
k_len = keyinfo->keylength - info->s->base.rec_reflength;
if(info->rtree_recursion_depth >= level)
{
k = page_buf + *saved_key;
if (!nod_flag)
{
/* Only leaf pages contain data references. */
/* Need to check next key with data reference. */
k = rt_PAGE_NEXT_KEY(k, k_len, nod_flag);
}
}
else
{
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
}
last = rt_PAGE_END(page_buf);
for (; k < last; k = rt_PAGE_NEXT_KEY(k, k_len, nod_flag))
{
if (nod_flag)
{
/* this is an internal node in the tree */
switch ((res = rtree_get_req(info, keyinfo, key_length,
_mi_kpos(nod_flag, k), level + 1)))
{
case 0: /* found - exit from recursion */
*saved_key = (uint) (k - page_buf);
goto ok;
case 1: /* not found - continue searching */
info->rtree_recursion_depth = level;
break;
default:
case -1: /* error */
goto err1;
}
}
else
{
/* this is a leaf */
uchar *after_key = rt_PAGE_NEXT_KEY(k, k_len, nod_flag);
info->lastpos = _mi_dpos(info, 0, after_key);
info->lastkey_length = k_len + info->s->base.rec_reflength;
memcpy(info->lastkey, k, info->lastkey_length);
info->rtree_recursion_depth = level;
*saved_key = (uint) (k - page_buf);
if (after_key < last)
{
info->int_keypos = (uchar*)saved_key;
memcpy(info->buff, page_buf, keyinfo->block_length);
info->int_maxpos = rt_PAGE_END(info->buff);
info->buff_used = 0;
}
else
{
info->buff_used = 1;
}
res = 0;
goto ok;
}
}
info->lastpos = HA_OFFSET_ERROR;
my_errno = HA_ERR_KEY_NOT_FOUND;
res = 1;
ok:
my_afree((uchar*)page_buf);
return res;
err1:
my_afree((uchar*)page_buf);
info->lastpos = HA_OFFSET_ERROR;
return -1;
} | O0 | c | rtree_get_req:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movq %rcx, -0x30(%rbp)
movl %r8d, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq 0x3b8(%rax), %rax
movslq -0x34(%rbp), %rcx
leaq (%rax,%rcx,4), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %eax
addl $0xf, %eax
andl $-0x10, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0xca8a1
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xcac7e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x58(%rbp), %r8
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0xbf8c0
cmpq $0x0, %rax
jne 0xca8c9
jmp 0xcac68
movq -0x58(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xca8ec
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x74(%rbp)
jmp 0xca8f3
xorl %eax, %eax
movl %eax, -0x74(%rbp)
jmp 0xca8f3
movl -0x74(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x12(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subl 0x178(%rcx), %eax
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rax
movl 0x3c0(%rax), %eax
cmpl -0x34(%rbp), %eax
jl 0xca97e
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rcx
movl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x4c(%rbp)
jne 0xca97c
movq -0x40(%rbp), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xca956
movl -0x4c(%rbp), %eax
movl %eax, -0x84(%rbp)
jmp 0xca969
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %eax
movl %eax, -0x84(%rbp)
movq -0x80(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0xca990
movq -0x58(%rbp), %rax
addq $0x2, %rax
movl -0x4c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x58(%rbp), %rax
movq -0x58(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
movq -0x58(%rbp), %rdx
movzbl (%rdx), %edx
movzwl %dx, %edx
shll $0x8, %edx
orl %edx, %ecx
movzwl %cx, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xcac3f
cmpl $0x0, -0x4c(%rbp)
je 0xcaa84
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x8c(%rbp)
movl -0x4c(%rbp), %edi
movq -0x40(%rbp), %rsi
callq 0xc0830
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl -0x8c(%rbp), %edx
movq %rax, %rcx
movl -0x34(%rbp), %r8d
incl %r8d
callq 0xca830
movl %eax, -0x50(%rbp)
movl %eax, %ecx
movl %ecx, -0x88(%rbp)
subl $-0x1, %eax
je 0xcaa7a
jmp 0xcaa38
movl -0x88(%rbp), %eax
testl %eax, %eax
je 0xcaa51
jmp 0xcaa44
movl -0x88(%rbp), %eax
subl $0x1, %eax
je 0xcaa69
jmp 0xcaa78
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
jmp 0xcac60
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3c0(%rax)
jmp 0xcaa7f
jmp 0xcaa7a
jmp 0xcac68
jmp 0xcabed
movq -0x40(%rbp), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xa8(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xcaaa6
movl -0x4c(%rbp), %eax
movl %eax, -0xac(%rbp)
jmp 0xcaab9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %eax
movl %eax, -0xac(%rbp)
movq -0xa8(%rbp), %rax
movl -0xac(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
movq -0x70(%rbp), %rdx
xorl %esi, %esi
callq 0xc0ab0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x170(%rax)
movl -0x5c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
addl 0x178(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1d8(%rax)
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x1d8(%rax), %eax
movl %eax, %edx
callq 0x29090
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x3c0(%rax)
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x70(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xcabd9
movq -0x68(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x128(%rax)
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x58(%rbp), %rsi
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %eax
movl %eax, %edx
callq 0x29090
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x100(%rax), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rdx
movq 0x100(%rdx), %rdx
movzbl (%rdx), %edx
movzwl %dx, %edx
shll $0x8, %edx
orl %edx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, %eax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x130(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x33d(%rax)
jmp 0xcabe4
movq -0x18(%rbp), %rax
movb $0x1, 0x33d(%rax)
movl $0x0, -0x50(%rbp)
jmp 0xcac60
jmp 0xcabef
movq -0x40(%rbp), %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0xcac11
movl -0x4c(%rbp), %eax
movl %eax, -0xbc(%rbp)
jmp 0xcac24
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %eax
movl %eax, -0xbc(%rbp)
movq -0xb8(%rbp), %rax
movl -0xbc(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0xca9c0
movq -0x18(%rbp), %rax
movq $-0x1, 0x170(%rax)
callq 0xf7b30
movl $0x78, (%rax)
movl $0x1, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xcac7e
movq -0x18(%rbp), %rax
movq $-0x1, 0x170(%rax)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xcaca4
movl -0xc0(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
callq 0x29230
nopl (%rax)
| rtree_get_req:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_34], r8d
mov rax, [rbp+var_18]
mov rax, [rax+3B8h]
movsxd rcx, [rbp+var_34]
lea rax, [rax+rcx*4]
mov [rbp+var_68], rax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+0Eh]
add eax, 0Fh
and eax, 0FFFFFFF0h
mov ecx, eax
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_58], rax
cmp rax, 0
jnz short loc_CA8A1
mov [rbp+var_C], 0FFFFFFFFh
jmp loc_CAC7E
loc_CA8A1:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_30]
mov r8, [rbp+var_58]
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
cmp rax, 0
jnz short loc_CA8C9
jmp loc_CAC68
loc_CA8C9:
mov rax, [rbp+var_58]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_CA8EC
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_74], eax
jmp short loc_CA8F3
loc_CA8EC:
xor eax, eax
mov [rbp+var_74], eax
jmp short $+2
loc_CA8F3:
mov eax, [rbp+var_74]
mov [rbp+var_4C], eax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+12h]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
sub eax, [rcx+178h]
mov [rbp+var_5C], eax
mov rax, [rbp+var_18]
mov eax, [rax+3C0h]
cmp eax, [rbp+var_34]
jl short loc_CA97E
mov rax, [rbp+var_58]
mov rcx, [rbp+var_68]
mov ecx, [rcx]
add rax, rcx
mov [rbp+var_40], rax
cmp [rbp+var_4C], 0
jnz short loc_CA97C
mov rax, [rbp+var_40]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_80], rax
cmp [rbp+var_4C], 0
jz short loc_CA956
mov eax, [rbp+var_4C]
mov [rbp+var_84], eax
jmp short loc_CA969
loc_CA956:
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax+178h]
mov [rbp+var_84], eax
loc_CA969:
mov rax, [rbp+var_80]
mov ecx, [rbp+var_84]
mov ecx, ecx
add rax, rcx
mov [rbp+var_40], rax
loc_CA97C:
jmp short loc_CA990
loc_CA97E:
mov rax, [rbp+var_58]
add rax, 2
mov ecx, [rbp+var_4C]
add rax, rcx
mov [rbp+var_40], rax
loc_CA990:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_58]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
mov rdx, [rbp+var_58]
movzx edx, byte ptr [rdx]
movzx edx, dx
shl edx, 8
or ecx, edx
movzx ecx, cx
and ecx, 7FFFh
mov ecx, ecx
add rax, rcx
mov [rbp+var_48], rax
loc_CA9C0:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_48]
jnb loc_CAC3F
cmp [rbp+var_4C], 0
jz loc_CAA84
mov rax, [rbp+var_18]
mov [rbp+var_A0], rax
mov rax, [rbp+var_20]
mov [rbp+var_98], rax
mov eax, [rbp+var_24]
mov [rbp+var_8C], eax
mov edi, [rbp+var_4C]
mov rsi, [rbp+var_40]
call _mi_kpos
mov rdi, [rbp+var_A0]
mov rsi, [rbp+var_98]
mov edx, [rbp+var_8C]
mov rcx, rax
mov r8d, [rbp+var_34]
inc r8d
call rtree_get_req
mov [rbp+var_50], eax
mov ecx, eax
mov [rbp+var_88], ecx
sub eax, 0FFFFFFFFh
jz short loc_CAA7A
jmp short $+2
loc_CAA38:
mov eax, [rbp+var_88]
test eax, eax
jz short loc_CAA51
jmp short $+2
loc_CAA44:
mov eax, [rbp+var_88]
sub eax, 1
jz short loc_CAA69
jmp short loc_CAA78
loc_CAA51:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_68]
mov [rax], ecx
jmp loc_CAC60
loc_CAA69:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
mov [rax+3C0h], ecx
jmp short loc_CAA7F
loc_CAA78:
jmp short $+2
loc_CAA7A:
jmp loc_CAC68
loc_CAA7F:
jmp loc_CABED
loc_CAA84:
mov rax, [rbp+var_40]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_A8], rax
cmp [rbp+var_4C], 0
jz short loc_CAAA6
mov eax, [rbp+var_4C]
mov [rbp+var_AC], eax
jmp short loc_CAAB9
loc_CAAA6:
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax+178h]
mov [rbp+var_AC], eax
loc_CAAB9:
mov rax, [rbp+var_A8]
mov ecx, [rbp+var_AC]
mov ecx, ecx
add rax, rcx
mov [rbp+var_70], rax
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_70]
xor esi, esi
call _mi_dpos
mov rcx, rax
mov rax, [rbp+var_18]
mov [rax+170h], rcx
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_18]
mov rax, [rax]
add ecx, [rax+178h]
mov rax, [rbp+var_18]
mov [rax+1D8h], ecx
mov rax, [rbp+var_18]
mov rdi, [rax+108h]
mov rsi, [rbp+var_40]
mov rax, [rbp+var_18]
mov eax, [rax+1D8h]
mov edx, eax
call _memcpy
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
mov [rax+3C0h], ecx
mov rax, [rbp+var_40]
mov rcx, [rbp+var_58]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_68]
mov [rax], ecx
mov rax, [rbp+var_70]
cmp rax, [rbp+var_48]
jnb loc_CABD9
mov rcx, [rbp+var_68]
mov rax, [rbp+var_18]
mov [rax+128h], rcx
mov rax, [rbp+var_18]
mov rdi, [rax+100h]
mov rsi, [rbp+var_58]
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+0Eh]
mov edx, eax
call _memcpy
mov rax, [rbp+var_18]
mov rcx, [rax+100h]
mov rax, [rbp+var_18]
mov rax, [rax+100h]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rdx, [rbp+var_18]
mov rdx, [rdx+100h]
movzx edx, byte ptr [rdx]
movzx edx, dx
shl edx, 8
or eax, edx
movzx eax, ax
and eax, 7FFFh
mov eax, eax
add rcx, rax
mov rax, [rbp+var_18]
mov [rax+130h], rcx
mov rax, [rbp+var_18]
mov byte ptr [rax+33Dh], 0
jmp short loc_CABE4
loc_CABD9:
mov rax, [rbp+var_18]
mov byte ptr [rax+33Dh], 1
loc_CABE4:
mov [rbp+var_50], 0
jmp short loc_CAC60
loc_CABED:
jmp short $+2
loc_CABEF:
mov rax, [rbp+var_40]
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_B8], rax
cmp [rbp+var_4C], 0
jz short loc_CAC11
mov eax, [rbp+var_4C]
mov [rbp+var_BC], eax
jmp short loc_CAC24
loc_CAC11:
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax+178h]
mov [rbp+var_BC], eax
loc_CAC24:
mov rax, [rbp+var_B8]
mov ecx, [rbp+var_BC]
mov ecx, ecx
add rax, rcx
mov [rbp+var_40], rax
jmp loc_CA9C0
loc_CAC3F:
mov rax, [rbp+var_18]
mov qword ptr [rax+170h], 0FFFFFFFFFFFFFFFFh
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov [rbp+var_50], 1
loc_CAC60:
mov eax, [rbp+var_50]
mov [rbp+var_C], eax
jmp short loc_CAC7E
loc_CAC68:
mov rax, [rbp+var_18]
mov qword ptr [rax+170h], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_C], 0FFFFFFFFh
loc_CAC7E:
mov eax, [rbp+var_C]
mov [rbp+var_C0], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_CACA4
mov eax, [rbp+var_C0]
mov rsp, rbp
pop rbp
retn
loc_CACA4:
call ___stack_chk_fail
| long long rtree_get_req(_QWORD *a1, long long a2, unsigned int a3, long long a4, int a5)
{
_QWORD *v5; // rdi
const char *v6; // rsi
long long v7; // rax
long long v8; // rax
int v10; // [rsp+0h] [rbp-C0h] BYREF
unsigned int v11; // [rsp+4h] [rbp-BCh]
unsigned long long v12; // [rsp+8h] [rbp-B8h]
unsigned int v13; // [rsp+14h] [rbp-ACh]
unsigned long long v14; // [rsp+18h] [rbp-A8h]
_QWORD *v15; // [rsp+20h] [rbp-A0h]
long long v16; // [rsp+28h] [rbp-98h]
unsigned int v17; // [rsp+34h] [rbp-8Ch]
unsigned int v18; // [rsp+38h] [rbp-88h]
unsigned int v19; // [rsp+3Ch] [rbp-84h]
unsigned long long v20; // [rsp+40h] [rbp-80h]
unsigned int v21; // [rsp+4Ch] [rbp-74h]
unsigned long long v22; // [rsp+50h] [rbp-70h]
_DWORD *v23; // [rsp+58h] [rbp-68h]
unsigned int v24; // [rsp+64h] [rbp-5Ch]
unsigned __int16 *v25; // [rsp+68h] [rbp-58h]
unsigned int req; // [rsp+70h] [rbp-50h]
unsigned int v27; // [rsp+74h] [rbp-4Ch]
unsigned long long v28; // [rsp+78h] [rbp-48h]
unsigned long long v29; // [rsp+80h] [rbp-40h]
int v30; // [rsp+8Ch] [rbp-34h]
long long v31; // [rsp+90h] [rbp-30h]
unsigned int v32; // [rsp+9Ch] [rbp-24h]
long long v33; // [rsp+A0h] [rbp-20h]
_QWORD *v34; // [rsp+A8h] [rbp-18h]
unsigned long long v36; // [rsp+B8h] [rbp-8h]
v36 = __readfsqword(0x28u);
v34 = a1;
v33 = a2;
v32 = a3;
v31 = a4;
v30 = a5;
v23 = (_DWORD *)(a1[119] + 4LL * a5);
v25 = (unsigned __int16 *)((char *)&v10 - ((*(unsigned __int16 *)(a2 + 14) + 15) & 0xFFFFFFF0));
if ( v25 )
{
v5 = v34;
v6 = (const char *)v33;
if ( mi_fetch_keypage(v34, v33, v31, 3, (int)v25, 0) )
{
if ( (*(_BYTE *)v25 & 0x80) != 0 )
v21 = *(_DWORD *)(*v34 + 380LL);
else
v21 = 0;
v27 = v21;
v24 = *(unsigned __int16 *)(v33 + 18) - *(_DWORD *)(*v34 + 376LL);
if ( *((_DWORD *)v34 + 240) < v30 )
{
v29 = (unsigned long long)v25 + v27 + 2;
}
else
{
v29 = (unsigned long long)v25 + (unsigned int)*v23;
if ( !v27 )
{
v20 = v24 + v29;
v19 = *(_DWORD *)(*v34 + 376LL);
v29 = v19 + v20;
}
}
v28 = (unsigned long long)v25 + (_byteswap_ushort(*v25) & 0x7FFF);
while ( 1 )
{
if ( v29 >= v28 )
{
v34[46] = -1LL;
*(_DWORD *)my_thread_var(v5, v6) = 120;
return 1;
}
if ( !v27 )
break;
v15 = v34;
v16 = v33;
v17 = v32;
v7 = mi_kpos(v27, v29);
v5 = v15;
v6 = (const char *)v16;
req = rtree_get_req(v15, v16, v17, v7, (unsigned int)(v30 + 1));
v18 = req;
if ( req == -1 )
goto LABEL_32;
if ( !v18 )
{
*v23 = v29 - (_DWORD)v25;
return req;
}
if ( v18 != 1 )
goto LABEL_32;
*((_DWORD *)v34 + 240) = v30;
v12 = v24 + v29;
if ( v27 )
v11 = v27;
else
v11 = *(_DWORD *)(*v34 + 376LL);
v29 = v11 + v12;
}
v14 = v24 + v29;
v13 = *(_DWORD *)(*v34 + 376LL);
v22 = v13 + v14;
v8 = mi_dpos((long long)v34, 0, v22);
v34[46] = v8;
*((_DWORD *)v34 + 118) = *(_DWORD *)(*v34 + 376LL) + v24;
memcpy(v34[33], v29, *((unsigned int *)v34 + 118));
*((_DWORD *)v34 + 240) = v30;
*v23 = v29 - (_DWORD)v25;
if ( v22 >= v28 )
{
*((_BYTE *)v34 + 829) = 1;
}
else
{
v34[37] = v23;
memcpy(v34[32], v25, *(unsigned __int16 *)(v33 + 14));
v34[38] = (_byteswap_ushort(*(_WORD *)v34[32]) & 0x7FFF) + v34[32];
*((_BYTE *)v34 + 829) = 0;
}
return 0;
}
else
{
LABEL_32:
v34[46] = -1LL;
return (unsigned int)-1;
}
}
else
{
return (unsigned int)-1;
}
}
| rtree_get_req:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x34],R8D
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x3b8]
MOVSXD RCX,dword ptr [RBP + -0x34]
LEA RAX,[RAX + RCX*0x4]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0xe]
ADD EAX,0xf
AND EAX,0xfffffff0
MOV ECX,EAX
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x58],RAX
CMP RAX,0x0
JNZ 0x001ca8a1
MOV dword ptr [RBP + -0xc],0xffffffff
JMP 0x001cac7e
LAB_001ca8a1:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x58]
MOV ECX,0x3
XOR R9D,R9D
CALL 0x001bf8c0
CMP RAX,0x0
JNZ 0x001ca8c9
JMP 0x001cac68
LAB_001ca8c9:
MOV RAX,qword ptr [RBP + -0x58]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001ca8ec
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x74],EAX
JMP 0x001ca8f3
LAB_001ca8ec:
XOR EAX,EAX
MOV dword ptr [RBP + -0x74],EAX
JMP 0x001ca8f3
LAB_001ca8f3:
MOV EAX,dword ptr [RBP + -0x74]
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x12]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
SUB EAX,dword ptr [RCX + 0x178]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x3c0]
CMP EAX,dword ptr [RBP + -0x34]
JL 0x001ca97e
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RCX]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
CMP dword ptr [RBP + -0x4c],0x0
JNZ 0x001ca97c
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x80],RAX
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x001ca956
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x84],EAX
JMP 0x001ca969
LAB_001ca956:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x178]
MOV dword ptr [RBP + -0x84],EAX
LAB_001ca969:
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,dword ptr [RBP + -0x84]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001ca97c:
JMP 0x001ca990
LAB_001ca97e:
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x2
MOV ECX,dword ptr [RBP + -0x4c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001ca990:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x58]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
MOV RDX,qword ptr [RBP + -0x58]
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DX
SHL EDX,0x8
OR ECX,EDX
MOVZX ECX,CX
AND ECX,0x7fff
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
LAB_001ca9c0:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x001cac3f
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x001caa84
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x98],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x8c],EAX
MOV EDI,dword ptr [RBP + -0x4c]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x001c0830
MOV RDI,qword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x98]
MOV EDX,dword ptr [RBP + -0x8c]
MOV RCX,RAX
MOV R8D,dword ptr [RBP + -0x34]
INC R8D
CALL 0x001ca830
MOV dword ptr [RBP + -0x50],EAX
MOV ECX,EAX
MOV dword ptr [RBP + -0x88],ECX
SUB EAX,-0x1
JZ 0x001caa7a
JMP 0x001caa38
LAB_001caa38:
MOV EAX,dword ptr [RBP + -0x88]
TEST EAX,EAX
JZ 0x001caa51
JMP 0x001caa44
LAB_001caa44:
MOV EAX,dword ptr [RBP + -0x88]
SUB EAX,0x1
JZ 0x001caa69
JMP 0x001caa78
LAB_001caa51:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV dword ptr [RAX],ECX
JMP 0x001cac60
LAB_001caa69:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x3c0],ECX
JMP 0x001caa7f
LAB_001caa78:
JMP 0x001caa7a
LAB_001caa7a:
JMP 0x001cac68
LAB_001caa7f:
JMP 0x001cabed
LAB_001caa84:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0xa8],RAX
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x001caaa6
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0xac],EAX
JMP 0x001caab9
LAB_001caaa6:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x178]
MOV dword ptr [RBP + -0xac],EAX
LAB_001caab9:
MOV RAX,qword ptr [RBP + -0xa8]
MOV ECX,dword ptr [RBP + -0xac]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x70]
XOR ESI,ESI
CALL 0x001c0ab0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x170],RCX
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
ADD ECX,dword ptr [RAX + 0x178]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x1d8],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x108]
MOV RSI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x1d8]
MOV EDX,EAX
CALL 0x00129090
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x3c0],ECX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x48]
JNC 0x001cabd9
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x128],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x100]
MOV RSI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0xe]
MOV EDX,EAX
CALL 0x00129090
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x100]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x100]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RDX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RDX + 0x100]
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DX
SHL EDX,0x8
OR EAX,EDX
MOVZX EAX,AX
AND EAX,0x7fff
MOV EAX,EAX
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x130],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x33d],0x0
JMP 0x001cabe4
LAB_001cabd9:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x33d],0x1
LAB_001cabe4:
MOV dword ptr [RBP + -0x50],0x0
JMP 0x001cac60
LAB_001cabed:
JMP 0x001cabef
LAB_001cabef:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0xb8],RAX
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x001cac11
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0xbc],EAX
JMP 0x001cac24
LAB_001cac11:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x178]
MOV dword ptr [RBP + -0xbc],EAX
LAB_001cac24:
MOV RAX,qword ptr [RBP + -0xb8]
MOV ECX,dword ptr [RBP + -0xbc]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001ca9c0
LAB_001cac3f:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x170],-0x1
CALL 0x001f7b30
MOV dword ptr [RAX],0x78
MOV dword ptr [RBP + -0x50],0x1
LAB_001cac60:
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001cac7e
LAB_001cac68:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x170],-0x1
MOV dword ptr [RBP + -0xc],0xffffffff
LAB_001cac7e:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0xc0],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001caca4
MOV EAX,dword ptr [RBP + -0xc0]
MOV RSP,RBP
POP RBP
RET
LAB_001caca4:
CALL 0x00129230
|
/* WARNING: Removing unreachable block (ram,0x001ca94b) */
/* WARNING: Removing unreachable block (ram,0x001caa9b) */
int rtree_get_req(long *param_1,long param_2,int4 param_3,int8 param_4,int param_5)
{
ushort uVar1;
uint uVar2;
void *pvVar3;
long lVar4;
long *plVar5;
int4 uVar6;
long lVar7;
int8 uVar8;
byte *pbVar9;
int4 *puVar10;
int iVar11;
long in_FS_OFFSET;
int8 uStack_d0;
int local_c8;
uint local_c4;
byte *local_c0;
uint local_b4;
byte *local_b0;
long *local_a8;
long local_a0;
int4 local_94;
int local_90;
uint local_8c;
byte *local_88;
uint local_7c;
byte *local_78;
uint *local_70;
uint local_64;
byte *local_60;
int local_58;
uint local_54;
byte *local_50;
byte *local_48;
int local_3c;
int8 local_38;
int4 local_2c;
long local_28;
long *local_20;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_70 = (uint *)(param_1[0x77] + (long)param_5 * 4);
lVar4 = -(ulong)(*(ushort *)(param_2 + 0xe) + 0xf & 0xfffffff0);
pbVar9 = (byte *)((long)&local_c8 + lVar4);
local_60 = pbVar9;
local_3c = param_5;
local_38 = param_4;
local_2c = param_3;
local_28 = param_2;
local_20 = param_1;
if (pbVar9 == (byte *)0x0) {
local_14 = -1;
}
else {
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1ca8be;
lVar7 = _mi_fetch_keypage(param_1,param_2,param_4,3,pbVar9,0);
if (lVar7 == 0) {
LAB_001cac68:
local_20[0x2e] = -1;
local_14 = -1;
}
else {
if ((*local_60 & 0x80) == 0) {
local_7c = 0;
}
else {
local_7c = *(uint *)(*local_20 + 0x17c);
}
local_54 = local_7c;
local_64 = (uint)*(ushort *)(local_28 + 0x12) - *(int *)(*local_20 + 0x178);
if ((int)local_20[0x78] < local_3c) {
local_48 = local_60 + (ulong)local_7c + 2;
}
else {
local_48 = local_60 + *local_70;
if (local_7c == 0) {
local_88 = local_48 + local_64;
local_8c = *(uint *)(*local_20 + 0x178);
local_48 = local_88 + local_8c;
}
}
local_50 = local_60 + ((uint)local_60[1] | (*local_60 & 0x7f) << 8);
while (plVar5 = local_20, pbVar9 = local_48, uVar2 = local_54, local_48 < local_50) {
if (local_54 == 0) {
local_b0 = local_48 + local_64;
local_b4 = *(uint *)(*local_20 + 0x178);
pbVar9 = local_b0 + local_b4;
local_78 = pbVar9;
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1caade;
lVar7 = _mi_dpos(plVar5,0,pbVar9);
pbVar9 = local_48;
local_20[0x2e] = lVar7;
*(uint *)(local_20 + 0x3b) = local_64 + *(int *)(*local_20 + 0x178);
pvVar3 = (void *)local_20[0x21];
uVar2 = *(uint *)(local_20 + 0x3b);
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1cab26;
memcpy(pvVar3,pbVar9,(ulong)uVar2);
pbVar9 = local_60;
*(int *)(local_20 + 0x78) = local_3c;
*local_70 = (int)local_48 - (int)local_60;
if (local_78 < local_50) {
local_20[0x25] = (long)local_70;
pvVar3 = (void *)local_20[0x20];
uVar1 = *(ushort *)(local_28 + 0xe);
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1cab81;
memcpy(pvVar3,pbVar9,(ulong)uVar1);
local_20[0x26] =
local_20[0x20] +
(ulong)((uint)*(byte *)(local_20[0x20] + 1) | (*(byte *)local_20[0x20] & 0x7f) << 8
);
*(int1 *)((long)local_20 + 0x33d) = 0;
}
else {
*(int1 *)((long)local_20 + 0x33d) = 1;
}
local_58 = 0;
goto LAB_001cac60;
}
local_a8 = local_20;
local_a0 = local_28;
local_94 = local_2c;
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1caa03;
uVar8 = _mi_kpos(uVar2,pbVar9);
uVar6 = local_94;
lVar7 = local_a0;
plVar5 = local_a8;
iVar11 = local_3c + 1;
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1caa26;
local_90 = rtree_get_req(plVar5,lVar7,uVar6,uVar8,iVar11);
local_58 = local_90;
if (local_90 == -1) goto LAB_001cac68;
if (local_90 == 0) {
*local_70 = (int)local_48 - (int)local_60;
goto LAB_001cac60;
}
if (local_90 != 1) goto LAB_001cac68;
*(int *)(local_20 + 0x78) = local_3c;
local_c0 = local_48 + local_64;
if (local_54 == 0) {
local_c4 = *(uint *)(*local_20 + 0x178);
}
else {
local_c4 = local_54;
}
local_58 = 1;
local_48 = local_c0 + local_c4;
}
local_20[0x2e] = -1;
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1cac53;
puVar10 = (int4 *)_my_thread_var();
*puVar10 = 0x78;
local_58 = 1;
LAB_001cac60:
local_14 = local_58;
}
}
local_c8 = local_14;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_14;
}
/* WARNING: Subroutine does not return */
*(int8 *)((long)&uStack_d0 + lVar4) = 0x1caca9;
__stack_chk_fail();
}
| |
24,506 | ma_ck_write_btree | eloqsql/storage/maria/ma_write.c | static my_bool _ma_ck_write_btree(MARIA_HA *info, MARIA_KEY *key)
{
my_bool error;
MARIA_KEYDEF *keyinfo= key->keyinfo;
my_off_t *root= &info->s->state.key_root[keyinfo->key_nr];
DBUG_ENTER("_ma_ck_write_btree");
error= _ma_ck_write_btree_with_log(info, key, root,
keyinfo->write_comp_flag | key->flag);
if (info->ft1_to_ft2)
{
if (!error)
error= _ma_ft_convert_to_ft2(info, key);
delete_dynamic(info->ft1_to_ft2);
my_free(info->ft1_to_ft2);
info->ft1_to_ft2=0;
}
DBUG_RETURN(error);
} | O0 | c | ma_ck_write_btree:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x118(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl 0xa5(%rcx), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movl 0xb4(%rax), %ecx
movq -0x10(%rbp), %rax
orl 0x18(%rax), %ecx
callq 0x6e140
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x320(%rax)
je 0x69ff8
cmpb $0x0, -0x11(%rbp)
jne 0x69fc9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f3c0
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq 0x320(%rax), %rdi
callq 0x105310
movq -0x8(%rbp), %rax
movq 0x320(%rax), %rdi
callq 0x126ac0
movq -0x8(%rbp), %rax
movq $0x0, 0x320(%rax)
jmp 0x69ffa
movb -0x11(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_ck_write_btree:
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+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+118h]
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+0A5h]
shl rcx, 3
add rax, rcx
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_28]
mov rax, [rbp+var_20]
mov ecx, [rax+0B4h]
mov rax, [rbp+var_10]
or ecx, [rax+18h]
call _ma_ck_write_btree_with_log
mov [rbp+var_11], al
mov rax, [rbp+var_8]
cmp qword ptr [rax+320h], 0
jz short loc_69FF8
cmp [rbp+var_11], 0
jnz short loc_69FC9
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _ma_ft_convert_to_ft2
mov [rbp+var_11], al
loc_69FC9:
mov rax, [rbp+var_8]
mov rdi, [rax+320h]
call delete_dynamic
mov rax, [rbp+var_8]
mov rdi, [rax+320h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+320h], 0
loc_69FF8:
jmp short $+2
loc_69FFA:
mov al, [rbp+var_11]
mov [rbp+var_29], al
mov al, [rbp+var_29]
add rsp, 30h
pop rbp
retn
| char ma_ck_write_btree(_QWORD *a1, long long a2)
{
char v3; // [rsp+1Fh] [rbp-11h]
v3 = ma_ck_write_btree_with_log(
a1,
a2,
8LL * *(unsigned __int8 *)(*(_QWORD *)(a2 + 8) + 165LL) + *(_QWORD *)(*a1 + 280LL),
(unsigned int)(*(_DWORD *)(a2 + 24) | *(_DWORD *)(*(_QWORD *)(a2 + 8) + 180LL)));
if ( a1[100] )
{
if ( !v3 )
v3 = ma_ft_convert_to_ft2(a1, a2);
delete_dynamic(a1[100]);
my_free(a1[100]);
a1[100] = 0LL;
}
return v3;
}
| _ma_ck_write_btree:
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 + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x118]
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0xa5]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0xb4]
MOV RAX,qword ptr [RBP + -0x10]
OR ECX,dword ptr [RAX + 0x18]
CALL 0x0016e140
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x320],0x0
JZ 0x00169ff8
CMP byte ptr [RBP + -0x11],0x0
JNZ 0x00169fc9
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0018f3c0
MOV byte ptr [RBP + -0x11],AL
LAB_00169fc9:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x320]
CALL 0x00205310
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x320]
CALL 0x00226ac0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x320],0x0
LAB_00169ff8:
JMP 0x00169ffa
LAB_00169ffa:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x29],AL
MOV AL,byte ptr [RBP + -0x29]
ADD RSP,0x30
POP RBP
RET
|
char _ma_ck_write_btree(long *param_1,long param_2)
{
char local_19;
local_19 = _ma_ck_write_btree_with_log
(param_1,param_2,
*(long *)(*param_1 + 0x118) +
(ulong)*(byte *)(*(long *)(param_2 + 8) + 0xa5) * 8,
*(uint *)(*(long *)(param_2 + 8) + 0xb4) | *(uint *)(param_2 + 0x18));
if (param_1[100] != 0) {
if (local_19 == '\0') {
local_19 = _ma_ft_convert_to_ft2(param_1,param_2);
}
delete_dynamic(param_1[100]);
my_free(param_1[100]);
param_1[100] = 0;
}
return local_19;
}
| |
24,507 | SegmentToPtr | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | void *SegmentToPtr(segment_t *s) {
if (!s) {
HEAP_LOG("Cannot convert NULL segment to pointer\n");
return NULL;
}
// Return aligned pointer after segment metadata
uintptr_t addr = (uintptr_t) s + sizeof(segment_t);
uintptr_t original_addr = addr;
addr = (addr + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
if (original_addr != addr) {
HEAP_LOG("Adjusted user pointer for alignment: %p -> %p\n", (void*)original_addr, (void*)addr);
}
HEAP_LOG("Segment %p converted to user pointer %p\n", s, (void*)addr);
return (void *) addr;
} | O0 | c | SegmentToPtr:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4029
movq $0x0, -0x8(%rbp)
jmp 0x4065
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x405d
jmp 0x405d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| SegmentToPtr:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_4029
mov [rbp+var_8], 0
jmp short loc_4065
loc_4029:
mov rax, [rbp+var_10]
add rax, 30h ; '0'
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
add rax, 10h
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_18]
jz short loc_405D
jmp short $+2
loc_405D:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
loc_4065:
mov rax, [rbp+var_8]
pop rbp
retn
| unsigned long long SegmentToPtr(long long a1)
{
if ( a1 )
return (a1 + 63) & 0xFFFFFFFFFFFFFFF0LL;
else
return 0LL;
}
| SegmentToPtr:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x00104029
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00104065
LAB_00104029:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x30
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x10
SUB RAX,0x1
AND RAX,-0x10
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x18]
JZ 0x0010405d
JMP 0x0010405d
LAB_0010405d:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_00104065:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong SegmentToPtr(long param_1)
{
ulong local_10;
if (param_1 == 0) {
local_10 = 0;
}
else {
local_10 = param_1 + 0x3fU & 0xfffffffffffffff0;
}
return local_10;
}
| |
24,508 | lunasvg::Canvas::strokePath(lunasvg::Path const&, lunasvg::StrokeData const&, lunasvg::Transform const&) | dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp | void Canvas::strokePath(const Path& path, const StrokeData& strokeData, const Transform& transform)
{
plutovg_canvas_reset_matrix(m_canvas);
plutovg_canvas_translate(m_canvas, -m_x, -m_y);
plutovg_canvas_transform(m_canvas, &transform.matrix());
plutovg_canvas_set_line_width(m_canvas, strokeData.lineWidth());
plutovg_canvas_set_miter_limit(m_canvas, strokeData.miterLimit());
plutovg_canvas_set_line_cap(m_canvas, static_cast<plutovg_line_cap_t>(strokeData.lineCap()));
plutovg_canvas_set_line_join(m_canvas, static_cast<plutovg_line_join_t>(strokeData.lineJoin()));
plutovg_canvas_set_dash_offset(m_canvas, strokeData.dashOffset());
plutovg_canvas_set_dash_array(m_canvas, strokeData.dashArray().data(), strokeData.dashArray().size());
plutovg_canvas_set_operator(m_canvas, PLUTOVG_OPERATOR_SRC_OVER);
plutovg_canvas_stroke_path(m_canvas, path.data());
} | O3 | cpp | lunasvg::Canvas::strokePath(lunasvg::Path const&, lunasvg::StrokeData const&, lunasvg::Transform const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0x23c12
xorl %eax, %eax
subl 0x10(%r14), %eax
cvtsi2ss %eax, %xmm0
xorl %eax, %eax
subl 0x14(%r14), %eax
movq 0x8(%r14), %rdi
cvtsi2ss %eax, %xmm1
callq 0x23bce
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x23c02
movq 0x8(%r14), %rdi
movss (%r15), %xmm0
callq 0x23ab8
movq 0x8(%r14), %rdi
movss 0x4(%r15), %xmm0
callq 0x23aec
movq 0x8(%r14), %rdi
movzbl 0xc(%r15), %esi
callq 0x23acc
movq 0x8(%r14), %rdi
movzbl 0xd(%r15), %esi
callq 0x23adc
movq 0x8(%r14), %rdi
movss 0x8(%r15), %xmm0
callq 0x23b0e
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
callq 0x23b18
movq 0x8(%r14), %rdi
movl $0x3, %esi
callq 0x23a71
movq 0x8(%r14), %rdi
movq (%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x240b0
nop
| _ZN7lunasvg6Canvas10strokePathERKNS_4PathERKNS_10StrokeDataERKNS_9TransformE:
push r15
push r14
push r12
push rbx
push rax
mov r12, rcx
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi+8]
call plutovg_canvas_reset_matrix
xor eax, eax
sub eax, [r14+10h]
cvtsi2ss xmm0, eax
xor eax, eax
sub eax, [r14+14h]
mov rdi, [r14+8]
cvtsi2ss xmm1, eax
call plutovg_canvas_translate
mov rdi, [r14+8]
mov rsi, r12
call plutovg_canvas_transform
mov rdi, [r14+8]
movss xmm0, dword ptr [r15]
call plutovg_canvas_set_line_width
mov rdi, [r14+8]
movss xmm0, dword ptr [r15+4]
call plutovg_canvas_set_miter_limit
mov rdi, [r14+8]
movzx esi, byte ptr [r15+0Ch]
call plutovg_canvas_set_line_cap
mov rdi, [r14+8]
movzx esi, byte ptr [r15+0Dh]
call plutovg_canvas_set_line_join
mov rdi, [r14+8]
movss xmm0, dword ptr [r15+8]
call plutovg_canvas_set_dash_offset
mov rdi, [r14+8]
mov rsi, [r15+10h]
mov rdx, [r15+18h]
sub rdx, rsi
shr rdx, 2
call plutovg_canvas_set_dash_array
mov rdi, [r14+8]
mov esi, 3
call plutovg_canvas_set_operator
mov rdi, [r14+8]
mov rsi, [rbx]
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp plutovg_canvas_stroke_path
| long long lunasvg::Canvas::strokePath(long long a1, _QWORD *a2, long long a3, long long a4)
{
plutovg_canvas_reset_matrix(*(_QWORD *)(a1 + 8));
plutovg_canvas_translate(*(_QWORD *)(a1 + 8), (float)-*(_DWORD *)(a1 + 16), (float)-*(_DWORD *)(a1 + 20));
plutovg_canvas_transform(*(_QWORD *)(a1 + 8), a4);
plutovg_canvas_set_line_width(*(_QWORD *)(a1 + 8), *(float *)a3);
plutovg_canvas_set_miter_limit(*(_QWORD *)(a1 + 8), *(float *)(a3 + 4));
plutovg_canvas_set_line_cap(*(_QWORD *)(a1 + 8), *(unsigned __int8 *)(a3 + 12));
plutovg_canvas_set_line_join(*(_QWORD *)(a1 + 8), *(unsigned __int8 *)(a3 + 13));
plutovg_canvas_set_dash_offset(*(_QWORD *)(a1 + 8), *(float *)(a3 + 8));
plutovg_canvas_set_dash_array(
*(_QWORD *)(a1 + 8),
*(_QWORD *)(a3 + 16),
(*(_QWORD *)(a3 + 24) - *(_QWORD *)(a3 + 16)) >> 2);
plutovg_canvas_set_operator(*(_QWORD *)(a1 + 8), 3LL);
return plutovg_canvas_stroke_path(*(_QWORD *)(a1 + 8), *a2);
}
| strokePath:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,RCX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x00123c12
XOR EAX,EAX
SUB EAX,dword ptr [R14 + 0x10]
CVTSI2SS XMM0,EAX
XOR EAX,EAX
SUB EAX,dword ptr [R14 + 0x14]
MOV RDI,qword ptr [R14 + 0x8]
CVTSI2SS XMM1,EAX
CALL 0x00123bce
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,R12
CALL 0x00123c02
MOV RDI,qword ptr [R14 + 0x8]
MOVSS XMM0,dword ptr [R15]
CALL 0x00123ab8
MOV RDI,qword ptr [R14 + 0x8]
MOVSS XMM0,dword ptr [R15 + 0x4]
CALL 0x00123aec
MOV RDI,qword ptr [R14 + 0x8]
MOVZX ESI,byte ptr [R15 + 0xc]
CALL 0x00123acc
MOV RDI,qword ptr [R14 + 0x8]
MOVZX ESI,byte ptr [R15 + 0xd]
CALL 0x00123adc
MOV RDI,qword ptr [R14 + 0x8]
MOVSS XMM0,dword ptr [R15 + 0x8]
CALL 0x00123b0e
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
MOV RDX,qword ptr [R15 + 0x18]
SUB RDX,RSI
SHR RDX,0x2
CALL 0x00123b18
MOV RDI,qword ptr [R14 + 0x8]
MOV ESI,0x3
CALL 0x00123a71
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [RBX]
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x001240b0
|
/* lunasvg::Canvas::strokePath(lunasvg::Path const&, lunasvg::StrokeData const&, lunasvg::Transform
const&) */
void __thiscall
lunasvg::Canvas::strokePath(Canvas *this,Path *param_1,StrokeData *param_2,Transform *param_3)
{
plutovg_canvas_reset_matrix(*(int8 *)(this + 8));
plutovg_canvas_translate
((float)-*(int *)(this + 0x10),(float)-*(int *)(this + 0x14),*(int8 *)(this + 8));
plutovg_canvas_transform(*(int8 *)(this + 8),param_3);
plutovg_canvas_set_line_width(*(int4 *)param_2,*(int8 *)(this + 8));
plutovg_canvas_set_miter_limit(*(int4 *)(param_2 + 4),*(int8 *)(this + 8));
plutovg_canvas_set_line_cap(*(int8 *)(this + 8),param_2[0xc]);
plutovg_canvas_set_line_join(*(int8 *)(this + 8),param_2[0xd]);
plutovg_canvas_set_dash_offset(*(int4 *)(param_2 + 8),*(int8 *)(this + 8));
plutovg_canvas_set_dash_array
(*(int8 *)(this + 8),*(long *)(param_2 + 0x10),
(ulong)(*(long *)(param_2 + 0x18) - *(long *)(param_2 + 0x10)) >> 2);
plutovg_canvas_set_operator(*(int8 *)(this + 8),3);
plutovg_canvas_stroke_path(*(int8 *)(this + 8),*(int8 *)param_1);
return;
}
| |
24,509 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | hkr04[P]cpp-mcp/common/json.hpp | inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
diyfp M_minus, diyfp w, diyfp M_plus)
{
static_assert(kAlpha >= -60, "internal error");
static_assert(kGamma <= -32, "internal error");
// Generates the digits (and the exponent) of a decimal floating-point
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
//
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
JSON_ASSERT(M_plus.e >= kAlpha);
JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
// M+ = f * 2^e
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
JSON_ASSERT(p1 > 0);
std::uint32_t pow10{};
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
//
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
//
// M+ = p1 + p2 * 2^e
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
//
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
//
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
//
// but stop as soon as
//
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
int n = k;
while (n > 0)
{
// Invariants:
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
//
p1 = r;
n--;
//
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
// pow10 = 10^n
//
// Now check if enough digits have been generated.
// Compute
//
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
//
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
decimal_exponent += n;
// We may now just stop. But instead look if the buffer could be
// decremented to bring V closer to w.
//
// pow10 = 10^n is now 1 ulp in the decimal representation V.
// The rounding procedure works with diyfp's with an implicit
// exponent of e.
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
}
pow10 /= 10;
//
// pow10 = 10^(n-1) <= p1 < 10^n
// Invariants restored.
}
// 2)
//
// The digits of the integral part have been generated:
//
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
// = buffer + p2 * 2^e
//
// Now generate the digits of the fractional part p2 * 2^e.
//
// Note:
// No decimal point is generated: the exponent is adjusted instead.
//
// p2 actually represents the fraction
//
// p2 * 2^e
// = p2 / 2^-e
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
//
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
//
// using
//
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
// = ( d) * 2^-e + ( r)
//
// or
// 10^m * p2 * 2^e = d + r * 2^e
//
// i.e.
//
// M+ = buffer + p2 * 2^e
// = buffer + 10^-m * (d + r * 2^e)
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
{
// Invariant:
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
p2 = r;
m++;
//
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
// Invariant restored.
// Check if enough digits have been generated.
//
// 10^-m * p2 * 2^e <= delta * 2^e
// p2 * 2^e <= 10^m * delta * 2^e
// p2 <= 10^m * delta
delta *= 10;
dist *= 10;
if (p2 <= delta)
{
break;
}
}
// V = buffer * 10^-m, with M- <= V <= M+.
decimal_exponent -= m;
// 1 ulp in the decimal representation is now 10^-m.
// Since delta and dist are now scaled by 10^m, we need to do the
// same with ulp in order to keep the units in sync.
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
// number (Loitsch, Theorem 6.2) which rounds back to w.
// For an input number of precision p, at least
//
// N = 1 + ceil(p * log_10(2))
//
// decimal digits are sufficient to identify all binary floating-point
// numbers (Matula, "In-and-Out conversions").
// This implies that the algorithm does not produce more than N decimal
// digits.
//
// N = 17 for p = 53 (IEEE double precision)
// N = 9 for p = 24 (IEEE single precision)
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
subq $0xf8, %rsp
movq %rdi, %rax
leaq 0x110(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x100(%rsp), %r9
movq %r9, 0x8(%rsp)
movq %rcx, 0xe8(%rsp)
movl %r8d, 0xf0(%rsp)
movq %rax, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
leaq 0xe8(%rsp), %rsi
callq 0x1b410
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl %edx, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movl 0xb0(%rsp), %eax
movl %eax, 0xc0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0xc8(%rsp)
callq 0x1b410
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl %edx, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq 0x80(%rsp), %rcx
movq %rcx, 0x90(%rsp)
movl 0x88(%rsp), %ecx
movl %ecx, 0x98(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, 0xa0(%rsp)
xorl %ecx, %ecx
subl 0x8(%rax), %ecx
movl %ecx, %ecx
movl $0x1, %esi
shlq %cl, %rsi
movl 0x8(%rax), %edx
leaq 0x70(%rsp), %rdi
callq 0x1ad90
movq 0x10(%rsp), %rax
movq (%rax), %rdx
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movl %ecx, 0x6c(%rsp)
movq (%rax), %rax
movq 0x70(%rsp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x6c(%rsp), %edi
leaq 0x5c(%rsp), %rsi
callq 0x1b450
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x54(%rsp)
cmpl $0x0, 0x54(%rsp)
jle 0x1b2b0
movl 0x6c(%rsp), %eax
xorl %edx, %edx
divl 0x5c(%rsp)
movl %eax, 0x50(%rsp)
movl 0x6c(%rsp), %eax
xorl %edx, %edx
divl 0x5c(%rsp)
movl %edx, 0x4c(%rsp)
movl 0x50(%rsp), %eax
addl $0x30, %eax
movb %al, %dl
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x4c(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0x54(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x54(%rsp)
movl 0x6c(%rsp), %eax
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
addq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0xc8(%rsp), %rax
ja 0x1b29a
movl 0x54(%rsp), %ecx
movq 0xd0(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl 0x5c(%rsp), %eax
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, 0x38(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rax
movl (%rax), %esi
movq 0xa0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
callq 0x1b5a0
jmp 0x1b3b2
movl 0x5c(%rsp), %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, 0x5c(%rsp)
jmp 0x1b1b6
movl $0x0, 0x34(%rsp)
imulq $0xa, 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
xorl %ecx, %ecx
subl 0x78(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x70(%rsp), %rcx
subq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x30, %rax
movb %al, %dl
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq %rax, 0x60(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
imulq $0xa, 0xc8(%rsp), %rax
movq %rax, 0xc8(%rsp)
imulq $0xa, 0xa0(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x60(%rsp), %rax
cmpq 0xc8(%rsp), %rax
ja 0x1b360
jmp 0x1b365
jmp 0x1b2b8
movl 0x34(%rsp), %edx
movq 0xd0(%rsp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rax
movl (%rax), %esi
movq 0xa0(%rsp), %rdx
movq 0xc8(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x1b5a0
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_:
sub rsp, 0F8h
mov rax, rdi
lea rdi, [rsp+0F8h+arg_10]; this
mov [rsp+0F8h+var_E8], rdi
lea r9, [rsp+0F8h+arg_0]
mov [rsp+0F8h+var_F0], r9
mov [rsp+0F8h+var_10], rcx
mov [rsp+0F8h+var_8], r8d
mov [rsp+0F8h+var_18], rax
mov [rsp+0F8h+var_20], rsi
mov [rsp+0F8h+var_28], rdx
lea rsi, [rsp+0F8h+var_10]; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov rsi, [rsp+0F8h+var_F0]; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *
mov rdi, [rsp+0F8h+var_E8]; this
mov [rsp+0F8h+var_48], edx
mov [rsp+0F8h+var_50], rax
mov eax, [rsp+0F8h+var_48]
mov [rsp+0F8h+var_38], eax
mov rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_40], rax
mov rax, [rsp+0F8h+var_40]
mov [rsp+0F8h+var_30], rax
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp3subERKS3_S5_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&,nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp const&)
mov rcx, rax
mov rax, [rsp+0F8h+var_E8]
mov [rsp+0F8h+var_70], edx
mov [rsp+0F8h+var_78], rcx
mov rcx, [rsp+0F8h+var_78]
mov [rsp+0F8h+var_68], rcx
mov ecx, [rsp+0F8h+var_70]
mov [rsp+0F8h+var_60], ecx
mov rcx, [rsp+0F8h+var_68]
mov qword ptr [rsp+0F8h+var_58], rcx
xor ecx, ecx
sub ecx, [rax+8]
mov ecx, ecx
mov esi, 1
shl rsi, cl; unsigned __int64
mov edx, [rax+8]; int
lea rdi, [rsp+0F8h+var_8C+4]; this
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfpC2Emi; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::diyfp(ulong,int)
mov rax, [rsp+0F8h+var_E8]
mov rdx, [rax]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shr rdx, cl; unsigned int *
mov rcx, rdx
mov dword ptr [rsp+0F8h+var_8C], ecx
mov rax, [rax]
mov rcx, [rsp+0F8h+var_8C+4]
sub rcx, 1
and rax, rcx
mov [rsp+0F8h+var_98], rax
mov [rsp+0F8h+var_9C], 0
mov edi, dword ptr [rsp+0F8h+var_8C]; this
lea rsi, [rsp+0F8h+var_9C]; unsigned int
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18find_largest_pow10EjRj; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(uint,uint &)
mov [rsp+0F8h+var_A0], eax
mov eax, [rsp+0F8h+var_A0]
mov [rsp+0F8h+var_A4], eax
loc_1B1B6:
cmp [rsp+0F8h+var_A4], 0
jle loc_1B2B0
mov eax, dword ptr [rsp+0F8h+var_8C]
xor edx, edx
div [rsp+0F8h+var_9C]
mov [rsp+0F8h+var_A8], eax
mov eax, dword ptr [rsp+0F8h+var_8C]
xor edx, edx
div [rsp+0F8h+var_9C]
mov [rsp+0F8h+var_AC], edx
mov eax, [rsp+0F8h+var_A8]
add eax, 30h ; '0'
mov dl, al
mov rax, [rsp+0F8h+var_18]
mov rsi, [rsp+0F8h+var_20]
mov ecx, [rsi]
mov edi, ecx
add edi, 1
mov [rsi], edi
movsxd rcx, ecx
mov [rax+rcx], dl
mov eax, [rsp+0F8h+var_AC]
mov dword ptr [rsp+0F8h+var_8C], eax
mov eax, [rsp+0F8h+var_A4]
add eax, 0FFFFFFFFh
mov [rsp+0F8h+var_A4], eax
mov eax, dword ptr [rsp+0F8h+var_8C]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shl rax, cl
add rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_B8], rax
mov rax, [rsp+0F8h+var_B8]
cmp rax, [rsp+0F8h+var_30]
ja short loc_1B29A
mov ecx, [rsp+0F8h+var_A4]
mov rax, [rsp+0F8h+var_28]
add ecx, [rax]
mov [rax], ecx
mov eax, [rsp+0F8h+var_9C]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shl rax, cl
mov [rsp+0F8h+var_C0], rax
mov rdi, [rsp+0F8h+var_18]; this
mov rax, [rsp+0F8h+var_20]
mov esi, [rax]; char *
mov rdx, qword ptr [rsp+0F8h+var_58]; int
mov rcx, [rsp+0F8h+var_30]; unsigned __int64
mov r8, [rsp+0F8h+var_B8]; unsigned __int64
mov r9, [rsp+0F8h+var_C0]; unsigned __int64
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char *,int,ulong,ulong,ulong,ulong)
jmp loc_1B3B2
loc_1B29A:
mov eax, [rsp+0F8h+var_9C]
mov ecx, 0Ah
xor edx, edx
div ecx
mov [rsp+0F8h+var_9C], eax
jmp loc_1B1B6
loc_1B2B0:
mov [rsp+0F8h+var_C4], 0
loc_1B2B8:
imul rax, [rsp+0F8h+var_98], 0Ah
mov [rsp+0F8h+var_98], rax
mov rax, [rsp+0F8h+var_98]
xor ecx, ecx
sub ecx, [rsp+0F8h+var_80]
mov ecx, ecx
shr rax, cl
mov [rsp+0F8h+var_D0], rax
mov rax, [rsp+0F8h+var_98]
mov rcx, [rsp+0F8h+var_8C+4]
sub rcx, 1
and rax, rcx
mov [rsp+0F8h+var_D8], rax
mov rax, [rsp+0F8h+var_D0]
add rax, 30h ; '0'
mov dl, al
mov rax, [rsp+0F8h+var_18]
mov rsi, [rsp+0F8h+var_20]
mov ecx, [rsi]
mov edi, ecx
add edi, 1
mov [rsi], edi
movsxd rcx, ecx
mov [rax+rcx], dl
mov rax, [rsp+0F8h+var_D8]
mov [rsp+0F8h+var_98], rax
mov eax, [rsp+0F8h+var_C4]
add eax, 1
mov [rsp+0F8h+var_C4], eax
imul rax, [rsp+0F8h+var_30], 0Ah
mov [rsp+0F8h+var_30], rax
imul rax, qword ptr [rsp+0F8h+var_58], 0Ah
mov qword ptr [rsp+0F8h+var_58], rax
mov rax, [rsp+0F8h+var_98]
cmp rax, [rsp+0F8h+var_30]
ja short loc_1B360
jmp short loc_1B365
loc_1B360:
jmp loc_1B2B8
loc_1B365:
mov edx, [rsp+0F8h+var_C4]
mov rax, [rsp+0F8h+var_28]
mov ecx, [rax]
sub ecx, edx
mov [rax], ecx
mov rax, [rsp+0F8h+var_8C+4]
mov [rsp+0F8h+var_E0], rax
mov rdi, [rsp+0F8h+var_18]; this
mov rax, [rsp+0F8h+var_20]
mov esi, [rax]; char *
mov rdx, qword ptr [rsp+0F8h+var_58]; int
mov rcx, [rsp+0F8h+var_30]; unsigned __int64
mov r8, [rsp+0F8h+var_98]; unsigned __int64
mov r9, [rsp+0F8h+var_E0]; unsigned __int64
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char *,int,ulong,ulong,ulong,ulong)
loc_1B3B2:
add rsp, 0F8h
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *a1,
_DWORD *a2,
const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *a3,
long long a4,
int a5,
long long a6,
char a7,
long long a8,
unsigned long long a9,
int a10)
{
unsigned long long v10; // rax
const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *v11; // rdx
long long v12; // rax
int v13; // edx
char v14; // dl
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v15; // rax
int v16; // ecx
char v18; // dl
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v19; // rax
int v20; // ecx
unsigned long long v21; // [rsp+0h] [rbp-F8h]
unsigned long long v22; // [rsp+20h] [rbp-D8h]
int v23; // [rsp+34h] [rbp-C4h]
unsigned long long v24; // [rsp+40h] [rbp-B8h]
unsigned int v25; // [rsp+4Ch] [rbp-ACh]
int largest_pow10; // [rsp+54h] [rbp-A4h]
unsigned int v27; // [rsp+5Ch] [rbp-9Ch] BYREF
unsigned long long v28; // [rsp+60h] [rbp-98h]
_DWORD v29[3]; // [rsp+6Ch] [rbp-8Ch] BYREF
int v30; // [rsp+78h] [rbp-80h]
long long v31; // [rsp+80h] [rbp-78h]
int v32; // [rsp+88h] [rbp-70h]
long long v33; // [rsp+90h] [rbp-68h]
int v34; // [rsp+98h] [rbp-60h]
int v35[2]; // [rsp+A0h] [rbp-58h]
unsigned long long v36; // [rsp+A8h] [rbp-50h]
int v37; // [rsp+B0h] [rbp-48h]
unsigned long long v38; // [rsp+B8h] [rbp-40h]
int v39; // [rsp+C0h] [rbp-38h]
unsigned long long v40; // [rsp+C8h] [rbp-30h]
const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *v41; // [rsp+D0h] [rbp-28h]
_DWORD *v42; // [rsp+D8h] [rbp-20h]
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v43; // [rsp+E0h] [rbp-18h]
long long v44; // [rsp+E8h] [rbp-10h] BYREF
int v45; // [rsp+F0h] [rbp-8h]
v44 = a4;
v45 = a5;
v43 = a1;
v42 = a2;
v41 = a3;
v10 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&a9,
(const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&v44,
a3);
v37 = (int)v11;
v36 = v10;
v39 = (int)v11;
v38 = v10;
v40 = v10;
v12 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::sub(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&a9,
(const nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&a7,
v11);
v32 = v13;
v31 = v12;
v33 = v12;
v34 = v13;
*(_QWORD *)v35 = v12;
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::diyfp(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp *)&v29[1],
1LL << -(char)a10,
a10);
v29[0] = a9 >> -(char)v30;
v28 = (*(_QWORD *)&v29[1] - 1LL) & a9;
v27 = 0;
largest_pow10 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)v29[0],
(unsigned int)&v27,
(unsigned int *)(a9 >> -(char)v30));
while ( largest_pow10 > 0 )
{
v25 = v29[0] % v27;
v14 = v29[0] / v27 + 48;
v15 = v43;
v16 = (*v42)++;
*((_BYTE *)v15 + v16) = v14;
v29[0] = v25;
--largest_pow10;
v24 = v28 + ((unsigned long long)v25 << -(char)v30);
if ( v24 <= v40 )
{
*(_DWORD *)v41 += largest_pow10;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
v43,
(char *)(unsigned int)*v42,
v35[0],
v40,
v24,
(unsigned long long)v27 << -(char)v30,
v21);
}
v27 /= 0xAu;
}
v23 = 0;
do
{
v28 *= 10LL;
v22 = (*(_QWORD *)&v29[1] - 1LL) & v28;
v18 = (v28 >> -(char)v30) + 48;
v19 = v43;
v20 = (*v42)++;
*((_BYTE *)v19 + v20) = v18;
v28 = v22;
++v23;
v40 *= 10LL;
*(_QWORD *)v35 *= 10LL;
}
while ( v22 > v40 );
*(_DWORD *)v41 -= v23;
return nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
v43,
(char *)(unsigned int)*v42,
v35[0],
v40,
v28,
*(unsigned long long *)&v29[1],
v21);
}
| grisu2_digit_gen:
SUB RSP,0xf8
MOV RAX,RDI
LEA RDI,[RSP + 0x110]
MOV qword ptr [RSP + 0x10],RDI
LEA R9,[RSP + 0x100]
MOV qword ptr [RSP + 0x8],R9
MOV qword ptr [RSP + 0xe8],RCX
MOV dword ptr [RSP + 0xf0],R8D
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xd8],RSI
MOV qword ptr [RSP + 0xd0],RDX
LEA RSI,[RSP + 0xe8]
CALL 0x0011b410
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0xb0],EDX
MOV qword ptr [RSP + 0xa8],RAX
MOV EAX,dword ptr [RSP + 0xb0]
MOV dword ptr [RSP + 0xc0],EAX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xb8],RAX
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0xc8],RAX
CALL 0x0011b410
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x88],EDX
MOV qword ptr [RSP + 0x80],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x90],RCX
MOV ECX,dword ptr [RSP + 0x88]
MOV dword ptr [RSP + 0x98],ECX
MOV RCX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xa0],RCX
XOR ECX,ECX
SUB ECX,dword ptr [RAX + 0x8]
MOV ECX,ECX
MOV ESI,0x1
SHL RSI,CL
MOV EDX,dword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x70]
CALL 0x0011ad90
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RAX]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHR RDX,CL
MOV RCX,RDX
MOV dword ptr [RSP + 0x6c],ECX
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RSP + 0x70]
SUB RCX,0x1
AND RAX,RCX
MOV qword ptr [RSP + 0x60],RAX
MOV dword ptr [RSP + 0x5c],0x0
MOV EDI,dword ptr [RSP + 0x6c]
LEA RSI,[RSP + 0x5c]
CALL 0x0011b450
MOV dword ptr [RSP + 0x58],EAX
MOV EAX,dword ptr [RSP + 0x58]
MOV dword ptr [RSP + 0x54],EAX
LAB_0011b1b6:
CMP dword ptr [RSP + 0x54],0x0
JLE 0x0011b2b0
MOV EAX,dword ptr [RSP + 0x6c]
XOR EDX,EDX
DIV dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x50],EAX
MOV EAX,dword ptr [RSP + 0x6c]
XOR EDX,EDX
DIV dword ptr [RSP + 0x5c]
MOV dword ptr [RSP + 0x4c],EDX
MOV EAX,dword ptr [RSP + 0x50]
ADD EAX,0x30
MOV DL,AL
MOV RAX,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xd8]
MOV ECX,dword ptr [RSI]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI],EDI
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x6c],EAX
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,-0x1
MOV dword ptr [RSP + 0x54],EAX
MOV EAX,dword ptr [RSP + 0x6c]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHL RAX,CL
ADD RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x40]
CMP RAX,qword ptr [RSP + 0xc8]
JA 0x0011b29a
MOV ECX,dword ptr [RSP + 0x54]
MOV RAX,qword ptr [RSP + 0xd0]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x5c]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHL RAX,CL
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RAX,qword ptr [RSP + 0xd8]
MOV ESI,dword ptr [RAX]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0x40]
MOV R9,qword ptr [RSP + 0x38]
CALL 0x0011b5a0
JMP 0x0011b3b2
LAB_0011b29a:
MOV EAX,dword ptr [RSP + 0x5c]
MOV ECX,0xa
XOR EDX,EDX
DIV ECX
MOV dword ptr [RSP + 0x5c],EAX
JMP 0x0011b1b6
LAB_0011b2b0:
MOV dword ptr [RSP + 0x34],0x0
LAB_0011b2b8:
IMUL RAX,qword ptr [RSP + 0x60],0xa
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x60]
XOR ECX,ECX
SUB ECX,dword ptr [RSP + 0x78]
MOV ECX,ECX
SHR RAX,CL
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x70]
SUB RCX,0x1
AND RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x28]
ADD RAX,0x30
MOV DL,AL
MOV RAX,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xd8]
MOV ECX,dword ptr [RSI]
MOV EDI,ECX
ADD EDI,0x1
MOV dword ptr [RSI],EDI
MOVSXD RCX,ECX
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x60],RAX
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,0x1
MOV dword ptr [RSP + 0x34],EAX
IMUL RAX,qword ptr [RSP + 0xc8],0xa
MOV qword ptr [RSP + 0xc8],RAX
IMUL RAX,qword ptr [RSP + 0xa0],0xa
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x60]
CMP RAX,qword ptr [RSP + 0xc8]
JA 0x0011b360
JMP 0x0011b365
LAB_0011b360:
JMP 0x0011b2b8
LAB_0011b365:
MOV EDX,dword ptr [RSP + 0x34]
MOV RAX,qword ptr [RSP + 0xd0]
MOV ECX,dword ptr [RAX]
SUB ECX,EDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RAX,qword ptr [RSP + 0xd8]
MOV ESI,dword ptr [RAX]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xc8]
MOV R8,qword ptr [RSP + 0x60]
MOV R9,qword ptr [RSP + 0x18]
CALL 0x0011b5a0
LAB_0011b3b2:
ADD RSP,0xf8
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen
(char *param_1,int *param_2,int *param_3,int8 param_4,int4 param_5)
{
int iVar1;
uint uVar2;
ulong uVar3;
ulong in_stack_00000018;
int in_stack_00000020;
int local_c4;
int local_a4;
uint local_9c;
ulong local_98;
uint local_8c;
ulong local_88;
char local_80;
int1 local_78 [12];
int1 local_68 [12];
ulong local_58;
int1 local_50 [12];
int1 local_40 [12];
ulong local_30;
int *local_28;
int *local_20;
char *local_18;
int8 local_10;
int4 local_8;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_10 = param_4;
local_8 = param_5;
local_50 = diyfp::sub((diyfp *)&stack0x00000018,(diyfp *)&local_10);
local_30 = local_50._0_8_;
local_40 = local_50;
local_78 = diyfp::sub((diyfp *)&stack0x00000018,&stack0x00000008);
local_58 = local_78._0_8_;
local_68 = local_78;
diyfp::diyfp((diyfp *)&local_88,1L << (-(char)in_stack_00000020 & 0x3fU),in_stack_00000020);
local_8c = (uint)(in_stack_00000018 >> (-local_80 & 0x3fU));
local_98 = in_stack_00000018 & local_88 - 1;
local_9c = 0;
local_a4 = find_largest_pow10(local_8c,&local_9c);
while( true ) {
if (local_a4 < 1) {
local_c4 = 0;
do {
uVar3 = local_98 * 10;
local_98 = uVar3 & local_88 - 1;
iVar1 = *local_20;
*local_20 = iVar1 + 1;
local_18[iVar1] = (char)(uVar3 >> (-local_80 & 0x3fU)) + '0';
local_c4 = local_c4 + 1;
local_30 = local_30 * 10;
local_58 = local_58 * 10;
} while (local_30 < local_98);
*local_28 = *local_28 - local_c4;
grisu2_round(local_18,*local_20,local_58,local_30,local_98,local_88);
return;
}
uVar2 = local_8c / local_9c;
local_8c = local_8c % local_9c;
iVar1 = *local_20;
*local_20 = iVar1 + 1;
local_18[iVar1] = (char)uVar2 + '0';
local_a4 = local_a4 + -1;
uVar3 = ((ulong)local_8c << (-local_80 & 0x3fU)) + local_98;
if (uVar3 <= local_30) break;
local_9c = local_9c / 10;
}
*local_28 = local_a4 + *local_28;
grisu2_round(local_18,*local_20,local_58,local_30,uVar3,(ulong)local_9c << (-local_80 & 0x3fU));
return;
}
| |
24,510 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) | hkr04[P]cpp-mcp/common/json.hpp | inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
diyfp M_minus, diyfp w, diyfp M_plus)
{
static_assert(kAlpha >= -60, "internal error");
static_assert(kGamma <= -32, "internal error");
// Generates the digits (and the exponent) of a decimal floating-point
// number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
// w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
//
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// Grisu2 generates the digits of M+ from left to right and stops as soon as
// V is in [M-,M+].
JSON_ASSERT(M_plus.e >= kAlpha);
JSON_ASSERT(M_plus.e <= kGamma);
std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
// Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
//
// M+ = f * 2^e
// = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
// = ((p1 ) * 2^-e + (p2 )) * 2^e
// = p1 + p2 * 2^e
const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
// 1)
//
// Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
JSON_ASSERT(p1 > 0);
std::uint32_t pow10{};
const int k = find_largest_pow10(p1, pow10);
// 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
//
// p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
// = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
//
// M+ = p1 + p2 * 2^e
// = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
// = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
// = d[k-1] * 10^(k-1) + ( rest) * 2^e
//
// Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
//
// p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
//
// but stop as soon as
//
// rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
int n = k;
while (n > 0)
{
// Invariants:
// M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
// pow10 = 10^(n-1) <= p1 < 10^n
//
const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
//
// M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
// = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
//
p1 = r;
n--;
//
// M+ = buffer * 10^n + (p1 + p2 * 2^e)
// pow10 = 10^n
//
// Now check if enough digits have been generated.
// Compute
//
// p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
//
// Note:
// Since rest and delta share the same exponent e, it suffices to
// compare the significands.
const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
if (rest <= delta)
{
// V = buffer * 10^n, with M- <= V <= M+.
decimal_exponent += n;
// We may now just stop. But instead look if the buffer could be
// decremented to bring V closer to w.
//
// pow10 = 10^n is now 1 ulp in the decimal representation V.
// The rounding procedure works with diyfp's with an implicit
// exponent of e.
//
// 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
//
const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
grisu2_round(buffer, length, dist, delta, rest, ten_n);
return;
}
pow10 /= 10;
//
// pow10 = 10^(n-1) <= p1 < 10^n
// Invariants restored.
}
// 2)
//
// The digits of the integral part have been generated:
//
// M+ = d[k-1]...d[1]d[0] + p2 * 2^e
// = buffer + p2 * 2^e
//
// Now generate the digits of the fractional part p2 * 2^e.
//
// Note:
// No decimal point is generated: the exponent is adjusted instead.
//
// p2 actually represents the fraction
//
// p2 * 2^e
// = p2 / 2^-e
// = d[-1] / 10^1 + d[-2] / 10^2 + ...
//
// Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
//
// p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
// + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
//
// using
//
// 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
// = ( d) * 2^-e + ( r)
//
// or
// 10^m * p2 * 2^e = d + r * 2^e
//
// i.e.
//
// M+ = buffer + p2 * 2^e
// = buffer + 10^-m * (d + r * 2^e)
// = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
//
// and stop as soon as 10^-m * r * 2^e <= delta * 2^e
JSON_ASSERT(p2 > delta);
int m = 0;
for (;;)
{
// Invariant:
// M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
// = buffer * 10^-m + 10^-m * (p2 ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
//
JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
p2 *= 10;
const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
//
// M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
// = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
// = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
JSON_ASSERT(d <= 9);
buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
//
// M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
//
p2 = r;
m++;
//
// M+ = buffer * 10^-m + 10^-m * p2 * 2^e
// Invariant restored.
// Check if enough digits have been generated.
//
// 10^-m * p2 * 2^e <= delta * 2^e
// p2 * 2^e <= 10^m * delta * 2^e
// p2 <= 10^m * delta
delta *= 10;
dist *= 10;
if (p2 <= delta)
{
break;
}
}
// V = buffer * 10^-m, with M- <= V <= M+.
decimal_exponent -= m;
// 1 ulp in the decimal representation is now 10^-m.
// Since delta and dist are now scaled by 10^m, we need to do the
// same with ulp in order to keep the units in sync.
//
// 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
//
const std::uint64_t ten_m = one.f;
grisu2_round(buffer, length, dist, delta, p2, ten_m);
// By construction this algorithm generates the shortest possible decimal
// number (Loitsch, Theorem 6.2) which rounds back to w.
// For an input number of precision p, at least
//
// N = 1 + ceil(p * log_10(2))
//
// decimal digits are sufficient to identify all binary floating-point
// numbers (Matula, "In-and-Out conversions").
// This implies that the algorithm does not produce more than N decimal
// digits.
//
// N = 17 for p = 53 (IEEE double precision)
// N = 9 for p = 24 (IEEE single precision)
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp, nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r9
movq %rdx, -0x20(%rsp)
movq 0x48(%rsp), %rax
xorl %r11d, %r11d
subl 0x50(%rsp), %r11d
movl $0x1, %edx
movl %r11d, %ecx
shlq %cl, %rdx
movq %rax, %r8
shrq %cl, %rax
movq 0x38(%rsp), %r12
movq %rdx, -0x38(%rsp)
leaq -0x1(%rdx), %r15
cmpl $0x3b9ac9ff, %eax # imm = 0x3B9AC9FF
jbe 0xb557
movl $0xa, %ebx
movl $0x3b9aca00, %r13d # imm = 0x3B9ACA00
jmp 0xb5f5
cmpl $0x5f5e0ff, %eax # imm = 0x5F5E0FF
jbe 0xb56e
movl $0x9, %ebx
movl $0x5f5e100, %r13d # imm = 0x5F5E100
jmp 0xb5f5
cmpl $0x98967f, %eax # imm = 0x98967F
jbe 0xb582
movl $0x8, %ebx
movl $0x989680, %r13d # imm = 0x989680
jmp 0xb5f5
cmpl $0xf423f, %eax # imm = 0xF423F
jbe 0xb596
movl $0x7, %ebx
movl $0xf4240, %r13d # imm = 0xF4240
jmp 0xb5f5
cmpl $0x1869f, %eax # imm = 0x1869F
jbe 0xb5aa
movl $0x6, %ebx
movl $0x186a0, %r13d # imm = 0x186A0
jmp 0xb5f5
cmpl $0x270f, %eax # imm = 0x270F
jbe 0xb5be
movl $0x5, %ebx
movl $0x2710, %r13d # imm = 0x2710
jmp 0xb5f5
cmpl $0x3e7, %eax # imm = 0x3E7
jbe 0xb5d2
movl $0x4, %ebx
movl $0x3e8, %r13d # imm = 0x3E8
jmp 0xb5f5
cmpl $0x63, %eax
jbe 0xb5e4
movl $0x3, %ebx
movl $0x64, %r13d
jmp 0xb5f5
xorl %ebx, %ebx
cmpl $0xa, %eax
setae %bl
leal (%rbx,%rbx,8), %r13d
incl %r13d
incl %ebx
movq %r8, %rbp
subq %r9, %rbp
movq %r8, %r14
subq %r12, %r14
movq %r15, -0x18(%rsp)
andq %r8, %r15
movq %r8, %rcx
subq %r12, %rcx
movq %rcx, -0x10(%rsp)
subq %r8, %r12
subq %r9, %r8
movq %r8, -0x8(%rsp)
movq %r11, -0x30(%rsp)
testl %ebx, %ebx
jle 0xb6fb
xorl %edx, %edx
divl %r13d
addb $0x30, %al
movslq (%rsi), %r8
leal 0x1(%r8), %r9d
movl %r9d, (%rsi)
movb %al, (%rdi,%r8)
decl %ebx
movl %edx, %eax
movq %rax, %rdx
movl %r11d, %ecx
shlq %cl, %rdx
addq %r15, %rdx
movq %rbp, %r8
movl %r13d, %r10d
subq %rdx, %r8
jae 0xb66e
movl $0xcccccccd, %ecx # imm = 0xCCCCCCCD
imulq %rcx, %r10
shrq $0x23, %r10
movl %r10d, %r13d
jmp 0xb6ed
movq -0x20(%rsp), %rcx
addl %ebx, (%rcx)
movl %r11d, %ecx
shlq %cl, %r10
cmpq %r14, %rdx
jae 0xb7a2
cmpq %r10, %r8
jb 0xb7a2
movl %r13d, -0x3c(%rsp)
movq %rbx, -0x28(%rsp)
movq %rsi, %rcx
movslq (%rsi), %r11
movq -0x10(%rsp), %rbx
subq %rdx, %rbx
leaq (%rdx,%r10), %r8
movq -0x8(%rsp), %r9
subq %r8, %r9
cmpq %r14, %r8
jb 0xb6bf
leaq (%r12,%r8), %r13
cmpq %r13, %rbx
jbe 0xb6db
decb -0x1(%rdi,%r11)
subq %r10, %r9
setb %r13b
cmpq %r14, %r8
jae 0xb6db
subq %r10, %rbx
addq %r10, %r8
testb %r13b, %r13b
je 0xb6b1
movq %rcx, %rsi
movq -0x30(%rsp), %r11
movq -0x28(%rsp), %rbx
movl -0x3c(%rsp), %r13d
cmpq %rdx, %rbp
jb 0xb624
jmp 0xb7a2
xorl %eax, %eax
movq -0x18(%rsp), %r10
addq %r15, %r15
leaq (%r15,%r15,4), %r15
movq %r15, %rdx
movl %r11d, %ecx
shrq %cl, %rdx
andq %r10, %r15
addb $0x30, %dl
movslq (%rsi), %rcx
leal 0x1(%rcx), %r8d
movl %r8d, (%rsi)
movb %dl, (%rdi,%rcx)
movq %rbp, %r8
addq %rbp, %r8
leaq (%r8,%r8,4), %rbp
movq %r14, %rdx
addq %r14, %rdx
leaq (%rdx,%rdx,4), %r14
decl %eax
movq %rbp, %r9
subq %r15, %r9
jb 0xb702
movq -0x20(%rsp), %rcx
addl %eax, (%rcx)
cmpq %r14, %r15
jae 0xb7a2
cmpq -0x38(%rsp), %r9
jb 0xb7a2
movslq (%rsi), %rax
leaq (%rdx,%rdx,4), %rcx
movq %rcx, %rdx
subq %r15, %rdx
leaq (%r8,%r8,4), %rsi
addq -0x38(%rsp), %r15
subq %r15, %rsi
negq %rcx
movq -0x38(%rsp), %r9
cmpq %r14, %r15
jb 0xb785
leaq (%rcx,%r15), %r8
cmpq %r8, %rdx
jbe 0xb7a2
decb -0x1(%rdi,%rax)
subq -0x38(%rsp), %rsi
setb %r8b
cmpq %r14, %r15
jae 0xb7a2
subq %r9, %rdx
addq %r9, %r15
testb %r8b, %r8b
je 0xb777
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl16grisu2_digit_genEPcRiS4_NS2_5diyfpES5_S5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
mov r9, rcx
mov [rsp+30h+var_50], rdx
mov rax, [rsp+30h+arg_10]
xor r11d, r11d
sub r11d, [rsp+30h+arg_18]
mov edx, 1
mov ecx, r11d
shl rdx, cl
mov r8, rax
shr rax, cl
mov r12, [rsp+30h+arg_0]
mov [rsp+30h+var_68], rdx
lea r15, [rdx-1]
cmp eax, 3B9AC9FFh
jbe short loc_B557
mov ebx, 0Ah
mov r13d, 3B9ACA00h
jmp loc_B5F5
loc_B557:
cmp eax, 5F5E0FFh
jbe short loc_B56E
mov ebx, 9
mov r13d, 5F5E100h
jmp loc_B5F5
loc_B56E:
cmp eax, 98967Fh
jbe short loc_B582
mov ebx, 8
mov r13d, 989680h
jmp short loc_B5F5
loc_B582:
cmp eax, 0F423Fh
jbe short loc_B596
mov ebx, 7
mov r13d, 0F4240h
jmp short loc_B5F5
loc_B596:
cmp eax, 1869Fh
jbe short loc_B5AA
mov ebx, 6
mov r13d, 186A0h
jmp short loc_B5F5
loc_B5AA:
cmp eax, 270Fh
jbe short loc_B5BE
mov ebx, 5
mov r13d, 2710h
jmp short loc_B5F5
loc_B5BE:
cmp eax, 3E7h
jbe short loc_B5D2
mov ebx, 4
mov r13d, 3E8h
jmp short loc_B5F5
loc_B5D2:
cmp eax, 63h ; 'c'
jbe short loc_B5E4
mov ebx, 3
mov r13d, 64h ; 'd'
jmp short loc_B5F5
loc_B5E4:
xor ebx, ebx
cmp eax, 0Ah
setnb bl
lea r13d, [rbx+rbx*8]
inc r13d
inc ebx
loc_B5F5:
mov rbp, r8
sub rbp, r9
mov r14, r8
sub r14, r12
mov [rsp+30h+var_48], r15
and r15, r8
mov rcx, r8
sub rcx, r12
mov [rsp+30h+var_40], rcx
sub r12, r8
sub r8, r9
mov [rsp+30h+var_38], r8
mov [rsp+30h+var_60], r11
loc_B624:
test ebx, ebx
jle loc_B6FB
xor edx, edx
div r13d
add al, 30h ; '0'
movsxd r8, dword ptr [rsi]
lea r9d, [r8+1]
mov [rsi], r9d
mov [rdi+r8], al
dec ebx
mov eax, edx
mov rdx, rax
mov ecx, r11d
shl rdx, cl
add rdx, r15
mov r8, rbp
mov r10d, r13d
sub r8, rdx
jnb short loc_B66E
mov ecx, 0CCCCCCCDh
imul r10, rcx
shr r10, 23h
mov r13d, r10d
jmp short loc_B6ED
loc_B66E:
mov rcx, [rsp+30h+var_50]
add [rcx], ebx
mov ecx, r11d
shl r10, cl
cmp rdx, r14
jnb loc_B7A2
cmp r8, r10
jb loc_B7A2
mov [rsp+30h+var_6C], r13d
mov [rsp+30h+var_58], rbx
mov rcx, rsi
movsxd r11, dword ptr [rsi]
mov rbx, [rsp+30h+var_40]
sub rbx, rdx
lea r8, [rdx+r10]
mov r9, [rsp+30h+var_38]
sub r9, r8
loc_B6B1:
cmp r8, r14
jb short loc_B6BF
lea r13, [r12+r8]
cmp rbx, r13
jbe short loc_B6DB
loc_B6BF:
dec byte ptr [rdi+r11-1]
sub r9, r10
setb r13b
cmp r8, r14
jnb short loc_B6DB
sub rbx, r10
add r8, r10
test r13b, r13b
jz short loc_B6B1
loc_B6DB:
mov rsi, rcx
mov r11, [rsp+30h+var_60]
mov rbx, [rsp+30h+var_58]
mov r13d, [rsp+30h+var_6C]
loc_B6ED:
cmp rbp, rdx
jb loc_B624
jmp loc_B7A2
loc_B6FB:
xor eax, eax
mov r10, [rsp+30h+var_48]
loc_B702:
add r15, r15
lea r15, [r15+r15*4]
mov rdx, r15
mov ecx, r11d
shr rdx, cl
and r15, r10
add dl, 30h ; '0'
movsxd rcx, dword ptr [rsi]
lea r8d, [rcx+1]
mov [rsi], r8d
mov [rdi+rcx], dl
mov r8, rbp
add r8, rbp
lea rbp, [r8+r8*4]
mov rdx, r14
add rdx, r14
lea r14, [rdx+rdx*4]
dec eax
mov r9, rbp
sub r9, r15
jb short loc_B702
mov rcx, [rsp+30h+var_50]
add [rcx], eax
cmp r15, r14
jnb short loc_B7A2
cmp r9, [rsp+30h+var_68]
jb short loc_B7A2
movsxd rax, dword ptr [rsi]
lea rcx, [rdx+rdx*4]
mov rdx, rcx
sub rdx, r15
lea rsi, [r8+r8*4]
add r15, [rsp+30h+var_68]
sub rsi, r15
neg rcx
mov r9, [rsp+30h+var_68]
loc_B777:
cmp r15, r14
jb short loc_B785
lea r8, [rcx+r15]
cmp rdx, r8
jbe short loc_B7A2
loc_B785:
dec byte ptr [rdi+rax-1]
sub rsi, [rsp+30h+var_68]
setb r8b
cmp r15, r14
jnb short loc_B7A2
sub rdx, r9
add r15, r9
test r8b, r8b
jz short loc_B777
loc_B7A2:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(
long long a1,
int *a2,
_DWORD *a3,
long long a4,
long long a5,
long long a6,
long long a7,
int a8,
unsigned long long a9,
int a10)
{
int v10; // r11d
unsigned long long result; // rax
int v12; // ebx
unsigned int v13; // r13d
BOOL v14; // ebx
unsigned long long v15; // rbp
unsigned long long v16; // r14
unsigned long long v17; // r15
long long v18; // r8
unsigned long long v19; // rdx
unsigned long long v20; // r10
long long v21; // r11
unsigned long long v22; // rbx
unsigned long long v23; // r8
unsigned long long v24; // r9
bool v25; // cf
unsigned long long v26; // r15
unsigned long long v27; // rdx
long long v28; // rcx
long long v29; // r8
long long v30; // rdx
long long v31; // rcx
unsigned long long v32; // rdx
unsigned long long v33; // r15
unsigned long long v34; // rsi
long long v35; // rcx
bool v36; // cf
unsigned long long v37; // [rsp+4h] [rbp-68h]
int v38; // [rsp+14h] [rbp-58h]
v10 = -a10;
result = a9 >> -(char)a10;
v37 = 1LL << -(char)a10;
if ( (unsigned int)result <= 0x3B9AC9FF )
{
if ( (unsigned int)result <= 0x5F5E0FF )
{
if ( (unsigned int)result <= 0x98967F )
{
if ( (unsigned int)result <= 0xF423F )
{
if ( (unsigned int)result <= 0x1869F )
{
if ( (unsigned int)result <= 0x270F )
{
if ( (unsigned int)result <= 0x3E7 )
{
if ( (unsigned int)result <= 0x63 )
{
v14 = (unsigned int)result >= 0xA;
v13 = 9 * v14 + 1;
v12 = v14 + 1;
}
else
{
v12 = 3;
v13 = 100;
}
}
else
{
v12 = 4;
v13 = 1000;
}
}
else
{
v12 = 5;
v13 = 10000;
}
}
else
{
v12 = 6;
v13 = 100000;
}
}
else
{
v12 = 7;
v13 = 1000000;
}
}
else
{
v12 = 8;
v13 = 10000000;
}
}
else
{
v12 = 9;
v13 = 100000000;
}
}
else
{
v12 = 10;
v13 = 1000000000;
}
v15 = a9 - a4;
v16 = a9 - a7;
v17 = a9 & (v37 - 1);
while ( v12 > 0 )
{
v18 = *a2;
*a2 = v18 + 1;
*(_BYTE *)(a1 + v18) = (unsigned int)result / v13 + 48;
--v12;
result = (unsigned int)result % v13;
v19 = v17 + (result << v10);
if ( v15 >= v19 )
{
*a3 += v12;
v20 = (unsigned long long)v13 << v10;
if ( v19 >= v16 || v15 - v19 < v20 )
return result;
v38 = v12;
v21 = *a2;
v22 = a9 - a7 - v19;
v23 = v19 + v20;
v24 = a9 - a4 - (v19 + v20);
do
{
if ( v23 >= v16 && v22 <= a7 - a9 + v23 )
break;
--*(_BYTE *)(a1 + v21 - 1);
v25 = v24 < v20;
v24 -= v20;
if ( v23 >= v16 )
break;
v22 -= v20;
v23 += v20;
}
while ( !v25 );
v10 = -a10;
v12 = v38;
}
else
{
v13 /= 0xAu;
}
if ( v15 >= v19 )
return result;
}
LODWORD(result) = 0;
do
{
v26 = 10 * v17;
v27 = v26 >> v10;
v17 = (v37 - 1) & v26;
v28 = *a2;
*a2 = v28 + 1;
*(_BYTE *)(a1 + v28) = v27 + 48;
v29 = 2 * v15;
v15 *= 10LL;
v30 = 2 * v16;
v16 *= 10LL;
result = (unsigned int)(result - 1);
}
while ( v15 < v17 );
*a3 += result;
if ( v17 < v16 && v15 - v17 >= v37 )
{
result = *a2;
v31 = 5 * v30;
v32 = 5 * v30 - v17;
v33 = v37 + v17;
v34 = 5 * v29 - v33;
v35 = -v31;
do
{
if ( v33 >= v16 && v32 <= v35 + v33 )
break;
--*(_BYTE *)(a1 + result - 1);
v36 = v34 < v37;
v34 -= v37;
if ( v33 >= v16 )
break;
v32 -= v37;
v33 += v37;
}
while ( !v36 );
}
return result;
}
| grisu2_digit_gen:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R9,RCX
MOV qword ptr [RSP + -0x20],RDX
MOV RAX,qword ptr [RSP + 0x48]
XOR R11D,R11D
SUB R11D,dword ptr [RSP + 0x50]
MOV EDX,0x1
MOV ECX,R11D
SHL RDX,CL
MOV R8,RAX
SHR RAX,CL
MOV R12,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + -0x38],RDX
LEA R15,[RDX + -0x1]
CMP EAX,0x3b9ac9ff
JBE 0x0010b557
MOV EBX,0xa
MOV R13D,0x3b9aca00
JMP 0x0010b5f5
LAB_0010b557:
CMP EAX,0x5f5e0ff
JBE 0x0010b56e
MOV EBX,0x9
MOV R13D,0x5f5e100
JMP 0x0010b5f5
LAB_0010b56e:
CMP EAX,0x98967f
JBE 0x0010b582
MOV EBX,0x8
MOV R13D,0x989680
JMP 0x0010b5f5
LAB_0010b582:
CMP EAX,0xf423f
JBE 0x0010b596
MOV EBX,0x7
MOV R13D,0xf4240
JMP 0x0010b5f5
LAB_0010b596:
CMP EAX,0x1869f
JBE 0x0010b5aa
MOV EBX,0x6
MOV R13D,0x186a0
JMP 0x0010b5f5
LAB_0010b5aa:
CMP EAX,0x270f
JBE 0x0010b5be
MOV EBX,0x5
MOV R13D,0x2710
JMP 0x0010b5f5
LAB_0010b5be:
CMP EAX,0x3e7
JBE 0x0010b5d2
MOV EBX,0x4
MOV R13D,0x3e8
JMP 0x0010b5f5
LAB_0010b5d2:
CMP EAX,0x63
JBE 0x0010b5e4
MOV EBX,0x3
MOV R13D,0x64
JMP 0x0010b5f5
LAB_0010b5e4:
XOR EBX,EBX
CMP EAX,0xa
SETNC BL
LEA R13D,[RBX + RBX*0x8]
INC R13D
INC EBX
LAB_0010b5f5:
MOV RBP,R8
SUB RBP,R9
MOV R14,R8
SUB R14,R12
MOV qword ptr [RSP + -0x18],R15
AND R15,R8
MOV RCX,R8
SUB RCX,R12
MOV qword ptr [RSP + -0x10],RCX
SUB R12,R8
SUB R8,R9
MOV qword ptr [RSP + -0x8],R8
MOV qword ptr [RSP + -0x30],R11
LAB_0010b624:
TEST EBX,EBX
JLE 0x0010b6fb
XOR EDX,EDX
DIV R13D
ADD AL,0x30
MOVSXD R8,dword ptr [RSI]
LEA R9D,[R8 + 0x1]
MOV dword ptr [RSI],R9D
MOV byte ptr [RDI + R8*0x1],AL
DEC EBX
MOV EAX,EDX
MOV RDX,RAX
MOV ECX,R11D
SHL RDX,CL
ADD RDX,R15
MOV R8,RBP
MOV R10D,R13D
SUB R8,RDX
JNC 0x0010b66e
MOV ECX,0xcccccccd
IMUL R10,RCX
SHR R10,0x23
MOV R13D,R10D
JMP 0x0010b6ed
LAB_0010b66e:
MOV RCX,qword ptr [RSP + -0x20]
ADD dword ptr [RCX],EBX
MOV ECX,R11D
SHL R10,CL
CMP RDX,R14
JNC 0x0010b7a2
CMP R8,R10
JC 0x0010b7a2
MOV dword ptr [RSP + -0x3c],R13D
MOV qword ptr [RSP + -0x28],RBX
MOV RCX,RSI
MOVSXD R11,dword ptr [RSI]
MOV RBX,qword ptr [RSP + -0x10]
SUB RBX,RDX
LEA R8,[RDX + R10*0x1]
MOV R9,qword ptr [RSP + -0x8]
SUB R9,R8
LAB_0010b6b1:
CMP R8,R14
JC 0x0010b6bf
LEA R13,[R12 + R8*0x1]
CMP RBX,R13
JBE 0x0010b6db
LAB_0010b6bf:
DEC byte ptr [RDI + R11*0x1 + -0x1]
SUB R9,R10
SETC R13B
CMP R8,R14
JNC 0x0010b6db
SUB RBX,R10
ADD R8,R10
TEST R13B,R13B
JZ 0x0010b6b1
LAB_0010b6db:
MOV RSI,RCX
MOV R11,qword ptr [RSP + -0x30]
MOV RBX,qword ptr [RSP + -0x28]
MOV R13D,dword ptr [RSP + -0x3c]
LAB_0010b6ed:
CMP RBP,RDX
JC 0x0010b624
JMP 0x0010b7a2
LAB_0010b6fb:
XOR EAX,EAX
MOV R10,qword ptr [RSP + -0x18]
LAB_0010b702:
ADD R15,R15
LEA R15,[R15 + R15*0x4]
MOV RDX,R15
MOV ECX,R11D
SHR RDX,CL
AND R15,R10
ADD DL,0x30
MOVSXD RCX,dword ptr [RSI]
LEA R8D,[RCX + 0x1]
MOV dword ptr [RSI],R8D
MOV byte ptr [RDI + RCX*0x1],DL
MOV R8,RBP
ADD R8,RBP
LEA RBP,[R8 + R8*0x4]
MOV RDX,R14
ADD RDX,R14
LEA R14,[RDX + RDX*0x4]
DEC EAX
MOV R9,RBP
SUB R9,R15
JC 0x0010b702
MOV RCX,qword ptr [RSP + -0x20]
ADD dword ptr [RCX],EAX
CMP R15,R14
JNC 0x0010b7a2
CMP R9,qword ptr [RSP + -0x38]
JC 0x0010b7a2
MOVSXD RAX,dword ptr [RSI]
LEA RCX,[RDX + RDX*0x4]
MOV RDX,RCX
SUB RDX,R15
LEA RSI,[R8 + R8*0x4]
ADD R15,qword ptr [RSP + -0x38]
SUB RSI,R15
NEG RCX
MOV R9,qword ptr [RSP + -0x38]
LAB_0010b777:
CMP R15,R14
JC 0x0010b785
LEA R8,[RCX + R15*0x1]
CMP RDX,R8
JBE 0x0010b7a2
LAB_0010b785:
DEC byte ptr [RDI + RAX*0x1 + -0x1]
SUB RSI,qword ptr [RSP + -0x38]
SETC R8B
CMP R15,R14
JNC 0x0010b7a2
SUB RDX,R9
ADD R15,R9
TEST R8B,R8B
JZ 0x0010b777
LAB_0010b7a2:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen(char*, int&, int&,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp,
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp) */
void nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_digit_gen
(long param_1,int *param_2,int *param_3,long param_4,int8 param_5,
int8 param_6,long param_7,int8 param_8,ulong param_9,char param_10)
{
char *pcVar1;
int iVar2;
uint uVar3;
ulong uVar4;
byte bVar5;
ulong uVar6;
ulong uVar7;
int iVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
ulong uVar13;
uint uVar14;
ulong uVar15;
ulong uVar16;
bool bVar17;
bVar5 = -param_10;
uVar6 = 1L << (bVar5 & 0x3f);
uVar4 = param_9 >> (bVar5 & 0x3f);
uVar3 = (uint)uVar4;
if (uVar3 < 1000000000) {
if (uVar3 < 100000000) {
if (uVar3 < 10000000) {
if (uVar3 < 1000000) {
if (uVar3 < 100000) {
if (uVar3 < 10000) {
if (uVar3 < 1000) {
if (uVar3 < 100) {
uVar14 = (uint)(9 < uVar3) * 9 + 1;
iVar8 = (9 < uVar3) + 1;
}
else {
iVar8 = 3;
uVar14 = 100;
}
}
else {
iVar8 = 4;
uVar14 = 1000;
}
}
else {
iVar8 = 5;
uVar14 = 10000;
}
}
else {
iVar8 = 6;
uVar14 = 100000;
}
}
else {
iVar8 = 7;
uVar14 = 1000000;
}
}
else {
iVar8 = 8;
uVar14 = 10000000;
}
}
else {
iVar8 = 9;
uVar14 = 100000000;
}
}
else {
iVar8 = 10;
uVar14 = 1000000000;
}
uVar10 = param_9 - param_4;
uVar15 = param_9 - param_7;
uVar16 = uVar6 - 1 & param_9;
do {
if (iVar8 < 1) {
iVar8 = 0;
do {
uVar13 = uVar15;
uVar7 = uVar10;
uVar4 = uVar16 * 10;
uVar16 = uVar4 & uVar6 - 1;
iVar2 = *param_2;
*param_2 = iVar2 + 1;
*(char *)(param_1 + iVar2) = (char)(uVar4 >> (bVar5 & 0x3f)) + '0';
uVar10 = uVar7 * 10;
uVar15 = uVar13 * 10;
iVar8 = iVar8 + -1;
} while (uVar10 < uVar16);
*param_3 = *param_3 + iVar8;
if ((uVar16 < uVar15) && (uVar6 <= uVar10 - uVar16)) {
iVar8 = *param_2;
uVar4 = uVar13 * 10 - uVar16;
uVar16 = uVar16 + uVar6;
uVar10 = uVar7 * 10 - uVar16;
do {
if ((uVar15 <= uVar16) && (uVar4 <= uVar13 * -10 + uVar16)) {
return;
}
pcVar1 = (char *)(param_1 + -1 + (long)iVar8);
*pcVar1 = *pcVar1 + -1;
bVar17 = uVar6 <= uVar10;
uVar10 = uVar10 - uVar6;
if (uVar15 <= uVar16) {
return;
}
uVar4 = uVar4 - uVar6;
uVar16 = uVar16 + uVar6;
} while (bVar17);
}
return;
}
uVar7 = uVar4 & 0xffffffff;
uVar4 = uVar7 % (ulong)uVar14;
iVar2 = *param_2;
*param_2 = iVar2 + 1;
*(char *)(param_1 + iVar2) = (char)(uVar7 / uVar14) + '0';
iVar8 = iVar8 + -1;
uVar7 = (uVar4 << (bVar5 & 0x3f)) + uVar16;
if (uVar10 < uVar7) {
uVar14 = uVar14 / 10;
}
else {
*param_3 = *param_3 + iVar8;
uVar13 = (ulong)uVar14 << (bVar5 & 0x3f);
if (uVar15 <= uVar7) {
return;
}
if (uVar10 - uVar7 < uVar13) {
return;
}
iVar2 = *param_2;
uVar9 = (param_9 - param_7) - uVar7;
uVar11 = uVar7 + uVar13;
uVar12 = (param_9 - param_4) - uVar11;
do {
if ((uVar15 <= uVar11) && (uVar9 <= (param_7 - param_9) + uVar11)) break;
pcVar1 = (char *)(param_1 + -1 + (long)iVar2);
*pcVar1 = *pcVar1 + -1;
bVar17 = uVar13 <= uVar12;
uVar12 = uVar12 - uVar13;
if (uVar15 <= uVar11) break;
uVar9 = uVar9 - uVar13;
uVar11 = uVar11 + uVar13;
} while (bVar17);
}
if (uVar7 <= uVar10) {
return;
}
} while( true );
}
| |
24,511 | ma_multi_malloc | eloqsql/libmariadb/libmariadb/ma_alloc.c | void *ma_multi_malloc(myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
size_t tot_length,length;
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args, size_t);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *)malloc(tot_length)))
return 0;
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,size_t);
res+=ALIGN_SIZE(length);
}
va_end(args);
return start;
} | O0 | c | ma_multi_malloc:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0x25a81
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rsi, -0x108(%rbp)
movl %edi, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0x25b0e
movq -0x120(%rbp), %rcx
movl -0x114(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x128(%rbp)
jmp 0x25b2b
movq -0x120(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x25bc6
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x25b7e
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x25b9b
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x25ad3
leaq -0x30(%rbp), %rax
movq -0x50(%rbp), %rdi
callq 0x135b0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x25bea
movq $0x0, -0x8(%rbp)
jmp 0x25d20
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0x25c51
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x158(%rbp)
jmp 0x25c6e
movq -0x150(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x25d14
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rax
movq %rax, -0x168(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x28, %eax
ja 0x25ccc
movq -0x168(%rbp), %rcx
movl -0x15c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x170(%rbp)
jmp 0x25ce9
movq -0x168(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x25c16
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopl (%rax)
| ma_multi_malloc:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_25A81
movaps [rbp+var_E0], xmm0
movaps [rbp+var_D0], xmm1
movaps [rbp+var_C0], xmm2
movaps [rbp+var_B0], xmm3
movaps [rbp+var_A0], xmm4
movaps [rbp+var_90], xmm5
movaps [rbp+var_80], xmm6
movaps [rbp+var_70], xmm7
loc_25A81:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_108], rsi
mov [rbp+var_C], edi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov [rbp+var_50], 0
loc_25AD3:
lea rax, [rbp+var_30]
mov [rbp+var_120], rax
mov eax, [rbp+var_30]
mov [rbp+var_114], eax
cmp eax, 28h ; '('
ja short loc_25B0E
mov rcx, [rbp+var_120]
mov edx, [rbp+var_114]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_128], rax
jmp short loc_25B2B
loc_25B0E:
mov rcx, [rbp+var_120]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_128], rax
loc_25B2B:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_25BC6
lea rax, [rbp+var_30]
mov [rbp+var_138], rax
mov eax, [rbp+var_30]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_25B7E
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_25B9B
loc_25B7E:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_25B9B:
mov rax, [rbp+var_140]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_50]
mov [rbp+var_50], rax
jmp loc_25AD3
loc_25BC6:
lea rax, [rbp+var_30]
mov rdi, [rbp+var_50]
call _malloc
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_25BEA
mov [rbp+var_8], 0
jmp loc_25D20
loc_25BEA:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 8
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_25C16:
lea rax, [rbp+var_30]
mov [rbp+var_150], rax
mov eax, [rbp+var_30]
mov [rbp+var_144], eax
cmp eax, 28h ; '('
ja short loc_25C51
mov rcx, [rbp+var_150]
mov edx, [rbp+var_144]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_158], rax
jmp short loc_25C6E
loc_25C51:
mov rcx, [rbp+var_150]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_158], rax
loc_25C6E:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_25D14
mov rcx, [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax], rcx
lea rax, [rbp+var_30]
mov [rbp+var_168], rax
mov eax, [rbp+var_30]
mov [rbp+var_15C], eax
cmp eax, 28h ; '('
ja short loc_25CCC
mov rcx, [rbp+var_168]
mov edx, [rbp+var_15C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_170], rax
jmp short loc_25CE9
loc_25CCC:
mov rcx, [rbp+var_168]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_170], rax
loc_25CE9:
mov rax, [rbp+var_170]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp loc_25C16
loc_25D14:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_25D20:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
| long long ma_multi_malloc(int a1, ...)
{
_QWORD *overflow_arg_area; // rax
_QWORD *v2; // rax
_QWORD *v3; // rax
_QWORD *v4; // rax
long long i; // [rsp+120h] [rbp-50h]
long long j; // [rsp+128h] [rbp-48h]
long long v8; // [rsp+130h] [rbp-40h]
va_list va; // [rsp+140h] [rbp-30h] BYREF
int v10; // [rsp+164h] [rbp-Ch]
va_start(va, a1);
v10 = a1;
for ( i = 0LL; ; i += (*v2 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*overflow_arg_area )
break;
if ( va[0].gp_offset > 0x28 )
{
v2 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v2 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
v8 = malloc(i);
if ( !v8 )
return 0LL;
va_end(va);
va_start(va, a1);
for ( j = v8; ; j += (*v4 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
v3 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v3 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*v3 )
break;
*(_QWORD *)*v3 = j;
if ( va[0].gp_offset > 0x28 )
{
v4 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
return v8;
}
| ma_multi_malloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x00125a81
MOVAPS xmmword ptr [RBP + -0xe0],XMM0
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM2
MOVAPS xmmword ptr [RBP + -0xb0],XMM3
MOVAPS xmmword ptr [RBP + -0xa0],XMM4
MOVAPS xmmword ptr [RBP + -0x90],XMM5
MOVAPS xmmword ptr [RBP + -0x80],XMM6
MOVAPS xmmword ptr [RBP + -0x70],XMM7
LAB_00125a81:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV qword ptr [RBP + -0x108],RSI
MOV dword ptr [RBP + -0xc],EDI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x8
MOV qword ptr [RBP + -0x50],0x0
LAB_00125ad3:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x114],EAX
CMP EAX,0x28
JA 0x00125b0e
MOV RCX,qword ptr [RBP + -0x120]
MOV EDX,dword ptr [RBP + -0x114]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x128],RAX
JMP 0x00125b2b
LAB_00125b0e:
MOV RCX,qword ptr [RBP + -0x120]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x128],RAX
LAB_00125b2b:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x00125bc6
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x00125b7e
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x00125b9b
LAB_00125b7e:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_00125b9b:
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00125ad3
LAB_00125bc6:
LEA RAX,[RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x001135b0
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x00125bea
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00125d20
LAB_00125bea:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x8
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_00125c16:
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x150],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x144],EAX
CMP EAX,0x28
JA 0x00125c51
MOV RCX,qword ptr [RBP + -0x150]
MOV EDX,dword ptr [RBP + -0x144]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x158],RAX
JMP 0x00125c6e
LAB_00125c51:
MOV RCX,qword ptr [RBP + -0x150]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x158],RAX
LAB_00125c6e:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x00125d14
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX],RCX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x168],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x15c],EAX
CMP EAX,0x28
JA 0x00125ccc
MOV RCX,qword ptr [RBP + -0x168]
MOV EDX,dword ptr [RBP + -0x15c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x170],RAX
JMP 0x00125ce9
LAB_00125ccc:
MOV RCX,qword ptr [RBP + -0x168]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x170],RAX
LAB_00125ce9:
MOV RAX,qword ptr [RBP + -0x170]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x00125c16
LAB_00125d14:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00125d20:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
void * ma_multi_malloc(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12
,int8 param_13,int8 param_14)
{
char in_AL;
long *local_178;
long *local_160;
long *local_148;
long *local_130;
long local_118 [4];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
long local_60;
size_t local_58;
void *local_50;
long local_40;
uint local_38;
int4 local_34;
long *local_30;
long *local_28;
int4 local_14;
void *local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (long *)&stack0x00000008;
local_34 = 0x30;
local_38 = 8;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 1;
}
local_40 = *local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 1;
}
local_60 = *local_148;
local_58 = (local_60 + 7U & 0xfffffffffffffff8) + local_58;
}
local_118[1] = param_10;
local_118[2] = param_11;
local_118[3] = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_14 = param_9;
local_10 = malloc(local_58);
if (local_10 == (void *)0x0) {
local_10 = (void *)0x0;
}
else {
local_30 = (long *)&stack0x00000008;
local_38 = 8;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 1;
}
if ((int8 *)*local_160 == (int8 *)0x0) break;
*(int8 *)*local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 1;
}
local_50 = (void *)((*local_178 + 7U & 0xfffffffffffffff8) + (long)local_50);
}
}
return local_10;
}
| |
24,512 | LefDefParser::defwEndGroups() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp | int
defwEndGroups()
{
defwFunc = DEFW_GROUP_END; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (defwState != DEFW_GROUP_START && defwState != DEFW_GROUP)
return DEFW_BAD_ORDER;
if (defwCounter > 0)
return DEFW_BAD_DATA;
else if (defwCounter < 0)
return DEFW_TOO_MANY_STMS;
if (defwState != DEFW_GROUP_START)
fprintf(defwFile, " ;\n");
fprintf(defwFile, "END GROUPS\n\n");
defwLines++;
defwState = DEFW_GROUP_END;
return DEFW_OK;
} | O0 | cpp | LefDefParser::defwEndGroups():
pushq %rax
leaq 0xcf70(%rip), %rax # 0x2b168
movl $0x4f, (%rax)
leaq 0xcf53(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x1e218
movl $0x1, 0x4(%rsp)
jmp 0x1e2d1
leaq 0xcf45(%rip), %rax # 0x2b164
cmpl $0x4d, (%rax)
je 0x1e23d
leaq 0xcf39(%rip), %rax # 0x2b164
cmpl $0x4e, (%rax)
je 0x1e23d
movl $0x2, 0x4(%rsp)
jmp 0x1e2d1
leaq 0xcf34(%rip), %rax # 0x2b178
cmpl $0x0, (%rax)
jle 0x1e253
movl $0x3, 0x4(%rsp)
jmp 0x1e2d1
leaq 0xcf1e(%rip), %rax # 0x2b178
cmpl $0x0, (%rax)
jge 0x1e269
movl $0x7, 0x4(%rsp)
jmp 0x1e2d1
jmp 0x1e26b
leaq 0xcef2(%rip), %rax # 0x2b164
cmpl $0x4d, (%rax)
je 0x1e28f
leaq 0xceda(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x5bca(%rip), %rsi # 0x23e52
movb $0x0, %al
callq 0x10f0
leaq 0xcec2(%rip), %rax # 0x2b158
movq (%rax), %rdi
leaq 0x6d51(%rip), %rsi # 0x24ff1
movb $0x0, %al
callq 0x10f0
leaq 0xceb2(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xcea6(%rip), %rax # 0x2b160
movl %ecx, (%rax)
leaq 0xcea1(%rip), %rax # 0x2b164
movl $0x4f, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
| _ZN12LefDefParser13defwEndGroupsEv:
push rax
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 4Fh ; 'O'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_1E218
mov [rsp+8+var_4], 1
jmp loc_1E2D1
loc_1E218:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 4Dh ; 'M'
jz short loc_1E23D
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 4Eh ; 'N'
jz short loc_1E23D
mov [rsp+8+var_4], 2
jmp loc_1E2D1
loc_1E23D:
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
cmp dword ptr [rax], 0
jle short loc_1E253
mov [rsp+8+var_4], 3
jmp short loc_1E2D1
loc_1E253:
lea rax, _ZN12LefDefParser11defwCounterE; LefDefParser::defwCounter
cmp dword ptr [rax], 0
jge short loc_1E269
mov [rsp+8+var_4], 7
jmp short loc_1E2D1
loc_1E269:
jmp short $+2
loc_1E26B:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 4Dh ; 'M'
jz short loc_1E28F
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aDividercharS+10h; " ;\n"
mov al, 0
call _fprintf
loc_1E28F:
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
lea rsi, aEndGroups; "END GROUPS\n\n"
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 4Fh ; 'O'
mov [rsp+8+var_4], 0
loc_1E2D1:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::defwEndGroups(LefDefParser *this)
{
LefDefParser::defwFunc = 79;
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwState == 77 || LefDefParser::defwState == 78 )
{
if ( LefDefParser::defwCounter <= 0 )
{
if ( LefDefParser::defwCounter >= 0 )
{
if ( LefDefParser::defwState != 77 )
fprintf(LefDefParser::defwFile, " ;\n");
fprintf(LefDefParser::defwFile, "END GROUPS\n\n");
++LefDefParser::defwLines;
LefDefParser::defwState = 79;
return 0;
}
else
{
return 7;
}
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| defwEndGroups:
PUSH RAX
LEA RAX,[0x12b168]
MOV dword ptr [RAX],0x4f
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x0011e218
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0011e2d1
LAB_0011e218:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x4d
JZ 0x0011e23d
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x4e
JZ 0x0011e23d
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0011e2d1
LAB_0011e23d:
LEA RAX,[0x12b178]
CMP dword ptr [RAX],0x0
JLE 0x0011e253
MOV dword ptr [RSP + 0x4],0x3
JMP 0x0011e2d1
LAB_0011e253:
LEA RAX,[0x12b178]
CMP dword ptr [RAX],0x0
JGE 0x0011e269
MOV dword ptr [RSP + 0x4],0x7
JMP 0x0011e2d1
LAB_0011e269:
JMP 0x0011e26b
LAB_0011e26b:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x4d
JZ 0x0011e28f
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x123e52]
MOV AL,0x0
CALL 0x001010f0
LAB_0011e28f:
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x124ff1]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x4f
MOV dword ptr [RSP + 0x4],0x0
LAB_0011e2d1:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::defwEndGroups() */
int4 LefDefParser::defwEndGroups(void)
{
int4 local_4;
defwFunc = 0x4f;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if ((defwState == 0x4d) || (defwState == 0x4e)) {
if (defwCounter < 1) {
if (defwCounter < 0) {
local_4 = 7;
}
else {
if (defwState != 0x4d) {
fprintf(defwFile," ;\n");
}
fprintf(defwFile,"END GROUPS\n\n");
defwLines = defwLines + 1;
defwState = 0x4f;
local_4 = 0;
}
}
else {
local_4 = 3;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
24,513 | my_casedn_str_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_casedn_str_utf8mb4(CHARSET_INFO *cs, char *src)
{
my_wc_t wc;
int srcres, dstres;
char *dst= src, *dst0= src;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(cs->casedn_multiply == 1);
while (*src &&
(srcres= my_mb_wc_utf8mb4_no_range(cs, &wc, (uchar *) src)) > 0)
{
my_tolower_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4_no_range(cs, wc, (uchar*) dst)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
/*
In rare cases lower string can be shorter than
the original string, for example:
"U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE"
(which is 0xC4B0 in utf8mb3, i.e. two bytes)
is converted into
"U+0069 LATIN SMALL LETTER I"
(which is 0x69 in utf8mb3, i.e. one byte)
So, we need to put '\0' terminator after converting.
*/
*dst= '\0';
return (size_t) (dst - dst0);
} | O0 | c | my_casedn_str_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x6a4de
jmp 0x6a4e0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x6a50e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rsi
callq 0x6e2a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6a517
jmp 0x6a566
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6e690
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6e550
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jg 0x6a53f
jmp 0x6a566
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x6a4e0
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_casedn_str_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_38], rax
jmp short $+2
loc_6A4DE:
jmp short $+2
loc_6A4E0:
mov rax, [rbp+var_10]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_39], al
jz short loc_6A50E
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
lea rsi, [rbp+var_18]
call my_mb_wc_utf8mb4_no_range
mov [rbp+var_1C], eax
cmp eax, 0
setnle al
mov [rbp+var_39], al
loc_6A50E:
mov al, [rbp+var_39]
test al, 1
jnz short loc_6A517
jmp short loc_6A566
loc_6A517:
mov rdi, [rbp+var_38]
lea rsi, [rbp+var_18]
call my_tolower_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call my_wc_mb_utf8mb4_no_range
mov [rbp+var_20], eax
cmp eax, 0
jg short loc_6A53F
jmp short loc_6A566
loc_6A53F:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_20]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_6A4E0
loc_6A566:
mov rax, [rbp+var_28]
mov byte ptr [rax], 0
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
sub rax, rcx
add rsp, 40h
pop rbp
retn
| _BYTE * my_casedn_str_utf8mb4(long long a1, _BYTE *a2)
{
bool v3; // [rsp+7h] [rbp-39h]
long long v4; // [rsp+8h] [rbp-38h]
_BYTE *v5; // [rsp+18h] [rbp-28h]
int v6; // [rsp+20h] [rbp-20h]
int v7; // [rsp+24h] [rbp-1Ch]
long long v8; // [rsp+28h] [rbp-18h] BYREF
_BYTE *v9; // [rsp+30h] [rbp-10h]
long long v10; // [rsp+38h] [rbp-8h]
v10 = a1;
v9 = a2;
v5 = a2;
v4 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v3 = 0;
if ( *v9 )
{
v7 = my_mb_wc_utf8mb4_no_range(v10, &v8, v9);
v3 = v7 > 0;
}
if ( !v3 )
break;
my_tolower_utf8mb4(v4, &v8);
v6 = my_wc_mb_utf8mb4_no_range(v10, v8, v5);
if ( v6 <= 0 )
break;
v9 += v7;
v5 += v6;
}
*v5 = 0;
return (_BYTE *)(v5 - a2);
}
| my_casedn_str_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0016a4de
LAB_0016a4de:
JMP 0x0016a4e0
LAB_0016a4e0:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x39],AL
JZ 0x0016a50e
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x18]
CALL 0x0016e2a0
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x39],AL
LAB_0016a50e:
MOV AL,byte ptr [RBP + -0x39]
TEST AL,0x1
JNZ 0x0016a517
JMP 0x0016a566
LAB_0016a517:
MOV RDI,qword ptr [RBP + -0x38]
LEA RSI,[RBP + -0x18]
CALL 0x0016e690
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0016e550
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JG 0x0016a53f
JMP 0x0016a566
LAB_0016a53f:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0016a4e0
LAB_0016a566:
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
ADD RSP,0x40
POP RBP
RET
|
long my_casedn_str_utf8mb4(long param_1,char *param_2)
{
int8 uVar1;
bool bVar2;
int iVar3;
char *local_30;
int local_24;
int8 local_20;
char *local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_2;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (*local_18 != '\0') {
local_24 = my_mb_wc_utf8mb4_no_range(local_10,&local_20,local_18);
bVar2 = 0 < local_24;
}
if (!bVar2) break;
my_tolower_utf8mb4(uVar1,&local_20);
iVar3 = my_wc_mb_utf8mb4_no_range(local_10,local_20,local_30);
if (iVar3 < 1) break;
local_18 = local_18 + local_24;
local_30 = local_30 + iVar3;
}
*local_30 = '\0';
return (long)local_30 - (long)param_2;
}
| |
24,514 | test_prepare_noparam | eloqsql/tests/mysql_client_test.c | static void test_prepare_noparam()
{
MYSQL_STMT *stmt;
int rc;
MYSQL_RES *result;
char query[MAX_TEST_QUERY_LENGTH];
myheader("test_prepare_noparam");
rc= mysql_query(mysql, "DROP TABLE IF EXISTS my_prepare");
myquery(rc);
rc= mysql_query(mysql, "CREATE TABLE my_prepare(col1 int, col2 varchar(50))");
myquery(rc);
/* insert by prepare */
strmov(query, "INSERT INTO my_prepare VALUES(10, 'venu')");
stmt= mysql_simple_prepare(mysql, query);
check_stmt(stmt);
verify_param_count(stmt, 0);
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
mysql_stmt_close(stmt);
/* now fetch the results ..*/
rc= mysql_commit(mysql);
myquery(rc);
/* test the results now, only one row should exist */
rc= mysql_query(mysql, "SELECT * FROM my_prepare");
myquery(rc);
/* get the result */
result= mysql_store_result(mysql);
mytest(result);
rc= my_process_result_set(result);
DIE_UNLESS(rc == 1);
mysql_free_result(result);
} | O0 | c | test_prepare_noparam:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x4930a
movsbl 0x4211c0(%rip), %eax # 0x46a4d1
cmpl $0x2, %eax
jge 0x49392
movq 0x265cbb(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0xe4ffd(%rip), %rsi # 0x12e324
movb $0x0, %al
callq 0x3a1c0
movq 0x265ca3(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
movl 0x4213de(%rip), %edx # 0x46a71c
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x4213d3(%rip) # 0x46a71c
movl 0x4213c9(%rip), %ecx # 0x46a718
movl 0x4211a6(%rip), %r8d # 0x46a4fc
leaq 0xe62cf(%rip), %rsi # 0x12f62c
leaq 0xe5478(%rip), %r9 # 0x12e7dc
movb $0x0, %al
callq 0x3a1c0
movq 0x265c66(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0xe4fe0(%rip), %rsi # 0x12e35c
movb $0x0, %al
callq 0x3a1c0
movq 0x265c4e(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
callq 0x3a4a0
movq 0x42113f(%rip), %rdi # 0x46a4d8
leaq 0xe92e8(%rip), %rsi # 0x132688
callq 0x3b3d0
movl %eax, -0x14c(%rbp)
movl -0x14c(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x0, -0x15c(%rbp)
je 0x493c9
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x15c(%rbp)
jne 0x493d4
jmp 0x493ec
leaq 0xe4831(%rip), %rdi # 0x12dc0c
movl $0xe05, %esi # imm = 0xE05
leaq 0xfab88(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x4210e5(%rip), %rdi # 0x46a4d8
leaq 0xe92ae(%rip), %rsi # 0x1326a8
callq 0x3b3d0
movl %eax, -0x14c(%rbp)
movl -0x14c(%rbp), %eax
movl %eax, -0x160(%rbp)
cmpl $0x0, -0x160(%rbp)
je 0x49423
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x160(%rbp)
jne 0x4942e
jmp 0x49446
leaq 0xe47d7(%rip), %rdi # 0x12dc0c
movl $0xe09, %esi # imm = 0xE09
leaq 0xfab2e(%rip), %rdx # 0x143f6f
callq 0x3c010
leaq -0x140(%rbp), %rdi
leaq 0xe9288(%rip), %rsi # 0x1326dc
callq 0x3a9c0
movq 0x421078(%rip), %rdi # 0x46a4d8
leaq -0x140(%rbp), %rsi
callq 0x3be90
movq %rax, -0x148(%rbp)
cmpq $0x0, -0x148(%rbp)
jne 0x49486
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpq $0x0, -0x148(%rbp)
je 0x49492
jmp 0x494aa
leaq 0xe4773(%rip), %rdi # 0x12dc0c
movl $0xe0e, %esi # imm = 0xE0E
leaq 0xe44c5(%rip), %rdx # 0x12d96a
callq 0x3c010
movq -0x148(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x41790
movq -0x148(%rbp), %rdi
callq 0x3b8a0
movl %eax, -0x14c(%rbp)
cmpl $0x0, -0x14c(%rbp)
je 0x494e5
movq -0x148(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3c0b0
cmpl $0x0, -0x14c(%rbp)
jne 0x494f0
jmp 0x49508
leaq 0xe4715(%rip), %rdi # 0x12dc0c
movl $0xe13, %esi # imm = 0xE13
leaq 0xf0309(%rip), %rdx # 0x13980c
callq 0x3c010
movq -0x148(%rbp), %rdi
callq 0x3b9f0
movq 0x420fbd(%rip), %rdi # 0x46a4d8
callq 0x3bbe0
movsbl %al, %eax
movl %eax, -0x14c(%rbp)
movl -0x14c(%rbp), %eax
movl %eax, -0x164(%rbp)
cmpl $0x0, -0x164(%rbp)
je 0x49547
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x164(%rbp)
jne 0x49552
jmp 0x4956a
leaq 0xe46b3(%rip), %rdi # 0x12dc0c
movl $0xe19, %esi # imm = 0xE19
leaq 0xfaa0a(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x420f67(%rip), %rdi # 0x46a4d8
leaq 0xe918e(%rip), %rsi # 0x132706
callq 0x3b3d0
movl %eax, -0x14c(%rbp)
movl -0x14c(%rbp), %eax
movl %eax, -0x168(%rbp)
cmpl $0x0, -0x168(%rbp)
je 0x495a1
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x168(%rbp)
jne 0x495ac
jmp 0x495c4
leaq 0xe4659(%rip), %rdi # 0x12dc0c
movl $0xe1d, %esi # imm = 0xE1D
leaq 0xfa9b0(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x420f0d(%rip), %rdi # 0x46a4d8
callq 0x3b210
movq %rax, -0x158(%rbp)
cmpq $0x0, -0x158(%rbp)
jne 0x49602
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
leaq 0xe461b(%rip), %rdi # 0x12dc0c
movl $0xe21, %esi # imm = 0xE21
leaq 0xe43df(%rip), %rdx # 0x12d9dc
callq 0x3c010
movq -0x158(%rbp), %rdi
callq 0x3c860
movl %eax, -0x14c(%rbp)
cmpl $0x1, -0x14c(%rbp)
jne 0x4961f
jmp 0x49637
leaq 0xe45e6(%rip), %rdi # 0x12dc0c
movl $0xe24, %esi # imm = 0xE24
leaq 0xe6858(%rip), %rdx # 0x12fe8a
callq 0x3c010
movq -0x158(%rbp), %rdi
callq 0x3b280
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x4965e
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
callq 0x3a2a0
nopw %cs:(%rax,%rax)
| test_prepare_noparam:
push rbp
mov rbp, rsp
sub rsp, 170h
mov rax, fs:28h
mov [rbp+var_8], rax
jmp short $+2
loc_4930A:
movsx eax, cs:opt_silent
cmp eax, 2
jge short loc_49392
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E324; "\n\n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov edx, cs:test_count
mov eax, edx
add eax, 1
mov cs:test_count, eax
mov ecx, cs:iter_count
mov r8d, cs:opt_count
lea rsi, aUOfUUS; "%u of (%u/%u): %s"
lea r9, aTestPrepareNop; "test_prepare_noparam"
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E35C; " \n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_49392:
mov rdi, cs:mysql
lea rsi, aDropTableIfExi_13; "DROP TABLE IF EXISTS my_prepare"
call wrap_mysql_query
mov [rbp+var_14C], eax
mov eax, [rbp+var_14C]
mov [rbp+var_15C], eax
cmp [rbp+var_15C], 0
jz short loc_493C9
xor eax, eax
mov edi, eax
call print_error
loc_493C9:
cmp [rbp+var_15C], 0
jnz short loc_493D4
jmp short loc_493EC
loc_493D4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E05h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_493EC:
mov rdi, cs:mysql
lea rsi, aCreateTableMyP; "CREATE TABLE my_prepare(col1 int, col2 "...
call wrap_mysql_query
mov [rbp+var_14C], eax
mov eax, [rbp+var_14C]
mov [rbp+var_160], eax
cmp [rbp+var_160], 0
jz short loc_49423
xor eax, eax
mov edi, eax
call print_error
loc_49423:
cmp [rbp+var_160], 0
jnz short loc_4942E
jmp short loc_49446
loc_4942E:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E09h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_49446:
lea rdi, [rbp+var_140]
lea rsi, aInsertIntoMyPr; "INSERT INTO my_prepare VALUES(10, 'venu"...
call _stpcpy
mov rdi, cs:mysql
lea rsi, [rbp+var_140]
call mysql_simple_prepare
mov [rbp+var_148], rax
cmp [rbp+var_148], 0
jnz short loc_49486
xor eax, eax
mov edi, eax
call print_error
loc_49486:
cmp [rbp+var_148], 0
jz short loc_49492
jmp short loc_494AA
loc_49492:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E0Eh
lea rdx, aStmt0; "stmt != 0"
call die
loc_494AA:
mov rdi, [rbp+var_148]
xor eax, eax
mov esi, eax
call verify_param_count
mov rdi, [rbp+var_148]
call wrap_mysql_stmt_execute
mov [rbp+var_14C], eax
cmp [rbp+var_14C], 0
jz short loc_494E5
mov rdi, [rbp+var_148]
xor eax, eax
mov esi, eax
call print_st_error
loc_494E5:
cmp [rbp+var_14C], 0
jnz short loc_494F0
jmp short loc_49508
loc_494F0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E13h
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
call die
loc_49508:
mov rdi, [rbp+var_148]
call wrap_mysql_stmt_close
mov rdi, cs:mysql
call wrap_mysql_commit
movsx eax, al
mov [rbp+var_14C], eax
mov eax, [rbp+var_14C]
mov [rbp+var_164], eax
cmp [rbp+var_164], 0
jz short loc_49547
xor eax, eax
mov edi, eax
call print_error
loc_49547:
cmp [rbp+var_164], 0
jnz short loc_49552
jmp short loc_4956A
loc_49552:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E19h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_4956A:
mov rdi, cs:mysql
lea rsi, aSelectFromMyPr; "SELECT * FROM my_prepare"
call wrap_mysql_query
mov [rbp+var_14C], eax
mov eax, [rbp+var_14C]
mov [rbp+var_168], eax
cmp [rbp+var_168], 0
jz short loc_495A1
xor eax, eax
mov edi, eax
call print_error
loc_495A1:
cmp [rbp+var_168], 0
jnz short loc_495AC
jmp short loc_495C4
loc_495AC:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E1Dh
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_495C4:
mov rdi, cs:mysql
call wrap_mysql_store_result
mov [rbp+var_158], rax
cmp [rbp+var_158], 0
jnz short loc_49602
xor eax, eax
mov edi, eax
call print_error
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E21h
lea rdx, aFalse; "FALSE"
call die
loc_49602:
mov rdi, [rbp+var_158]
call my_process_result_set
mov [rbp+var_14C], eax
cmp [rbp+var_14C], 1
jnz short loc_4961F
jmp short loc_49637
loc_4961F:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0E24h
lea rdx, aRc1; "rc == 1"
call die
loc_49637:
mov rdi, [rbp+var_158]
call wrap_mysql_free_result
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_4965E
add rsp, 170h
pop rbp
retn
loc_4965E:
call ___stack_chk_fail
| unsigned long long test_prepare_noparam()
{
int v0; // edx
char v1; // al
int v3; // [rsp+Ch] [rbp-164h]
long long v4; // [rsp+18h] [rbp-158h]
long long v5; // [rsp+28h] [rbp-148h]
_BYTE v6[312]; // [rsp+30h] [rbp-140h] BYREF
unsigned long long v7; // [rsp+168h] [rbp-8h]
v7 = __readfsqword(0x28u);
if ( opt_silent < 2 )
{
fprintf(stdout, "\n\n#####################################\n");
v0 = test_count++;
fprintf(stdout, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_prepare_noparam");
fprintf(stdout, " \n#####################################\n");
fflush(stdout);
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP TABLE IF EXISTS my_prepare") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3589, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"CREATE TABLE my_prepare(col1 int, col2 varchar(50))") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3593, "r == 0");
}
stpcpy(v6, "INSERT INTO my_prepare VALUES(10, 'venu')");
v5 = mysql_simple_prepare(mysql, (long long)v6);
if ( !v5 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3598, "stmt != 0");
}
verify_param_count(v5, 0LL);
if ( (unsigned int)wrap_mysql_stmt_execute(v5) )
{
print_st_error(v5, 0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3603, "rc == 0");
}
wrap_mysql_stmt_close(v5);
v1 = wrap_mysql_commit(mysql);
v3 = v1;
if ( v1 )
print_error(0LL);
if ( v3 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3609, "r == 0");
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"SELECT * FROM my_prepare") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3613, "r == 0");
}
v4 = wrap_mysql_store_result(mysql);
if ( !v4 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3617, "FALSE");
}
if ( (unsigned int)my_process_result_set(v4) != 1 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 3620, "rc == 1");
wrap_mysql_free_result(v4);
return __readfsqword(0x28u);
}
| test_prepare_noparam:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014930a
LAB_0014930a:
MOVSX EAX,byte ptr [0x0056a4d1]
CMP EAX,0x2
JGE 0x00149392
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e324]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [0x0056a71c]
MOV EAX,EDX
ADD EAX,0x1
MOV dword ptr [0x0056a71c],EAX
MOV ECX,dword ptr [0x0056a718]
MOV R8D,dword ptr [0x0056a4fc]
LEA RSI,[0x22f62c]
LEA R9,[0x22e7dc]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e35c]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
CALL 0x0013a4a0
LAB_00149392:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x232688]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x14c],EAX
MOV EAX,dword ptr [RBP + -0x14c]
MOV dword ptr [RBP + -0x15c],EAX
CMP dword ptr [RBP + -0x15c],0x0
JZ 0x001493c9
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_001493c9:
CMP dword ptr [RBP + -0x15c],0x0
JNZ 0x001493d4
JMP 0x001493ec
LAB_001493d4:
LEA RDI,[0x22dc0c]
MOV ESI,0xe05
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_001493ec:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x2326a8]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x14c],EAX
MOV EAX,dword ptr [RBP + -0x14c]
MOV dword ptr [RBP + -0x160],EAX
CMP dword ptr [RBP + -0x160],0x0
JZ 0x00149423
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_00149423:
CMP dword ptr [RBP + -0x160],0x0
JNZ 0x0014942e
JMP 0x00149446
LAB_0014942e:
LEA RDI,[0x22dc0c]
MOV ESI,0xe09
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_00149446:
LEA RDI,[RBP + -0x140]
LEA RSI,[0x2326dc]
CALL 0x0013a9c0
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[RBP + -0x140]
CALL 0x0013be90
MOV qword ptr [RBP + -0x148],RAX
CMP qword ptr [RBP + -0x148],0x0
JNZ 0x00149486
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_00149486:
CMP qword ptr [RBP + -0x148],0x0
JZ 0x00149492
JMP 0x001494aa
LAB_00149492:
LEA RDI,[0x22dc0c]
MOV ESI,0xe0e
LEA RDX,[0x22d96a]
CALL 0x0013c010
LAB_001494aa:
MOV RDI,qword ptr [RBP + -0x148]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00141790
MOV RDI,qword ptr [RBP + -0x148]
CALL 0x0013b8a0
MOV dword ptr [RBP + -0x14c],EAX
CMP dword ptr [RBP + -0x14c],0x0
JZ 0x001494e5
MOV RDI,qword ptr [RBP + -0x148]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0013c0b0
LAB_001494e5:
CMP dword ptr [RBP + -0x14c],0x0
JNZ 0x001494f0
JMP 0x00149508
LAB_001494f0:
LEA RDI,[0x22dc0c]
MOV ESI,0xe13
LEA RDX,[0x23980c]
CALL 0x0013c010
LAB_00149508:
MOV RDI,qword ptr [RBP + -0x148]
CALL 0x0013b9f0
MOV RDI,qword ptr [0x0056a4d8]
CALL 0x0013bbe0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x14c],EAX
MOV EAX,dword ptr [RBP + -0x14c]
MOV dword ptr [RBP + -0x164],EAX
CMP dword ptr [RBP + -0x164],0x0
JZ 0x00149547
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_00149547:
CMP dword ptr [RBP + -0x164],0x0
JNZ 0x00149552
JMP 0x0014956a
LAB_00149552:
LEA RDI,[0x22dc0c]
MOV ESI,0xe19
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0014956a:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x232706]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x14c],EAX
MOV EAX,dword ptr [RBP + -0x14c]
MOV dword ptr [RBP + -0x168],EAX
CMP dword ptr [RBP + -0x168],0x0
JZ 0x001495a1
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_001495a1:
CMP dword ptr [RBP + -0x168],0x0
JNZ 0x001495ac
JMP 0x001495c4
LAB_001495ac:
LEA RDI,[0x22dc0c]
MOV ESI,0xe1d
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_001495c4:
MOV RDI,qword ptr [0x0056a4d8]
CALL 0x0013b210
MOV qword ptr [RBP + -0x158],RAX
CMP qword ptr [RBP + -0x158],0x0
JNZ 0x00149602
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LEA RDI,[0x22dc0c]
MOV ESI,0xe21
LEA RDX,[0x22d9dc]
CALL 0x0013c010
LAB_00149602:
MOV RDI,qword ptr [RBP + -0x158]
CALL 0x0013c860
MOV dword ptr [RBP + -0x14c],EAX
CMP dword ptr [RBP + -0x14c],0x1
JNZ 0x0014961f
JMP 0x00149637
LAB_0014961f:
LEA RDI,[0x22dc0c]
MOV ESI,0xe24
LEA RDX,[0x22fe8a]
CALL 0x0013c010
LAB_00149637:
MOV RDI,qword ptr [RBP + -0x158]
CALL 0x0013b280
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0014965e
ADD RSP,0x170
POP RBP
RET
LAB_0014965e:
CALL 0x0013a2a0
|
void test_prepare_noparam(void)
{
char cVar1;
int iVar2;
long lVar3;
ulong uVar4;
long in_FS_OFFSET;
char local_148 [312];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if (opt_silent < '\x02') {
fprintf(*(FILE **)PTR_stdout_003aefd8,"\n\n#####################################\n");
uVar4 = (ulong)test_count;
test_count = test_count + 1;
fprintf(*(FILE **)PTR_stdout_003aefd8,"%u of (%u/%u): %s",uVar4,(ulong)iter_count,
(ulong)opt_count,"test_prepare_noparam");
fprintf(*(FILE **)PTR_stdout_003aefd8," \n#####################################\n");
fflush(*(FILE **)PTR_stdout_003aefd8);
}
iVar2 = wrap_mysql_query(mysql,"DROP TABLE IF EXISTS my_prepare");
if (iVar2 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe05,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"CREATE TABLE my_prepare(col1 int, col2 varchar(50))");
if (iVar2 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe09,"r == 0");
}
stpcpy(local_148,"INSERT INTO my_prepare VALUES(10, \'venu\')");
lVar3 = mysql_simple_prepare(mysql,local_148);
if (lVar3 == 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe0e,"stmt != 0");
}
verify_param_count(lVar3,0);
iVar2 = wrap_mysql_stmt_execute(lVar3);
if (iVar2 != 0) {
print_st_error(lVar3,0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe13,"rc == 0");
}
wrap_mysql_stmt_close(lVar3);
cVar1 = wrap_mysql_commit(mysql);
if (cVar1 != '\0') {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe19,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"SELECT * FROM my_prepare");
if (iVar2 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe1d,"r == 0");
}
lVar3 = wrap_mysql_store_result(mysql);
if (lVar3 == 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe21,"FALSE");
}
iVar2 = my_process_result_set(lVar3);
if (iVar2 != 1) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0xe24,"rc == 1");
}
wrap_mysql_free_result(lVar3);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,515 | string_format[abi:cxx11](char const*, ...) | monkey531[P]llama/common/common.cpp | std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
} | O3 | cpp | string_format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x7b93a
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x30(%rsp)
movq (%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x18d28
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0x7b9ff
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x827d2
movq (%r13), %rdi
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x18d28
cmpl %r15d, %eax
jne 0x7ba20
movq 0x8(%rsp), %rsi
movl %r15d, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x590a2
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7b9eb
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x186a0
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x44d03(%rip), %rdi # 0xc0709
leaq 0x44d48(%rip), %rdx # 0xc0755
leaq 0x44d58(%rip), %rcx # 0xc076c
movl $0x1b2, %esi # imm = 0x1B2
xorl %eax, %eax
callq 0x18ad0
leaq 0x44ce2(%rip), %rdi # 0xc0709
leaq 0x44d27(%rip), %rdx # 0xc0755
leaq 0x44d53(%rip), %rcx # 0xc0788
movl $0x1b5, %esi # imm = 0x1B5
xorl %eax, %eax
callq 0x18ad0
jmp 0x7ba43
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x7ba5d
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x186a0
movq %rbx, %rdi
callq 0x18b90
| _Z13string_formatB5cxx11PKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_7B93A
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_7B93A:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_108], rsi
mov rax, [rcx]
mov [rsp+138h+var_118], rax
mov rax, [rcx+8]
mov [rsp+138h+var_110], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_7B9FF
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_130]
lea rdx, [rsp+138h+var_131]
mov rdi, r13
mov rsi, r12
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_118]
mov rsi, r12
mov rdx, r14
call vsnprintf
cmp eax, r15d
jnz short loc_7BA20
mov rsi, [rsp+138h+var_130]
mov edx, r15d
lea rax, [rbx+10h]
mov [rbx], rax
add rdx, rsi
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_7B9EB
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B9EB:
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_7B9FF:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 1B2h
xor eax, eax
call _ggml_abort
loc_7BA20:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 1B5h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_7BA43:
mov rbx, rax
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_7BA5D
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7BA5D:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * string_format[abi:cxx11](
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
unsigned int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
_BYTE *v18; // rsi
long long v20; // rbx
char v21; // [rsp+7h] [rbp-131h] BYREF
void *v22; // [rsp+8h] [rbp-130h] BYREF
long long v23; // [rsp+18h] [rbp-120h]
_QWORD v24[4]; // [rsp+20h] [rbp-118h] BYREF
_QWORD v25[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v26[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v27; // [rsp+70h] [rbp-C8h]
long long v28; // [rsp+78h] [rbp-C0h]
long long v29; // [rsp+80h] [rbp-B8h]
long long v30; // [rsp+88h] [rbp-B0h]
__m128 v31; // [rsp+90h] [rbp-A8h]
__m128 v32; // [rsp+A0h] [rbp-98h]
__m128 v33; // [rsp+B0h] [rbp-88h]
__m128 v34; // [rsp+C0h] [rbp-78h]
__m128 v35; // [rsp+D0h] [rbp-68h]
__m128 v36; // [rsp+E0h] [rbp-58h]
__m128 v37; // [rsp+F0h] [rbp-48h]
__m128 v38; // [rsp+100h] [rbp-38h]
v31 = a7;
v32 = a8;
v33 = a9;
v34 = a10;
v35 = a11;
v36 = a12;
v37 = a13;
v38 = a14;
v27 = a3;
v28 = a4;
v29 = a5;
v30 = a6;
v25[0] = 0x3000000010LL;
v25[1] = &a15;
v25[2] = v26;
v24[2] = v26;
v24[0] = 0x3000000010LL;
v24[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v25);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
434LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_7:
v20 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
437LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
if ( v22 )
operator delete(v22, v23 - (_QWORD)v22);
_Unwind_Resume(v20);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector(&v22, v17, &v21);
if ( (unsigned int)vsnprintf(v22, v17, a2, v24) != v16 )
goto LABEL_7;
v18 = v22;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, v18, (long long)&v18[v16]);
if ( v22 )
operator delete(v22, v23 - (_QWORD)v22);
return a1;
}
| string_format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x0017b93a
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_0017b93a:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x28],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x00118d28
CMP EAX,0x7fffffff
JNC 0x0017b9ff
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R13
MOV RSI,R12
CALL 0x001827d2
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x20]
MOV RSI,R12
MOV RDX,R14
CALL 0x00118d28
CMP EAX,R15D
JNZ 0x0017ba20
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,R15D
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
ADD RDX,RSI
LAB_0017b9cc:
MOV RDI,RBX
CALL 0x001590a2
LAB_0017b9d4:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0017b9eb
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x001186a0
LAB_0017b9eb:
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0017b9ff:
LEA RDI,[0x1c0709]
LEA RDX,[0x1c0755]
LEA RCX,[0x1c076c]
MOV ESI,0x1b2
XOR EAX,EAX
CALL 0x00118ad0
LAB_0017ba20:
LEA RDI,[0x1c0709]
LEA RDX,[0x1c0755]
LEA RCX,[0x1c0788]
MOV ESI,0x1b5
XOR EAX,EAX
CALL 0x00118ad0
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
char *local_130 [2];
long local_120;
int8 local_118;
int1 *local_110;
int1 *local_108;
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
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;
local_108 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_110 = &stack0x00000008;
local_118 = 0x3000000010;
local_f0 = local_110;
local_e8 = local_108;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector((ulong)local_130,(allocator *)(ulong)(uVar1 + 1))
;
uVar2 = vsnprintf(local_130[0],(size_t)(ulong)(uVar1 + 1),in_RSI,&local_118);
if (uVar2 == uVar1) {
*(char **)param_1 = param_1 + 0x10;
/* try { // try from 0017b9cc to 0017b9d3 has its CatchHandler @ 0017ba41 */
std::__cxx11::string::_M_construct<char_const*>(param_1,local_130[0],local_130[0] + uVar1);
if (local_130[0] != (char *)0x0) {
operator_delete(local_130[0],local_120 - (long)local_130[0]);
}
return param_1;
}
/* try { // try from 0017ba20 to 0017ba40 has its CatchHandler @ 0017ba43 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b5,
"GGML_ASSERT(%s) failed","size2 == size");
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b2,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
| |
24,516 | func_uni_big5_onechar | eloqsql/strings/ctype-big5.c | static int func_uni_big5_onechar(int code){
if ((code>=0x00A2)&&(code<=0x00F7))
return(tab_uni_big50[code-0x00A2]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_big51[code-0x02C7]);
if ((code>=0x2013)&&(code<=0x22BF))
return(tab_uni_big52[code-0x2013]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_big53[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_big54[code-0x3000]);
if ((code>=0x32A3)&&(code<=0x32A3))
return(tab_uni_big55[code-0x32A3]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_big56[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9483))
return(tab_uni_big57[code-0x4E00]);
if ((code>=0x9577)&&(code<=0x9FA4))
return(tab_uni_big58[code-0x9577]);
if ((code>=0xFA0C)&&(code<=0xFA0D))
return(tab_uni_big59[code-0xFA0C]);
if ((code>=0xFE30)&&(code<=0xFFFD))
return(tab_uni_big510[code-0xFE30]);
return(0);
} | O0 | c | func_uni_big5_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa2, -0x8(%rbp)
jl 0x36837
cmpl $0xf7, -0x8(%rbp)
jg 0x36837
movl -0x8(%rbp), %eax
subl $0xa2, %eax
movslq %eax, %rcx
leaq 0x547b5(%rip), %rax # 0x8afe0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x36867
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x36867
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0x54835(%rip), %rax # 0x8b090
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x2013, -0x8(%rbp) # imm = 0x2013
jl 0x36897
cmpl $0x22bf, -0x8(%rbp) # imm = 0x22BF
jg 0x36897
movl -0x8(%rbp), %eax
subl $0x2013, %eax # imm = 0x2013
movslq %eax, %rcx
leaq 0x54b25(%rip), %rax # 0x8b3b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x368c7
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x368c7
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0x55055(%rip), %rax # 0x8b910
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x368f7
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x368f7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0x553f5(%rip), %rax # 0x8bce0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jl 0x36927
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0x36927
movl -0x8(%rbp), %eax
subl $0x32a3, %eax # imm = 0x32A3
movslq %eax, %rcx
leaq 0x55619(%rip), %rax # 0x8bf34
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0x36957
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0x36957
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0x555f5(%rip), %rax # 0x8bf40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x36987
cmpl $0x9483, -0x8(%rbp) # imm = 0x9483
jg 0x36987
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0x55655(%rip), %rax # 0x8bfd0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0x9577, -0x8(%rbp) # imm = 0x9577
jl 0x369b4
cmpl $0x9fa4, -0x8(%rbp) # imm = 0x9FA4
jg 0x369b4
movl -0x8(%rbp), %eax
subl $0x9577, %eax # imm = 0x9577
movslq %eax, %rcx
leaq 0x5e335(%rip), %rax # 0x94ce0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0xfa0c, -0x8(%rbp) # imm = 0xFA0C
jl 0x369e1
cmpl $0xfa0d, -0x8(%rbp) # imm = 0xFA0D
jg 0x369e1
movl -0x8(%rbp), %eax
subl $0xfa0c, %eax # imm = 0xFA0C
movslq %eax, %rcx
leaq 0x5f764(%rip), %rax # 0x9613c
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0x36a0e
cmpl $0xfffd, -0x8(%rbp) # imm = 0xFFFD
jg 0x36a0e
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0x5f73b(%rip), %rax # 0x96140
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x36a15
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_big5_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A2h
jl short loc_36837
cmp [rbp+var_8], 0F7h
jg short loc_36837
mov eax, [rbp+var_8]
sub eax, 0A2h
movsxd rcx, eax
lea rax, tab_uni_big50
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_36837:
cmp [rbp+var_8], 2C7h
jl short loc_36867
cmp [rbp+var_8], 451h
jg short loc_36867
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_big51
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_36867:
cmp [rbp+var_8], 2013h
jl short loc_36897
cmp [rbp+var_8], 22BFh
jg short loc_36897
mov eax, [rbp+var_8]
sub eax, 2013h
movsxd rcx, eax
lea rax, tab_uni_big52
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_36897:
cmp [rbp+var_8], 2460h
jl short loc_368C7
cmp [rbp+var_8], 2642h
jg short loc_368C7
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_big53
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_368C7:
cmp [rbp+var_8], 3000h
jl short loc_368F7
cmp [rbp+var_8], 3129h
jg short loc_368F7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_big54
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_368F7:
cmp [rbp+var_8], 32A3h
jl short loc_36927
cmp [rbp+var_8], 32A3h
jg short loc_36927
mov eax, [rbp+var_8]
sub eax, 32A3h
movsxd rcx, eax
lea rax, tab_uni_big55
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_36927:
cmp [rbp+var_8], 338Eh
jl short loc_36957
cmp [rbp+var_8], 33D5h
jg short loc_36957
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_big56
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_36957:
cmp [rbp+var_8], 4E00h
jl short loc_36987
cmp [rbp+var_8], 9483h
jg short loc_36987
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_big57
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_36A15
loc_36987:
cmp [rbp+var_8], 9577h
jl short loc_369B4
cmp [rbp+var_8], 9FA4h
jg short loc_369B4
mov eax, [rbp+var_8]
sub eax, 9577h
movsxd rcx, eax
lea rax, tab_uni_big58
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_36A15
loc_369B4:
cmp [rbp+var_8], 0FA0Ch
jl short loc_369E1
cmp [rbp+var_8], 0FA0Dh
jg short loc_369E1
mov eax, [rbp+var_8]
sub eax, 0FA0Ch
movsxd rcx, eax
lea rax, tab_uni_big59
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_36A15
loc_369E1:
cmp [rbp+var_8], 0FE30h
jl short loc_36A0E
cmp [rbp+var_8], 0FFFDh
jg short loc_36A0E
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_big510
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_36A15
loc_36A0E:
mov [rbp+var_4], 0
loc_36A15:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_big5_onechar(int a1)
{
if ( a1 < 162 || a1 > 247 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8211 || a1 > 8895 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 == 12963 )
{
return tab_uni_big55;
}
else if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 38019 )
{
if ( a1 < 38263 || a1 > 40868 )
{
if ( a1 < 64012 || a1 > 64013 )
{
if ( a1 < 65072 || a1 > 65533 )
return 0;
else
return tab_uni_big510[a1 - 65072];
}
else
{
return tab_uni_big59[a1 - 64012];
}
}
else
{
return tab_uni_big58[a1 - 38263];
}
}
else
{
return tab_uni_big57[a1 - 19968];
}
}
else
{
return tab_uni_big56[a1 - 13198];
}
}
else
{
return tab_uni_big54[a1 - 12288];
}
}
else
{
return tab_uni_big53[a1 - 9312];
}
}
else
{
return tab_uni_big52[a1 - 8211];
}
}
else
{
return tab_uni_big51[a1 - 711];
}
}
else
{
return tab_uni_big50[a1 - 162];
}
}
| func_uni_big5_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa2
JL 0x00136837
CMP dword ptr [RBP + -0x8],0xf7
JG 0x00136837
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa2
MOVSXD RCX,EAX
LEA RAX,[0x18afe0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136837:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x00136867
CMP dword ptr [RBP + -0x8],0x451
JG 0x00136867
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x18b090]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136867:
CMP dword ptr [RBP + -0x8],0x2013
JL 0x00136897
CMP dword ptr [RBP + -0x8],0x22bf
JG 0x00136897
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2013
MOVSXD RCX,EAX
LEA RAX,[0x18b3b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136897:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x001368c7
CMP dword ptr [RBP + -0x8],0x2642
JG 0x001368c7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x18b910]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_001368c7:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x001368f7
CMP dword ptr [RBP + -0x8],0x3129
JG 0x001368f7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x18bce0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_001368f7:
CMP dword ptr [RBP + -0x8],0x32a3
JL 0x00136927
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x00136927
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x32a3
MOVSXD RCX,EAX
LEA RAX,[0x18bf34]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136927:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x00136957
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x00136957
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x18bf40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136957:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x00136987
CMP dword ptr [RBP + -0x8],0x9483
JG 0x00136987
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x18bfd0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136987:
CMP dword ptr [RBP + -0x8],0x9577
JL 0x001369b4
CMP dword ptr [RBP + -0x8],0x9fa4
JG 0x001369b4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9577
MOVSXD RCX,EAX
LEA RAX,[0x194ce0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_001369b4:
CMP dword ptr [RBP + -0x8],0xfa0c
JL 0x001369e1
CMP dword ptr [RBP + -0x8],0xfa0d
JG 0x001369e1
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfa0c
MOVSXD RCX,EAX
LEA RAX,[0x19613c]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_001369e1:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x00136a0e
CMP dword ptr [RBP + -0x8],0xfffd
JG 0x00136a0e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x196140]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00136a15
LAB_00136a0e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00136a15:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_big5_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa2) || (0xf7 < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2013) || (0x22bf < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x32a3) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9483 < param_1)) {
if ((param_1 < 0x9577) || (0x9fa4 < param_1)) {
if ((param_1 < 0xfa0c) || (0xfa0d < param_1)) {
if ((param_1 < 0xfe30) || (0xfffd < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_big510 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)((long)&tab_uni_big59 + (long)(param_1 + -0xfa0c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big58 + (long)(param_1 + -0x9577) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big57 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big56 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = (&tab_uni_big55)[param_1 + -0x32a3];
}
}
else {
uVar1 = *(int2 *)(tab_uni_big54 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big53 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big52 + (long)(param_1 + -0x2013) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big51 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_big50 + (long)(param_1 + -0xa2) * 2);
}
return uVar1;
}
| |
24,517 | uf_prespace_selected | eloqsql/storage/maria/ma_packrec.c | static void uf_prespace_selected(MARIA_COLUMNDEF *rec,
MARIA_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
uint spaces;
if (get_bit(bit_buff))
{
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill(to, spaces, ' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
else
decode_bytes(rec,bit_buff,to,end);
} | O3 | c | uf_prespace_selected:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r8
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsi), %eax
testl %eax, %eax
je 0x3b300
movl (%r14), %ebx
decl %eax
movl %eax, 0x4(%r14)
btl %eax, %ebx
jb 0x3b333
jmp 0x3b31d
movq %r14, %rdi
movq %r8, %rbx
callq 0x3a7b0
movq %rbx, %r8
movl $0x1f, 0x4(%r14)
movl (%r14), %ebx
testl %ebx, %ebx
js 0x3b32e
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r8, %rcx
jmp 0x3b3d3
movl $0x1f, %eax
movl 0x24(%r15), %r13d
movl %eax, %ecx
subl %r13d, %ecx
jae 0x3b389
subl %eax, %r13d
movl %eax, %eax
leaq 0xa5de6(%rip), %rcx # 0xe1130
andl (%rcx,%rax,4), %ebx
movl %r13d, %ecx
shll %cl, %ebx
movq %r14, %rdi
movq %r15, -0x30(%rbp)
movq %r12, %r15
movq %r8, %r12
callq 0x3a7b0
movq %r12, %r8
movq %r15, %r12
movq -0x30(%rbp), %r15
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r14)
movl (%r14), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %eax, %ebx
jmp 0x3b39d
movl %ecx, 0x4(%r14)
shrl %cl, %ebx
movl 0x24(%r15), %eax
leaq 0xa5d96(%rip), %rcx # 0xe1130
andl (%rcx,%rax,4), %ebx
movl %ebx, %edx
leaq (%r12,%rdx), %r13
cmpq %r8, %r13
jbe 0x3b3b2
movl $0x1, 0x28(%r14)
jmp 0x3b3e6
movq %r12, %rdi
movl $0x20, %esi
movq %r8, %rbx
callq 0x292c0
cmpq %rbx, %r13
je 0x3b3e6
movq %rbx, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a96d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| uf_prespace_selected:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r8, rcx
mov r12, rdx
mov r14, rsi
mov r15, rdi
mov eax, [rsi+4]
test eax, eax
jz short loc_3B300
mov ebx, [r14]
dec eax
mov [r14+4], eax
bt ebx, eax
jb short loc_3B333
jmp short loc_3B31D
loc_3B300:
mov rdi, r14
mov rbx, r8
call fill_buffer
mov r8, rbx
mov dword ptr [r14+4], 1Fh
mov ebx, [r14]
test ebx, ebx
js short loc_3B32E
loc_3B31D:
mov rdi, r15
mov rsi, r14
mov rdx, r12
mov rcx, r8
jmp loc_3B3D3
loc_3B32E:
mov eax, 1Fh
loc_3B333:
mov r13d, [r15+24h]
mov ecx, eax
sub ecx, r13d
jnb short loc_3B389
sub r13d, eax
mov eax, eax
lea rcx, mask
and ebx, [rcx+rax*4]
mov ecx, r13d
shl ebx, cl
mov rdi, r14
mov [rbp+var_30], r15
mov r15, r12
mov r12, r8
call fill_buffer
mov r8, r12
mov r12, r15
mov r15, [rbp+var_30]
mov eax, 20h ; ' '
sub eax, r13d
mov [r14+4], eax
mov eax, [r14]
neg r13d
mov ecx, r13d
shr eax, cl
add ebx, eax
jmp short loc_3B39D
loc_3B389:
mov [r14+4], ecx
shr ebx, cl
mov eax, [r15+24h]
lea rcx, mask
and ebx, [rcx+rax*4]
loc_3B39D:
mov edx, ebx
lea r13, [r12+rdx]
cmp r13, r8
jbe short loc_3B3B2
mov dword ptr [r14+28h], 1
jmp short loc_3B3E6
loc_3B3B2:
mov rdi, r12
mov esi, 20h ; ' '
mov rbx, r8
call _memset
cmp r13, rbx
jz short loc_3B3E6
mov rcx, rbx
mov rdi, r15
mov rsi, r14
mov rdx, r13
loc_3B3D3:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp decode_bytes
loc_3B3E6:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long uf_prespace_selected(long long a1, unsigned int *a2, _BYTE *a3, _BYTE *a4)
{
_BYTE *v4; // r8
long long v6; // r15
unsigned int v7; // eax
unsigned int v8; // ebx
unsigned int v9; // eax
_BYTE *v11; // rdx
_BYTE *v12; // rcx
unsigned int v13; // r13d
unsigned int v14; // ecx
int v15; // r13d
int v16; // ebx
_BYTE *v17; // r15
_BYTE *v18; // r12
long long result; // rax
unsigned int v20; // ebx
long long v21; // rdx
_BYTE *v22; // r13
_BYTE *v23; // rbx
v4 = a4;
v6 = a1;
v7 = a2[1];
if ( v7 )
{
v8 = *a2;
v9 = v7 - 1;
a2[1] = v9;
if ( !_bittest((const int *)&v8, v9) )
goto LABEL_5;
}
else
{
fill_buffer((long long)a2);
v4 = a4;
a2[1] = 31;
v8 = *a2;
if ( (*a2 & 0x80000000) == 0 )
{
LABEL_5:
v11 = a3;
v12 = v4;
return (long long)decode_bytes(a1, (long long)a2, v11, v12);
}
v9 = 31;
}
v13 = *(_DWORD *)(a1 + 36);
v14 = v9 - v13;
if ( v9 >= v13 )
{
a2[1] = v14;
result = *(unsigned int *)(a1 + 36);
v20 = mask[result] & (v8 >> v14);
}
else
{
v15 = v13 - v9;
v16 = (mask[v9] & v8) << v15;
v17 = a3;
v18 = v4;
fill_buffer((long long)a2);
v4 = v18;
a3 = v17;
v6 = a1;
a2[1] = 32 - v15;
result = *a2 >> -(char)v15;
v20 = result + v16;
}
v21 = v20;
v22 = &a3[v20];
if ( v22 > v4 )
{
a2[10] = 1;
return result;
}
v23 = v4;
result = memset(a3, 32LL, v21);
if ( v22 != v23 )
{
v12 = v23;
a1 = v6;
v11 = v22;
return (long long)decode_bytes(a1, (long long)a2, v11, v12);
}
return result;
}
| uf_prespace_selected:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R8,RCX
MOV R12,RDX
MOV R14,RSI
MOV R15,RDI
MOV EAX,dword ptr [RSI + 0x4]
TEST EAX,EAX
JZ 0x0013b300
MOV EBX,dword ptr [R14]
DEC EAX
MOV dword ptr [R14 + 0x4],EAX
BT EBX,EAX
JC 0x0013b333
JMP 0x0013b31d
LAB_0013b300:
MOV RDI,R14
MOV RBX,R8
CALL 0x0013a7b0
MOV R8,RBX
MOV dword ptr [R14 + 0x4],0x1f
MOV EBX,dword ptr [R14]
TEST EBX,EBX
JS 0x0013b32e
LAB_0013b31d:
MOV RDI,R15
MOV RSI,R14
MOV RDX,R12
MOV RCX,R8
JMP 0x0013b3d3
LAB_0013b32e:
MOV EAX,0x1f
LAB_0013b333:
MOV R13D,dword ptr [R15 + 0x24]
MOV ECX,EAX
SUB ECX,R13D
JNC 0x0013b389
SUB R13D,EAX
MOV EAX,EAX
LEA RCX,[0x1e1130]
AND EBX,dword ptr [RCX + RAX*0x4]
MOV ECX,R13D
SHL EBX,CL
MOV RDI,R14
MOV qword ptr [RBP + -0x30],R15
MOV R15,R12
MOV R12,R8
CALL 0x0013a7b0
MOV R8,R12
MOV R12,R15
MOV R15,qword ptr [RBP + -0x30]
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R14 + 0x4],EAX
MOV EAX,dword ptr [R14]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EBX,EAX
JMP 0x0013b39d
LAB_0013b389:
MOV dword ptr [R14 + 0x4],ECX
SHR EBX,CL
MOV EAX,dword ptr [R15 + 0x24]
LEA RCX,[0x1e1130]
AND EBX,dword ptr [RCX + RAX*0x4]
LAB_0013b39d:
MOV EDX,EBX
LEA R13,[R12 + RDX*0x1]
CMP R13,R8
JBE 0x0013b3b2
MOV dword ptr [R14 + 0x28],0x1
JMP 0x0013b3e6
LAB_0013b3b2:
MOV RDI,R12
MOV ESI,0x20
MOV RBX,R8
CALL 0x001292c0
CMP R13,RBX
JZ 0x0013b3e6
MOV RCX,RBX
MOV RDI,R15
MOV RSI,R14
MOV RDX,R13
LAB_0013b3d3:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0013a96d
LAB_0013b3e6:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void uf_prespace_selected(long param_1,uint *param_2,void *param_3,void *param_4)
{
void *pvVar1;
uint uVar2;
uint uVar3;
uint uVar4;
byte bVar5;
uint uVar6;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar6 = *param_2;
if (-1 < (int)uVar6) goto LAB_0013b3d3;
uVar4 = 0x1f;
}
else {
uVar6 = *param_2;
uVar4 = param_2[1] - 1;
param_2[1] = uVar4;
if ((uVar6 >> (uVar4 & 0x1f) & 1) == 0) goto LAB_0013b3d3;
}
uVar2 = *(uint *)(param_1 + 0x24);
if (uVar4 < uVar2) {
uVar3 = (&mask)[uVar4];
bVar5 = (byte)(uVar2 - uVar4);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar2 - uVar4);
uVar6 = ((uVar6 & uVar3) << (bVar5 & 0x1f)) + (*param_2 >> (-bVar5 & 0x1f));
}
else {
param_2[1] = uVar4 - uVar2;
uVar6 = uVar6 >> ((byte)(uVar4 - uVar2) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x24)];
}
pvVar1 = (void *)((long)param_3 + (ulong)uVar6);
if (param_4 < pvVar1) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)uVar6);
param_3 = pvVar1;
if (pvVar1 != param_4) {
LAB_0013b3d3:
decode_bytes(param_1,param_2,param_3,param_4);
return;
}
}
return;
}
| |
24,518 | js_array_buffer_get_maxByteLength | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_buffer_get_maxByteLength(JSContext *ctx,
JSValue this_val,
int class_id)
{
JSArrayBuffer *abuf = JS_GetOpaque2(ctx, this_val, class_id);
if (!abuf)
return JS_EXCEPTION;
if (array_buffer_is_resizable(abuf))
return js_uint32(abuf->max_byte_length);
return js_uint32(abuf->byte_length);
} | O1 | c | js_array_buffer_get_maxByteLength:
pushq %rax
callq 0x275b5
testq %rax, %rax
je 0x7fb69
movslq 0x4(%rax), %rcx
testq %rcx, %rcx
js 0x7fb74
xorl %esi, %esi
xorl %edx, %edx
jmp 0x7fba2
movl $0x6, %edx
xorl %ecx, %ecx
xorl %esi, %esi
jmp 0x7fba2
movslq (%rax), %rax
xorl %esi, %esi
testq %rax, %rax
movl %eax, %ecx
cvtsi2sd %rcx, %xmm0
movq %xmm0, %rcx
cmovnsq %rax, %rcx
movl $0x7, %edx
cmovnsq %rsi, %rdx
movabsq $0x7fffffff00000000, %rsi # imm = 0x7FFFFFFF00000000
andq %rcx, %rsi
movl %ecx, %eax
orq %rsi, %rax
popq %rcx
retq
| js_array_buffer_get_maxByteLength:
push rax
call JS_GetOpaque2
test rax, rax
jz short loc_7FB69
movsxd rcx, dword ptr [rax+4]
test rcx, rcx
js short loc_7FB74
xor esi, esi
xor edx, edx
jmp short loc_7FBA2
loc_7FB69:
mov edx, 6
xor ecx, ecx
xor esi, esi
jmp short loc_7FBA2
loc_7FB74:
movsxd rax, dword ptr [rax]
xor esi, esi
test rax, rax
mov ecx, eax
cvtsi2sd xmm0, rcx
movq rcx, xmm0
cmovns rcx, rax
mov edx, 7
cmovns rdx, rsi
mov rsi, 7FFFFFFF00000000h
and rsi, rcx
loc_7FBA2:
mov eax, ecx
or rax, rsi
pop rcx
retn
| long long js_array_buffer_get_maxByteLength(long long a1, long long a2, int a3, unsigned int a4)
{
int *Opaque2; // rax
double v5; // rcx
long long v6; // rsi
long long v7; // rax
Opaque2 = (int *)JS_GetOpaque2(a1, a2, a3, a4);
if ( Opaque2 )
{
*(_QWORD *)&v5 = Opaque2[1];
if ( v5 < 0.0 )
{
v7 = *Opaque2;
v5 = (double)(int)v7;
if ( v7 >= 0 )
v5 = *(double *)&v7;
v6 = *(_QWORD *)&v5 & 0x7FFFFFFF00000000LL;
}
else
{
v6 = 0LL;
}
}
else
{
LODWORD(v5) = 0;
v6 = 0LL;
}
return v6 | LODWORD(v5);
}
| |||
24,519 | js_array_buffer_get_maxByteLength | bluesky950520[P]quickjs/quickjs.c | static JSValue js_array_buffer_get_maxByteLength(JSContext *ctx,
JSValue this_val,
int class_id)
{
JSArrayBuffer *abuf = JS_GetOpaque2(ctx, this_val, class_id);
if (!abuf)
return JS_EXCEPTION;
if (array_buffer_is_resizable(abuf))
return js_uint32(abuf->max_byte_length);
return js_uint32(abuf->byte_length);
} | O2 | c | js_array_buffer_get_maxByteLength:
pushq %rax
callq 0x21207
testq %rax, %rax
je 0x6b5dc
movslq 0x4(%rax), %rcx
testq %rcx, %rcx
js 0x6b5e5
xorl %esi, %esi
xorl %edx, %edx
jmp 0x6b611
pushq $0x6
popq %rdx
xorl %ecx, %ecx
xorl %esi, %esi
jmp 0x6b611
movslq (%rax), %rax
xorl %esi, %esi
testq %rax, %rax
movl %eax, %ecx
cvtsi2sd %rcx, %xmm0
movq %xmm0, %rcx
cmovnsq %rax, %rcx
pushq $0x7
popq %rdx
cmovnsq %rsi, %rdx
movabsq $0x7fffffff00000000, %rsi # imm = 0x7FFFFFFF00000000
andq %rcx, %rsi
movl %ecx, %eax
orq %rsi, %rax
popq %rcx
retq
| js_array_buffer_get_maxByteLength:
push rax
call JS_GetOpaque2
test rax, rax
jz short loc_6B5DC
movsxd rcx, dword ptr [rax+4]
test rcx, rcx
js short loc_6B5E5
xor esi, esi
xor edx, edx
jmp short loc_6B611
loc_6B5DC:
push 6
pop rdx
xor ecx, ecx
xor esi, esi
jmp short loc_6B611
loc_6B5E5:
movsxd rax, dword ptr [rax]
xor esi, esi
test rax, rax
mov ecx, eax
cvtsi2sd xmm0, rcx
movq rcx, xmm0
cmovns rcx, rax
push 7
pop rdx
cmovns rdx, rsi
mov rsi, 7FFFFFFF00000000h
and rsi, rcx
loc_6B611:
mov eax, ecx
or rax, rsi
pop rcx
retn
| long long js_array_buffer_get_maxByteLength(long long a1, long long a2, int a3, unsigned int a4)
{
int *Opaque2; // rax
double v5; // rcx
long long v6; // rsi
long long v7; // rax
Opaque2 = (int *)JS_GetOpaque2(a1, a2, a3, a4);
if ( Opaque2 )
{
*(_QWORD *)&v5 = Opaque2[1];
if ( v5 < 0.0 )
{
v7 = *Opaque2;
v5 = (double)(int)v7;
if ( v7 >= 0 )
v5 = *(double *)&v7;
v6 = *(_QWORD *)&v5 & 0x7FFFFFFF00000000LL;
}
else
{
v6 = 0LL;
}
}
else
{
LODWORD(v5) = 0;
v6 = 0LL;
}
return v6 | LODWORD(v5);
}
| js_array_buffer_get_maxByteLength:
PUSH RAX
CALL 0x00121207
TEST RAX,RAX
JZ 0x0016b5dc
MOVSXD RCX,dword ptr [RAX + 0x4]
TEST RCX,RCX
JS 0x0016b5e5
XOR ESI,ESI
XOR EDX,EDX
JMP 0x0016b611
LAB_0016b5dc:
PUSH 0x6
POP RDX
XOR ECX,ECX
XOR ESI,ESI
JMP 0x0016b611
LAB_0016b5e5:
MOVSXD RAX,dword ptr [RAX]
XOR ESI,ESI
TEST RAX,RAX
MOV ECX,EAX
CVTSI2SD XMM0,RCX
MOVQ RCX,XMM0
CMOVNS RCX,RAX
PUSH 0x7
POP RDX
CMOVNS RDX,RSI
MOV RSI,0x7fffffff00000000
AND RSI,RCX
LAB_0016b611:
MOV EAX,ECX
OR RAX,RSI
POP RCX
RET
|
int1 [16] js_array_buffer_get_maxByteLength(void)
{
uint uVar1;
uint *puVar2;
double dVar3;
double dVar4;
int8 uVar5;
ulong uVar6;
int1 auVar7 [16];
puVar2 = (uint *)JS_GetOpaque2();
if (puVar2 == (uint *)0x0) {
uVar5 = 6;
dVar4 = 0.0;
uVar6 = 0;
}
else {
dVar4 = (double)(long)(int)puVar2[1];
if ((long)dVar4 < 0) {
uVar1 = *puVar2;
dVar3 = (double)(long)(int)uVar1;
dVar4 = (double)uVar1;
if (-1 < (long)dVar3) {
dVar4 = dVar3;
}
uVar5 = 7;
if (-1 < (long)dVar3) {
uVar5 = 0;
}
uVar6 = (ulong)dVar4 & 0x7fffffff00000000;
}
else {
uVar6 = 0;
uVar5 = 0;
}
}
auVar7._0_8_ = (ulong)dVar4 & 0xffffffff | uVar6;
auVar7._8_8_ = uVar5;
return auVar7;
}
| |
24,520 | LefDefParser::defiAssertion::bumpItems() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiAssertion.cpp | void defiAssertion::bumpItems() {
int i;
char* newTypes;
int** newItems;
(numItemsAllocated_) *= 2;
newTypes = (char*)malloc(numItemsAllocated_ * sizeof(char));
newItems = (int**)malloc(numItemsAllocated_ * sizeof(int*));
for (i = 0; i < numItems_; i++) {
newItems[i] = items_[i];
newTypes[i] = itemTypes_[i];
}
free((char*)items_);
free((char*)itemTypes_);
items_ = newItems;
itemTypes_ = newTypes;
} | O0 | cpp | LefDefParser::defiAssertion::bumpItems():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x44(%rax), %ecx
shll %ecx
movl %ecx, 0x44(%rax)
movslq 0x44(%rax), %rdi
shlq $0x0, %rdi
callq 0x72d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movslq 0x44(%rax), %rdi
shlq $0x3, %rdi
callq 0x72d0
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movq (%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x40(%rcx), %eax
jge 0x458cf
movq (%rsp), %rax
movq 0x50(%rax), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rsp), %rcx
movslq 0x1c(%rsp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x48(%rax), %rax
movslq 0x1c(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x10(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4587d
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x72a0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x48(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser13defiAssertion9bumpItemsEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_28], rax
mov ecx, [rax+44h]
shl ecx, 1
mov [rax+44h], ecx
movsxd rdi, dword ptr [rax+44h]
shl rdi, 0
call _malloc
mov rcx, rax
mov rax, [rsp+28h+var_28]
mov [rsp+28h+var_18], rcx
movsxd rdi, dword ptr [rax+44h]
shl rdi, 3
call _malloc
mov [rsp+28h+var_20], rax
mov [rsp+28h+var_C], 0
loc_4587D:
mov rcx, [rsp+28h+var_28]
mov eax, [rsp+28h+var_C]
cmp eax, [rcx+40h]
jge short loc_458CF
mov rax, [rsp+28h+var_28]
mov rcx, [rax+50h]
movsxd rdx, [rsp+28h+var_C]
mov rsi, [rcx+rdx*8]
mov rcx, [rsp+28h+var_20]
movsxd rdx, [rsp+28h+var_C]
mov [rcx+rdx*8], rsi
mov rax, [rax+48h]
movsxd rcx, [rsp+28h+var_C]
mov dl, [rax+rcx]
mov rax, [rsp+28h+var_18]
movsxd rcx, [rsp+28h+var_C]
mov [rax+rcx], dl
mov eax, [rsp+28h+var_C]
add eax, 1
mov [rsp+28h+var_C], eax
jmp short loc_4587D
loc_458CF:
mov rax, [rsp+28h+var_28]
mov rdi, [rax+50h]
call _free
mov rax, [rsp+28h+var_28]
mov rdi, [rax+48h]
call _free
mov rax, [rsp+28h+var_28]
mov rcx, [rsp+28h+var_20]
mov [rax+50h], rcx
mov rcx, [rsp+28h+var_18]
mov [rax+48h], rcx
add rsp, 28h
retn
| LefDefParser::defiAssertion * LefDefParser::defiAssertion::bumpItems(LefDefParser::defiAssertion *this)
{
LefDefParser::defiAssertion *result; // rax
long long v2; // [rsp+8h] [rbp-20h]
long long v3; // [rsp+10h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-Ch]
*((_DWORD *)this + 17) *= 2;
v3 = malloc(*((int *)this + 17));
v2 = malloc(8LL * *((int *)this + 17));
for ( i = 0; i < *((_DWORD *)this + 16); ++i )
{
*(_QWORD *)(v2 + 8LL * i) = *(_QWORD *)(*((_QWORD *)this + 10) + 8LL * i);
*(_BYTE *)(v3 + i) = *(_BYTE *)(*((_QWORD *)this + 9) + i);
}
free(*((_QWORD *)this + 10));
free(*((_QWORD *)this + 9));
result = this;
*((_QWORD *)this + 10) = v2;
*((_QWORD *)this + 9) = v3;
return result;
}
| bumpItems:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV ECX,dword ptr [RAX + 0x44]
SHL ECX,0x1
MOV dword ptr [RAX + 0x44],ECX
MOVSXD RDI,dword ptr [RAX + 0x44]
SHL RDI,0x0
CALL 0x001072d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x10],RCX
MOVSXD RDI,dword ptr [RAX + 0x44]
SHL RDI,0x3
CALL 0x001072d0
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x1c],0x0
LAB_0014587d:
MOV RCX,qword ptr [RSP]
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RCX + 0x40]
JGE 0x001458cf
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RAX + 0x50]
MOVSXD RDX,dword ptr [RSP + 0x1c]
MOV RSI,qword ptr [RCX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x8]
MOVSXD RDX,dword ptr [RSP + 0x1c]
MOV qword ptr [RCX + RDX*0x8],RSI
MOV RAX,qword ptr [RAX + 0x48]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOV DL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RSP + 0x10]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0014587d
LAB_001458cf:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x50]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x48]
CALL 0x001072a0
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x50],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x48],RCX
ADD RSP,0x28
RET
|
/* LefDefParser::defiAssertion::bumpItems() */
void __thiscall LefDefParser::defiAssertion::bumpItems(defiAssertion *this)
{
void *pvVar1;
void *pvVar2;
int local_c;
*(int *)(this + 0x44) = *(int *)(this + 0x44) << 1;
pvVar1 = malloc((long)*(int *)(this + 0x44));
pvVar2 = malloc((long)*(int *)(this + 0x44) << 3);
for (local_c = 0; local_c < *(int *)(this + 0x40); local_c = local_c + 1) {
*(int8 *)((long)pvVar2 + (long)local_c * 8) =
*(int8 *)(*(long *)(this + 0x50) + (long)local_c * 8);
*(int1 *)((long)pvVar1 + (long)local_c) =
*(int1 *)(*(long *)(this + 0x48) + (long)local_c);
}
free(*(void **)(this + 0x50));
free(*(void **)(this + 0x48));
*(void **)(this + 0x50) = pvVar2;
*(void **)(this + 0x48) = pvVar1;
return;
}
| |
24,521 | mi_unique_hash | eloqsql/storage/myisam/mi_unique.c | ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const uchar *record)
{
const uchar *pos, *end;
ha_checksum crc= 0;
ulong seed1=0, seed2= 4;
HA_KEYSEG *keyseg;
for (keyseg=def->seg ; keyseg < def->end ; keyseg++)
{
enum ha_base_keytype type=(enum ha_base_keytype) keyseg->type;
uint length=keyseg->length;
if (keyseg->null_bit)
{
if (record[keyseg->null_pos] & keyseg->null_bit)
{
/*
Change crc in a way different from an empty string or 0.
(This is an optimisation; The code will work even if this isn't
done)
*/
crc=((crc << 8) + 511+
(crc >> (8*sizeof(ha_checksum)-8)));
continue;
}
}
pos= record+keyseg->start;
if (keyseg->flag & HA_VAR_LENGTH_PART)
{
uint pack_length= keyseg->bit_start;
uint tmp_length= (pack_length == 1 ? (uint) *(uchar*) pos :
uint2korr(pos));
pos+= pack_length; /* Skip VARCHAR length */
set_if_smaller(length,tmp_length);
}
else if (keyseg->flag & HA_BLOB_PART)
{
uint tmp_length=_mi_calc_blob_length(keyseg->bit_start,pos);
memcpy((char**) &pos, pos+keyseg->bit_start, sizeof(char*));
if (!length || length > tmp_length)
length=tmp_length; /* The whole blob */
}
end= pos+length;
if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
type == HA_KEYTYPE_VARTEXT2)
{
my_ci_hash_sort(keyseg->charset,
(const uchar*) pos, length,
&seed1, &seed2);
crc^= seed1;
}
else
while (pos != end)
crc=((crc << 8) +
(((uchar) *(uchar*) pos++))) +
(crc >> (8*sizeof(ha_checksum)-8));
}
return crc;
} | O0 | c | mi_unique_hash:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x4, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xc66a8
movq -0x40(%rbp), %rax
movzbl 0x18(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rax
movzwl 0x14(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
cmpb $0x0, 0x19(%rax)
je 0xc6550
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0xc(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
movzbl 0x19(%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xc654e
movl -0x24(%rbp), %eax
shll $0x8, %eax
addl $0x1ff, %eax # imm = 0x1FF
movl -0x24(%rbp), %ecx
shrl $0x18, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0xc6697
jmp 0xc6550
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xc65c1
movq -0x40(%rbp), %rax
movzbl 0x1a(%rax), %eax
movl %eax, -0x4c(%rbp)
cmpl $0x1, -0x4c(%rbp)
jne 0xc658f
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x58(%rbp)
jmp 0xc6599
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x50(%rbp), %eax
jbe 0xc65bd
movl -0x50(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xc65bf
jmp 0xc6614
movq -0x40(%rbp), %rax
movzwl 0x12(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xc6612
movq -0x40(%rbp), %rax
movzbl 0x1a(%rax), %edi
movq -0x18(%rbp), %rsi
callq 0xac960
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl 0x1a(%rcx), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xc660a
movl -0x48(%rbp), %eax
cmpl -0x54(%rbp), %eax
jbe 0xc6610
movl -0x54(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xc6612
jmp 0xc6614
movq -0x18(%rbp), %rax
movl -0x48(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x44(%rbp)
je 0xc6634
cmpl $0xf, -0x44(%rbp)
je 0xc6634
cmpl $0x11, -0x44(%rbp)
jne 0xc6660
movq -0x40(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x48(%rbp), %eax
movl %eax, %edx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
callq 0xc66c0
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
xorq %rcx, %rax
movl %eax, -0x24(%rbp)
jmp 0xc6695
jmp 0xc6662
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0xc6693
movl -0x24(%rbp), %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
addl %ecx, %eax
movl -0x24(%rbp), %ecx
shrl $0x18, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0xc6662
jmp 0xc6695
jmp 0xc6697
movq -0x40(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
jmp 0xc64e3
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mi_unique_hash:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_24], 0
mov [rbp+var_30], 0
mov [rbp+var_38], 4
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_40], rax
loc_C64E3:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_8]
cmp rax, [rcx+10h]
jnb loc_C66A8
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax+18h]
mov [rbp+var_44], eax
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+14h]
mov [rbp+var_48], eax
mov rax, [rbp+var_40]
cmp byte ptr [rax+19h], 0
jz short loc_C6550
mov rax, [rbp+var_10]
mov rcx, [rbp+var_40]
mov ecx, [rcx+0Ch]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx+19h]
and eax, ecx
cmp eax, 0
jz short loc_C654E
mov eax, [rbp+var_24]
shl eax, 8
add eax, 1FFh
mov ecx, [rbp+var_24]
shr ecx, 18h
add eax, ecx
mov [rbp+var_24], eax
jmp loc_C6697
loc_C654E:
jmp short $+2
loc_C6550:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_40]
mov ecx, [rcx+8]
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+12h]
and eax, 8
cmp eax, 0
jz short loc_C65C1
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax+1Ah]
mov [rbp+var_4C], eax
cmp [rbp+var_4C], 1
jnz short loc_C658F
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov [rbp+var_58], eax
jmp short loc_C6599
loc_C658F:
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
mov [rbp+var_58], eax
loc_C6599:
mov eax, [rbp+var_58]
mov [rbp+var_50], eax
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_48]
cmp eax, [rbp+var_50]
jbe short loc_C65BD
mov eax, [rbp+var_50]
mov [rbp+var_48], eax
loc_C65BD:
jmp short $+2
loc_C65BF:
jmp short loc_C6614
loc_C65C1:
mov rax, [rbp+var_40]
movzx eax, word ptr [rax+12h]
and eax, 20h
cmp eax, 0
jz short loc_C6612
mov rax, [rbp+var_40]
movzx edi, byte ptr [rax+1Ah]
mov rsi, [rbp+var_18]
call _mi_calc_blob_length
mov [rbp+var_54], eax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_40]
movzx ecx, byte ptr [rcx+1Ah]
movsxd rcx, ecx
mov rax, [rax+rcx]
mov [rbp+var_18], rax
cmp [rbp+var_48], 0
jz short loc_C660A
mov eax, [rbp+var_48]
cmp eax, [rbp+var_54]
jbe short loc_C6610
loc_C660A:
mov eax, [rbp+var_54]
mov [rbp+var_48], eax
loc_C6610:
jmp short $+2
loc_C6612:
jmp short $+2
loc_C6614:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_48]
add rax, rcx
mov [rbp+var_20], rax
cmp [rbp+var_44], 1
jz short loc_C6634
cmp [rbp+var_44], 0Fh
jz short loc_C6634
cmp [rbp+var_44], 11h
jnz short loc_C6660
loc_C6634:
mov rax, [rbp+var_40]
mov rdi, [rax]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_48]
mov edx, eax
lea rcx, [rbp+var_30]
lea r8, [rbp+var_38]
call my_ci_hash_sort_0
mov rcx, [rbp+var_30]
mov eax, [rbp+var_24]
xor rax, rcx
mov [rbp+var_24], eax
jmp short loc_C6695
loc_C6660:
jmp short $+2
loc_C6662:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jz short loc_C6693
mov eax, [rbp+var_24]
shl eax, 8
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 1
mov [rbp+var_18], rdx
movzx ecx, byte ptr [rcx]
add eax, ecx
mov ecx, [rbp+var_24]
shr ecx, 18h
add eax, ecx
mov [rbp+var_24], eax
jmp short loc_C6662
loc_C6693:
jmp short $+2
loc_C6695:
jmp short $+2
loc_C6697:
mov rax, [rbp+var_40]
add rax, 20h ; ' '
mov [rbp+var_40], rax
jmp loc_C64E3
loc_C66A8:
mov eax, [rbp+var_24]
add rsp, 60h
pop rbp
retn
| long long mi_unique_hash(long long a1, long long a2)
{
unsigned __int8 *v2; // rcx
unsigned int v4; // [rsp+8h] [rbp-58h]
unsigned int v5; // [rsp+Ch] [rbp-54h]
unsigned int v6; // [rsp+18h] [rbp-48h]
int v7; // [rsp+1Ch] [rbp-44h]
unsigned long long i; // [rsp+20h] [rbp-40h]
long long v9; // [rsp+28h] [rbp-38h] BYREF
long long v10; // [rsp+30h] [rbp-30h] BYREF
unsigned int v11; // [rsp+3Ch] [rbp-24h]
unsigned __int8 *v12; // [rsp+40h] [rbp-20h]
unsigned __int8 *v13; // [rsp+48h] [rbp-18h]
long long v14; // [rsp+50h] [rbp-10h]
long long v15; // [rsp+58h] [rbp-8h]
v15 = a1;
v14 = a2;
v11 = 0;
v10 = 0LL;
v9 = 4LL;
for ( i = *(_QWORD *)(a1 + 8); i < *(_QWORD *)(v15 + 16); i += 32LL )
{
v7 = *(unsigned __int8 *)(i + 24);
v6 = *(unsigned __int16 *)(i + 20);
if ( *(_BYTE *)(i + 25) && (*(_BYTE *)(i + 25) & *(_BYTE *)(v14 + *(unsigned int *)(i + 12))) != 0 )
{
v11 = HIBYTE(v11) + (v11 << 8) + 511;
}
else
{
v13 = (unsigned __int8 *)(*(unsigned int *)(i + 8) + v14);
if ( (*(_WORD *)(i + 18) & 8) != 0 )
{
if ( *(_BYTE *)(i + 26) == 1 )
v4 = *v13;
else
v4 = *(unsigned __int16 *)v13;
v13 += *(unsigned __int8 *)(i + 26);
if ( v6 > v4 )
v6 = v4;
}
else if ( (*(_WORD *)(i + 18) & 0x20) != 0 )
{
v5 = mi_calc_blob_length(*(unsigned __int8 *)(i + 26), v13);
v13 = *(unsigned __int8 **)&v13[*(unsigned __int8 *)(i + 26)];
if ( !v6 || v6 > v5 )
v6 = v5;
}
v12 = &v13[v6];
if ( v7 == 1 || v7 == 15 || v7 == 17 )
{
my_ci_hash_sort_0(*(_QWORD *)i, v13, v6, &v10, &v9);
v11 ^= v10;
}
else
{
while ( v13 != v12 )
{
v2 = v13++;
v11 = HIBYTE(v11) + *v2 + (v11 << 8);
}
}
}
}
return v11;
}
| mi_unique_hash:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x24],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x38],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x40],RAX
LAB_001c64e3:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x001c66a8
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX + 0x18]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x40]
CMP byte ptr [RAX + 0x19],0x0
JZ 0x001c6550
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX + 0xc]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RCX + 0x19]
AND EAX,ECX
CMP EAX,0x0
JZ 0x001c654e
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x8
ADD EAX,0x1ff
MOV ECX,dword ptr [RBP + -0x24]
SHR ECX,0x18
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c6697
LAB_001c654e:
JMP 0x001c6550
LAB_001c6550:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RCX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001c65c1
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX + 0x1a]
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x4c],0x1
JNZ 0x001c658f
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
JMP 0x001c6599
LAB_001c658f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
LAB_001c6599:
MOV EAX,dword ptr [RBP + -0x58]
MOV dword ptr [RBP + -0x50],EAX
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x50]
JBE 0x001c65bd
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x48],EAX
LAB_001c65bd:
JMP 0x001c65bf
LAB_001c65bf:
JMP 0x001c6614
LAB_001c65c1:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX + 0x12]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001c6612
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EDI,byte ptr [RAX + 0x1a]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001ac960
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RCX + 0x1a]
MOVSXD RCX,ECX
MOV RAX,qword ptr [RAX + RCX*0x1]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RBP + -0x48],0x0
JZ 0x001c660a
MOV EAX,dword ptr [RBP + -0x48]
CMP EAX,dword ptr [RBP + -0x54]
JBE 0x001c6610
LAB_001c660a:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x48],EAX
LAB_001c6610:
JMP 0x001c6612
LAB_001c6612:
JMP 0x001c6614
LAB_001c6614:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x48]
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x44],0x1
JZ 0x001c6634
CMP dword ptr [RBP + -0x44],0xf
JZ 0x001c6634
CMP dword ptr [RBP + -0x44],0x11
JNZ 0x001c6660
LAB_001c6634:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x48]
MOV EDX,EAX
LEA RCX,[RBP + -0x30]
LEA R8,[RBP + -0x38]
CALL 0x001c66c0
MOV RCX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x24]
XOR RAX,RCX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c6695
LAB_001c6660:
JMP 0x001c6662
LAB_001c6662:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001c6693
MOV EAX,dword ptr [RBP + -0x24]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOVZX ECX,byte ptr [RCX]
ADD EAX,ECX
MOV ECX,dword ptr [RBP + -0x24]
SHR ECX,0x18
ADD EAX,ECX
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001c6662
LAB_001c6693:
JMP 0x001c6695
LAB_001c6695:
JMP 0x001c6697
LAB_001c6697:
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x20
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001c64e3
LAB_001c66a8:
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x60
POP RBP
RET
|
uint mi_unique_hash(long param_1,long param_2)
{
char cVar1;
uint uVar2;
uint local_60;
uint local_50;
int8 *local_48;
int8 local_40;
int8 local_38;
uint local_2c;
ushort *local_28;
ushort *local_20;
long local_18;
long local_10;
local_2c = 0;
local_38 = 0;
local_40 = 4;
local_18 = param_2;
local_10 = param_1;
for (local_48 = *(int8 **)(param_1 + 8); local_48 < *(int8 **)(local_10 + 0x10);
local_48 = local_48 + 4) {
cVar1 = *(char *)(local_48 + 3);
local_50 = (uint)*(ushort *)((long)local_48 + 0x14);
if ((*(char *)((long)local_48 + 0x19) == '\0') ||
((*(byte *)(local_18 + (ulong)*(uint *)((long)local_48 + 0xc)) &
*(byte *)((long)local_48 + 0x19)) == 0)) {
local_20 = (ushort *)(local_18 + (ulong)*(uint *)(local_48 + 1));
if ((*(ushort *)((long)local_48 + 0x12) & 8) == 0) {
if ((*(ushort *)((long)local_48 + 0x12) & 0x20) != 0) {
uVar2 = _mi_calc_blob_length(*(int1 *)((long)local_48 + 0x1a),local_20);
local_20 = *(ushort **)
((long)local_20 + (long)(int)(uint)*(byte *)((long)local_48 + 0x1a));
if ((local_50 == 0) || (uVar2 < local_50)) {
local_50 = uVar2;
}
}
}
else {
if (*(byte *)((long)local_48 + 0x1a) == 1) {
local_60 = (uint)(byte)*local_20;
}
else {
local_60 = (uint)*local_20;
}
local_20 = (ushort *)((long)local_20 + (ulong)(uint)*(byte *)((long)local_48 + 0x1a));
if (local_60 < local_50) {
local_50 = local_60;
}
}
local_28 = (ushort *)((long)local_20 + (ulong)local_50);
if (((cVar1 == '\x01') || (cVar1 == '\x0f')) || (cVar1 == '\x11')) {
my_ci_hash_sort(*local_48,local_20,local_50,&local_38,&local_40);
local_2c = local_2c ^ (uint)local_38;
}
else {
for (; local_20 != local_28; local_20 = (ushort *)((long)local_20 + 1)) {
local_2c = local_2c * 0x100 + (uint)(byte)*local_20 + (local_2c >> 0x18);
}
}
}
else {
local_2c = local_2c * 0x100 + 0x1ff + (local_2c >> 0x18);
}
}
return local_2c;
}
| |
24,522 | LefDefParser::lefiNoiseResistance::clear() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiCrossTalk.cpp | void
lefiNoiseResistance::clear()
{
int i;
lefiNoiseVictim *r;
int max = numVictims_;
for (i = 0; i < max; i++) {
r = victims_[i];
r->Destroy();
lefFree((char*) r);
}
numVictims_ = 0;
numNums_ = 0;
} | O0 | cpp | LefDefParser::lefiNoiseResistance::clear():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x8dfc2
movq (%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8dd20
movq 0x10(%rsp), %rdi
callq 0x52810
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x8df81
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| _ZN12LefDefParser19lefiNoiseResistance5clearEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_28], rax
mov eax, [rax+10h]
mov [rsp+28h+var_1C], eax
mov [rsp+28h+var_C], 0
loc_8DF81:
mov eax, [rsp+28h+var_C]
cmp eax, [rsp+28h+var_1C]
jge short loc_8DFC2
mov rax, [rsp+28h+var_28]
mov rax, [rax+18h]
movsxd rcx, [rsp+28h+var_C]
mov rax, [rax+rcx*8]
mov [rsp+28h+var_18], rax
mov rdi, [rsp+28h+var_18]; this
call _ZN12LefDefParser15lefiNoiseVictim7DestroyEv; LefDefParser::lefiNoiseVictim::Destroy(void)
mov rdi, [rsp+28h+var_18]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov eax, [rsp+28h+var_C]
add eax, 1
mov [rsp+28h+var_C], eax
jmp short loc_8DF81
loc_8DFC2:
mov rax, [rsp+28h+var_28]
mov dword ptr [rax+10h], 0
mov dword ptr [rax], 0
add rsp, 28h
retn
| LefDefParser::lefiNoiseResistance * LefDefParser::lefiNoiseResistance::clear(
LefDefParser::lefiNoiseResistance *this,
void *a2)
{
LefDefParser::lefiNoiseResistance *result; // rax
int v3; // [rsp+Ch] [rbp-1Ch]
LefDefParser **v4; // [rsp+10h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-Ch]
v3 = *((_DWORD *)this + 4);
for ( i = 0; i < v3; ++i )
{
v4 = *(LefDefParser ***)(*((_QWORD *)this + 3) + 8LL * i);
LefDefParser::lefiNoiseVictim::Destroy(v4, a2);
LefDefParser::lefFree((LefDefParser *)v4, a2);
}
result = this;
*((_DWORD *)this + 4) = 0;
*(_DWORD *)this = 0;
return result;
}
| clear:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP],RAX
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x1c],0x0
LAB_0018df81:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0xc]
JGE 0x0018dfc2
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x18]
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0018dd20
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00152810
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x0018df81
LAB_0018dfc2:
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x10],0x0
MOV dword ptr [RAX],0x0
ADD RSP,0x28
RET
|
/* LefDefParser::lefiNoiseResistance::clear() */
void __thiscall LefDefParser::lefiNoiseResistance::clear(lefiNoiseResistance *this)
{
int iVar1;
lefiNoiseVictim *this_00;
int local_c;
iVar1 = *(int *)(this + 0x10);
for (local_c = 0; local_c < iVar1; local_c = local_c + 1) {
this_00 = *(lefiNoiseVictim **)(*(long *)(this + 0x18) + (long)local_c * 8);
lefiNoiseVictim::Destroy(this_00);
lefFree(this_00);
}
*(int4 *)(this + 0x10) = 0;
*(int4 *)this = 0;
return;
}
| |
24,523 | LefDefParser::lefiNoiseResistance::clear() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiCrossTalk.cpp | void
lefiNoiseResistance::clear()
{
int i;
lefiNoiseVictim *r;
int max = numVictims_;
for (i = 0; i < max; i++) {
r = victims_[i];
r->Destroy();
lefFree((char*) r);
}
numVictims_ = 0;
numNums_ = 0;
} | O3 | cpp | LefDefParser::lefiNoiseResistance::clear():
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x10(%rdi), %r15
testq %r15, %r15
jle 0x569e4
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %r14
movl $0x0, 0x8(%r14)
movq 0x10(%r14), %rdi
callq 0x322d0
movq %r14, %rdi
callq 0x322d0
incq %r12
cmpq %r12, %r15
jne 0x569bb
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZN12LefDefParser19lefiNoiseResistance5clearEv:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
movsxd r15, dword ptr [rdi+10h]
test r15, r15
jle short loc_569E4
xor r12d, r12d
loc_569BB:
mov rax, [rbx+18h]
mov r14, [rax+r12*8]
mov dword ptr [r14+8], 0
mov rdi, [r14+10h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, r14; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
inc r12
cmp r15, r12
jnz short loc_569BB
loc_569E4:
xor eax, eax
mov [rbx+10h], eax
mov [rbx], eax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long LefDefParser::lefiNoiseResistance::clear(LefDefParser::lefiNoiseResistance *this, void *a2)
{
long long v2; // r15
long long i; // r12
long long v4; // r14
long long result; // rax
v2 = *((int *)this + 4);
if ( v2 > 0 )
{
for ( i = 0LL; i != v2; ++i )
{
v4 = *(_QWORD *)(*((_QWORD *)this + 3) + 8 * i);
*(_DWORD *)(v4 + 8) = 0;
LefDefParser::lefFree(*(LefDefParser **)(v4 + 16), a2);
LefDefParser::lefFree((LefDefParser *)v4, a2);
}
}
result = 0LL;
*((_DWORD *)this + 4) = 0;
*(_DWORD *)this = 0;
return result;
}
| clear:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVSXD R15,dword ptr [RDI + 0x10]
TEST R15,R15
JLE 0x001569e4
XOR R12D,R12D
LAB_001569bb:
MOV RAX,qword ptr [RBX + 0x18]
MOV R14,qword ptr [RAX + R12*0x8]
MOV dword ptr [R14 + 0x8],0x0
MOV RDI,qword ptr [R14 + 0x10]
CALL 0x001322d0
MOV RDI,R14
CALL 0x001322d0
INC R12
CMP R15,R12
JNZ 0x001569bb
LAB_001569e4:
XOR EAX,EAX
MOV dword ptr [RBX + 0x10],EAX
MOV dword ptr [RBX],EAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::lefiNoiseResistance::clear() */
void __thiscall LefDefParser::lefiNoiseResistance::clear(lefiNoiseResistance *this)
{
int iVar1;
void *pvVar2;
long lVar3;
iVar1 = *(int *)(this + 0x10);
if (0 < (long)iVar1) {
lVar3 = 0;
do {
pvVar2 = *(void **)(*(long *)(this + 0x18) + lVar3 * 8);
*(int4 *)((long)pvVar2 + 8) = 0;
lefFree(*(void **)((long)pvVar2 + 0x10));
lefFree(pvVar2);
lVar3 = lVar3 + 1;
} while (iVar1 != lVar3);
}
*(int4 *)(this + 0x10) = 0;
*(int4 *)this = 0;
return;
}
| |
24,524 | rtree_delete | eloqsql/storage/myisam/rt_index.c | int rtree_delete(MI_INFO *info, uint keynr, uchar *key, uint key_length)
{
uint page_size;
stPageList ReinsertList;
my_off_t old_root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
DBUG_ENTER("rtree_delete");
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
DBUG_RETURN(-1); /* purecov: inspected */
}
DBUG_PRINT("rtree", ("starting deletion at root page: %lu",
(ulong) old_root));
ReinsertList.pages = NULL;
ReinsertList.n_pages = 0;
ReinsertList.m_pages = 0;
switch (rtree_delete_req(info, keyinfo, key, key_length, old_root,
&page_size, &ReinsertList, 0))
{
case 2: /* empty */
{
info->s->state.key_root[keynr] = HA_OFFSET_ERROR;
DBUG_RETURN(0);
}
case 0: /* deleted */
{
uint nod_flag;
ulong i;
for (i = 0; i < ReinsertList.n_pages; ++i)
{
uchar *page_buf;
uchar *k;
uchar *last;
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
{
my_errno = HA_ERR_OUT_OF_MEM;
goto err1;
}
if (!_mi_fetch_keypage(info, keyinfo, ReinsertList.pages[i].offs,
DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
DBUG_PRINT("rtree", ("reinserting keys from "
"page: %lu level: %d nod_flag: %u",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level, nod_flag));
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
last = rt_PAGE_END(page_buf);
for (; k < last; k = rt_PAGE_NEXT_KEY(k, key_length, nod_flag))
{
int res;
if ((res= rtree_insert_level(info, keynr, k, key_length,
ReinsertList.pages[i].level)) == -1)
{
my_afree((uchar*)page_buf);
goto err1;
}
if (res)
{
ulong j;
DBUG_PRINT("rtree", ("root has been split, adjust levels"));
for (j= i; j < ReinsertList.n_pages; j++)
{
ReinsertList.pages[j].level++;
DBUG_PRINT("rtree", ("keys from page: %lu now level: %d",
(ulong) ReinsertList.pages[i].offs,
ReinsertList.pages[i].level));
}
}
}
my_afree((uchar*)page_buf);
if (_mi_dispose(info, keyinfo, ReinsertList.pages[i].offs,
DFLT_INIT_HITS))
goto err1;
}
if (ReinsertList.pages)
my_free(ReinsertList.pages);
/* check for redundant root (not leaf, 1 child) and eliminate */
if ((old_root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
goto err1;
if (!_mi_fetch_keypage(info, keyinfo, old_root, DFLT_INIT_HITS,
info->buff, 0))
goto err1;
nod_flag = mi_test_if_nod(info->buff);
page_size = mi_getint(info->buff);
if (nod_flag && (page_size == 2 + key_length + nod_flag))
{
my_off_t new_root = _mi_kpos(nod_flag,
rt_PAGE_FIRST_KEY(info->buff, nod_flag));
if (_mi_dispose(info, keyinfo, old_root, DFLT_INIT_HITS))
goto err1;
info->s->state.key_root[keynr] = new_root;
}
info->update= HA_STATE_DELETED;
DBUG_RETURN(0);
err1:
DBUG_RETURN(-1); /* purecov: inspected */
}
case 1: /* not found */
{
my_errno = HA_ERR_KEY_NOT_FOUND;
DBUG_RETURN(-1); /* purecov: inspected */
}
default:
case -1: /* error */
{
DBUG_RETURN(-1); /* purecov: inspected */
}
}
} | O3 | c | rtree_delete:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %r14d
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movl %esi, -0x3c(%rbp)
movl %esi, %ebx
movq 0x98(%rax), %rcx
movq (%rcx,%rbx,8), %r8
cmpq $-0x1, %r8
je 0x8da06
imulq $0x70, %rbx, %r13
addq 0x218(%rax), %r13
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq -0x84(%rbp), %r9
movq %rdi, -0x38(%rbp)
movq %r13, %rsi
movl %r14d, %ecx
pushq $0x0
pushq %rax
callq 0x8db53
addq $0x10, %rsp
cmpl $0x2, %eax
je 0x8da2c
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpl $0x1, %eax
je 0x8da1c
testl %eax, %eax
jne 0x8db16
movq %rbx, -0x48(%rbp)
movq -0xa0(%rbp), %r12
movq -0x90(%rbp), %rbx
testq %r12, %r12
movq %r14, -0x70(%rbp)
je 0x8da52
movl %r14d, %eax
movq %rax, -0x80(%rbp)
xorl %r14d, %r14d
movq %rbx, -0x60(%rbp)
movq -0x38(%rbp), %rdi
movq %r13, -0x78(%rbp)
movq %rbx, -0x50(%rbp)
movzwl 0xe(%r13), %eax
movq %rsp, %r15
addl $0xf, %eax
andl $-0x10, %eax
subq %rax, %r15
movq %r15, %rsp
movq %r14, %rax
shlq $0x4, %rax
movq %rax, -0x58(%rbp)
movq 0x8(%rbx,%rax), %rdx
movq %r13, %rsi
movl $0x3, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x86f80
testq %rax, %rax
je 0x8da11
movq %r14, -0x68(%rbp)
movzbl (%r15), %ebx
xorl %eax, %eax
testb %bl, %bl
movq -0x38(%rbp), %rdi
jns 0x8d941
movq (%rdi), %rax
movl 0x17c(%rax), %eax
movl %eax, %r13d
leaq (%r15,%r13), %r14
addq $0x2, %r14
movzbl 0x1(%r15), %eax
andl $0x7f, %ebx
shll $0x8, %ebx
orq %rax, %rbx
addq %r15, %rbx
cmpq %rbx, %r14
jae 0x8d9c4
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
leaq (%rax,%rcx), %r15
movl (%r15), %r8d
movl -0x3c(%rbp), %esi
movq %r14, %rdx
movq -0x70(%rbp), %rcx
callq 0x8d5b9
testl %eax, %eax
je 0x8d9a3
cmpl $-0x1, %eax
je 0x8da4a
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rcx
incl (%rax)
incq %rcx
addq $0x10, %rax
cmpq %r12, %rcx
jb 0x8d995
movq %r13, %rax
testl %r13d, %r13d
movq -0x38(%rbp), %rdi
jne 0x8d9b8
movq (%rdi), %rax
movl 0x178(%rax), %eax
addq -0x80(%rbp), %r14
addq %rax, %r14
cmpq %rbx, %r14
jb 0x8d96e
movq -0x50(%rbp), %rbx
movq -0x58(%rbp), %rax
addq %rbx, %rax
addq $0x8, %rax
movq (%rax), %rdx
movq -0x78(%rbp), %r13
movq %r13, %rsi
movl $0x3, %ecx
callq 0x870ff
testl %eax, %eax
jne 0x8da11
movq -0x68(%rbp), %r14
incq %r14
addq $0x10, -0x60(%rbp)
cmpq %r12, %r14
movq -0x38(%rbp), %rdi
jne 0x8d8e6
jmp 0x8da5b
callq 0xa4ab2
movl $0x89, (%rax)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0x8db16
callq 0xa4ab2
movl $0x78, (%rax)
jmp 0x8db16
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movq $-0x1, (%rax,%rbx,8)
xorl %r12d, %r12d
jmp 0x8db16
movl %eax, %r12d
jmp 0x8db16
testq %rbx, %rbx
movq -0x38(%rbp), %rdi
je 0x8da67
movq %rbx, %rdi
callq 0xa2e9e
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x98(%rax), %rax
movq -0x48(%rbp), %rcx
movq (%rax,%rcx,8), %r14
cmpq $-0x1, %r14
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
je 0x8db16
movq 0x100(%rdi), %r8
movq %rdi, %rbx
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0x86f80
testq %rax, %rax
je 0x8db16
movq 0x100(%rbx), %rax
movzbl (%rax), %ecx
testb %cl, %cl
js 0x8dac8
movl $0x8, 0x1d0(%rbx)
jmp 0x8da42
movq (%rbx), %rdx
movl 0x17c(%rdx), %edi
testq %rdi, %rdi
je 0x8dab9
andl $0x7f, %ecx
shll $0x8, %ecx
movzbl 0x1(%rax), %edx
orl %ecx, %edx
movq -0x70(%rbp), %rcx
addl %edi, %ecx
addl $0x2, %ecx
cmpl %ecx, %edx
jne 0x8dab9
leaq (%rax,%rdi), %rsi
addq $0x2, %rsi
callq 0x878fa
movq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movl $0x3, %ecx
callq 0x870ff
testl %eax, %eax
je 0x8db37
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x8db4e
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
movq 0x98(%rax), %rax
movq -0x48(%rbp), %rcx
movq %r15, (%rax,%rcx,8)
jmp 0x8dab9
callq 0x29220
| rtree_delete:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14d, ecx
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_3C], esi
mov ebx, esi
mov rcx, [rax+98h]
mov r8, [rcx+rbx*8]
cmp r8, 0FFFFFFFFFFFFFFFFh
jz loc_8DA06
imul r13, rbx, 70h ; 'p'
add r13, [rax+218h]
xorps xmm0, xmm0
lea rax, [rbp+var_A0]
movaps xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
lea r9, [rbp+var_84]
mov [rbp+var_38], rdi
mov rsi, r13
mov ecx, r14d
push 0
push rax
call rtree_delete_req
add rsp, 10h
cmp eax, 2
jz loc_8DA2C
mov r12d, 0FFFFFFFFh
cmp eax, 1
jz loc_8DA1C
test eax, eax
jnz loc_8DB16
mov [rbp+var_48], rbx
mov r12, [rbp+var_A0]
mov rbx, [rbp+var_90]
test r12, r12
mov [rbp+var_70], r14
jz loc_8DA52
mov eax, r14d
mov [rbp+var_80], rax
xor r14d, r14d
mov [rbp+var_60], rbx
mov rdi, [rbp+var_38]
mov [rbp+var_78], r13
mov [rbp+var_50], rbx
loc_8D8E6:
movzx eax, word ptr [r13+0Eh]
mov r15, rsp
add eax, 0Fh
and eax, 0FFFFFFF0h
sub r15, rax
mov rsp, r15
mov rax, r14
shl rax, 4
mov [rbp+var_58], rax
mov rdx, [rbx+rax+8]
mov rsi, r13
mov ecx, 3
mov r8, r15
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz loc_8DA11
mov [rbp+var_68], r14
movzx ebx, byte ptr [r15]
xor eax, eax
test bl, bl
mov rdi, [rbp+var_38]
jns short loc_8D941
mov rax, [rdi]
mov eax, [rax+17Ch]
loc_8D941:
mov r13d, eax
lea r14, [r15+r13]
add r14, 2
movzx eax, byte ptr [r15+1]
and ebx, 7Fh
shl ebx, 8
or rbx, rax
add rbx, r15
cmp r14, rbx
jnb short loc_8D9C4
mov rax, [rbp+var_50]
mov rcx, [rbp+var_58]
lea r15, [rax+rcx]
loc_8D96E:
mov r8d, [r15]
mov esi, [rbp+var_3C]
mov rdx, r14
mov rcx, [rbp+var_70]
call rtree_insert_level
test eax, eax
jz short loc_8D9A3
cmp eax, 0FFFFFFFFh
jz loc_8DA4A
mov rax, [rbp+var_60]
mov rcx, [rbp+var_68]
loc_8D995:
inc dword ptr [rax]
inc rcx
add rax, 10h
cmp rcx, r12
jb short loc_8D995
loc_8D9A3:
mov rax, r13
test r13d, r13d
mov rdi, [rbp+var_38]
jnz short loc_8D9B8
mov rax, [rdi]
mov eax, [rax+178h]
loc_8D9B8:
add r14, [rbp+var_80]
add r14, rax
cmp r14, rbx
jb short loc_8D96E
loc_8D9C4:
mov rbx, [rbp+var_50]
mov rax, [rbp+var_58]
add rax, rbx
add rax, 8
mov rdx, [rax]
mov r13, [rbp+var_78]
mov rsi, r13
mov ecx, 3
call _mi_dispose
test eax, eax
jnz short loc_8DA11
mov r14, [rbp+var_68]
inc r14
add [rbp+var_60], 10h
cmp r14, r12
mov rdi, [rbp+var_38]
jnz loc_8D8E6
jmp short loc_8DA5B
loc_8DA06:
call _my_thread_var
mov dword ptr [rax], 89h
loc_8DA11:
mov r12d, 0FFFFFFFFh
jmp loc_8DB16
loc_8DA1C:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
jmp loc_8DB16
loc_8DA2C:
mov rax, [rbp+var_38]
mov rax, [rax]
mov rax, [rax+98h]
mov qword ptr [rax+rbx*8], 0FFFFFFFFFFFFFFFFh
loc_8DA42:
xor r12d, r12d
jmp loc_8DB16
loc_8DA4A:
mov r12d, eax
jmp loc_8DB16
loc_8DA52:
test rbx, rbx
mov rdi, [rbp+var_38]
jz short loc_8DA67
loc_8DA5B:
mov rdi, rbx
call my_free
mov rdi, [rbp+var_38]
loc_8DA67:
mov rax, [rdi]
mov rax, [rax+98h]
mov rcx, [rbp+var_48]
mov r14, [rax+rcx*8]
cmp r14, 0FFFFFFFFFFFFFFFFh
mov r12d, 0FFFFFFFFh
jz loc_8DB16
mov r8, [rdi+100h]
mov rbx, rdi
mov rsi, r13
mov rdx, r14
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
test rax, rax
jz short loc_8DB16
mov rax, [rbx+100h]
movzx ecx, byte ptr [rax]
test cl, cl
js short loc_8DAC8
loc_8DAB9:
mov dword ptr [rbx+1D0h], 8
jmp loc_8DA42
loc_8DAC8:
mov rdx, [rbx]
mov edi, [rdx+17Ch]
test rdi, rdi
jz short loc_8DAB9
and ecx, 7Fh
shl ecx, 8
movzx edx, byte ptr [rax+1]
or edx, ecx
mov rcx, [rbp+var_70]
add ecx, edi
add ecx, 2
cmp edx, ecx
jnz short loc_8DAB9
lea rsi, [rax+rdi]
add rsi, 2
call _mi_kpos
mov r15, rax
mov rdi, rbx
mov rsi, r13
mov rdx, r14
mov ecx, 3
call _mi_dispose
test eax, eax
jz short loc_8DB37
loc_8DB16:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_8DB4E
mov eax, r12d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8DB37:
mov rax, [rbx]
mov rax, [rax+98h]
mov rcx, [rbp+var_48]
mov [rax+rcx*8], r15
jmp loc_8DAB9
loc_8DB4E:
call ___stack_chk_fail
| long long rtree_delete(_QWORD *a1, unsigned int a2, int a3, unsigned int a4)
{
long long v4; // r14
long long v5; // rax
long long v6; // r8
long long v7; // r13
int v8; // eax
unsigned int v9; // r12d
unsigned long long v10; // r12
_DWORD *v11; // rbx
unsigned long long v12; // r14
_QWORD *v13; // rdi
char *v14; // r15
unsigned int v15; // eax
long long *v16; // rdi
long long v17; // r13
unsigned long long v18; // r14
char *v19; // rbx
int *v20; // r15
int inserted; // eax
_DWORD *v22; // rax
unsigned long long v23; // rcx
long long v24; // rax
_QWORD *v25; // rdi
long long v26; // rax
long long v27; // r14
_DWORD *v28; // rbx
char *v29; // rax
long long v30; // rdi
unsigned long long v31; // r15
__int128 v33; // [rsp+0h] [rbp-A0h] BYREF
_DWORD *v34; // [rsp+10h] [rbp-90h]
char v35; // [rsp+1Ch] [rbp-84h] BYREF
long long v36; // [rsp+20h] [rbp-80h]
long long v37; // [rsp+28h] [rbp-78h]
long long v38; // [rsp+30h] [rbp-70h]
unsigned long long v39; // [rsp+38h] [rbp-68h]
_DWORD *v40; // [rsp+40h] [rbp-60h]
long long v41; // [rsp+48h] [rbp-58h]
_DWORD *v42; // [rsp+50h] [rbp-50h]
long long v43; // [rsp+58h] [rbp-48h]
unsigned int v44; // [rsp+64h] [rbp-3Ch]
_QWORD *v45; // [rsp+68h] [rbp-38h]
unsigned long long v46; // [rsp+70h] [rbp-30h]
v4 = a4;
v46 = __readfsqword(0x28u);
v5 = *a1;
v44 = a2;
v6 = *(_QWORD *)(*(_QWORD *)(v5 + 152) + 8LL * a2);
if ( v6 == -1 )
{
*(_DWORD *)my_thread_var(a1) = 137;
return (unsigned int)-1;
}
v7 = *(_QWORD *)(v5 + 536) + 112LL * a2;
v33 = 0LL;
v34 = 0LL;
v45 = a1;
v8 = rtree_delete_req((_DWORD)a1, v7, a3, a4, v6, (unsigned int)&v35, (long long)&v33, 0);
if ( v8 == 2 )
{
*(_QWORD *)(*(_QWORD *)(*v45 + 152LL) + 8LL * a2) = -1LL;
return 0;
}
v9 = -1;
if ( v8 == 1 )
{
*(_DWORD *)my_thread_var(a1) = 120;
return v9;
}
if ( !v8 )
{
v43 = a2;
v10 = v33;
v11 = v34;
v38 = v4;
if ( (_QWORD)v33 )
{
v36 = (unsigned int)v4;
v12 = 0LL;
v40 = v34;
v13 = v45;
v37 = v7;
v42 = v34;
while ( 1 )
{
v14 = (char *)&v33 - ((*(unsigned __int16 *)(v7 + 14) + 15) & 0xFFFFFFF0);
v41 = 16 * v12;
if ( !mi_fetch_keypage(v13, v7, *(_QWORD *)&v11[4 * v12 + 2]) )
break;
v39 = v12;
v15 = 0;
v16 = v45;
if ( *v14 < 0 )
v15 = *(_DWORD *)(*v45 + 380LL);
v17 = v15;
v18 = (unsigned long long)&v14[v15 + 2];
v19 = &v14[(unsigned __int8)v14[1] | (unsigned long long)((unsigned __int8)(*v14 & 0x7F) << 8)];
if ( v18 < (unsigned long long)v19 )
{
v20 = &v42[(unsigned long long)v41 / 4];
do
{
inserted = rtree_insert_level(v16, v44, v18, v38, *v20);
if ( inserted )
{
if ( inserted == -1 )
return (unsigned int)-1;
v22 = v40;
v23 = v39;
do
{
++*v22;
++v23;
v22 += 4;
}
while ( v23 < v10 );
}
v24 = v17;
v16 = v45;
if ( !(_DWORD)v17 )
v24 = *(unsigned int *)(*v45 + 376LL);
v18 += v24 + v36;
}
while ( v18 < (unsigned long long)v19 );
}
v11 = v42;
v7 = v37;
if ( (unsigned int)mi_dispose(v16, v37, *(_QWORD *)&v42[(unsigned long long)v41 / 4 + 2], 3u) )
break;
v12 = v39 + 1;
v40 += 4;
v13 = v45;
if ( v39 + 1 == v10 )
goto LABEL_29;
}
return (unsigned int)-1;
}
v25 = v45;
if ( v34 )
{
LABEL_29:
my_free(v11);
v25 = v45;
}
v26 = *(_QWORD *)(*v25 + 152LL);
v27 = *(_QWORD *)(v26 + 8 * v43);
v9 = -1;
if ( v27 != -1 )
{
v28 = v25;
if ( mi_fetch_keypage(v25, v7, *(_QWORD *)(v26 + 8 * v43)) )
{
v29 = (char *)v25[32];
if ( *v29 < 0 )
{
v30 = *(unsigned int *)(*v25 + 380LL);
if ( *(_DWORD *)(*(_QWORD *)v28 + 380LL) )
{
if ( (((*v29 & 0x7F) << 8) | (unsigned __int8)v29[1]) == (_DWORD)v30 + (_DWORD)v38 + 2 )
{
v31 = mi_kpos(v30, (long long)&v29[v30 + 2]);
if ( (unsigned int)mi_dispose(v28, v7, v27, 3u) )
return v9;
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)v28 + 152LL) + 8 * v43) = v31;
}
}
}
v28[116] = 8;
return 0;
}
}
}
return v9;
}
| rtree_delete:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14D,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV dword ptr [RBP + -0x3c],ESI
MOV EBX,ESI
MOV RCX,qword ptr [RAX + 0x98]
MOV R8,qword ptr [RCX + RBX*0x8]
CMP R8,-0x1
JZ 0x0018da06
IMUL R13,RBX,0x70
ADD R13,qword ptr [RAX + 0x218]
XORPS XMM0,XMM0
LEA RAX,[RBP + -0xa0]
MOVAPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
LEA R9,[RBP + -0x84]
MOV qword ptr [RBP + -0x38],RDI
MOV RSI,R13
MOV ECX,R14D
PUSH 0x0
PUSH RAX
CALL 0x0018db53
ADD RSP,0x10
CMP EAX,0x2
JZ 0x0018da2c
MOV R12D,0xffffffff
CMP EAX,0x1
JZ 0x0018da1c
TEST EAX,EAX
JNZ 0x0018db16
MOV qword ptr [RBP + -0x48],RBX
MOV R12,qword ptr [RBP + -0xa0]
MOV RBX,qword ptr [RBP + -0x90]
TEST R12,R12
MOV qword ptr [RBP + -0x70],R14
JZ 0x0018da52
MOV EAX,R14D
MOV qword ptr [RBP + -0x80],RAX
XOR R14D,R14D
MOV qword ptr [RBP + -0x60],RBX
MOV RDI,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x78],R13
MOV qword ptr [RBP + -0x50],RBX
LAB_0018d8e6:
MOVZX EAX,word ptr [R13 + 0xe]
MOV R15,RSP
ADD EAX,0xf
AND EAX,0xfffffff0
SUB R15,RAX
MOV RSP,R15
MOV RAX,R14
SHL RAX,0x4
MOV qword ptr [RBP + -0x58],RAX
MOV RDX,qword ptr [RBX + RAX*0x1 + 0x8]
MOV RSI,R13
MOV ECX,0x3
MOV R8,R15
XOR R9D,R9D
CALL 0x00186f80
TEST RAX,RAX
JZ 0x0018da11
MOV qword ptr [RBP + -0x68],R14
MOVZX EBX,byte ptr [R15]
XOR EAX,EAX
TEST BL,BL
MOV RDI,qword ptr [RBP + -0x38]
JNS 0x0018d941
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x17c]
LAB_0018d941:
MOV R13D,EAX
LEA R14,[R15 + R13*0x1]
ADD R14,0x2
MOVZX EAX,byte ptr [R15 + 0x1]
AND EBX,0x7f
SHL EBX,0x8
OR RBX,RAX
ADD RBX,R15
CMP R14,RBX
JNC 0x0018d9c4
MOV RAX,qword ptr [RBP + -0x50]
MOV RCX,qword ptr [RBP + -0x58]
LEA R15,[RAX + RCX*0x1]
LAB_0018d96e:
MOV R8D,dword ptr [R15]
MOV ESI,dword ptr [RBP + -0x3c]
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x70]
CALL 0x0018d5b9
TEST EAX,EAX
JZ 0x0018d9a3
CMP EAX,-0x1
JZ 0x0018da4a
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
LAB_0018d995:
INC dword ptr [RAX]
INC RCX
ADD RAX,0x10
CMP RCX,R12
JC 0x0018d995
LAB_0018d9a3:
MOV RAX,R13
TEST R13D,R13D
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x0018d9b8
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x178]
LAB_0018d9b8:
ADD R14,qword ptr [RBP + -0x80]
ADD R14,RAX
CMP R14,RBX
JC 0x0018d96e
LAB_0018d9c4:
MOV RBX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,RBX
ADD RAX,0x8
MOV RDX,qword ptr [RAX]
MOV R13,qword ptr [RBP + -0x78]
MOV RSI,R13
MOV ECX,0x3
CALL 0x001870ff
TEST EAX,EAX
JNZ 0x0018da11
MOV R14,qword ptr [RBP + -0x68]
INC R14
ADD qword ptr [RBP + -0x60],0x10
CMP R14,R12
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x0018d8e6
JMP 0x0018da5b
LAB_0018da06:
CALL 0x001a4ab2
MOV dword ptr [RAX],0x89
LAB_0018da11:
MOV R12D,0xffffffff
JMP 0x0018db16
LAB_0018da1c:
CALL 0x001a4ab2
MOV dword ptr [RAX],0x78
JMP 0x0018db16
LAB_0018da2c:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RAX + RBX*0x8],-0x1
LAB_0018da42:
XOR R12D,R12D
JMP 0x0018db16
LAB_0018da4a:
MOV R12D,EAX
JMP 0x0018db16
LAB_0018da52:
TEST RBX,RBX
MOV RDI,qword ptr [RBP + -0x38]
JZ 0x0018da67
LAB_0018da5b:
MOV RDI,RBX
CALL 0x001a2e9e
MOV RDI,qword ptr [RBP + -0x38]
LAB_0018da67:
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RBP + -0x48]
MOV R14,qword ptr [RAX + RCX*0x8]
CMP R14,-0x1
MOV R12D,0xffffffff
JZ 0x0018db16
MOV R8,qword ptr [RDI + 0x100]
MOV RBX,RDI
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
XOR R9D,R9D
CALL 0x00186f80
TEST RAX,RAX
JZ 0x0018db16
MOV RAX,qword ptr [RBX + 0x100]
MOVZX ECX,byte ptr [RAX]
TEST CL,CL
JS 0x0018dac8
LAB_0018dab9:
MOV dword ptr [RBX + 0x1d0],0x8
JMP 0x0018da42
LAB_0018dac8:
MOV RDX,qword ptr [RBX]
MOV EDI,dword ptr [RDX + 0x17c]
TEST RDI,RDI
JZ 0x0018dab9
AND ECX,0x7f
SHL ECX,0x8
MOVZX EDX,byte ptr [RAX + 0x1]
OR EDX,ECX
MOV RCX,qword ptr [RBP + -0x70]
ADD ECX,EDI
ADD ECX,0x2
CMP EDX,ECX
JNZ 0x0018dab9
LEA RSI,[RAX + RDI*0x1]
ADD RSI,0x2
CALL 0x001878fa
MOV R15,RAX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
MOV ECX,0x3
CALL 0x001870ff
TEST EAX,EAX
JZ 0x0018db37
LAB_0018db16:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0018db4e
MOV EAX,R12D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018db37:
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x98]
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + RCX*0x8],R15
JMP 0x0018dab9
LAB_0018db4e:
CALL 0x00129220
|
int8 rtree_delete(long *param_1,uint param_2,int8 param_3,uint param_4)
{
byte bVar1;
byte bVar2;
int4 uVar3;
ulong uVar4;
uint uVar5;
long *plVar6;
ulong *puVar7;
int iVar8;
uint uVar9;
long lVar10;
int *piVar11;
int4 *puVar12;
long lVar13;
int8 uVar14;
ulong uVar15;
int8 uVar16;
long lVar17;
ulong uVar18;
byte *pbVar19;
ulong *puVar20;
long in_FS_OFFSET;
ulong local_a8 [2];
int *local_98;
int1 local_8c [4];
ulong local_88;
long local_80;
ulong local_78;
ulong local_70;
int *local_68;
long local_60;
int *local_58;
ulong local_50;
uint local_44;
long *local_40;
long local_38;
puVar20 = local_a8;
uVar18 = (ulong)param_4;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar15 = (ulong)param_2;
lVar10 = *(long *)(*(long *)(*param_1 + 0x98) + uVar15 * 8);
local_44 = param_2;
if (lVar10 == -1) {
puVar12 = (int4 *)_my_thread_var();
*puVar12 = 0x89;
LAB_0018da11:
uVar16 = 0xffffffff;
goto LAB_0018db16;
}
lVar17 = uVar15 * 0x70 + *(long *)(*param_1 + 0x218);
local_a8[0] = 0;
local_a8[1] = 0;
local_98 = (int *)0x0;
local_40 = param_1;
iVar8 = rtree_delete_req(param_1,lVar17,param_3,uVar18,lVar10,local_8c,local_a8,0);
uVar4 = local_a8[0];
puVar20 = local_a8;
if (iVar8 == 2) {
*(int8 *)(*(long *)(*local_40 + 0x98) + uVar15 * 8) = 0xffffffffffffffff;
puVar20 = local_a8;
}
else {
uVar16 = 0xffffffff;
if (iVar8 == 1) {
puVar12 = (int4 *)_my_thread_var();
*puVar12 = 0x78;
goto LAB_0018db16;
}
puVar20 = local_a8;
if (iVar8 != 0) goto LAB_0018db16;
piVar11 = local_98;
local_78 = uVar18;
local_50 = uVar15;
if (local_a8[0] == 0) {
puVar20 = local_a8;
puVar7 = local_a8;
if (local_98 != (int *)0x0) goto LAB_0018da5b;
}
else {
local_88 = (ulong)param_4;
uVar15 = 0;
local_68 = local_98;
local_58 = local_98;
puVar20 = local_a8;
local_80 = lVar17;
do {
plVar6 = local_40;
puVar20 = (ulong *)((long)puVar20 + -(ulong)(*(ushort *)(lVar17 + 0xe) + 0xf & 0xfffffff0));
local_60 = uVar15 * 0x10;
uVar16 = *(int8 *)(piVar11 + uVar15 * 4 + 2);
*(byte *)((long)puVar20 + -8) = 0x1d;
*(byte *)((long)puVar20 + -7) = 0xd9;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
lVar10 = _mi_fetch_keypage(plVar6,lVar17,uVar16,3,puVar20,0);
if (lVar10 == 0) goto LAB_0018da11;
local_70 = uVar15;
bVar1 = *(byte *)puVar20;
uVar9 = 0;
if ((char)bVar1 < '\0') {
uVar9 = *(uint *)(*local_40 + 0x17c);
}
pbVar19 = (byte *)((long)puVar20 + (ulong)uVar9 + 2);
bVar2 = *(byte *)((long)puVar20 + 1);
if (pbVar19 < (byte *)((long)puVar20 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2))) {
puVar12 = (int4 *)((long)local_58 + local_60);
do {
plVar6 = local_40;
uVar5 = local_44;
uVar15 = local_78;
uVar3 = *puVar12;
*(byte *)((long)puVar20 + -8) = 0x80;
*(byte *)((long)puVar20 + -7) = 0xd9;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
iVar8 = rtree_insert_level(plVar6,uVar5,pbVar19,uVar15,uVar3);
if (iVar8 != 0) {
piVar11 = local_68;
uVar15 = local_70;
if (iVar8 == -1) {
uVar16 = 0xffffffff;
goto LAB_0018db16;
}
do {
*piVar11 = *piVar11 + 1;
uVar15 = uVar15 + 1;
piVar11 = piVar11 + 4;
} while (uVar15 < uVar4);
}
uVar15 = (ulong)uVar9;
if (uVar9 == 0) {
uVar15 = (ulong)*(uint *)(*local_40 + 0x178);
}
pbVar19 = pbVar19 + uVar15 + local_88;
} while (pbVar19 < (byte *)((long)puVar20 + ((ulong)((bVar1 & 0x7f) << 8) | (ulong)bVar2))
);
}
plVar6 = local_40;
piVar11 = local_58;
lVar17 = local_80;
uVar16 = *(int8 *)((long)local_58 + local_60 + 8);
*(byte *)((long)puVar20 + -8) = 0xe7;
*(byte *)((long)puVar20 + -7) = 0xd9;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
iVar8 = _mi_dispose(plVar6,lVar17,uVar16,3);
if (iVar8 != 0) goto LAB_0018da11;
uVar15 = local_70 + 1;
local_68 = local_68 + 4;
} while (uVar15 != uVar4);
LAB_0018da5b:
*(byte *)((long)puVar20 + -8) = 99;
*(byte *)((long)puVar20 + -7) = 0xda;
*(byte *)((long)puVar20 + -6) = 0x18;
*(byte *)((long)puVar20 + -5) = 0;
*(byte *)((long)puVar20 + -4) = 0;
*(byte *)((long)puVar20 + -3) = 0;
*(byte *)((long)puVar20 + -2) = 0;
*(byte *)((long)puVar20 + -1) = 0;
my_free(piVar11);
puVar7 = puVar20;
}
puVar20 = puVar7;
plVar6 = local_40;
lVar10 = *(long *)(*(long *)(*local_40 + 0x98) + local_50 * 8);
uVar16 = 0xffffffff;
if (lVar10 == -1) goto LAB_0018db16;
lVar13 = local_40[0x20];
*(int8 *)((long)puVar20 + -8) = 0x18daa6;
lVar13 = _mi_fetch_keypage(plVar6,lVar17,lVar10,3,lVar13,0);
if (lVar13 == 0) goto LAB_0018db16;
pbVar19 = (byte *)plVar6[0x20];
if ((char)*pbVar19 < '\0') {
uVar15 = (ulong)*(uint *)(*plVar6 + 0x17c);
if ((uVar15 != 0) &&
(((uint)pbVar19[1] | (*pbVar19 & 0x7f) << 8) ==
(int)local_78 + *(uint *)(*plVar6 + 0x17c) + 2)) {
*(int8 *)((long)puVar20 + -8) = 0x18dafc;
uVar14 = _mi_kpos(uVar15,pbVar19 + uVar15 + 2);
*(int8 *)((long)puVar20 + -8) = 0x18db12;
iVar8 = _mi_dispose(plVar6,lVar17,lVar10,3);
if (iVar8 != 0) goto LAB_0018db16;
*(int8 *)(*(long *)(*plVar6 + 0x98) + local_50 * 8) = uVar14;
}
}
*(int4 *)(plVar6 + 0x3a) = 8;
}
uVar16 = 0;
LAB_0018db16:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)puVar20 + -8) = rtree_delete_req;
__stack_chk_fail();
}
return uVar16;
}
| |
24,525 | list_delete | eloqsql/libmariadb/libmariadb/ma_list.c | LIST *list_delete(LIST *root, LIST *element)
{
if (element->prev)
element->prev->next=element->next;
else
root=element->next;
if (element->next)
element->next->prev=element->prev;
return root;
} | O0 | c | list_delete:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3d5cb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3d5d7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d5f4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| list_delete:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz short loc_3D5CB
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+8], rcx
jmp short loc_3D5D7
loc_3D5CB:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_8], rax
loc_3D5D7:
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_3D5F4
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax], rcx
loc_3D5F4:
mov rax, [rbp+var_8]
pop rbp
retn
| long long list_delete(long long a1, _QWORD *a2)
{
if ( *a2 )
*(_QWORD *)(*a2 + 8LL) = a2[1];
else
a1 = a2[1];
if ( a2[1] )
*(_QWORD *)a2[1] = *a2;
return a1;
}
| list_delete:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x0013d5cb
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0013d5d7
LAB_0013d5cb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
LAB_0013d5d7:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0013d5f4
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX],RCX
LAB_0013d5f4:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long list_delete(long param_1,long *param_2)
{
long local_10;
if (*param_2 == 0) {
local_10 = param_2[1];
}
else {
*(long *)(*param_2 + 8) = param_2[1];
local_10 = param_1;
}
if (param_2[1] != 0) {
*(long *)param_2[1] = *param_2;
}
return local_10;
}
| |
24,526 | ft_outline_create | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-rasterize.c | static PVG_FT_Outline* ft_outline_create(int points, int contours)
{
size_t points_size = ALIGN_SIZE((points + contours) * sizeof(PVG_FT_Vector));
size_t tags_size = ALIGN_SIZE((points + contours) * sizeof(char));
size_t contours_size = ALIGN_SIZE(contours * sizeof(int));
size_t contours_flag_size = ALIGN_SIZE(contours * sizeof(char));
PVG_FT_Outline* outline = malloc(points_size + tags_size + contours_size + contours_flag_size + sizeof(PVG_FT_Outline));
PVG_FT_Byte* outline_data = (PVG_FT_Byte*)(outline + 1);
outline->points = (PVG_FT_Vector*)(outline_data);
outline->tags = (char*)(outline_data + points_size);
outline->contours = (int*)(outline_data + points_size + tags_size);
outline->contours_flag = (char*)(outline_data + points_size + tags_size + contours_size);
outline->n_points = 0;
outline->n_contours = 0;
outline->flags = 0x0;
return outline;
} | O0 | c | ft_outline_create:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
cltq
shlq $0x4, %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
cltq
shlq $0x0, %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x18(%rbp)
movslq -0x8(%rbp), %rax
shlq $0x2, %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x20(%rbp)
movslq -0x8(%rbp), %rax
shlq $0x0, %rax
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
addq -0x20(%rbp), %rdi
addq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0xb4d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
addq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rcx
addq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ft_outline_create:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
add eax, [rbp+var_8]
cdqe
shl rax, 4
add rax, 7
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_10], rax
mov eax, [rbp+var_4]
add eax, [rbp+var_8]
cdqe
shl rax, 0
add rax, 7
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_18], rax
movsxd rax, [rbp+var_8]
shl rax, 2
add rax, 7
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], rax
movsxd rax, [rbp+var_8]
shl rax, 0
add rax, 7
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
add rdi, [rbp+var_18]
add rdi, [rbp+var_20]
add rdi, [rbp+var_28]
add rdi, 30h ; '0'
call _malloc
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rax, 30h ; '0'
mov [rbp+var_38], rax
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
add rcx, [rbp+var_10]
mov rax, [rbp+var_30]
mov [rax+10h], rcx
mov rcx, [rbp+var_38]
add rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax+18h], rcx
mov rcx, [rbp+var_38]
add rcx, [rbp+var_10]
add rcx, [rbp+var_18]
add rcx, [rbp+var_20]
mov rax, [rbp+var_30]
mov [rax+20h], rcx
mov rax, [rbp+var_30]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_30]
mov dword ptr [rax], 0
mov rax, [rbp+var_30]
mov dword ptr [rax+28h], 0
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
| long long ft_outline_create(int a1, int a2)
{
long long result; // rax
unsigned long long v3; // [rsp+20h] [rbp-20h]
unsigned long long v4; // [rsp+28h] [rbp-18h]
unsigned long long v5; // [rsp+30h] [rbp-10h]
v5 = (16LL * (a2 + a1) + 7) & 0xFFFFFFFFFFFFFFF8LL;
v4 = (a2 + a1 + 7LL) & 0xFFFFFFFFFFFFFFF8LL;
v3 = (4LL * a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
result = malloc(((a2 + 7LL) & 0xFFFFFFFFFFFFFFF8LL) + v3 + v4 + v5 + 48);
*(_QWORD *)(result + 8) = result + 48;
*(_QWORD *)(result + 16) = v5 + result + 48;
*(_QWORD *)(result + 24) = v4 + v5 + result + 48;
*(_QWORD *)(result + 32) = v3 + v4 + v5 + result + 48;
*(_DWORD *)(result + 4) = 0;
*(_DWORD *)result = 0;
*(_DWORD *)(result + 40) = 0;
return result;
}
| ft_outline_create:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x4
ADD RAX,0x7
AND RAX,-0x8
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,dword ptr [RBP + -0x8]
CDQE
SHL RAX,0x0
ADD RAX,0x7
AND RAX,-0x8
MOV qword ptr [RBP + -0x18],RAX
MOVSXD RAX,dword ptr [RBP + -0x8]
SHL RAX,0x2
ADD RAX,0x7
AND RAX,-0x8
MOV qword ptr [RBP + -0x20],RAX
MOVSXD RAX,dword ptr [RBP + -0x8]
SHL RAX,0x0
ADD RAX,0x7
AND RAX,-0x8
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x18]
ADD RDI,qword ptr [RBP + -0x20]
ADD RDI,qword ptr [RBP + -0x28]
ADD RDI,0x30
CALL 0x0010b4d0
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x30
MOV qword ptr [RBP + -0x38],RAX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
ADD RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x28],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
int4 * ft_outline_create(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int4 *puVar4;
int4 *puVar5;
lVar1 = (long)(param_1 + param_2) * 0x10;
uVar2 = (long)(param_1 + param_2) + 7U & 0xfffffffffffffff8;
uVar3 = (long)param_2 * 4 + 7U & 0xfffffffffffffff8;
puVar4 = (int4 *)
malloc(lVar1 + uVar2 + uVar3 + ((long)param_2 + 7U & 0xfffffffffffffff8) + 0x30);
puVar5 = puVar4 + 0xc;
*(int4 **)(puVar4 + 2) = puVar5;
*(int4 **)(puVar4 + 4) = puVar5 + (long)(param_1 + param_2) * 4;
*(ulong *)(puVar4 + 6) = (long)puVar5 + uVar2 + lVar1;
*(ulong *)(puVar4 + 8) = (long)puVar5 + uVar3 + uVar2 + lVar1;
puVar4[1] = 0;
*puVar4 = 0;
puVar4[10] = 0;
return puVar4;
}
| |
24,527 | ft_outline_create | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-rasterize.c | static PVG_FT_Outline* ft_outline_create(int points, int contours)
{
size_t points_size = ALIGN_SIZE((points + contours) * sizeof(PVG_FT_Vector));
size_t tags_size = ALIGN_SIZE((points + contours) * sizeof(char));
size_t contours_size = ALIGN_SIZE(contours * sizeof(int));
size_t contours_flag_size = ALIGN_SIZE(contours * sizeof(char));
PVG_FT_Outline* outline = malloc(points_size + tags_size + contours_size + contours_flag_size + sizeof(PVG_FT_Outline));
PVG_FT_Byte* outline_data = (PVG_FT_Byte*)(outline + 1);
outline->points = (PVG_FT_Vector*)(outline_data);
outline->tags = (char*)(outline_data + points_size);
outline->contours = (int*)(outline_data + points_size + tags_size);
outline->contours_flag = (char*)(outline_data + points_size + tags_size + contours_size);
outline->n_points = 0;
outline->n_contours = 0;
outline->flags = 0x0;
return outline;
} | O1 | c | ft_outline_create:
pushq %r15
pushq %r14
pushq %rbx
addl %esi, %edi
movslq %edi, %rbx
movq %rbx, %r14
shlq $0x4, %r14
addq $0x7, %rbx
andq $-0x8, %rbx
movslq %esi, %rax
leaq 0x7(,%rax,4), %r15
andq $-0x8, %r15
addq $0x7, %rax
andq $-0x8, %rax
addq %r14, %rax
addq %rbx, %rax
leaq (%r15,%rax), %rdi
addq $0x30, %rdi
callq 0xa400
leaq 0x30(%rax), %rcx
movq %rcx, 0x8(%rax)
leaq (%rax,%r14), %rcx
addq $0x30, %rcx
movq %rcx, 0x10(%rax)
addq %rcx, %rbx
movq %rbx, 0x18(%rax)
addq %r15, %rbx
movq %rbx, 0x20(%rax)
movq $0x0, (%rax)
movl $0x0, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
| ft_outline_create:
push r15
push r14
push rbx
add edi, esi
movsxd rbx, edi
mov r14, rbx
shl r14, 4
add rbx, 7
and rbx, 0FFFFFFFFFFFFFFF8h
movsxd rax, esi
lea r15, ds:7[rax*4]
and r15, 0FFFFFFFFFFFFFFF8h
add rax, 7
and rax, 0FFFFFFFFFFFFFFF8h
add rax, r14
add rax, rbx
lea rdi, [r15+rax]
add rdi, 30h ; '0'
call _malloc
lea rcx, [rax+30h]
mov [rax+8], rcx
lea rcx, [rax+r14]
add rcx, 30h ; '0'
mov [rax+10h], rcx
add rbx, rcx
mov [rax+18h], rbx
add rbx, r15
mov [rax+20h], rbx
mov qword ptr [rax], 0
mov dword ptr [rax+28h], 0
pop rbx
pop r14
pop r15
retn
| long long ft_outline_create(int a1, int a2)
{
long long v2; // r14
unsigned long long v3; // rbx
unsigned long long v4; // r15
long long result; // rax
long long v6; // rcx
unsigned long long v7; // rbx
v2 = 16LL * (a2 + a1);
v3 = (a2 + a1 + 7LL) & 0xFFFFFFFFFFFFFFF8LL;
v4 = (4LL * a2 + 7) & 0xFFFFFFFFFFFFFFF8LL;
result = malloc(v4 + v3 + v2 + ((a2 + 7LL) & 0xFFFFFFFFFFFFFFF8LL) + 48);
*(_QWORD *)(result + 8) = result + 48;
v6 = result + v2 + 48;
*(_QWORD *)(result + 16) = v6;
v7 = v6 + v3;
*(_QWORD *)(result + 24) = v7;
*(_QWORD *)(result + 32) = v4 + v7;
*(_QWORD *)result = 0LL;
*(_DWORD *)(result + 40) = 0;
return result;
}
| ft_outline_create:
PUSH R15
PUSH R14
PUSH RBX
ADD EDI,ESI
MOVSXD RBX,EDI
MOV R14,RBX
SHL R14,0x4
ADD RBX,0x7
AND RBX,-0x8
MOVSXD RAX,ESI
LEA R15,[0x7 + RAX*0x4]
AND R15,-0x8
ADD RAX,0x7
AND RAX,-0x8
ADD RAX,R14
ADD RAX,RBX
LEA RDI,[R15 + RAX*0x1]
ADD RDI,0x30
CALL 0x0010a400
LEA RCX,[RAX + 0x30]
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[RAX + R14*0x1]
ADD RCX,0x30
MOV qword ptr [RAX + 0x10],RCX
ADD RBX,RCX
MOV qword ptr [RAX + 0x18],RBX
ADD RBX,R15
MOV qword ptr [RAX + 0x20],RBX
MOV qword ptr [RAX],0x0
MOV dword ptr [RAX + 0x28],0x0
POP RBX
POP R14
POP R15
RET
|
void ft_outline_create(int param_1,int param_2)
{
int8 *puVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
lVar2 = (long)(param_1 + param_2);
uVar3 = lVar2 + 7U & 0xfffffffffffffff8;
uVar4 = (long)param_2 * 4 + 7U & 0xfffffffffffffff8;
puVar1 = (int8 *)
malloc(uVar4 + ((long)param_2 + 7U & 0xfffffffffffffff8) + lVar2 * 0x10 + uVar3 + 0x30);
puVar1[1] = puVar1 + 6;
puVar1[2] = puVar1 + lVar2 * 2 + 6;
lVar2 = uVar3 + (long)(puVar1 + lVar2 * 2 + 6);
puVar1[3] = lVar2;
puVar1[4] = lVar2 + uVar4;
*puVar1 = 0;
*(int4 *)(puVar1 + 5) = 0;
return;
}
| |
24,528 | CutSegment | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | segment_t *CutSegment(segment_t *s, int size_to_cut) {
if (s->size <= size_to_cut) {
HEAP_LOG("Cannot cut segment: segment size %d <= requested size %d\n", s->size, size_to_cut);
return s;
}
uintptr_t addr = (uintptr_t) s;
addr += (s->size - size_to_cut) * BLOCK_SIZE;
// Ensure new segment is aligned
uintptr_t original_addr = addr;
addr = (addr + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
if (original_addr != addr) {
HEAP_LOG("Adjusted segment address for alignment: %p -> %p\n", (void*)original_addr, (void*)addr);
}
segment_t *result = (segment_t *) addr;
// Update sizes accounting for alignment adjustments
int actual_size = (addr - (uintptr_t) s) / BLOCK_SIZE;
s->size -= size_to_cut;
// Initialize new segment
result->size = size_to_cut;
result->prev = s;
result->next = s->next;
result->is_free = s->is_free;
result->magic = SEGMENT_MAGIC;
result->allocation_file = NULL;
result->allocation_line = 0;
result->allocation_id = 0;
// Update linked list pointers
if (s->next) s->next->prev = result;
s->next = result;
HEAP_LOG("Segment cut: original=%p (size=%d), new=%p (size=%d)\n",
s, s->size, result, result->size);
initialize_segment_integrity(result);
return result;
} | O0 | c | CutSegment:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jg 0x3978
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a7f
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x14(%rbp), %eax
shll $0xc, %eax
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
subq $0x1, %rax
andq $-0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x39bf
jmp 0x39bf
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
shrq $0xc, %rax
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl $0xcafebafe, 0x28(%rax) # imm = 0xCAFEBAFE
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3a62
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rdi
callq 0x3a90
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| CutSegment:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov eax, [rax+4]
cmp eax, [rbp+var_14]
jg short loc_3978
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
jmp loc_3A7F
loc_3978:
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov eax, [rax+4]
sub eax, [rbp+var_14]
shl eax, 0Ch
cdqe
add rax, [rbp+var_20]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
add rax, 10h
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF0h
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jz short loc_39BF
jmp short $+2
loc_39BF:
mov rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
sub rax, rcx
shr rax, 0Ch
mov [rbp+var_34], eax
mov edx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, [rax+4]
sub ecx, edx
mov [rax+4], ecx
mov ecx, [rbp+var_14]
mov rax, [rbp+var_30]
mov [rax+4], ecx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_30]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+8]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov ecx, [rax]
mov rax, [rbp+var_30]
mov [rax], ecx
mov rax, [rbp+var_30]
mov dword ptr [rax+28h], 0CAFEBAFEh
mov rax, [rbp+var_30]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_30]
mov dword ptr [rax+20h], 0
mov rax, [rbp+var_30]
mov dword ptr [rax+24h], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_3A62
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rax+10h], rcx
loc_3A62:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rdi, [rbp+var_30]
call initialize_segment_integrity
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_3A7F:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| unsigned long long CutSegment(long long a1, int a2)
{
unsigned long long v3; // [rsp+10h] [rbp-30h]
if ( *(_DWORD *)(a1 + 4) <= a2 )
return a1;
v3 = (a1 + ((*(_DWORD *)(a1 + 4) - a2) << 12) + 15) & 0xFFFFFFFFFFFFFFF0LL;
*(_DWORD *)(a1 + 4) -= a2;
*(_DWORD *)(v3 + 4) = a2;
*(_QWORD *)(v3 + 16) = a1;
*(_QWORD *)(v3 + 8) = *(_QWORD *)(a1 + 8);
*(_DWORD *)v3 = *(_DWORD *)a1;
*(_DWORD *)(v3 + 40) = -889275650;
*(_QWORD *)(v3 + 24) = 0LL;
*(_DWORD *)(v3 + 32) = 0;
*(_DWORD *)(v3 + 36) = 0;
if ( *(_QWORD *)(a1 + 8) )
*(_QWORD *)(*(_QWORD *)(a1 + 8) + 16LL) = v3;
*(_QWORD *)(a1 + 8) = v3;
initialize_segment_integrity(v3);
return v3;
}
| CutSegment:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
CMP EAX,dword ptr [RBP + -0x14]
JG 0x00103978
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00103a7f
LAB_00103978:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
SUB EAX,dword ptr [RBP + -0x14]
SHL EAX,0xc
CDQE
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x10
SUB RAX,0x1
AND RAX,-0x10
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001039bf
JMP 0x001039bf
LAB_001039bf:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
SHR RAX,0xc
MOV dword ptr [RBP + -0x34],EAX
MOV EDX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4]
SUB ECX,EDX
MOV dword ptr [RAX + 0x4],ECX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x4],ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x28],0xcafebafe
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00103a62
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x10],RCX
LAB_00103a62:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00103a90
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_00103a7f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int4 * CutSegment(int4 *param_1,int param_2)
{
int4 *local_10;
local_10 = param_1;
if (param_2 < (int)param_1[1]) {
local_10 = (int4 *)
((long)param_1 + (long)((param_1[1] - param_2) * 0x1000) + 0xf & 0xfffffffffffffff0);
param_1[1] = param_1[1] - param_2;
local_10[1] = param_2;
*(int4 **)(local_10 + 4) = param_1;
*(int8 *)(local_10 + 2) = *(int8 *)(param_1 + 2);
*local_10 = *param_1;
local_10[10] = 0xcafebafe;
*(int8 *)(local_10 + 6) = 0;
local_10[8] = 0;
local_10[9] = 0;
if (*(long *)(param_1 + 2) != 0) {
*(int4 **)(*(long *)(param_1 + 2) + 0x10) = local_10;
}
*(int4 **)(param_1 + 2) = local_10;
initialize_segment_integrity(local_10);
}
return local_10;
}
| |
24,529 | CutSegment | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | segment_t *CutSegment(segment_t *s, int size_to_cut) {
if (s->size <= size_to_cut) {
HEAP_LOG("Cannot cut segment: segment size %d <= requested size %d\n", s->size, size_to_cut);
return s;
}
uintptr_t addr = (uintptr_t) s;
addr += (s->size - size_to_cut) * BLOCK_SIZE;
// Ensure new segment is aligned
uintptr_t original_addr = addr;
addr = (addr + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
if (original_addr != addr) {
HEAP_LOG("Adjusted segment address for alignment: %p -> %p\n", (void*)original_addr, (void*)addr);
}
segment_t *result = (segment_t *) addr;
// Update sizes accounting for alignment adjustments
int actual_size = (addr - (uintptr_t) s) / BLOCK_SIZE;
s->size -= size_to_cut;
// Initialize new segment
result->size = size_to_cut;
result->prev = s;
result->next = s->next;
result->is_free = s->is_free;
result->magic = SEGMENT_MAGIC;
result->allocation_file = NULL;
result->allocation_line = 0;
result->allocation_id = 0;
// Update linked list pointers
if (s->next) s->next->prev = result;
s->next = result;
HEAP_LOG("Segment cut: original=%p (size=%d), new=%p (size=%d)\n",
s, s->size, result, result->size);
initialize_segment_integrity(result);
return result;
} | O1 | c | CutSegment:
movq %rdi, %rax
movl 0x4(%rdi), %ecx
subl %esi, %ecx
jle 0x2806
pushq %rbx
movl %ecx, %edx
shll $0xc, %edx
movslq %edx, %rdx
leaq (%rax,%rdx), %rbx
addq $0xf, %rbx
andq $-0x10, %rbx
movl %ecx, 0x4(%rax)
movl %esi, 0x4(%rbx)
movq %rax, 0x10(%rbx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %ecx
movl %ecx, (%rbx)
movl $0xcafebafe, 0x28(%rbx) # imm = 0xCAFEBAFE
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x27f6
movq %rbx, 0x10(%rcx)
movq %rbx, 0x8(%rax)
movq %rbx, %rdi
callq 0x2807
movq %rbx, %rax
popq %rbx
retq
| CutSegment:
mov rax, rdi
mov ecx, [rdi+4]
sub ecx, esi
jle short locret_2806
push rbx
mov edx, ecx
shl edx, 0Ch
movsxd rdx, edx
lea rbx, [rax+rdx]
add rbx, 0Fh
and rbx, 0FFFFFFFFFFFFFFF0h
mov [rax+4], ecx
mov [rbx+4], esi
mov [rbx+10h], rax
mov rcx, [rax+8]
mov [rbx+8], rcx
mov ecx, [rax]
mov [rbx], ecx
mov dword ptr [rbx+28h], 0CAFEBAFEh
xorps xmm0, xmm0
movups xmmword ptr [rbx+18h], xmm0
mov rcx, [rax+8]
test rcx, rcx
jz short loc_27F6
mov [rcx+10h], rbx
loc_27F6:
mov [rax+8], rbx
mov rdi, rbx
call initialize_segment_integrity
mov rax, rbx
pop rbx
locret_2806:
retn
| unsigned long long CutSegment(unsigned long long a1, int a2)
{
unsigned long long result; // rax
int v3; // ecx
bool v4; // cc
int v5; // ecx
long long v6; // rdx
unsigned long long v7; // rbx
long long v8; // rcx
result = a1;
v3 = *(_DWORD *)(a1 + 4);
v4 = v3 <= a2;
v5 = v3 - a2;
if ( !v4 )
{
v6 = v5 << 12;
v7 = (a1 + v6 + 15) & 0xFFFFFFFFFFFFFFF0LL;
*(_DWORD *)(a1 + 4) = v5;
*(_DWORD *)(v7 + 4) = a2;
*(_QWORD *)(v7 + 16) = a1;
*(_QWORD *)(v7 + 8) = *(_QWORD *)(a1 + 8);
*(_DWORD *)v7 = *(_DWORD *)a1;
*(_DWORD *)(v7 + 40) = -889275650;
*(_OWORD *)(v7 + 24) = 0LL;
v8 = *(_QWORD *)(a1 + 8);
if ( v8 )
*(_QWORD *)(v8 + 16) = v7;
*(_QWORD *)(a1 + 8) = v7;
initialize_segment_integrity((a1 + v6 + 15) & 0xFFFFFFFFFFFFFFF0LL);
return v7;
}
return result;
}
| CutSegment:
MOV RAX,RDI
MOV ECX,dword ptr [RDI + 0x4]
SUB ECX,ESI
JLE 0x00102806
PUSH RBX
MOV EDX,ECX
SHL EDX,0xc
MOVSXD RDX,EDX
LEA RBX,[RAX + RDX*0x1]
ADD RBX,0xf
AND RBX,-0x10
MOV dword ptr [RAX + 0x4],ECX
MOV dword ptr [RBX + 0x4],ESI
MOV qword ptr [RBX + 0x10],RAX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RCX
MOV ECX,dword ptr [RAX]
MOV dword ptr [RBX],ECX
MOV dword ptr [RBX + 0x28],0xcafebafe
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x18],XMM0
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x001027f6
MOV qword ptr [RCX + 0x10],RBX
LAB_001027f6:
MOV qword ptr [RAX + 0x8],RBX
MOV RDI,RBX
CALL 0x00102807
MOV RAX,RBX
POP RBX
LAB_00102806:
RET
|
int4 * CutSegment(int4 *param_1,int param_2)
{
int iVar1;
int4 *puVar2;
iVar1 = param_1[1] - param_2;
puVar2 = param_1;
if (iVar1 != 0 && param_2 <= (int)param_1[1]) {
puVar2 = (int4 *)((long)param_1 + (long)(iVar1 * 0x1000) + 0xf & 0xfffffffffffffff0);
param_1[1] = iVar1;
puVar2[1] = param_2;
*(int4 **)(puVar2 + 4) = param_1;
*(int8 *)(puVar2 + 2) = *(int8 *)(param_1 + 2);
*puVar2 = *param_1;
puVar2[10] = 0xcafebafe;
*(int8 *)(puVar2 + 6) = 0;
*(int8 *)(puVar2 + 8) = 0;
if (*(long *)(param_1 + 2) != 0) {
*(int4 **)(*(long *)(param_1 + 2) + 0x10) = puVar2;
}
*(int4 **)(param_1 + 2) = puVar2;
initialize_segment_integrity(puVar2);
}
return puVar2;
}
| |
24,530 | CutSegment | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | segment_t *CutSegment(segment_t *s, int size_to_cut) {
if (s->size <= size_to_cut) {
HEAP_LOG("Cannot cut segment: segment size %d <= requested size %d\n", s->size, size_to_cut);
return s;
}
uintptr_t addr = (uintptr_t) s;
addr += (s->size - size_to_cut) * BLOCK_SIZE;
// Ensure new segment is aligned
uintptr_t original_addr = addr;
addr = (addr + ALIGNMENT - 1) & ~(ALIGNMENT - 1);
if (original_addr != addr) {
HEAP_LOG("Adjusted segment address for alignment: %p -> %p\n", (void*)original_addr, (void*)addr);
}
segment_t *result = (segment_t *) addr;
// Update sizes accounting for alignment adjustments
int actual_size = (addr - (uintptr_t) s) / BLOCK_SIZE;
s->size -= size_to_cut;
// Initialize new segment
result->size = size_to_cut;
result->prev = s;
result->next = s->next;
result->is_free = s->is_free;
result->magic = SEGMENT_MAGIC;
result->allocation_file = NULL;
result->allocation_line = 0;
result->allocation_id = 0;
// Update linked list pointers
if (s->next) s->next->prev = result;
s->next = result;
HEAP_LOG("Segment cut: original=%p (size=%d), new=%p (size=%d)\n",
s, s->size, result, result->size);
initialize_segment_integrity(result);
return result;
} | O3 | c | CutSegment:
movq %rdi, %rax
movl 0x4(%rdi), %ecx
subl %esi, %ecx
jle 0x276a
pushq %rbx
movl %ecx, %edx
shll $0xc, %edx
movslq %edx, %rdx
leaq (%rax,%rdx), %rbx
addq $0xf, %rbx
andq $-0x10, %rbx
movl %ecx, 0x4(%rax)
movl %esi, 0x4(%rbx)
movq %rax, 0x10(%rbx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movl (%rax), %edx
movl %edx, (%rbx)
movl $0xcafebafe, 0x28(%rbx) # imm = 0xCAFEBAFE
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
testq %rcx, %rcx
je 0x275a
movq %rbx, 0x10(%rcx)
movq %rbx, 0x8(%rax)
movq %rbx, %rdi
callq 0x276b
movq %rbx, %rax
popq %rbx
retq
| CutSegment:
mov rax, rdi
mov ecx, [rdi+4]
sub ecx, esi
jle short locret_276A
push rbx
mov edx, ecx
shl edx, 0Ch
movsxd rdx, edx
lea rbx, [rax+rdx]
add rbx, 0Fh
and rbx, 0FFFFFFFFFFFFFFF0h
mov [rax+4], ecx
mov [rbx+4], esi
mov [rbx+10h], rax
mov rcx, [rax+8]
mov [rbx+8], rcx
mov edx, [rax]
mov [rbx], edx
mov dword ptr [rbx+28h], 0CAFEBAFEh
xorps xmm0, xmm0
movups xmmword ptr [rbx+18h], xmm0
test rcx, rcx
jz short loc_275A
mov [rcx+10h], rbx
loc_275A:
mov [rax+8], rbx
mov rdi, rbx
call initialize_segment_integrity
mov rax, rbx
pop rbx
locret_276A:
retn
| unsigned long long CutSegment(unsigned long long a1, int a2)
{
unsigned long long result; // rax
int v3; // ecx
bool v4; // cc
int v5; // ecx
unsigned long long v6; // rbx
long long v7; // rcx
result = a1;
v3 = *(_DWORD *)(a1 + 4);
v4 = v3 <= a2;
v5 = v3 - a2;
if ( !v4 )
{
v6 = (a1 + (v5 << 12) + 15) & 0xFFFFFFFFFFFFFFF0LL;
*(_DWORD *)(a1 + 4) = v5;
*(_DWORD *)(v6 + 4) = a2;
*(_QWORD *)(v6 + 16) = a1;
v7 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(v6 + 8) = v7;
*(_DWORD *)v6 = *(_DWORD *)a1;
*(_DWORD *)(v6 + 40) = -889275650;
*(_OWORD *)(v6 + 24) = 0LL;
if ( v7 )
*(_QWORD *)(v7 + 16) = v6;
*(_QWORD *)(a1 + 8) = v6;
initialize_segment_integrity(v6);
return v6;
}
return result;
}
| CutSegment:
MOV RAX,RDI
MOV ECX,dword ptr [RDI + 0x4]
SUB ECX,ESI
JLE 0x0010276a
PUSH RBX
MOV EDX,ECX
SHL EDX,0xc
MOVSXD RDX,EDX
LEA RBX,[RAX + RDX*0x1]
ADD RBX,0xf
AND RBX,-0x10
MOV dword ptr [RAX + 0x4],ECX
MOV dword ptr [RBX + 0x4],ESI
MOV qword ptr [RBX + 0x10],RAX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RCX
MOV EDX,dword ptr [RAX]
MOV dword ptr [RBX],EDX
MOV dword ptr [RBX + 0x28],0xcafebafe
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x18],XMM0
TEST RCX,RCX
JZ 0x0010275a
MOV qword ptr [RCX + 0x10],RBX
LAB_0010275a:
MOV qword ptr [RAX + 0x8],RBX
MOV RDI,RBX
CALL 0x0010276b
MOV RAX,RBX
POP RBX
LAB_0010276a:
RET
|
int4 * CutSegment(int4 *param_1,int param_2)
{
long lVar1;
int iVar2;
int4 *puVar3;
iVar2 = param_1[1] - param_2;
puVar3 = param_1;
if (iVar2 != 0 && param_2 <= (int)param_1[1]) {
puVar3 = (int4 *)((long)param_1 + (long)(iVar2 * 0x1000) + 0xf & 0xfffffffffffffff0);
param_1[1] = iVar2;
puVar3[1] = param_2;
*(int4 **)(puVar3 + 4) = param_1;
lVar1 = *(long *)(param_1 + 2);
*(long *)(puVar3 + 2) = lVar1;
*puVar3 = *param_1;
puVar3[10] = 0xcafebafe;
*(int8 *)(puVar3 + 6) = 0;
*(int8 *)(puVar3 + 8) = 0;
if (lVar1 != 0) {
*(int4 **)(lVar1 + 0x10) = puVar3;
}
*(int4 **)(param_1 + 2) = puVar3;
initialize_segment_integrity(puVar3);
}
return puVar3;
}
| |
24,531 | r3d_primitive_load_cube | r3d/src/details/r3d_primitives.c | r3d_primitive_t r3d_primitive_load_cube(void)
{
static const float VERTICES[] =
{
// Positions // Normals // Texcoords
-1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, // Front top-left
-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // Front bottom-left
1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, // Front top-right
1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, // Front bottom-right
-1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, // Back top-left
-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, // Back bottom-left
1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, // Back top-right
1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, // Back bottom-right
};
static const unsigned short INDICES[] =
{
// Front face
0, 1, 2, 2, 1, 3,
// Back face
4, 5, 6, 6, 5, 7,
// Left face
4, 5, 0, 0, 5, 1,
// Right face
2, 3, 6, 6, 3, 7,
// Top face
4, 0, 6, 6, 0, 2,
// Bottom face
1, 5, 3, 3, 5, 7
};
r3d_primitive_t cube = { 0 };
cube.vao = rlLoadVertexArray();
rlEnableVertexArray(cube.vao);
cube.ebo = rlLoadVertexBufferElement(INDICES, sizeof(INDICES), false);
cube.vbo = rlLoadVertexBuffer(VERTICES, sizeof(VERTICES), false);
rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, 3, RL_FLOAT, false, 8 * sizeof(float), 0);
rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, 2, RL_FLOAT, false, 8 * sizeof(float), 6 * sizeof(float));
rlSetVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, 3, RL_FLOAT, false, 8 * sizeof(float), 3 * sizeof(float));
rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION);
rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD);
rlEnableVertexAttribute(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL);
rlDisableVertexArray();
return cube;
} | O3 | c | r3d_primitive_load_cube:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x1e474
movl %eax, %ebx
movl %eax, %edi
callq 0x1e3ad
leaq 0x9351a(%rip), %rdi # 0x164160
movl $0x48, %esi
xorl %edx, %edx
callq 0x1e270
movl %eax, %r14d
leaq 0x93404(%rip), %rdi # 0x164060
movl $0x100, %esi # imm = 0x100
xorl %edx, %edx
callq 0x1e207
movl %eax, %r15d
xorl %edi, %edi
movl $0x3, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl $0x20, %r8d
xorl %r9d, %r9d
callq 0x1e4a7
movl $0x1, %edi
movl $0x2, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl $0x20, %r8d
movl $0x18, %r9d
callq 0x1e4a7
movl $0x2, %edi
movl $0x3, %esi
movl $0x1406, %edx # imm = 0x1406
xorl %ecx, %ecx
movl $0x20, %r8d
movl $0xc, %r9d
callq 0x1e4a7
xorl %edi, %edi
callq 0x1e3e5
movl $0x1, %edi
callq 0x1e3e5
movl $0x2, %edi
callq 0x1e3e5
callq 0x1e3cd
shlq $0x20, %r15
movl %ebx, %eax
orq %r15, %rax
movl %r14d, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| r3d_primitive_load_cube:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
call rlLoadVertexArray
mov ebx, eax
mov edi, eax
call rlEnableVertexArray
lea rdi, r3d_primitive_load_cube_INDICES
mov esi, 48h ; 'H'
xor edx, edx
call rlLoadVertexBufferElement
mov r14d, eax
lea rdi, r3d_primitive_load_cube_VERTICES
mov esi, 100h
xor edx, edx
call rlLoadVertexBuffer
mov r15d, eax
xor edi, edi
mov esi, 3
mov edx, 1406h
xor ecx, ecx
mov r8d, 20h ; ' '
xor r9d, r9d
call rlSetVertexAttribute
mov edi, 1
mov esi, 2
mov edx, 1406h
xor ecx, ecx
mov r8d, 20h ; ' '
mov r9d, 18h
call rlSetVertexAttribute
mov edi, 2
mov esi, 3
mov edx, 1406h
xor ecx, ecx
mov r8d, 20h ; ' '
mov r9d, 0Ch
call rlSetVertexAttribute
xor edi, edi
call rlEnableVertexAttribute
mov edi, 1
call rlEnableVertexAttribute
mov edi, 2
call rlEnableVertexAttribute
call rlDisableVertexArray
shl r15, 20h
mov eax, ebx
or rax, r15
mov edx, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long r3d_primitive_load_cube(long long a1)
{
long long VertexArray; // rbx
long long VertexBuffer; // r15
VertexArray = (unsigned int)rlLoadVertexArray(a1);
rlEnableVertexArray(VertexArray);
rlLoadVertexBufferElement((long long)&r3d_primitive_load_cube_INDICES, 72, 0);
VertexBuffer = (unsigned int)rlLoadVertexBuffer((long long)&r3d_primitive_load_cube_VERTICES, 256, 0);
rlSetVertexAttribute(0LL, 3LL, 5126LL, 0LL, 32LL, 0);
rlSetVertexAttribute(1LL, 2LL, 5126LL, 0LL, 32LL, 24);
rlSetVertexAttribute(2LL, 3LL, 5126LL, 0LL, 32LL, 12);
rlEnableVertexAttribute(0LL);
rlEnableVertexAttribute(1LL);
rlEnableVertexAttribute(2LL);
rlDisableVertexArray(2LL);
return (VertexBuffer << 32) | (unsigned int)VertexArray;
}
| r3d_primitive_load_cube:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CALL 0x0011e474
MOV EBX,EAX
MOV EDI,EAX
CALL 0x0011e3ad
LEA RDI,[0x264160]
MOV ESI,0x48
XOR EDX,EDX
CALL 0x0011e270
MOV R14D,EAX
LEA RDI,[0x264060]
MOV ESI,0x100
XOR EDX,EDX
CALL 0x0011e207
MOV R15D,EAX
XOR EDI,EDI
MOV ESI,0x3
MOV EDX,0x1406
XOR ECX,ECX
MOV R8D,0x20
XOR R9D,R9D
CALL 0x0011e4a7
MOV EDI,0x1
MOV ESI,0x2
MOV EDX,0x1406
XOR ECX,ECX
MOV R8D,0x20
MOV R9D,0x18
CALL 0x0011e4a7
MOV EDI,0x2
MOV ESI,0x3
MOV EDX,0x1406
XOR ECX,ECX
MOV R8D,0x20
MOV R9D,0xc
CALL 0x0011e4a7
XOR EDI,EDI
CALL 0x0011e3e5
MOV EDI,0x1
CALL 0x0011e3e5
MOV EDI,0x2
CALL 0x0011e3e5
CALL 0x0011e3cd
SHL R15,0x20
MOV EAX,EBX
OR RAX,R15
MOV EDX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int1 [16] r3d_primitive_load_cube(void)
{
int4 uVar1;
int4 uVar2;
int1 auVar3 [16];
auVar3._0_4_ = rlLoadVertexArray();
rlEnableVertexArray(auVar3._0_4_);
uVar1 = rlLoadVertexBufferElement(r3d_primitive_load_cube_INDICES,0x48,0);
uVar2 = rlLoadVertexBuffer(r3d_primitive_load_cube_VERTICES,0x100,0);
rlSetVertexAttribute(0,3,0x1406,0,0x20,0);
rlSetVertexAttribute(1,2,0x1406,0,0x20,0x18);
rlSetVertexAttribute(2,3,0x1406,0,0x20,0xc);
rlEnableVertexAttribute(0);
rlEnableVertexAttribute(1);
rlEnableVertexAttribute(2);
rlDisableVertexArray();
auVar3._4_4_ = uVar2;
auVar3._8_4_ = uVar1;
auVar3._12_4_ = 0;
return auVar3;
}
| |
24,532 | minja::Value::to_int() const | monkey531[P]llama/common/minja.hpp | int64_t to_int() const {
if (is_null()) return 0;
if (is_boolean()) return get<bool>() ? 1 : 0;
if (is_number()) return static_cast<int64_t>(get<double>());
if (is_string()) {
try {
return std::stol(get<std::string>());
} catch (const std::exception &) {
return 0;
}
}
return 0;
} | O2 | cpp | minja::Value::to_int() const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x63efa
testb %al, %al
je 0x82a07
xorl %ebx, %ebx
jmp 0x82a5f
movb 0x40(%rbx), %al
cmpb $0x4, %al
jne 0x82a1b
movq %rbx, %rdi
callq 0x6428e
movzbl %al, %ebx
jmp 0x82a5f
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x82a32
movq %rbx, %rdi
callq 0x6382c
cvttsd2si %xmm0, %rbx
jmp 0x82a5f
cmpb $0x3, %al
jne 0x82a03
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x64344
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x82a9f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241c8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241c8
jmp 0x82a82
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x82a9a
callq 0x23390
callq 0x23e60
jmp 0x82a03
callq 0x23f90
| _ZNK5minja5Value6to_intEv:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jz short loc_82A07
loc_82A03:
xor ebx, ebx
jmp short loc_82A5F
loc_82A07:
mov al, [rbx+40h]
cmp al, 4
jnz short loc_82A1B
mov rdi, rbx
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
movzx ebx, al
jmp short loc_82A5F
loc_82A1B:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_82A32
mov rdi, rbx
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
cvttsd2si rbx, xmm0
jmp short loc_82A5F
loc_82A32:
cmp al, 3
jnz short loc_82A03
lea rdi, [rsp+38h+var_30]
mov rsi, rbx
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rdi, [rsp+38h+var_30]
push 0Ah
pop rdx
xor esi, esi
call _ZNSt7__cxx114stolERKNS_12basic_stringIcSt11char_traitsIcESaIcEEEPmi; std::stol(std::string const&,ulong *,int)
mov rbx, rax
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_82A5F:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
mov r14, rdx
mov rbx, rax
lea rdi, [rsp+38h+var_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_82A82
mov r14, rdx
mov rbx, rax
loc_82A82:
mov rdi, rbx; void *
cmp r14d, 1
jnz short loc_82A9A
call ___cxa_begin_catch
call ___cxa_end_catch
jmp loc_82A03
loc_82A9A:
call __Unwind_Resume
| long long minja::Value::to_int(minja::Value *this, double a2)
{
long long v2; // rbx
char v3; // al
_BYTE v5[48]; // [rsp+8h] [rbp-30h] BYREF
if ( !minja::Value::is_null(this) )
{
v3 = *((_BYTE *)this + 64);
if ( v3 == 4 )
return (unsigned __int8)minja::Value::get<bool>(this);
if ( (unsigned __int8)(v3 - 5) <= 2u )
{
minja::Value::get<double>(this);
return (unsigned int)(int)a2;
}
if ( v3 == 3 )
{
minja::Value::get<std::string>((long long)v5, this);
v2 = std::stol(v5, 0LL, 10LL);
std::string::~string(v5);
return v2;
}
}
return 0LL;
}
| to_int:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
CALL 0x00163efa
TEST AL,AL
JZ 0x00182a07
LAB_00182a03:
XOR EBX,EBX
JMP 0x00182a5f
LAB_00182a07:
MOV AL,byte ptr [RBX + 0x40]
CMP AL,0x4
JNZ 0x00182a1b
MOV RDI,RBX
CALL 0x0016428e
MOVZX EBX,AL
JMP 0x00182a5f
LAB_00182a1b:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x00182a32
MOV RDI,RBX
CALL 0x0016382c
CVTTSD2SI RBX,XMM0
JMP 0x00182a5f
LAB_00182a32:
CMP AL,0x3
JNZ 0x00182a03
LAB_00182a36:
LEA RDI,[RSP + 0x8]
MOV RSI,RBX
CALL 0x00164344
LAB_00182a43:
LEA RDI,[RSP + 0x8]
PUSH 0xa
POP RDX
XOR ESI,ESI
CALL 0x00182a9f
LAB_00182a52:
MOV RBX,RAX
LEA RDI,[RSP + 0x8]
CALL 0x001241c8
LAB_00182a5f:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
|
/* minja::Value::to_int() const */
ulong __thiscall minja::Value::to_int(Value *this)
{
Value VVar1;
char cVar2;
bool bVar3;
ulong uVar4;
double dVar5;
string local_30 [32];
cVar2 = is_null(this);
if (cVar2 == '\0') {
VVar1 = this[0x40];
if (VVar1 == (Value)0x4) {
bVar3 = get<bool>(this);
return (ulong)bVar3;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar5 = get<double>(this);
return (long)dVar5;
}
if (VVar1 == (Value)0x3) {
/* try { // try from 00182a36 to 00182a42 has its CatchHandler @ 00182a7c */
get<std::__cxx11::string>();
/* try { // try from 00182a43 to 00182a51 has its CatchHandler @ 00182a6a */
uVar4 = std::__cxx11::stol(local_30,(ulong *)0x0,10);
std::__cxx11::string::~string(local_30);
return uVar4;
}
}
return 0;
}
| |
24,533 | my_like_range_czech | eloqsql/strings/ctype-czech.c | static my_bool my_like_range_czech(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr,size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length, char *min_str,
char *max_str,
size_t *min_length,size_t *max_length)
{
#ifdef EXAMPLE
uchar value;
const char *end=ptr+ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
for (; ptr != end && min_str != min_end ; ptr++)
{
if (*ptr == w_one) /* '_' in SQL */
{ break; }
if (*ptr == w_many) /* '%' in SQL */
{ break; }
if (*ptr == escape && ptr+1 != end)
{ ptr++; } /* Skip escape */
value = CZ_SORT_TABLE[0][(int) (uchar) *ptr];
if (value == 0) /* Ignore in the first pass */
{ continue; }
if (value <= 2) /* End of pass or end of string */
{ break; }
if (value == 255) /* Double char too compicated */
{ break; }
*min_str++= *max_str++ = *ptr;
}
if (cs->state & MY_CS_BINSORT)
*min_length= (size_t) (min_str - min_org);
else
{
/* 'a\0\0... is the smallest possible string */
*min_length= res_length;
}
/* a\ff\ff... is the biggest possible string */
*max_length= res_length;
while (min_str != min_end)
{
*min_str++ = min_sort_char; /* Because of key compression */
*max_str++ = max_sort_char;
}
return 0;
#else
return 1;
#endif
} | O3 | c | my_like_range_czech:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r11
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %r12
movq 0x10(%rbp), %r15
leaq (%r12,%r15), %r10
testq %rdx, %rdx
sete %sil
testq %r15, %r15
sete %bl
orb %sil, %bl
jne 0x6b178
addq %r11, %rdx
leaq 0x8ab31(%rip), %r13 # 0xf5c57
movq %r12, %r14
movb (%r11), %bl
cmpb %r8b, %bl
je 0x6b17b
cmpb %r9b, %bl
je 0x6b17b
leaq 0x1(%r11), %rsi
cmpq %rdx, %rsi
cmoveq %r11, %rsi
cmpb %cl, %bl
cmovneq %r11, %rsi
movzbl (%rsi), %r11d
movb (%r11,%r13), %bl
testb %bl, %bl
je 0x6b166
incb %bl
cmpb $0x4, %bl
jb 0x6b17b
movb %r11b, (%rax)
incq %rax
movb %r11b, (%r14)
incq %r14
incq %rsi
cmpq %rdx, %rsi
je 0x6b17b
movq %rsi, %r11
cmpq %r10, %r14
jne 0x6b129
jmp 0x6b17b
movq %r12, %r14
movq %r14, %rcx
subq %r12, %rcx
testb $0x10, 0xc(%rdi)
cmoveq %r15, %rcx
movq 0x28(%rbp), %rdx
movq %rcx, (%rdx)
movq 0x30(%rbp), %rcx
movq %r15, (%rcx)
cmpq %r10, %r14
je 0x6b1ab
movb $0x20, (%r14)
incq %r14
movb $0x39, (%rax)
incq %rax
jmp 0x6b197
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_like_range_czech:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov r11, rsi
mov rax, [rbp+arg_10]
mov r12, [rbp+arg_8]
mov r15, [rbp+arg_0]
lea r10, [r12+r15]
test rdx, rdx
setz sil
test r15, r15
setz bl
or bl, sil
jnz short loc_6B178
add rdx, r11
lea r13, unk_F5C57
mov r14, r12
loc_6B129:
mov bl, [r11]
cmp bl, r8b
jz short loc_6B17B
cmp bl, r9b
jz short loc_6B17B
lea rsi, [r11+1]
cmp rsi, rdx
cmovz rsi, r11
cmp bl, cl
cmovnz rsi, r11
movzx r11d, byte ptr [rsi]
mov bl, [r11+r13]
test bl, bl
jz short loc_6B166
inc bl
cmp bl, 4
jb short loc_6B17B
mov [rax], r11b
inc rax
mov [r14], r11b
inc r14
loc_6B166:
inc rsi
cmp rsi, rdx
jz short loc_6B17B
mov r11, rsi
cmp r14, r10
jnz short loc_6B129
jmp short loc_6B17B
loc_6B178:
mov r14, r12
loc_6B17B:
mov rcx, r14
sub rcx, r12
test byte ptr [rdi+0Ch], 10h
cmovz rcx, r15
mov rdx, [rbp+arg_18]
mov [rdx], rcx
mov rcx, [rbp+arg_20]
mov [rcx], r15
loc_6B197:
cmp r14, r10
jz short loc_6B1AB
mov byte ptr [r14], 20h ; ' '
inc r14
mov byte ptr [rax], 39h ; '9'
inc rax
jmp short loc_6B197
loc_6B1AB:
xor eax, eax
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_like_range_czech(
long long a1,
unsigned __int8 *a2,
long long a3,
char a4,
char a5,
char a6,
long long a7,
long long a8,
_BYTE *a9,
long long *a10,
_QWORD *a11)
{
unsigned __int8 *v11; // r11
_BYTE *v13; // r10
unsigned __int8 *v14; // rdx
_BYTE *v15; // r14
unsigned __int8 v16; // bl
unsigned __int8 *v17; // rsi
long long v18; // r11
char v19; // bl
unsigned __int8 *v20; // rsi
long long v21; // rcx
v11 = a2;
v13 = (_BYTE *)(a8 + a7);
if ( a3 == 0 || a7 == 0 )
{
v15 = (_BYTE *)a8;
}
else
{
v14 = &a2[a3];
v15 = (_BYTE *)a8;
do
{
v16 = *v11;
if ( *v11 == a5 || v16 == a6 )
break;
v17 = v11 + 1;
if ( v11 + 1 == v14 )
v17 = v11;
if ( v16 != a4 )
v17 = v11;
v18 = *v17;
v19 = byte_F5C57[v18];
if ( v19 )
{
if ( (unsigned __int8)(v19 + 1) < 4u )
break;
*a9++ = v18;
*v15++ = v18;
}
v20 = v17 + 1;
if ( v20 == v14 )
break;
v11 = v20;
}
while ( v15 != v13 );
}
v21 = (long long)&v15[-a8];
if ( (*(_BYTE *)(a1 + 12) & 0x10) == 0 )
v21 = a7;
*a10 = v21;
*a11 = a7;
while ( v15 != v13 )
{
*v15++ = 32;
*a9++ = 57;
}
return 0LL;
}
| my_like_range_czech:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R11,RSI
MOV RAX,qword ptr [RBP + 0x20]
MOV R12,qword ptr [RBP + 0x18]
MOV R15,qword ptr [RBP + 0x10]
LEA R10,[R12 + R15*0x1]
TEST RDX,RDX
SETZ SIL
TEST R15,R15
SETZ BL
OR BL,SIL
JNZ 0x0016b178
ADD RDX,R11
LEA R13,[0x1f5c57]
MOV R14,R12
LAB_0016b129:
MOV BL,byte ptr [R11]
CMP BL,R8B
JZ 0x0016b17b
CMP BL,R9B
JZ 0x0016b17b
LEA RSI,[R11 + 0x1]
CMP RSI,RDX
CMOVZ RSI,R11
CMP BL,CL
CMOVNZ RSI,R11
MOVZX R11D,byte ptr [RSI]
MOV BL,byte ptr [R11 + R13*0x1]
TEST BL,BL
JZ 0x0016b166
INC BL
CMP BL,0x4
JC 0x0016b17b
MOV byte ptr [RAX],R11B
INC RAX
MOV byte ptr [R14],R11B
INC R14
LAB_0016b166:
INC RSI
CMP RSI,RDX
JZ 0x0016b17b
MOV R11,RSI
CMP R14,R10
JNZ 0x0016b129
JMP 0x0016b17b
LAB_0016b178:
MOV R14,R12
LAB_0016b17b:
MOV RCX,R14
SUB RCX,R12
TEST byte ptr [RDI + 0xc],0x10
CMOVZ RCX,R15
MOV RDX,qword ptr [RBP + 0x28]
MOV qword ptr [RDX],RCX
MOV RCX,qword ptr [RBP + 0x30]
MOV qword ptr [RCX],R15
LAB_0016b197:
CMP R14,R10
JZ 0x0016b1ab
MOV byte ptr [R14],0x20
INC R14
MOV byte ptr [RAX],0x39
INC RAX
JMP 0x0016b197
LAB_0016b1ab:
XOR EAX,EAX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
my_like_range_czech(long param_1,byte *param_2,long param_3,byte param_4,byte param_5,byte param_6,
long param_7,byte *param_8,byte *param_9,long *param_10,long *param_11)
{
byte bVar1;
long lVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
pbVar5 = param_8;
if (param_7 != 0 && param_3 != 0) {
pbVar3 = param_2 + param_3;
while ((bVar1 = *param_2, bVar1 != param_5 && (bVar1 != param_6))) {
pbVar4 = param_2 + 1;
if (param_2 + 1 == pbVar3) {
pbVar4 = param_2;
}
if (bVar1 != param_4) {
pbVar4 = param_2;
}
bVar1 = *pbVar4;
if ((&DAT_001f5c57)[bVar1] != '\0') {
if ((byte)((&DAT_001f5c57)[bVar1] + 1) < 4) break;
*param_9 = bVar1;
param_9 = param_9 + 1;
*pbVar5 = bVar1;
pbVar5 = pbVar5 + 1;
}
param_2 = pbVar4 + 1;
if ((param_2 == pbVar3) || (pbVar5 == param_8 + param_7)) break;
}
}
lVar2 = (long)pbVar5 - (long)param_8;
if ((*(byte *)(param_1 + 0xc) & 0x10) == 0) {
lVar2 = param_7;
}
*param_10 = lVar2;
*param_11 = param_7;
for (; pbVar5 != param_8 + param_7; pbVar5 = pbVar5 + 1) {
*pbVar5 = 0x20;
*param_9 = 0x39;
param_9 = param_9 + 1;
}
return 0;
}
| |
24,534 | my_like_range_simple | eloqsql/strings/ctype-simple.c | my_bool my_like_range_simple(CHARSET_INFO *cs,
const char *ptr, size_t ptr_length,
pbool escape, pbool w_one, pbool w_many,
size_t res_length,
char *min_str,char *max_str,
size_t *min_length, size_t *max_length)
{
const char *end= ptr + ptr_length;
char *min_org=min_str;
char *min_end=min_str+res_length;
size_t charlen= res_length / cs->mbmaxlen;
for (; ptr != end && min_str != min_end && charlen > 0 ; ptr++, charlen--)
{
if (*ptr == escape && ptr+1 != end)
{
ptr++; /* Skip escape */
*min_str++= *max_str++ = *ptr;
continue;
}
if (*ptr == w_one) /* '_' in SQL */
{
*min_str++='\0'; /* This should be min char */
*max_str++= (char) cs->max_sort_char;
continue;
}
if (*ptr == w_many) /* '%' in SQL */
{
/* Calculate length of keys */
*min_length= (cs->state & (MY_CS_BINSORT | MY_CS_NOPAD)) ?
(size_t) (min_str - min_org) :
res_length;
*max_length= res_length;
do
{
*min_str++= 0;
*max_str++= (char) cs->max_sort_char;
} while (min_str != min_end);
return 0;
}
*min_str++= *max_str++ = *ptr;
}
*min_length= *max_length = (size_t) (min_str - min_org);
while (min_str != min_end)
*min_str++= *max_str++ = ' '; /* Because if key compression */
return 0;
} | O0 | c | my_like_range_simple:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x60(%rbp)
movl %ecx, %eax
movl -0x60(%rbp), %ecx
movl %eax, -0x5c(%rbp)
movq %rdx, %rax
movl -0x5c(%rbp), %edx
movq %rax, -0x58(%rbp)
movq %rsi, %rax
movq -0x58(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq %rdi, %r8
movq -0x50(%rbp), %rdi
movb %r9b, %al
movq 0x30(%rbp), %r9
movq 0x28(%rbp), %r9
movq 0x20(%rbp), %r9
movq 0x18(%rbp), %r9
movq 0x10(%rbp), %r9
movq %r8, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movb %dl, -0x21(%rbp)
movb %cl, -0x22(%rbp)
movb %al, -0x23(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rbp), %rax
addq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x9c(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x61(%rbp)
je 0x595c8
movq 0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x61(%rbp)
je 0x595c8
cmpq $0x0, -0x48(%rbp)
seta %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x595d4
jmp 0x59749
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5962a
movq -0x18(%rbp), %rax
addq $0x1, %rax
cmpq -0x30(%rbp), %rax
je 0x5962a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rbp)
movb %cl, (%rax)
jmp 0x5972c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5966e
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movb %al, %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
jmp 0x5972c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x23(%rbp), %ecx
cmpl %ecx, %eax
jne 0x59704
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x20010, %eax # imm = 0x20010
cmpl $0x0, %eax
je 0x596a3
movq 0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
jmp 0x596ab
movq 0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq 0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movb %al, %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq 0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jne 0x596c1
movb $0x0, -0x1(%rbp)
jmp 0x59796
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq 0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rbp)
movb %cl, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x5959f
movq 0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rax, %rcx
movq 0x30(%rbp), %rax
movq %rcx, (%rax)
movq 0x28(%rbp), %rax
movq %rcx, (%rax)
movq 0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x59792
movq 0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rbp)
movb $0x20, (%rax)
movq 0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rbp)
movb $0x20, (%rax)
jmp 0x59762
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax,%rax)
| my_like_range_simple:
push rbp
mov rbp, rsp
mov [rbp+var_60], r8d
mov eax, ecx
mov ecx, [rbp+var_60]
mov [rbp+var_5C], eax
mov rax, rdx
mov edx, [rbp+var_5C]
mov [rbp+var_58], rax
mov rax, rsi
mov rsi, [rbp+var_58]
mov [rbp+var_50], rax
mov r8, rdi
mov rdi, [rbp+var_50]
mov al, r9b
mov r9, [rbp+arg_20]
mov r9, [rbp+arg_18]
mov r9, [rbp+arg_10]
mov r9, [rbp+arg_8]
mov r9, [rbp+arg_0]
mov [rbp+var_10], r8
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_21], dl
mov [rbp+var_22], cl
mov [rbp+var_23], al
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_30], rax
mov rax, [rbp+arg_8]
mov [rbp+var_38], rax
mov rax, [rbp+arg_8]
add rax, [rbp+arg_0]
mov [rbp+var_40], rax
mov rax, [rbp+arg_0]
mov rcx, [rbp+var_10]
mov ecx, [rcx+9Ch]
xor edx, edx
div rcx
mov [rbp+var_48], rax
loc_5959F:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_30]
mov [rbp+var_61], al
jz short loc_595C8
mov rcx, [rbp+arg_8]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_61], al
jz short loc_595C8
cmp [rbp+var_48], 0
setnbe al
mov [rbp+var_61], al
loc_595C8:
mov al, [rbp+var_61]
test al, 1
jnz short loc_595D4
jmp loc_59749
loc_595D4:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_21]
cmp eax, ecx
jnz short loc_5962A
mov rax, [rbp+var_18]
add rax, 1
cmp rax, [rbp+var_30]
jz short loc_5962A
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov cl, [rax]
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+arg_8]
mov rdx, rax
add rdx, 1
mov [rbp+arg_8], rdx
mov [rax], cl
jmp loc_5972C
loc_5962A:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_22]
cmp eax, ecx
jnz short loc_5966E
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rax, [rax+0A8h]
mov cl, al
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
jmp loc_5972C
loc_5966E:
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
movsx ecx, [rbp+var_23]
cmp eax, ecx
jnz loc_59704
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
and eax, 20010h
cmp eax, 0
jz short loc_596A3
mov rax, [rbp+arg_8]
mov rcx, [rbp+var_38]
sub rax, rcx
mov [rbp+var_70], rax
jmp short loc_596AB
loc_596A3:
mov rax, [rbp+arg_0]
mov [rbp+var_70], rax
loc_596AB:
mov rcx, [rbp+var_70]
mov rax, [rbp+arg_18]
mov [rax], rcx
mov rcx, [rbp+arg_0]
mov rax, [rbp+arg_20]
mov [rax], rcx
loc_596C1:
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
mov rax, [rax+0A8h]
mov cl, al
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_40]
jnz short loc_596C1
mov [rbp+var_1], 0
jmp loc_59796
loc_59704:
mov rax, [rbp+var_18]
mov cl, [rax]
mov rax, [rbp+arg_10]
mov rdx, rax
add rdx, 1
mov [rbp+arg_10], rdx
mov [rax], cl
mov rax, [rbp+arg_8]
mov rdx, rax
add rdx, 1
mov [rbp+arg_8], rdx
mov [rax], cl
loc_5972C:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rax, [rbp+var_48]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_48], rax
jmp loc_5959F
loc_59749:
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_38]
sub rcx, rax
mov rax, [rbp+arg_20]
mov [rax], rcx
mov rax, [rbp+arg_18]
mov [rax], rcx
loc_59762:
mov rax, [rbp+arg_8]
cmp rax, [rbp+var_40]
jz short loc_59792
mov rax, [rbp+arg_10]
mov rcx, rax
add rcx, 1
mov [rbp+arg_10], rcx
mov byte ptr [rax], 20h ; ' '
mov rax, [rbp+arg_8]
mov rcx, rax
add rcx, 1
mov [rbp+arg_8], rcx
mov byte ptr [rax], 20h ; ' '
jmp short loc_59762
loc_59792:
mov [rbp+var_1], 0
loc_59796:
mov al, [rbp+var_1]
pop rbp
retn
| char my_like_range_simple(
long long a1,
_BYTE *a2,
long long a3,
char a4,
char a5,
char a6,
unsigned long long a7,
_BYTE *a8,
_BYTE *a9,
unsigned long long *a10,
_QWORD *a11)
{
char v11; // cl
_BYTE *v12; // rax
_BYTE *v13; // rax
_BYTE *v14; // rax
_BYTE *v15; // rax
_BYTE *v16; // rax
_BYTE *v17; // rax
char v18; // cl
_BYTE *v19; // rax
_BYTE *v20; // rax
_BYTE *v21; // rax
_BYTE *v22; // rax
unsigned long long v24; // [rsp+0h] [rbp-70h]
bool v25; // [rsp+Fh] [rbp-61h]
unsigned long long i; // [rsp+28h] [rbp-48h]
_BYTE *v27; // [rsp+30h] [rbp-40h]
long long v28; // [rsp+38h] [rbp-38h]
_BYTE *v29; // [rsp+40h] [rbp-30h]
_BYTE *v31; // [rsp+58h] [rbp-18h]
v31 = a2;
v29 = &a2[a3];
v28 = (long long)a8;
v27 = &a8[a7];
for ( i = a7 / *(unsigned int *)(a1 + 156); ; --i )
{
v25 = 0;
if ( v31 != v29 )
{
v25 = 0;
if ( a8 != v27 )
v25 = i != 0;
}
if ( !v25 )
{
*a11 = &a8[-v28];
*a10 = (unsigned long long)&a8[-v28];
while ( a8 != v27 )
{
v21 = a9++;
*v21 = 32;
v22 = a8++;
*v22 = 32;
}
return 0;
}
if ( (char)*v31 == a4 && v31 + 1 != v29 )
{
v11 = *++v31;
v12 = a9++;
*v12 = *v31;
v13 = a8++;
*v13 = v11;
goto LABEL_19;
}
if ( (char)*v31 == a5 )
{
v14 = a8++;
*v14 = 0;
v15 = a9++;
*v15 = *(_QWORD *)(a1 + 168);
goto LABEL_19;
}
if ( (char)*v31 == a6 )
break;
v18 = *v31;
v19 = a9++;
*v19 = *v31;
v20 = a8++;
*v20 = v18;
LABEL_19:
++v31;
}
if ( (*(_DWORD *)(a1 + 12) & 0x20010) != 0 )
v24 = (unsigned long long)&a8[-v28];
else
v24 = a7;
*a10 = v24;
*a11 = a7;
do
{
v16 = a8++;
*v16 = 0;
v17 = a9++;
*v17 = *(_QWORD *)(a1 + 168);
}
while ( a8 != v27 );
return 0;
}
| my_like_range_simple:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x60],R8D
MOV EAX,ECX
MOV ECX,dword ptr [RBP + -0x60]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,RDX
MOV EDX,dword ptr [RBP + -0x5c]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],RAX
MOV R8,RDI
MOV RDI,qword ptr [RBP + -0x50]
MOV AL,R9B
MOV R9,qword ptr [RBP + 0x30]
MOV R9,qword ptr [RBP + 0x28]
MOV R9,qword ptr [RBP + 0x20]
MOV R9,qword ptr [RBP + 0x18]
MOV R9,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],R8
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV byte ptr [RBP + -0x21],DL
MOV byte ptr [RBP + -0x22],CL
MOV byte ptr [RBP + -0x23],AL
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + 0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x18]
ADD RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x9c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x48],RAX
LAB_0015959f:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x30]
MOV byte ptr [RBP + -0x61],AL
JZ 0x001595c8
MOV RCX,qword ptr [RBP + 0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x61],AL
JZ 0x001595c8
CMP qword ptr [RBP + -0x48],0x0
SETA AL
MOV byte ptr [RBP + -0x61],AL
LAB_001595c8:
MOV AL,byte ptr [RBP + -0x61]
TEST AL,0x1
JNZ 0x001595d4
JMP 0x00159749
LAB_001595d4:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x21]
CMP EAX,ECX
JNZ 0x0015962a
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0015962a
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x18],RDX
MOV byte ptr [RAX],CL
JMP 0x0015972c
LAB_0015962a:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x22]
CMP EAX,ECX
JNZ 0x0015966e
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa8]
MOV CL,AL
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
JMP 0x0015972c
LAB_0015966e:
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
MOVSX ECX,byte ptr [RBP + -0x23]
CMP EAX,ECX
JNZ 0x00159704
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x20010
CMP EAX,0x0
JZ 0x001596a3
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
SUB RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001596ab
LAB_001596a3:
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x70],RAX
LAB_001596ab:
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],RCX
LAB_001596c1:
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa8]
MOV CL,AL
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x40]
JNZ 0x001596c1
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00159796
LAB_00159704:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + 0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + 0x18]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + 0x18],RDX
MOV byte ptr [RAX],CL
LAB_0015972c:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0015959f
LAB_00159749:
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x38]
SUB RCX,RAX
MOV RAX,qword ptr [RBP + 0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + 0x28]
MOV qword ptr [RAX],RCX
LAB_00159762:
MOV RAX,qword ptr [RBP + 0x18]
CMP RAX,qword ptr [RBP + -0x40]
JZ 0x00159792
MOV RAX,qword ptr [RBP + 0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x20],RCX
MOV byte ptr [RAX],0x20
MOV RAX,qword ptr [RBP + 0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + 0x18],RCX
MOV byte ptr [RAX],0x20
JMP 0x00159762
LAB_00159792:
MOV byte ptr [RBP + -0x1],0x0
LAB_00159796:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int8
my_like_range_simple
(long param_1,char *param_2,long param_3,char param_4,char param_5,char param_6,
ulong param_7,char *param_8,char *param_9,ulong *param_10,ulong *param_11)
{
char cVar1;
char *pcVar2;
char *pcVar3;
ulong uVar4;
bool bVar5;
ulong local_78;
ulong local_50;
char *local_20;
pcVar3 = param_8;
pcVar2 = param_8 + param_7;
local_50 = param_7 / *(uint *)(param_1 + 0x9c);
local_20 = param_2;
while( true ) {
bVar5 = false;
if ((local_20 != param_2 + param_3) && (bVar5 = false, param_8 != pcVar2)) {
bVar5 = local_50 != 0;
}
if (!bVar5) break;
if ((*local_20 == param_4) && (local_20 + 1 != param_2 + param_3)) {
local_20 = local_20 + 1;
cVar1 = *local_20;
*param_9 = cVar1;
*param_8 = cVar1;
}
else if (*local_20 == param_5) {
*param_8 = '\0';
*param_9 = (char)*(int8 *)(param_1 + 0xa8);
}
else {
if (*local_20 == param_6) {
if ((*(uint *)(param_1 + 0xc) & 0x20010) == 0) {
local_78 = param_7;
}
else {
local_78 = (long)param_8 - (long)pcVar3;
}
*param_10 = local_78;
*param_11 = param_7;
do {
pcVar3 = param_8 + 1;
*param_8 = '\0';
*param_9 = (char)*(int8 *)(param_1 + 0xa8);
param_8 = pcVar3;
param_9 = param_9 + 1;
} while (pcVar3 != pcVar2);
return 0;
}
cVar1 = *local_20;
*param_9 = cVar1;
*param_8 = cVar1;
}
param_9 = param_9 + 1;
param_8 = param_8 + 1;
local_20 = local_20 + 1;
local_50 = local_50 - 1;
}
uVar4 = (long)param_8 - (long)pcVar3;
*param_11 = uVar4;
*param_10 = uVar4;
while (param_8 != pcVar2) {
*param_9 = ' ';
*param_8 = ' ';
param_8 = param_8 + 1;
param_9 = param_9 + 1;
}
return 0;
}
| |
24,535 | rope_yarn | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void rope_yarn(
float theta_extrap, float freq_scale, float corr_dims[2], int64_t i0, float ext_factor, float mscale,
float * cos_theta, float * sin_theta) {
// Get n-d rotational scaling corrected for extrapolation
float theta_interp = freq_scale * theta_extrap;
float theta = theta_interp;
if (ext_factor != 0.0f) {
float ramp_mix = rope_yarn_ramp(corr_dims[0], corr_dims[1], i0) * ext_factor;
theta = theta_interp * (1 - ramp_mix) + theta_extrap * ramp_mix;
// Get n-d magnitude scaling corrected for interpolation
mscale *= 1.0f + 0.1f * logf(1.0f / freq_scale);
}
*cos_theta = cosf(theta) * mscale;
*sin_theta = sinf(theta) * mscale;
} | O1 | c | rope_yarn:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
vmulss %xmm1, %xmm0, %xmm8
vxorps %xmm7, %xmm7, %xmm7
vucomiss %xmm7, %xmm2
vmovss %xmm3, (%rsp)
jne 0x27903
jnp 0x2798a
vmovss (%rdi), %xmm4
vmovss 0x4(%rdi), %xmm5
movl %esi, %eax
shrl $0x1f, %eax
addl %esi, %eax
sarl %eax
vcvtsi2ss %eax, %xmm6, %xmm6
vsubss %xmm4, %xmm6, %xmm6
vsubss %xmm4, %xmm5, %xmm4
vmovss 0xed33(%rip), %xmm5 # 0x3665c
vmaxss %xmm4, %xmm5, %xmm4
vdivss %xmm4, %xmm6, %xmm4
vmaxss %xmm4, %xmm7, %xmm3
vmovss 0xecb7(%rip), %xmm4 # 0x365f4
vminss %xmm3, %xmm4, %xmm3
vsubss %xmm3, %xmm4, %xmm3
vmulss %xmm2, %xmm3, %xmm2
vsubss %xmm2, %xmm4, %xmm3
vmulss %xmm0, %xmm2, %xmm0
vfmadd231ss %xmm3, %xmm8, %xmm0 # xmm0 = (xmm8 * xmm3) + xmm0
vmovss %xmm0, 0x4(%rsp)
vdivss %xmm1, %xmm4, %xmm0
callq 0x8b50
vmovss 0xec87(%rip), %xmm1 # 0x365f4
vfmadd132ss 0xecea(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
vmovss (%rsp), %xmm1
vmulss %xmm1, %xmm0, %xmm1
vmovss %xmm1, (%rsp)
vmovss 0x4(%rsp), %xmm8
vmovss %xmm8, 0x4(%rsp)
vmovaps %xmm8, %xmm0
callq 0x8420
vmulss (%rsp), %xmm0, %xmm0
vmovss %xmm0, (%r14)
vmovss 0x4(%rsp), %xmm0
callq 0x8510
vmulss (%rsp), %xmm0, %xmm0
vmovss %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| rope_yarn:
push r14
push rbx
push rax
mov rbx, rcx
mov r14, rdx
vmulss xmm8, xmm0, xmm1
vxorps xmm7, xmm7, xmm7
vucomiss xmm2, xmm7
vmovss [rsp+18h+var_18], xmm3
jnz short loc_27903
jnp loc_2798A
loc_27903:
vmovss xmm4, dword ptr [rdi]
vmovss xmm5, dword ptr [rdi+4]
mov eax, esi
shr eax, 1Fh
add eax, esi
sar eax, 1
vcvtsi2ss xmm6, xmm6, eax
vsubss xmm6, xmm6, xmm4
vsubss xmm4, xmm5, xmm4
vmovss xmm5, cs:dword_3665C
vmaxss xmm4, xmm5, xmm4
vdivss xmm4, xmm6, xmm4
vmaxss xmm3, xmm7, xmm4
vmovss xmm4, cs:dword_365F4
vminss xmm3, xmm4, xmm3
vsubss xmm3, xmm4, xmm3
vmulss xmm2, xmm3, xmm2
vsubss xmm3, xmm4, xmm2
vmulss xmm0, xmm2, xmm0
vfmadd231ss xmm0, xmm8, xmm3
vmovss [rsp+18h+var_14], xmm0
vdivss xmm0, xmm4, xmm1
call _logf
vmovss xmm1, cs:dword_365F4
vfmadd132ss xmm0, xmm1, cs:dword_36660
vmovss xmm1, [rsp+18h+var_18]
vmulss xmm1, xmm0, xmm1
vmovss [rsp+18h+var_18], xmm1
vmovss xmm8, [rsp+18h+var_14]
loc_2798A:
vmovss [rsp+18h+var_14], xmm8
vmovaps xmm0, xmm8
call _cosf
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [r14], xmm0
vmovss xmm0, [rsp+18h+var_14]
call _sinf
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [rbx], xmm0
add rsp, 8
pop rbx
pop r14
retn
| void rope_yarn(
long long _RDI,
__m128 _XMM0,
double a3,
__m128 _XMM2,
__m128 _XMM3,
double a6,
double a7,
__m128 _XMM6,
__m128 _XMM7,
long long a10,
long long a11,
long long a12)
{
char v12; // zf
char v13; // pf
_RBX = a12;
_R14 = a11;
__asm
{
vmulss xmm8, xmm0, xmm1
vxorps xmm7, xmm7, xmm7
vucomiss xmm2, xmm7
vmovss [rsp+18h+var_18], xmm3
}
if ( !v12 || v13 )
{
__asm
{
vmovss xmm4, dword ptr [rdi]
vmovss xmm5, dword ptr [rdi+4]
vcvtsi2ss xmm6, xmm6, eax
vsubss xmm6, xmm6, xmm4
vsubss xmm4, xmm5, xmm4
vmovss xmm5, cs:dword_3665C
vmaxss xmm4, xmm5, xmm4
vdivss xmm4, xmm6, xmm4
vmaxss xmm3, xmm7, xmm4
vmovss xmm4, cs:dword_365F4
vminss xmm3, xmm4, xmm3
vsubss xmm3, xmm4, xmm3
vmulss xmm2, xmm3, xmm2
vsubss xmm3, xmm4, xmm2
vmulss xmm0, xmm2, xmm0
vfmadd231ss xmm0, xmm8, xmm3
vmovss [rsp+18h+var_14], xmm0
vdivss xmm0, xmm4, xmm1
}
*(double *)&_XMM0 = logf(*(double *)&_XMM0);
__asm
{
vmovss xmm1, cs:dword_365F4
vfmadd132ss xmm0, xmm1, cs:dword_36660
vmovss xmm1, [rsp+18h+var_18]
vmulss xmm1, xmm0, xmm1
vmovss [rsp+18h+var_18], xmm1
vmovss xmm8, [rsp+18h+var_14]
}
}
__asm
{
vmovss [rsp+18h+var_14], xmm8
vmovaps xmm0, xmm8
}
*(double *)&_XMM0 = cosf(*(double *)&_XMM0);
__asm
{
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [r14], xmm0
vmovss xmm0, [rsp+18h+var_14]
}
*(double *)&_XMM0 = sinf(*(double *)&_XMM0);
__asm
{
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [rbx], xmm0
}
}
| rope_yarn:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
VMULSS XMM8,XMM0,XMM1
VXORPS XMM7,XMM7,XMM7
VUCOMISS XMM2,XMM7
VMOVSS dword ptr [RSP],XMM3
JNZ 0x00127903
JNP 0x0012798a
LAB_00127903:
VMOVSS XMM4,dword ptr [RDI]
VMOVSS XMM5,dword ptr [RDI + 0x4]
MOV EAX,ESI
SHR EAX,0x1f
ADD EAX,ESI
SAR EAX,0x1
VCVTSI2SS XMM6,XMM6,EAX
VSUBSS XMM6,XMM6,XMM4
VSUBSS XMM4,XMM5,XMM4
VMOVSS XMM5,dword ptr [0x0013665c]
VMAXSS XMM4,XMM5,XMM4
VDIVSS XMM4,XMM6,XMM4
VMAXSS XMM3,XMM7,XMM4
VMOVSS XMM4,dword ptr [0x001365f4]
VMINSS XMM3,XMM4,XMM3
VSUBSS XMM3,XMM4,XMM3
VMULSS XMM2,XMM3,XMM2
VSUBSS XMM3,XMM4,XMM2
VMULSS XMM0,XMM2,XMM0
VFMADD231SS XMM0,XMM8,XMM3
VMOVSS dword ptr [RSP + 0x4],XMM0
VDIVSS XMM0,XMM4,XMM1
CALL 0x00108b50
VMOVSS XMM1,dword ptr [0x001365f4]
VFMADD132SS XMM0,XMM1,dword ptr [0x00136660]
VMOVSS XMM1,dword ptr [RSP]
VMULSS XMM1,XMM0,XMM1
VMOVSS dword ptr [RSP],XMM1
VMOVSS XMM8,dword ptr [RSP + 0x4]
LAB_0012798a:
VMOVSS dword ptr [RSP + 0x4],XMM8
VMOVAPS XMM0,XMM8
CALL 0x00108420
VMULSS XMM0,XMM0,dword ptr [RSP]
VMOVSS dword ptr [R14],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x00108510
VMULSS XMM0,XMM0,dword ptr [RSP]
VMOVSS dword ptr [RBX],XMM0
ADD RSP,0x8
POP RBX
POP R14
RET
|
void rope_yarn(float param_1,float param_2,float param_3,float param_4,float *param_5,int param_6,
float *param_7,float *param_8)
{
int1 auVar1 [16];
float fVar2;
float fVar3;
int1 auVar4 [64];
int1 extraout_var [60];
fVar3 = param_1 * param_2;
if ((param_3 != 0.0) || (NAN(param_3))) {
auVar1 = vmaxss_avx(ZEXT416(DAT_0013665c),ZEXT416((uint)(param_5[1] - *param_5)));
auVar1 = vmaxss_avx(ZEXT816(0) << 0x40,
ZEXT416((uint)(((float)(param_6 / 2) - *param_5) / auVar1._0_4_)));
auVar1 = vminss_avx(ZEXT416((uint)DAT_001365f4),auVar1);
param_3 = (DAT_001365f4 - auVar1._0_4_) * param_3;
auVar1 = vfmadd231ss_fma(ZEXT416((uint)(param_3 * param_1)),ZEXT416((uint)fVar3),
ZEXT416((uint)(DAT_001365f4 - param_3)));
fVar3 = auVar1._0_4_;
auVar4._0_4_ = logf(DAT_001365f4 / param_2);
auVar4._4_60_ = extraout_var;
auVar1 = vfmadd132ss_fma(auVar4._0_16_,ZEXT416((uint)DAT_001365f4),ZEXT416(DAT_00136660));
param_4 = auVar1._0_4_ * param_4;
}
fVar2 = cosf(fVar3);
*param_7 = fVar2 * param_4;
fVar3 = sinf(fVar3);
*param_8 = fVar3 * param_4;
return;
}
| |
24,536 | rope_yarn | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | static void rope_yarn(
float theta_extrap, float freq_scale, float corr_dims[2], int64_t i0, float ext_factor, float mscale,
float * cos_theta, float * sin_theta) {
// Get n-d rotational scaling corrected for extrapolation
float theta_interp = freq_scale * theta_extrap;
float theta = theta_interp;
if (ext_factor != 0.0f) {
float ramp_mix = rope_yarn_ramp(corr_dims[0], corr_dims[1], i0) * ext_factor;
theta = theta_interp * (1 - ramp_mix) + theta_extrap * ramp_mix;
// Get n-d magnitude scaling corrected for interpolation
mscale *= 1.0f + 0.1f * logf(1.0f / freq_scale);
}
*cos_theta = cosf(theta) * mscale;
*sin_theta = sinf(theta) * mscale;
} | O2 | c | rope_yarn:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
vmulss %xmm1, %xmm0, %xmm8
vxorps %xmm7, %xmm7, %xmm7
vucomiss %xmm7, %xmm2
vmovss %xmm3, (%rsp)
jne 0x2592b
jnp 0x259b1
vmovss (%rdi), %xmm4
vmovss 0x4(%rdi), %xmm5
pushq $0x2
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
vcvtsi2ss %eax, %xmm6, %xmm6
vsubss %xmm4, %xmm6, %xmm6
vsubss %xmm4, %xmm5, %xmm4
vmovss 0xdd5c(%rip), %xmm5 # 0x336ac
vmaxss %xmm4, %xmm5, %xmm4
vdivss %xmm4, %xmm6, %xmm4
vmaxss %xmm4, %xmm7, %xmm3
vmovss 0xdcdc(%rip), %xmm4 # 0x33640
vminss %xmm3, %xmm4, %xmm3
vsubss %xmm3, %xmm4, %xmm3
vmulss %xmm2, %xmm3, %xmm2
vsubss %xmm2, %xmm4, %xmm3
vmulss %xmm0, %xmm2, %xmm0
vfmadd231ss %xmm3, %xmm8, %xmm0 # xmm0 = (xmm8 * xmm3) + xmm0
vmovss %xmm0, 0x4(%rsp)
vdivss %xmm1, %xmm4, %xmm0
callq 0x8cd0
vmovss 0xdcac(%rip), %xmm1 # 0x33640
vfmadd132ss 0xdd13(%rip), %xmm1, %xmm0 # xmm0 = (xmm0 * mem) + xmm1
vmovss (%rsp), %xmm1
vmulss %xmm1, %xmm0, %xmm1
vmovss %xmm1, (%rsp)
vmovss 0x4(%rsp), %xmm8
vmovss %xmm8, 0x4(%rsp)
vmovaps %xmm8, %xmm0
callq 0x84e0
vmulss (%rsp), %xmm0, %xmm0
vmovss %xmm0, (%r14)
vmovss 0x4(%rsp), %xmm0
callq 0x85d0
vmulss (%rsp), %xmm0, %xmm0
vmovss %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| rope_yarn:
push r14
push rbx
push rax
mov rbx, rcx
mov r14, rdx
vmulss xmm8, xmm0, xmm1
vxorps xmm7, xmm7, xmm7
vucomiss xmm2, xmm7
vmovss [rsp+18h+var_18], xmm3
jnz short loc_2592B
jnp loc_259B1
loc_2592B:
vmovss xmm4, dword ptr [rdi]
vmovss xmm5, dword ptr [rdi+4]
push 2
pop rcx
mov eax, esi
cdq
idiv ecx
vcvtsi2ss xmm6, xmm6, eax
vsubss xmm6, xmm6, xmm4
vsubss xmm4, xmm5, xmm4
vmovss xmm5, cs:dword_336AC
vmaxss xmm4, xmm5, xmm4
vdivss xmm4, xmm6, xmm4
vmaxss xmm3, xmm7, xmm4
vmovss xmm4, dword ptr cs:byte_33640
vminss xmm3, xmm4, xmm3
vsubss xmm3, xmm4, xmm3
vmulss xmm2, xmm3, xmm2
vsubss xmm3, xmm4, xmm2
vmulss xmm0, xmm2, xmm0
vfmadd231ss xmm0, xmm8, xmm3
vmovss [rsp+18h+var_14], xmm0
vdivss xmm0, xmm4, xmm1
call _logf
vmovss xmm1, dword ptr cs:byte_33640
vfmadd132ss xmm0, xmm1, cs:dword_336B0
vmovss xmm1, [rsp+18h+var_18]
vmulss xmm1, xmm0, xmm1
vmovss [rsp+18h+var_18], xmm1
vmovss xmm8, [rsp+18h+var_14]
loc_259B1:
vmovss [rsp+18h+var_14], xmm8
vmovaps xmm0, xmm8
call _cosf
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [r14], xmm0
vmovss xmm0, [rsp+18h+var_14]
call _sinf
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [rbx], xmm0
add rsp, 8
pop rbx
pop r14
retn
| void rope_yarn(
long long _RDI,
long long a2,
long long a3,
long long a4,
__m128 _XMM0,
double a6,
__m128 _XMM2,
__m128 _XMM3,
double a9,
double a10,
__m128 _XMM6,
__m128 _XMM7)
{
char v12; // zf
char v13; // pf
long long v20; // rdx
_RBX = a4;
_R14 = a3;
__asm
{
vmulss xmm8, xmm0, xmm1
vxorps xmm7, xmm7, xmm7
vucomiss xmm2, xmm7
vmovss [rsp+18h+var_18], xmm3
}
if ( !v12 || v13 )
{
__asm
{
vmovss xmm4, dword ptr [rdi]
vmovss xmm5, dword ptr [rdi+4]
}
v20 = (unsigned int)((int)a2 >> 31);
LODWORD(v20) = (int)a2 % 2;
__asm
{
vcvtsi2ss xmm6, xmm6, eax
vsubss xmm6, xmm6, xmm4
vsubss xmm4, xmm5, xmm4
vmovss xmm5, cs:dword_336AC
vmaxss xmm4, xmm5, xmm4
vdivss xmm4, xmm6, xmm4
vmaxss xmm3, xmm7, xmm4
vmovss xmm4, dword ptr cs:byte_33640
vminss xmm3, xmm4, xmm3
vsubss xmm3, xmm4, xmm3
vmulss xmm2, xmm3, xmm2
vsubss xmm3, xmm4, xmm2
vmulss xmm0, xmm2, xmm0
vfmadd231ss xmm0, xmm8, xmm3
vmovss [rsp+18h+var_14], xmm0
vdivss xmm0, xmm4, xmm1
}
*(double *)&_XMM0 = logf(_RDI, a2, v20, *(double *)&_XMM0);
__asm
{
vmovss xmm1, dword ptr cs:byte_33640
vfmadd132ss xmm0, xmm1, cs:dword_336B0
vmovss xmm1, [rsp+18h+var_18]
vmulss xmm1, xmm0, xmm1
vmovss [rsp+18h+var_18], xmm1
vmovss xmm8, [rsp+18h+var_14]
}
}
__asm
{
vmovss [rsp+18h+var_14], xmm8
vmovaps xmm0, xmm8
}
*(double *)&_XMM0 = cosf(*(double *)&_XMM0);
__asm
{
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [r14], xmm0
vmovss xmm0, [rsp+18h+var_14]
}
*(double *)&_XMM0 = sinf(*(double *)&_XMM0);
__asm
{
vmulss xmm0, xmm0, [rsp+18h+var_18]
vmovss dword ptr [rbx], xmm0
}
}
| rope_yarn:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
VMULSS XMM8,XMM0,XMM1
VXORPS XMM7,XMM7,XMM7
VUCOMISS XMM2,XMM7
VMOVSS dword ptr [RSP],XMM3
JNZ 0x0012592b
JNP 0x001259b1
LAB_0012592b:
VMOVSS XMM4,dword ptr [RDI]
VMOVSS XMM5,dword ptr [RDI + 0x4]
PUSH 0x2
POP RCX
MOV EAX,ESI
CDQ
IDIV ECX
VCVTSI2SS XMM6,XMM6,EAX
VSUBSS XMM6,XMM6,XMM4
VSUBSS XMM4,XMM5,XMM4
VMOVSS XMM5,dword ptr [0x001336ac]
VMAXSS XMM4,XMM5,XMM4
VDIVSS XMM4,XMM6,XMM4
VMAXSS XMM3,XMM7,XMM4
VMOVSS XMM4,dword ptr [0x00133640]
VMINSS XMM3,XMM4,XMM3
VSUBSS XMM3,XMM4,XMM3
VMULSS XMM2,XMM3,XMM2
VSUBSS XMM3,XMM4,XMM2
VMULSS XMM0,XMM2,XMM0
VFMADD231SS XMM0,XMM8,XMM3
VMOVSS dword ptr [RSP + 0x4],XMM0
VDIVSS XMM0,XMM4,XMM1
CALL 0x00108cd0
VMOVSS XMM1,dword ptr [0x00133640]
VFMADD132SS XMM0,XMM1,dword ptr [0x001336b0]
VMOVSS XMM1,dword ptr [RSP]
VMULSS XMM1,XMM0,XMM1
VMOVSS dword ptr [RSP],XMM1
VMOVSS XMM8,dword ptr [RSP + 0x4]
LAB_001259b1:
VMOVSS dword ptr [RSP + 0x4],XMM8
VMOVAPS XMM0,XMM8
CALL 0x001084e0
VMULSS XMM0,XMM0,dword ptr [RSP]
VMOVSS dword ptr [R14],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x4]
CALL 0x001085d0
VMULSS XMM0,XMM0,dword ptr [RSP]
VMOVSS dword ptr [RBX],XMM0
ADD RSP,0x8
POP RBX
POP R14
RET
|
void rope_yarn(float param_1,float param_2,float param_3,float param_4,float *param_5,int param_6,
float *param_7,float *param_8)
{
int1 auVar1 [16];
float fVar2;
float fVar3;
int1 auVar4 [64];
int1 extraout_var [60];
fVar3 = param_1 * param_2;
if ((param_3 != 0.0) || (NAN(param_3))) {
auVar1 = vmaxss_avx(ZEXT416(DAT_001336ac),ZEXT416((uint)(param_5[1] - *param_5)));
auVar1 = vmaxss_avx(ZEXT816(0) << 0x40,
ZEXT416((uint)(((float)(param_6 / 2) - *param_5) / auVar1._0_4_)));
auVar1 = vminss_avx(ZEXT416((uint)DAT_00133640),auVar1);
param_3 = (DAT_00133640 - auVar1._0_4_) * param_3;
auVar1 = vfmadd231ss_fma(ZEXT416((uint)(param_3 * param_1)),ZEXT416((uint)fVar3),
ZEXT416((uint)(DAT_00133640 - param_3)));
fVar3 = auVar1._0_4_;
auVar4._0_4_ = logf(DAT_00133640 / param_2);
auVar4._4_60_ = extraout_var;
auVar1 = vfmadd132ss_fma(auVar4._0_16_,ZEXT416((uint)DAT_00133640),ZEXT416(DAT_001336b0));
param_4 = auVar1._0_4_ * param_4;
}
fVar2 = cosf(fVar3);
*param_7 = fVar2 * param_4;
fVar3 = sinf(fVar3);
*param_8 = fVar3 * param_4;
return;
}
| |
24,537 | ggml_compute_forward_soft_max_ext_back | monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c | static void ggml_compute_forward_soft_max_ext_back(
const struct ggml_compute_params * params,
struct ggml_tensor * dst) {
const struct ggml_tensor * src0 = dst->src[0];
switch (src0->type) {
case GGML_TYPE_F32:
{
ggml_compute_forward_soft_max_ext_back_f32(params, dst);
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O0 | c | ggml_compute_forward_soft_max_ext_back:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x165bb
jmp 0x165aa
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x31df0
jmp 0x165d5
leaq 0x9b598(%rip), %rdi # 0xb1b5a
movl $0x236e, %esi # imm = 0x236E
leaq 0x9b6f9(%rip), %rdx # 0xb1cc7
movb $0x0, %al
callq 0xd030
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| ggml_compute_forward_soft_max_ext_back:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rax, [rsp+18h+var_10]
mov rax, [rax+98h]
mov [rsp+18h+var_18], rax
mov rax, [rsp+18h+var_18]
mov eax, [rax]
test eax, eax
jnz short loc_165BB
jmp short $+2
loc_165AA:
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call ggml_compute_forward_soft_max_ext_back_f32
jmp short loc_165D5
loc_165BB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 236Eh
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_165D5:
add rsp, 18h
retn
| double ggml_compute_forward_soft_max_ext_back(long long a1, long long a2)
{
double result; // xmm0_8
if ( **(_DWORD **)(a2 + 152) )
return ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
9070LL,
"fatal error");
ggml_compute_forward_soft_max_ext_back_f32(a1, a2);
return result;
}
| ggml_compute_forward_soft_max_ext_back:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x001165bb
JMP 0x001165aa
LAB_001165aa:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00131df0
JMP 0x001165d5
LAB_001165bb:
LEA RDI,[0x1b1b5a]
MOV ESI,0x236e
LEA RDX,[0x1b1cc7]
MOV AL,0x0
CALL 0x0010d030
LAB_001165d5:
ADD RSP,0x18
RET
|
void ggml_compute_forward_soft_max_ext_back(int8 param_1,long param_2)
{
if (**(int **)(param_2 + 0x98) == 0) {
ggml_compute_forward_soft_max_ext_back_f32(param_1,param_2);
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x236e,"fatal error");
}
| |
24,538 | func_gb2312_uni_onechar | eloqsql/strings/ctype-gb2312.c | static int func_gb2312_uni_onechar(int code){
if ((code>=0x2121)&&(code<=0x2658))
return(tab_gb2312_uni0[code-0x2121]);
if ((code>=0x2721)&&(code<=0x296F))
return(tab_gb2312_uni1[code-0x2721]);
if ((code>=0x3021)&&(code<=0x777E))
return(tab_gb2312_uni2[code-0x3021]);
return(0);
} | O0 | c | func_gb2312_uni_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2121, -0x8(%rbp) # imm = 0x2121
jl 0x9af34
cmpl $0x2658, -0x8(%rbp) # imm = 0x2658
jg 0x9af34
movl -0x8(%rbp), %eax
subl $0x2121, %eax # imm = 0x2121
movslq %eax, %rcx
leaq 0xcfde5(%rip), %rax # 0x16ad10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x9af95
cmpl $0x2721, -0x8(%rbp) # imm = 0x2721
jl 0x9af61
cmpl $0x296f, -0x8(%rbp) # imm = 0x296F
jg 0x9af61
movl -0x8(%rbp), %eax
subl $0x2721, %eax # imm = 0x2721
movslq %eax, %rcx
leaq 0xd0828(%rip), %rax # 0x16b780
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x9af95
cmpl $0x3021, -0x8(%rbp) # imm = 0x3021
jl 0x9af8e
cmpl $0x777e, -0x8(%rbp) # imm = 0x777E
jg 0x9af8e
movl -0x8(%rbp), %eax
subl $0x3021, %eax # imm = 0x3021
movslq %eax, %rcx
leaq 0xd0c9b(%rip), %rax # 0x16bc20
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x9af95
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_gb2312_uni_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 2121h
jl short loc_9AF34
cmp [rbp+var_8], 2658h
jg short loc_9AF34
mov eax, [rbp+var_8]
sub eax, 2121h
movsxd rcx, eax
lea rax, tab_gb2312_uni0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_9AF95
loc_9AF34:
cmp [rbp+var_8], 2721h
jl short loc_9AF61
cmp [rbp+var_8], 296Fh
jg short loc_9AF61
mov eax, [rbp+var_8]
sub eax, 2721h
movsxd rcx, eax
lea rax, tab_gb2312_uni1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_9AF95
loc_9AF61:
cmp [rbp+var_8], 3021h
jl short loc_9AF8E
cmp [rbp+var_8], 777Eh
jg short loc_9AF8E
mov eax, [rbp+var_8]
sub eax, 3021h
movsxd rcx, eax
lea rax, tab_gb2312_uni2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_9AF95
loc_9AF8E:
mov [rbp+var_4], 0
loc_9AF95:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_gb2312_uni_onechar(int a1)
{
if ( a1 < 8481 || a1 > 9816 )
{
if ( a1 < 10017 || a1 > 10607 )
{
if ( a1 < 12321 || a1 > 30590 )
return 0;
else
return tab_gb2312_uni2[a1 - 12321];
}
else
{
return tab_gb2312_uni1[a1 - 10017];
}
}
else
{
return tab_gb2312_uni0[a1 - 8481];
}
}
| func_gb2312_uni_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0x2121
JL 0x0019af34
CMP dword ptr [RBP + -0x8],0x2658
JG 0x0019af34
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2121
MOVSXD RCX,EAX
LEA RAX,[0x26ad10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019af95
LAB_0019af34:
CMP dword ptr [RBP + -0x8],0x2721
JL 0x0019af61
CMP dword ptr [RBP + -0x8],0x296f
JG 0x0019af61
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2721
MOVSXD RCX,EAX
LEA RAX,[0x26b780]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019af95
LAB_0019af61:
CMP dword ptr [RBP + -0x8],0x3021
JL 0x0019af8e
CMP dword ptr [RBP + -0x8],0x777e
JG 0x0019af8e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3021
MOVSXD RCX,EAX
LEA RAX,[0x26bc20]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019af95
LAB_0019af8e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0019af95:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_gb2312_uni_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0x2121) || (0x2658 < param_1)) {
if ((param_1 < 0x2721) || (0x296f < param_1)) {
if ((param_1 < 0x3021) || (0x777e < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni2 + (long)(param_1 + -0x3021) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni1 + (long)(param_1 + -0x2721) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni0 + (long)(param_1 + -0x2121) * 2);
}
return uVar1;
}
| |
24,539 | JS_GetPropertyStr | bluesky950520[P]quickjs/quickjs.c | JSValue JS_GetPropertyStr(JSContext *ctx, JSValue this_obj,
const char *prop)
{
JSAtom atom;
JSValue ret;
atom = JS_NewAtom(ctx, prop);
ret = JS_GetProperty(ctx, this_obj, atom);
JS_FreeAtom(ctx, atom);
return ret;
} | O3 | c | JS_GetPropertyStr:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rdi
callq 0xe240
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1f8ef
movl %eax, %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %eax, %ecx
movq %r15, %r8
movq %r14, %r9
pushq $0x0
pushq $0x0
callq 0x22c0f
addq $0x10, %rsp
movq %rax, %r14
movq %rdx, %r15
movq %r12, %rdi
movl %ebx, %esi
callq 0x202f5
movq %r14, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| JS_GetPropertyStr:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
mov rdi, rcx
call _strlen
mov rdi, r12
mov rsi, rbx
mov rdx, rax
call JS_NewAtomLen
mov ebx, eax
mov rdi, r12
mov rsi, r15
mov rdx, r14
mov ecx, eax
mov r8, r15
mov r9, r14
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r14, rax
mov r15, rdx
mov rdi, r12
mov esi, ebx
call JS_FreeAtom
mov rax, r14
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| unsigned long long JS_GetPropertyStr(long long a1, long long a2, long long a3, unsigned __int8 *a4)
{
unsigned __int8 *v4; // rbx
long long v6; // rax
unsigned long long PropertyInternal2; // r14
v4 = a4;
v6 = strlen(a4);
LODWORD(v4) = JS_NewAtomLen(a1, v4, v6);
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, (unsigned int)v4, a2, a3, 0LL, 0);
JS_FreeAtom(a1, (int)v4);
return PropertyInternal2;
}
| JS_GetPropertyStr:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
MOV RDI,RCX
CALL 0x0010e240
MOV RDI,R12
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0011f8ef
MOV EBX,EAX
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
MOV ECX,EAX
MOV R8,R15
MOV R9,R14
PUSH 0x0
PUSH 0x0
CALL 0x00122c0f
ADD RSP,0x10
MOV R14,RAX
MOV R15,RDX
MOV RDI,R12
MOV ESI,EBX
CALL 0x001202f5
MOV RAX,R14
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16]
JS_GetPropertyStr(int8 param_1,int8 param_2,int8 param_3,char *param_4)
{
int4 uVar1;
size_t sVar2;
int1 auVar3 [16];
sVar2 = strlen(param_4);
uVar1 = JS_NewAtomLen(param_1,param_4,sVar2);
auVar3 = JS_GetPropertyInternal2(param_1,param_2,param_3,uVar1,param_2,param_3,0,0);
JS_FreeAtom(param_1,uVar1);
return auVar3;
}
| |
24,540 | test::test(cmd_params_instance const&, llama_model const*, llama_context const*) | llama.cpp/examples/llama-bench/llama-bench.cpp | test(const cmd_params_instance & inst, const llama_model * lmodel, const llama_context * ctx) :
cpu_info(get_cpu_info()),
gpu_info(get_gpu_info()) {
model_filename = inst.model;
char buf[128];
llama_model_desc(lmodel, buf, sizeof(buf));
model_type = buf;
model_size = llama_model_size(lmodel);
model_n_params = llama_model_n_params(lmodel);
n_batch = inst.n_batch;
n_ubatch = inst.n_ubatch;
n_threads = inst.n_threads;
cpu_mask = inst.cpu_mask;
cpu_strict = inst.cpu_strict;
poll = inst.poll;
type_k = inst.type_k;
type_v = inst.type_v;
n_gpu_layers = inst.n_gpu_layers;
split_mode = inst.split_mode;
main_gpu = inst.main_gpu;
no_kv_offload = inst.no_kv_offload;
flash_attn = inst.flash_attn;
tensor_split = inst.tensor_split;
use_mmap = inst.use_mmap;
embeddings = inst.embeddings;
n_prompt = inst.n_prompt;
n_gen = inst.n_gen;
// RFC 3339 date-time format
time_t t = time(NULL);
std::strftime(buf, sizeof(buf), "%FT%TZ", gmtime(&t));
test_time = buf;
(void) ctx;
} | O3 | cpp | test::test(cmd_params_instance const&, llama_model const*, llama_context const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
xorl %r13d, %r13d
leaq 0x60(%rsp), %r15
leaq 0x7(%rsp), %rbp
callq 0x16870
cmpq %rax, %r13
jae 0x1dda9
movq %r13, %rdi
callq 0x165c0
movq %rax, %r14
movq %rax, %rdi
callq 0x16670
testl $0xfffffffd, %eax # imm = 0xFFFFFFFD
jne 0x1dda4
movq %r14, %rdi
callq 0x16730
movq %r15, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x1d42c
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f1fe
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x1dda4
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x16100
incq %r13
jmp 0x1dd43
leaq 0x60(%rsp), %rdx
leaq 0x70(%rsp), %r15
movq %r15, (%rdx)
movw $0x202c, 0x10(%rdx) # imm = 0x202C
movq $0x2, 0x8(%rdx)
movb $0x0, 0x12(%rdx)
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x1cb63
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x1ddec
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x16100
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x1d80c
leaq 0x20(%rbx), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
xorl %ebp, %ebp
leaq 0x60(%rsp), %r15
leaq 0x7(%rsp), %r12
callq 0x16870
cmpq %rax, %rbp
jae 0x1de82
movq %rbp, %rdi
callq 0x165c0
movq %rax, %r14
movq %rax, %rdi
callq 0x16670
cmpl $0x1, %eax
jne 0x1de7d
movq %r14, %rdi
callq 0x16730
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1d42c
movq %r13, %rdi
movq %r15, %rsi
callq 0x1f1fe
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x1de7d
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x16100
incq %rbp
jmp 0x1de1e
leaq 0x60(%rsp), %rdx
leaq 0x70(%rsp), %r15
movq %r15, (%rdx)
movw $0x202c, 0x10(%rdx) # imm = 0x202C
movq $0x2, 0x8(%rdx)
movb $0x0, 0x12(%rdx)
leaq 0x40(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x1cb63
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x1dec7
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x16100
leaq 0x40(%rsp), %rdi
callq 0x1d80c
leaq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
movq %rax, 0x30(%rsp)
movq %rax, 0x40(%rbx)
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movb %al, 0x50(%rbx)
leaq 0x60(%rbx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x28(%rsp)
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movb %al, 0x70(%rbx)
leaq 0xa0(%rbx), %rcx
movq %rcx, 0x38(%rsp)
leaq 0xb0(%rbx), %rcx
movq %rcx, 0x20(%rsp)
movq %rcx, 0xa0(%rbx)
movq %rax, 0xa8(%rbx)
movb %al, 0xb0(%rbx)
leaq 0xe0(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%rbx)
movq %rax, 0xf0(%rbx)
leaq 0x108(%rbx), %r13
leaq 0x118(%rbx), %rbp
movq %rbp, 0x108(%rbx)
movq %rax, 0x110(%rbx)
movb %al, 0x118(%rbx)
movups %xmm0, 0x128(%rbx)
movq %rax, 0x138(%rbx)
movq %rdi, 0x58(%rsp)
movq 0x10(%rsp), %rsi
callq 0x16d00
leaq 0x60(%rsp), %rsi
movl $0x80, %edx
movq 0x18(%rsp), %rdi
callq 0x16ca0
movq 0x68(%rbx), %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x16440
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x16590
movq 0x18(%rsp), %rdi
callq 0x161c0
movq %rax, 0x80(%rbx)
movq 0x18(%rsp), %rdi
callq 0x16040
movq %rax, 0x88(%rbx)
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rax
movq %rax, 0x90(%rbx)
movl 0x38(%rcx), %eax
movl %eax, 0x98(%rbx)
leaq 0x40(%rcx), %rsi
movq 0x38(%rsp), %rdi
callq 0x16d00
movq 0x10(%rsp), %rcx
movb 0x60(%rcx), %al
movb %al, 0xc0(%rbx)
movl 0x64(%rcx), %eax
movl %eax, 0xc4(%rbx)
movq 0x30(%rcx), %rax
movq %rax, 0xc8(%rbx)
movl 0x68(%rcx), %eax
movl %eax, 0xd0(%rbx)
movq 0x90(%rcx), %rax
movq %rax, 0xd4(%rbx)
movb 0x98(%rcx), %al
movb %al, 0xdc(%rbx)
movb 0x99(%rcx), %al
movb %al, 0xdd(%rbx)
leaq 0xa0(%rcx), %rsi
movq %r12, %rdi
callq 0x2ea54
movq 0x10(%rsp), %rcx
movb 0xb8(%rcx), %al
movb %al, 0xf8(%rbx)
movb 0xb9(%rcx), %al
movb %al, 0xf9(%rbx)
movq 0x20(%rcx), %rax
movq %rax, 0xfc(%rbx)
xorl %edi, %edi
callq 0x16840
leaq 0x40(%rsp), %rdi
movq %rax, (%rdi)
callq 0x16270
leaq 0x227eb(%rip), %rdx # 0x4089c
leaq 0x60(%rsp), %r14
movl $0x80, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x16a80
movq 0x110(%rbx), %r15
movq %r14, %rdi
callq 0x16440
movq %r13, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x16590
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e12a
jmp 0x1e12a
movq %rax, %r14
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
jne 0x1e226
jmp 0x1e244
movq %rax, %r14
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
jne 0x1e201
jmp 0x1e26a
movq %rax, %r14
leaq 0x128(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1e14b
movq 0x138(%rbx), %rsi
subq %rdi, %rsi
callq 0x16100
movq (%r13), %rdi
cmpq %rbp, %rdi
je 0x1e160
movq (%rbp), %rsi
incq %rsi
callq 0x16100
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1e178
movq 0xf0(%rbx), %rsi
subq %rdi, %rsi
callq 0x16100
movq 0x38(%rsp), %rax
movq (%rax), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1e197
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x16100
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x28(%rsp), %rdi
je 0x1e1b6
movq 0x28(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x16100
movq 0x58(%rsp), %rax
movq (%rax), %rdi
cmpq 0x30(%rsp), %rdi
je 0x1e1d5
movq 0x30(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x16100
movq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x1e24e
movq (%rax), %rsi
incq %rsi
callq 0x16100
jmp 0x1e24e
movq %rax, %r14
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x1e26a
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x16100
jmp 0x1e26a
jmp 0x1e267
jmp 0x1e267
movq %rax, %r14
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x1e244
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x16100
jmp 0x1e244
jmp 0x1e241
jmp 0x1e241
jmp 0x1e241
jmp 0x1e241
jmp 0x1e267
jmp 0x1e267
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x1d80c
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x1e274
movq (%rbx), %rsi
incq %rsi
callq 0x16100
jmp 0x1e274
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x1d80c
movq %r14, %rdi
callq 0x16720
| _ZN4testC2ERK19cmd_params_instancePK11llama_modelPK13llama_context:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_100], rdx
mov [rsp+118h+var_108], rsi
mov rbx, rdi
xorps xmm0, xmm0
lea r12, [rsp+118h+var_D8]
movaps xmmword ptr [r12], xmm0
mov qword ptr [r12+10h], 0
xor r13d, r13d
lea r15, [rsp+118h+var_B8]
lea rbp, [rsp+118h+var_111]
loc_1DD43:
call _ggml_backend_dev_count
cmp r13, rax
jnb short loc_1DDA9
mov rdi, r13
call _ggml_backend_dev_get
mov r14, rax
mov rdi, rax
call _ggml_backend_dev_type
test eax, 0FFFFFFFDh
jnz short loc_1DDA4
mov rdi, r14
call _ggml_backend_dev_description
mov rdi, r15
mov rsi, rax
mov rdx, rbp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+118h+var_B8]; void *
lea rax, [rsp+118h+var_A8]
cmp rdi, rax
jz short loc_1DDA4
mov rsi, [rsp+118h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DDA4:
inc r13
jmp short loc_1DD43
loc_1DDA9:
lea rdx, [rsp+118h+var_B8]
lea r15, [rsp+118h+var_A8]
mov [rdx], r15
mov word ptr [rdx+10h], 202Ch
mov qword ptr [rdx+8], 2
mov byte ptr [rdx+12h], 0
lea rsi, [rsp+118h+var_D8]
mov rdi, rbx
call _ZL4joinINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEES5_RKSt6vectorIT_SaIS7_EERKS5_; join<std::string>(std::vector<std::string> const&,std::string const&)
mov rdi, [rsp+118h+var_B8]; void *
cmp rdi, r15
jz short loc_1DDEC
mov rsi, [rsp+118h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DDEC:
lea r13, [rsp+118h+var_D8]
mov rdi, r13; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rax, [rbx+20h]
mov [rsp+118h+var_110], rax
xorps xmm0, xmm0
movaps xmmword ptr [r13+0], xmm0
mov qword ptr [r13+10h], 0
xor ebp, ebp
lea r15, [rsp+118h+var_B8]
lea r12, [rsp+118h+var_111]
loc_1DE1E:
call _ggml_backend_dev_count
cmp rbp, rax
jnb short loc_1DE82
mov rdi, rbp
call _ggml_backend_dev_get
mov r14, rax
mov rdi, rax
call _ggml_backend_dev_type
cmp eax, 1
jnz short loc_1DE7D
mov rdi, r14
call _ggml_backend_dev_description
mov rdi, r15
mov rsi, rax
mov rdx, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, r13
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+118h+var_B8]; void *
lea rax, [rsp+118h+var_A8]
cmp rdi, rax
jz short loc_1DE7D
mov rsi, [rsp+118h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DE7D:
inc rbp
jmp short loc_1DE1E
loc_1DE82:
lea rdx, [rsp+118h+var_B8]
lea r15, [rsp+118h+var_A8]
mov [rdx], r15
mov word ptr [rdx+10h], 202Ch
mov qword ptr [rdx+8], 2
mov byte ptr [rdx+12h], 0
lea rsi, [rsp+118h+var_D8]
mov rdi, [rsp+118h+var_110]
call _ZL4joinINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEES5_RKSt6vectorIT_SaIS7_EERKS5_; join<std::string>(std::vector<std::string> const&,std::string const&)
mov rdi, [rsp+118h+var_B8]; void *
cmp rdi, r15
jz short loc_1DEC7
mov rsi, [rsp+118h+var_A8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1DEC7:
lea rdi, [rsp+118h+var_D8]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rbx+40h]
lea rax, [rbx+50h]
mov [rsp+118h+var_E8], rax
mov [rbx+40h], rax
xor eax, eax
mov [rbx+48h], rax
mov [rbx+50h], al
lea rcx, [rbx+60h]
mov [rsp+118h+var_110], rcx
lea rcx, [rbx+70h]
mov [rsp+118h+var_F0], rcx
mov [rbx+60h], rcx
mov [rbx+68h], rax
mov [rbx+70h], al
lea rcx, [rbx+0A0h]
mov [rsp+118h+var_E0], rcx
lea rcx, [rbx+0B0h]
mov [rsp+118h+var_F8], rcx
mov [rbx+0A0h], rcx
mov [rbx+0A8h], rax
mov [rbx+0B0h], al
lea r12, [rbx+0E0h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+0E0h], xmm0
mov [rbx+0F0h], rax
lea r13, [rbx+108h]
lea rbp, [rbx+118h]
mov [rbx+108h], rbp
mov [rbx+110h], rax
mov [rbx+118h], al
movups xmmword ptr [rbx+128h], xmm0
mov [rbx+138h], rax
mov [rsp+118h+var_C0], rdi
mov rsi, [rsp+118h+var_108]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
lea rsi, [rsp+118h+var_B8]
mov edx, 80h
mov rdi, [rsp+118h+var_100]
call _llama_model_desc
mov r14, [rbx+68h]
lea r15, [rsp+118h+var_B8]
mov rdi, r15
call _strlen
mov rdi, [rsp+118h+var_110]
xor esi, esi
mov rdx, r14
mov rcx, r15
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
mov rdi, [rsp+118h+var_100]
call _llama_model_size
mov [rbx+80h], rax
mov rdi, [rsp+118h+var_100]
call _llama_model_n_params
mov [rbx+88h], rax
mov rcx, [rsp+118h+var_108]
mov rax, [rcx+28h]
mov [rbx+90h], rax
mov eax, [rcx+38h]
mov [rbx+98h], eax
lea rsi, [rcx+40h]
mov rdi, [rsp+118h+var_E0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
mov rcx, [rsp+118h+var_108]
mov al, [rcx+60h]
mov [rbx+0C0h], al
mov eax, [rcx+64h]
mov [rbx+0C4h], eax
mov rax, [rcx+30h]
mov [rbx+0C8h], rax
mov eax, [rcx+68h]
mov [rbx+0D0h], eax
mov rax, [rcx+90h]
mov [rbx+0D4h], rax
mov al, [rcx+98h]
mov [rbx+0DCh], al
mov al, [rcx+99h]
mov [rbx+0DDh], al
lea rsi, [rcx+0A0h]
mov rdi, r12
call _ZNSt6vectorIfSaIfEEaSERKS1_; std::vector<float>::operator=(std::vector<float> const&)
mov rcx, [rsp+118h+var_108]
mov al, [rcx+0B8h]
mov [rbx+0F8h], al
mov al, [rcx+0B9h]
mov [rbx+0F9h], al
mov rax, [rcx+20h]
mov [rbx+0FCh], rax
xor edi, edi
call _time
lea rdi, [rsp+118h+var_D8]
mov [rdi], rax
call _gmtime
lea rdx, aFtTz; "%FT%TZ"
lea r14, [rsp+118h+var_B8]
mov esi, 80h
mov rdi, r14
mov rcx, rax
call _strftime
mov r15, [rbx+110h]
mov rdi, r14
call _strlen
mov rdi, r13
xor esi, esi
mov rdx, r15
mov rcx, r14
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_1E12A
jmp short loc_1E12A
mov r14, rax
mov rdi, [rsp+arg_58]
cmp rdi, r15
jnz loc_1E226
jmp loc_1E244
mov r14, rax
mov rdi, [rsp+arg_58]
cmp rdi, r15
jnz loc_1E201
jmp loc_1E26A
loc_1E12A:
mov r14, rax
lea rax, [rbx+128h]
mov rdi, [rax]; void *
test rdi, rdi
jz short loc_1E14B
mov rsi, [rbx+138h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E14B:
mov rdi, [r13+0]; void *
cmp rdi, rbp
jz short loc_1E160
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E160:
mov rdi, [r12]; void *
test rdi, rdi
jz short loc_1E178
mov rsi, [rbx+0F0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E178:
mov rax, [rsp+arg_30]
mov rdi, [rax]; void *
cmp rdi, [rsp+arg_18]
jz short loc_1E197
mov rax, [rsp+arg_18]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E197:
mov rax, [rsp+arg_0]
mov rdi, [rax]; void *
cmp rdi, [rsp+arg_20]
jz short loc_1E1B6
mov rax, [rsp+arg_20]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E1B6:
mov rax, [rsp+arg_50]
mov rdi, [rax]; void *
cmp rdi, [rsp+arg_28]
jz short loc_1E1D5
mov rax, [rsp+arg_28]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1E1D5:
mov rdi, [rbx+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_1E24E
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E24E
mov r14, rax
mov rdi, [rsp+arg_58]; void *
lea rax, [rsp+arg_68]
cmp rdi, rax
jz short loc_1E26A
loc_1E201:
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E26A
jmp short loc_1E267
jmp short loc_1E267
mov r14, rax
mov rdi, [rsp+arg_58]; void *
lea rax, [rsp+arg_68]
cmp rdi, rax
jz short loc_1E244
loc_1E226:
mov rsi, [rsp+arg_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E244
jmp short loc_1E241
jmp short loc_1E241
jmp short loc_1E241
jmp short loc_1E241
jmp short loc_1E267
jmp short loc_1E267
loc_1E241:
mov r14, rax
loc_1E244:
lea rdi, [rsp+arg_38]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_1E24E:
mov rdi, [rbx]; void *
add rbx, 10h
cmp rdi, rbx
jz short loc_1E274
mov rsi, [rbx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1E274
loc_1E267:
mov r14, rax
loc_1E26A:
lea rdi, [rsp+arg_38]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_1E274:
mov rdi, r14
call __Unwind_Resume
| long long test::test(long long a1, long long a2, long long a3)
{
unsigned long long i; // r13
long long v4; // r14
long long v5; // rax
unsigned long long j; // rbp
long long v7; // r14
long long v8; // rax
long long v9; // r14
long long v10; // rax
long long v11; // rax
long long v12; // r15
long long v13; // rax
__int128 v16; // [rsp+40h] [rbp-D8h] BYREF
long long v17; // [rsp+50h] [rbp-C8h]
long long v18; // [rsp+58h] [rbp-C0h]
void *v19; // [rsp+60h] [rbp-B8h] BYREF
long long v20; // [rsp+68h] [rbp-B0h]
char v21[168]; // [rsp+70h] [rbp-A8h] BYREF
v16 = 0LL;
v17 = 0LL;
for ( i = 0LL; i < ggml_backend_dev_count(); ++i )
{
v4 = ggml_backend_dev_get(i);
if ( (ggml_backend_dev_type(v4) & 0xFFFFFFFD) == 0 )
{
v5 = ggml_backend_dev_description(v4);
std::string::basic_string<std::allocator<char>>(&v19, v5);
std::vector<std::string>::emplace_back<std::string>(&v16, &v19);
if ( v19 != v21 )
operator delete(v19, *(_QWORD *)v21 + 1LL);
}
}
v19 = v21;
strcpy(v21, ", ");
v20 = 2LL;
join<std::string>(a1, (long long *)&v16, &v19);
if ( v19 != v21 )
operator delete(v19, *(_QWORD *)v21 + 1LL);
std::vector<std::string>::~vector(&v16);
v16 = 0LL;
v17 = 0LL;
for ( j = 0LL; j < ggml_backend_dev_count(); ++j )
{
v7 = ggml_backend_dev_get(j);
if ( (unsigned int)ggml_backend_dev_type(v7) == 1 )
{
v8 = ggml_backend_dev_description(v7);
std::string::basic_string<std::allocator<char>>(&v19, v8);
std::vector<std::string>::emplace_back<std::string>(&v16, &v19);
if ( v19 != v21 )
operator delete(v19, *(_QWORD *)v21 + 1LL);
}
}
v19 = v21;
strcpy(v21, ", ");
v20 = 2LL;
join<std::string>(a1 + 32, (long long *)&v16, &v19);
if ( v19 != v21 )
operator delete(v19, *(_QWORD *)v21 + 1LL);
std::vector<std::string>::~vector(&v16);
*(_QWORD *)(a1 + 64) = a1 + 80;
*(_QWORD *)(a1 + 72) = 0LL;
*(_BYTE *)(a1 + 80) = 0;
*(_QWORD *)(a1 + 96) = a1 + 112;
*(_QWORD *)(a1 + 104) = 0LL;
*(_BYTE *)(a1 + 112) = 0;
*(_QWORD *)(a1 + 160) = a1 + 176;
*(_QWORD *)(a1 + 168) = 0LL;
*(_BYTE *)(a1 + 176) = 0;
*(_OWORD *)(a1 + 224) = 0LL;
*(_QWORD *)(a1 + 240) = 0LL;
*(_QWORD *)(a1 + 264) = a1 + 280;
*(_QWORD *)(a1 + 272) = 0LL;
*(_BYTE *)(a1 + 280) = 0;
*(_OWORD *)(a1 + 296) = 0LL;
*(_QWORD *)(a1 + 312) = 0LL;
v18 = a1 + 64;
std::string::_M_assign(a1 + 64, a2);
llama_model_desc(a3, &v19, 128LL);
v9 = *(_QWORD *)(a1 + 104);
v10 = strlen(&v19);
std::string::_M_replace(a1 + 96, 0LL, v9, &v19, v10);
*(_QWORD *)(a1 + 128) = llama_model_size(a3);
*(_QWORD *)(a1 + 136) = llama_model_n_params(a3);
*(_QWORD *)(a1 + 144) = *(_QWORD *)(a2 + 40);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 56);
std::string::_M_assign(a1 + 160, a2 + 64);
*(_BYTE *)(a1 + 192) = *(_BYTE *)(a2 + 96);
*(_DWORD *)(a1 + 196) = *(_DWORD *)(a2 + 100);
*(_QWORD *)(a1 + 200) = *(_QWORD *)(a2 + 48);
*(_DWORD *)(a1 + 208) = *(_DWORD *)(a2 + 104);
*(_QWORD *)(a1 + 212) = *(_QWORD *)(a2 + 144);
*(_BYTE *)(a1 + 220) = *(_BYTE *)(a2 + 152);
*(_BYTE *)(a1 + 221) = *(_BYTE *)(a2 + 153);
std::vector<float>::operator=(a1 + 224, a2 + 160);
*(_BYTE *)(a1 + 248) = *(_BYTE *)(a2 + 184);
*(_BYTE *)(a1 + 249) = *(_BYTE *)(a2 + 185);
*(_QWORD *)(a1 + 252) = *(_QWORD *)(a2 + 32);
*(_QWORD *)&v16 = time(0LL);
v11 = gmtime();
strftime(&v19, 128LL, "%FT%TZ", v11);
v12 = *(_QWORD *)(a1 + 272);
v13 = strlen(&v19);
return std::string::_M_replace(a1 + 264, 0LL, v12, &v19, v13);
}
| test:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x10],RSI
MOV RBX,RDI
XORPS XMM0,XMM0
LEA R12,[RSP + 0x40]
MOVAPS xmmword ptr [R12],XMM0
MOV qword ptr [R12 + 0x10],0x0
XOR R13D,R13D
LEA R15,[RSP + 0x60]
LEA RBP,[RSP + 0x7]
LAB_0011dd43:
CALL 0x00116870
CMP R13,RAX
JNC 0x0011dda9
LAB_0011dd4d:
MOV RDI,R13
CALL 0x001165c0
LAB_0011dd55:
MOV R14,RAX
MOV RDI,RAX
CALL 0x00116670
TEST EAX,0xfffffffd
JNZ 0x0011dda4
LAB_0011dd67:
MOV RDI,R14
CALL 0x00116730
LAB_0011dd6f:
MOV RDI,R15
MOV RSI,RAX
MOV RDX,RBP
CALL 0x0011d42c
LAB_0011dd7d:
MOV RDI,R12
MOV RSI,R15
CALL 0x0011f1fe
MOV RDI,qword ptr [RSP + 0x60]
LEA RAX,[RSP + 0x70]
CMP RDI,RAX
JZ 0x0011dda4
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x00116100
LAB_0011dda4:
INC R13
JMP 0x0011dd43
LAB_0011dda9:
LEA RDX,[RSP + 0x60]
LEA R15,[RSP + 0x70]
MOV qword ptr [RDX],R15
MOV word ptr [RDX + 0x10],0x202c
MOV qword ptr [RDX + 0x8],0x2
MOV byte ptr [RDX + 0x12],0x0
LAB_0011ddc8:
LEA RSI,[RSP + 0x40]
MOV RDI,RBX
CALL 0x0011cb63
MOV RDI,qword ptr [RSP + 0x60]
CMP RDI,R15
JZ 0x0011ddec
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x00116100
LAB_0011ddec:
LEA R13,[RSP + 0x40]
MOV RDI,R13
CALL 0x0011d80c
LEA RAX,[RBX + 0x20]
MOV qword ptr [RSP + 0x8],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R13],XMM0
MOV qword ptr [R13 + 0x10],0x0
XOR EBP,EBP
LEA R15,[RSP + 0x60]
LEA R12,[RSP + 0x7]
LAB_0011de1e:
CALL 0x00116870
CMP RBP,RAX
JNC 0x0011de82
LAB_0011de28:
MOV RDI,RBP
CALL 0x001165c0
LAB_0011de30:
MOV R14,RAX
MOV RDI,RAX
CALL 0x00116670
CMP EAX,0x1
JNZ 0x0011de7d
LAB_0011de40:
MOV RDI,R14
CALL 0x00116730
LAB_0011de48:
MOV RDI,R15
MOV RSI,RAX
MOV RDX,R12
CALL 0x0011d42c
LAB_0011de56:
MOV RDI,R13
MOV RSI,R15
CALL 0x0011f1fe
MOV RDI,qword ptr [RSP + 0x60]
LEA RAX,[RSP + 0x70]
CMP RDI,RAX
JZ 0x0011de7d
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x00116100
LAB_0011de7d:
INC RBP
JMP 0x0011de1e
LAB_0011de82:
LEA RDX,[RSP + 0x60]
LEA R15,[RSP + 0x70]
MOV qword ptr [RDX],R15
MOV word ptr [RDX + 0x10],0x202c
MOV qword ptr [RDX + 0x8],0x2
MOV byte ptr [RDX + 0x12],0x0
LAB_0011dea1:
LEA RSI,[RSP + 0x40]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011cb63
MOV RDI,qword ptr [RSP + 0x60]
CMP RDI,R15
JZ 0x0011dec7
MOV RSI,qword ptr [RSP + 0x70]
INC RSI
CALL 0x00116100
LAB_0011dec7:
LEA RDI,[RSP + 0x40]
CALL 0x0011d80c
LEA RDI,[RBX + 0x40]
LEA RAX,[RBX + 0x50]
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RBX + 0x40],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x48],RAX
MOV byte ptr [RBX + 0x50],AL
LEA RCX,[RBX + 0x60]
MOV qword ptr [RSP + 0x8],RCX
LEA RCX,[RBX + 0x70]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RBX + 0x60],RCX
MOV qword ptr [RBX + 0x68],RAX
MOV byte ptr [RBX + 0x70],AL
LEA RCX,[RBX + 0xa0]
MOV qword ptr [RSP + 0x38],RCX
LEA RCX,[RBX + 0xb0]
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RBX + 0xa0],RCX
MOV qword ptr [RBX + 0xa8],RAX
MOV byte ptr [RBX + 0xb0],AL
LEA R12,[RBX + 0xe0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xe0],XMM0
MOV qword ptr [RBX + 0xf0],RAX
LEA R13,[RBX + 0x108]
LEA RBP,[RBX + 0x118]
MOV qword ptr [RBX + 0x108],RBP
MOV qword ptr [RBX + 0x110],RAX
MOV byte ptr [RBX + 0x118],AL
MOVUPS xmmword ptr [RBX + 0x128],XMM0
MOV qword ptr [RBX + 0x138],RAX
LAB_0011df7c:
MOV qword ptr [RSP + 0x58],RDI
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00116d00
LAB_0011df8b:
LEA RSI,[RSP + 0x60]
MOV EDX,0x80
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00116ca0
MOV R14,qword ptr [RBX + 0x68]
LEA R15,[RSP + 0x60]
MOV RDI,R15
CALL 0x00116440
MOV RDI,qword ptr [RSP + 0x8]
XOR ESI,ESI
MOV RDX,R14
MOV RCX,R15
MOV R8,RAX
CALL 0x00116590
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001161c0
MOV qword ptr [RBX + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00116040
MOV qword ptr [RBX + 0x88],RAX
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RCX + 0x28]
MOV qword ptr [RBX + 0x90],RAX
MOV EAX,dword ptr [RCX + 0x38]
MOV dword ptr [RBX + 0x98],EAX
LEA RSI,[RCX + 0x40]
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x00116d00
MOV RCX,qword ptr [RSP + 0x10]
MOV AL,byte ptr [RCX + 0x60]
MOV byte ptr [RBX + 0xc0],AL
MOV EAX,dword ptr [RCX + 0x64]
MOV dword ptr [RBX + 0xc4],EAX
MOV RAX,qword ptr [RCX + 0x30]
MOV qword ptr [RBX + 0xc8],RAX
MOV EAX,dword ptr [RCX + 0x68]
MOV dword ptr [RBX + 0xd0],EAX
MOV RAX,qword ptr [RCX + 0x90]
MOV qword ptr [RBX + 0xd4],RAX
MOV AL,byte ptr [RCX + 0x98]
MOV byte ptr [RBX + 0xdc],AL
MOV AL,byte ptr [RCX + 0x99]
MOV byte ptr [RBX + 0xdd],AL
LEA RSI,[RCX + 0xa0]
MOV RDI,R12
CALL 0x0012ea54
MOV RCX,qword ptr [RSP + 0x10]
MOV AL,byte ptr [RCX + 0xb8]
MOV byte ptr [RBX + 0xf8],AL
MOV AL,byte ptr [RCX + 0xb9]
MOV byte ptr [RBX + 0xf9],AL
MOV RAX,qword ptr [RCX + 0x20]
MOV qword ptr [RBX + 0xfc],RAX
XOR EDI,EDI
CALL 0x00116840
LEA RDI,[RSP + 0x40]
MOV qword ptr [RDI],RAX
CALL 0x00116270
LEA RDX,[0x14089c]
LEA R14,[RSP + 0x60]
MOV ESI,0x80
MOV RDI,R14
MOV RCX,RAX
CALL 0x00116a80
MOV R15,qword ptr [RBX + 0x110]
MOV RDI,R14
CALL 0x00116440
LAB_0011e0d5:
MOV RDI,R13
XOR ESI,ESI
MOV RDX,R15
MOV RCX,R14
MOV R8,RAX
CALL 0x00116590
LAB_0011e0e8:
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* test::test(cmd_params_instance const&, llama_model const*, llama_context const*) */
void __thiscall
test::test(test *this,cmd_params_instance *param_1,llama_model *param_2,llama_context *param_3)
{
int iVar1;
ulong uVar2;
int8 uVar3;
char *pcVar4;
tm *__tp;
ulong uVar5;
allocator local_111;
vector *local_110;
cmd_params_instance *local_108;
llama_model *local_100;
test *local_f8;
test *local_f0;
test *local_e8;
test *local_e0;
time_t local_d8 [3];
string *local_c0;
int2 *local_b8;
int8 local_b0;
int2 local_a8;
int1 uStack_a6;
int5 uStack_a5;
local_d8[0] = 0;
local_d8[1] = 0;
local_d8[2] = 0;
uVar5 = 0;
local_108 = param_1;
local_100 = param_2;
while( true ) {
/* try { // try from 0011dd43 to 0011dd47 has its CatchHandler @ 0011e267 */
uVar2 = ggml_backend_dev_count();
if (uVar2 <= uVar5) break;
/* try { // try from 0011dd4d to 0011dd54 has its CatchHandler @ 0011e23d */
uVar3 = ggml_backend_dev_get(uVar5);
/* try { // try from 0011dd55 to 0011dd5f has its CatchHandler @ 0011e23f */
uVar2 = ggml_backend_dev_type(uVar3);
if ((uVar2 & 0xfffffffd) == 0) {
/* try { // try from 0011dd67 to 0011dd6e has its CatchHandler @ 0011e212 */
pcVar4 = (char *)ggml_backend_dev_description(uVar3);
/* try { // try from 0011dd6f to 0011dd7c has its CatchHandler @ 0011e210 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_b8,pcVar4,&local_111);
/* try { // try from 0011dd7d to 0011dd87 has its CatchHandler @ 0011e1ef */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_d8,
(string *)&local_b8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,CONCAT53(uStack_a5,CONCAT12(uStack_a6,local_a8)) + 1);
}
}
uVar5 = uVar5 + 1;
}
local_a8 = 0x202c;
local_b0 = 2;
uStack_a6 = 0;
/* try { // try from 0011ddc8 to 0011ddd4 has its CatchHandler @ 0011e114 */
local_b8 = &local_a8;
join<std::__cxx11::string>((vector *)this,(string *)local_d8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,CONCAT53(uStack_a5,CONCAT12(uStack_a6,local_a8)) + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_d8);
local_110 = (vector *)(this + 0x20);
local_d8[0] = 0;
local_d8[1] = 0;
local_d8[2] = 0;
uVar5 = 0;
while( true ) {
/* try { // try from 0011de1e to 0011de22 has its CatchHandler @ 0011e241 */
uVar2 = ggml_backend_dev_count();
if (uVar2 <= uVar5) break;
/* try { // try from 0011de28 to 0011de2f has its CatchHandler @ 0011e23b */
uVar3 = ggml_backend_dev_get(uVar5);
/* try { // try from 0011de30 to 0011de3a has its CatchHandler @ 0011e239 */
iVar1 = ggml_backend_dev_type(uVar3);
if (iVar1 == 1) {
/* try { // try from 0011de40 to 0011de47 has its CatchHandler @ 0011e237 */
pcVar4 = (char *)ggml_backend_dev_description(uVar3);
/* try { // try from 0011de48 to 0011de55 has its CatchHandler @ 0011e235 */
std::__cxx11::string::string<std::allocator<char>>((string *)&local_b8,pcVar4,&local_111);
/* try { // try from 0011de56 to 0011de60 has its CatchHandler @ 0011e214 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_d8,
(string *)&local_b8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,CONCAT53(uStack_a5,CONCAT12(uStack_a6,local_a8)) + 1);
}
}
uVar5 = uVar5 + 1;
}
local_a8 = 0x202c;
local_b0 = 2;
uStack_a6 = 0;
/* try { // try from 0011dea1 to 0011deaf has its CatchHandler @ 0011e0fe */
local_b8 = &local_a8;
join<std::__cxx11::string>(local_110,(string *)local_d8);
if (local_b8 != &local_a8) {
operator_delete(local_b8,CONCAT53(uStack_a5,CONCAT12(uStack_a6,local_a8)) + 1);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_d8);
local_c0 = (string *)(this + 0x40);
local_e8 = this + 0x50;
*(test **)(this + 0x40) = local_e8;
*(int8 *)(this + 0x48) = 0;
this[0x50] = (test)0x0;
local_110 = (vector *)(this + 0x60);
local_f0 = this + 0x70;
*(test **)(this + 0x60) = local_f0;
*(int8 *)(this + 0x68) = 0;
this[0x70] = (test)0x0;
local_e0 = this + 0xa0;
local_f8 = this + 0xb0;
*(test **)(this + 0xa0) = local_f8;
*(int8 *)(this + 0xa8) = 0;
this[0xb0] = (test)0x0;
*(int8 *)(this + 0xe0) = 0;
*(int8 *)(this + 0xe8) = 0;
*(int8 *)(this + 0xf0) = 0;
*(test **)(this + 0x108) = this + 0x118;
*(int8 *)(this + 0x110) = 0;
this[0x118] = (test)0x0;
*(int8 *)(this + 0x128) = 0;
*(int8 *)(this + 0x130) = 0;
*(int8 *)(this + 0x138) = 0;
/* try { // try from 0011df7c to 0011df8a has its CatchHandler @ 0011e0fc */
std::__cxx11::string::_M_assign(local_c0);
/* try { // try from 0011df8b to 0011e06d has its CatchHandler @ 0011e12a */
llama_model_desc(local_100,&local_b8,0x80);
pcVar4 = *(char **)(this + 0x68);
strlen((char *)&local_b8);
std::__cxx11::string::_M_replace((ulong)local_110,0,pcVar4,(ulong)&local_b8);
uVar3 = llama_model_size(local_100);
*(int8 *)(this + 0x80) = uVar3;
uVar3 = llama_model_n_params(local_100);
*(int8 *)(this + 0x88) = uVar3;
*(int8 *)(this + 0x90) = *(int8 *)(local_108 + 0x28);
*(int4 *)(this + 0x98) = *(int4 *)(local_108 + 0x38);
std::__cxx11::string::_M_assign((string *)local_e0);
*(cmd_params_instance *)(this + 0xc0) = local_108[0x60];
*(int4 *)(this + 0xc4) = *(int4 *)(local_108 + 100);
*(int8 *)(this + 200) = *(int8 *)(local_108 + 0x30);
*(int4 *)(this + 0xd0) = *(int4 *)(local_108 + 0x68);
*(int8 *)(this + 0xd4) = *(int8 *)(local_108 + 0x90);
*(cmd_params_instance *)(this + 0xdc) = local_108[0x98];
*(cmd_params_instance *)(this + 0xdd) = local_108[0x99];
std::vector<float,std::allocator<float>>::operator=
((vector<float,std::allocator<float>> *)(this + 0xe0),(vector *)(local_108 + 0xa0));
*(cmd_params_instance *)(this + 0xf8) = local_108[0xb8];
*(cmd_params_instance *)(this + 0xf9) = local_108[0xb9];
*(int8 *)(this + 0xfc) = *(int8 *)(local_108 + 0x20);
local_d8[0] = time((time_t *)0x0);
__tp = gmtime(local_d8);
strftime((char *)&local_b8,0x80,"%FT%TZ",__tp);
pcVar4 = *(char **)(this + 0x110);
strlen((char *)&local_b8);
/* try { // try from 0011e0d5 to 0011e0e7 has its CatchHandler @ 0011e0fa */
std::__cxx11::string::_M_replace((ulong)(this + 0x108),0,pcVar4,(ulong)&local_b8);
return;
}
| |
24,541 | spdlog::details::short_level_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h | void format(const details::log_msg &msg, const std::tm &, memory_buf_t &dest) override {
string_view_t level_name{level::to_short_c_str(msg.level)};
ScopedPadder p(level_name.size(), padinfo_, dest);
fmt_helper::append_string_view(level_name, dest);
} | O0 | c | spdlog::details::short_level_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
subq $0xa8, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x88(%rsp), %rax
movl 0x10(%rax), %edi
callq 0x39c10
leaq 0x68(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0xa0(%rsp)
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rcx
movq %rcx, (%rax)
movq 0x98(%rsp), %rdi
callq 0x16290
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x2a430
movq 0x18(%rsp), %rdx
movq %rax, %rsi
addq $0x8, %rdx
movq 0x78(%rsp), %rcx
leaq 0x40(%rsp), %rdi
callq 0x5b820
movups 0x68(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x78(%rsp), %rdx
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x43a00
jmp 0x5c471
leaq 0x40(%rsp), %rdi
callq 0x5b910
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5b910
movq 0x28(%rsp), %rdi
callq 0x16cf0
nopw %cs:(%rax,%rax)
nop
| _ZN6spdlog7details21short_level_formatterINS0_13scoped_padderEE6formatERKNS0_7log_msgERK2tmRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE:
sub rsp, 0A8h
mov [rsp+0A8h+var_18], rdi
mov [rsp+0A8h+var_20], rsi
mov [rsp+0A8h+var_28], rdx
mov [rsp+0A8h+var_30], rcx
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_90], rax
mov rax, [rsp+0A8h+var_20]
mov edi, [rax+10h]
call _ZN6spdlog5level14to_short_c_strENS0_10level_enumE; spdlog::level::to_short_c_str(spdlog::level::level_enum)
lea rcx, [rsp+0A8h+var_40]
mov [rsp+0A8h+var_A0], rcx
mov [rsp+0A8h+var_8], rcx
mov [rsp+0A8h+var_10], rax
mov rax, [rsp+0A8h+var_8]
mov [rsp+0A8h+var_98], rax
mov rcx, [rsp+0A8h+var_10]
mov [rax], rcx
mov rdi, [rsp+0A8h+var_10]
call _strlen
mov rdi, [rsp+0A8h+var_A0]
mov rcx, rax
mov rax, [rsp+0A8h+var_98]
mov [rax+8], rcx
call _ZNK3fmt3v1017basic_string_viewIcE4sizeEv; fmt::v10::basic_string_view<char>::size(void)
mov rdx, [rsp+0A8h+var_90]
mov rsi, rax
add rdx, 8
mov rcx, [rsp+0A8h+var_30]
lea rdi, [rsp+0A8h+var_68]
call _ZN6spdlog7details13scoped_padderC2EmRKNS0_12padding_infoERN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::scoped_padder::scoped_padder(ulong,spdlog::details::padding_info const&,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
movups xmm0, [rsp+0A8h+var_40]
movaps [rsp+0A8h+var_78], xmm0
mov rdx, [rsp+0A8h+var_30]
mov rdi, qword ptr [rsp+0A8h+var_78]
mov rsi, qword ptr [rsp+0A8h+var_78+8]
call _ZN6spdlog7details10fmt_helper18append_string_viewEN3fmt3v1017basic_string_viewIcEERNS3_19basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::fmt_helper::append_string_view(fmt::v10::basic_string_view<char>,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
jmp short $+2
loc_5C471:
lea rdi, [rsp+0A8h+var_68]; this
call _ZN6spdlog7details13scoped_padderD2Ev; spdlog::details::scoped_padder::~scoped_padder()
add rsp, 0A8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_38]; this
call _ZN6spdlog7details13scoped_padderD2Ev; spdlog::details::scoped_padder::~scoped_padder()
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| void spdlog::details::short_level_formatter<spdlog::details::scoped_padder>::format(
long long a1,
long long a2,
long long a3,
_QWORD *a4)
{
long long v4; // rax
long long v5; // rax
_BYTE v6[40]; // [rsp+40h] [rbp-68h] BYREF
long long v7; // [rsp+68h] [rbp-40h] BYREF
long long v8; // [rsp+70h] [rbp-38h]
_QWORD *v9; // [rsp+78h] [rbp-30h]
long long v10; // [rsp+80h] [rbp-28h]
long long v11; // [rsp+88h] [rbp-20h]
long long v12; // [rsp+90h] [rbp-18h]
long long v13; // [rsp+98h] [rbp-10h]
long long *v14; // [rsp+A0h] [rbp-8h]
v12 = a1;
v11 = a2;
v10 = a3;
v9 = a4;
v4 = spdlog::level::to_short_c_str(*(_DWORD *)(a2 + 16));
v14 = &v7;
v13 = v4;
v7 = v4;
v8 = strlen(v4);
v5 = fmt::v10::basic_string_view<char>::size((long long)&v7);
spdlog::details::scoped_padder::scoped_padder(
(spdlog::details::scoped_padder *)v6,
v5,
(_QWORD *)(a1 + 8),
(long long)v9);
spdlog::details::fmt_helper::append_string_view(v7, v8, v9);
spdlog::details::scoped_padder::~scoped_padder((spdlog::details::scoped_padder *)v6);
}
| format:
SUB RSP,0xa8
MOV qword ptr [RSP + 0x90],RDI
MOV qword ptr [RSP + 0x88],RSI
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x78],RCX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV EDI,dword ptr [RAX + 0x10]
CALL 0x00139c10
LEA RCX,[RSP + 0x68]
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0xa0],RCX
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x10],RAX
MOV RCX,qword ptr [RSP + 0x98]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RSP + 0x98]
CALL 0x00116290
MOV RDI,qword ptr [RSP + 0x8]
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
CALL 0x0012a430
MOV RDX,qword ptr [RSP + 0x18]
MOV RSI,RAX
ADD RDX,0x8
MOV RCX,qword ptr [RSP + 0x78]
LEA RDI,[RSP + 0x40]
CALL 0x0015b820
MOVUPS XMM0,xmmword ptr [RSP + 0x68]
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOV RDX,qword ptr [RSP + 0x78]
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
LAB_0015c46a:
CALL 0x00143a00
LAB_0015c46f:
JMP 0x0015c471
LAB_0015c471:
LEA RDI,[RSP + 0x40]
CALL 0x0015b910
ADD RSP,0xa8
RET
|
/* spdlog::details::short_level_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg
const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::short_level_formatter<spdlog::details::scoped_padder>::format
(short_level_formatter<spdlog::details::scoped_padder> *this,log_msg *param_1,tm *param_2,
basic_memory_buffer *param_3)
{
size_t sVar1;
ulong uVar2;
scoped_padder local_68 [40];
int4 local_40;
int4 uStack_3c;
int4 uStack_38;
int4 uStack_34;
basic_memory_buffer *local_30;
tm *local_28;
log_msg *local_20;
short_level_formatter<spdlog::details::scoped_padder> *local_18;
char *local_10;
basic_string_view<char> *local_8;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
local_18 = this;
local_10 = (char *)level::to_short_c_str(*(int4 *)(param_1 + 0x10));
uStack_3c = (int4)((ulong)local_10 >> 0x20);
local_40 = SUB84(local_10,0);
local_8 = (basic_string_view<char> *)&local_40;
sVar1 = strlen(local_10);
uStack_34 = (int4)(sVar1 >> 0x20);
uStack_38 = (int4)sVar1;
uVar2 = fmt::v10::basic_string_view<char>::size((basic_string_view<char> *)&local_40);
scoped_padder::scoped_padder(local_68,uVar2,(padding_info *)(this + 8),local_30);
/* try { // try from 0015c46a to 0015c46e has its CatchHandler @ 0015c483 */
fmt_helper::append_string_view
((fmt_helper *)CONCAT44(uStack_3c,local_40),CONCAT44(uStack_34,uStack_38),local_30);
scoped_padder::~scoped_padder(local_68);
return;
}
| |
24,542 | ModbusTcpPort::~ModbusTcpPort() | serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpPort_unix.cpp | ModbusTcpPort::~ModbusTcpPort()
{
ModbusTcpPortPrivateUnix *d = d_unix(d_ptr);
if (!d->socket->isInvalid())
{
d->socket->shutdown();
d->socket->close();
}
} | O2 | cpp | ModbusTcpPort::~ModbusTcpPort():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe282(%rip), %rax # 0x1cad8
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
movq 0x180(%r14), %rdi
cmpl $-0x1, (%rdi)
je 0xe87a
callq 0xf90c
movq 0x180(%r14), %rdi
callq 0xf916
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a6c
movq %rax, %rdi
callq 0x5af3
nop
| _ZN13ModbusTcpPortD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, off_1CAD8
mov [rdi], rax
mov r14, [rdi+8]
mov rdi, [r14+180h]; this
cmp dword ptr [rdi], 0FFFFFFFFh
jz short loc_E87A
call _ZN15ModbusTcpSocket8shutdownEv; ModbusTcpSocket::shutdown(void)
mov rdi, [r14+180h]; this
call _ZN15ModbusTcpSocket5closeEv; ModbusTcpSocket::close(void)
loc_E87A:
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN10ModbusPortD2Ev; ModbusPort::~ModbusPort()
mov rdi, rax
call __clang_call_terminate
| void ModbusTcpPort::~ModbusTcpPort(ModbusTcpPort *this)
{
long long v2; // r14
ModbusTcpSocket *v3; // rdi
*(_QWORD *)this = off_1CAD8;
v2 = *((_QWORD *)this + 1);
v3 = *(ModbusTcpSocket **)(v2 + 384);
if ( *(_DWORD *)v3 != -1 )
{
ModbusTcpSocket::shutdown(v3);
ModbusTcpSocket::close(*(ModbusTcpSocket **)(v2 + 384));
}
ModbusPort::~ModbusPort(this);
}
| ~ModbusTcpPort:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x11cad8]
MOV qword ptr [RDI],RAX
MOV R14,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [R14 + 0x180]
CMP dword ptr [RDI],-0x1
JZ 0x0010e87a
CALL 0x0010f90c
MOV RDI,qword ptr [R14 + 0x180]
LAB_0010e875:
CALL 0x0010f916
LAB_0010e87a:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00108a6c
|
/* ModbusTcpPort::~ModbusTcpPort() */
void __thiscall ModbusTcpPort::~ModbusTcpPort(ModbusTcpPort *this)
{
long lVar1;
ModbusTcpSocket *this_00;
*(int ***)this = &PTR__ModbusTcpPort_0011cad8;
lVar1 = *(long *)(this + 8);
this_00 = *(ModbusTcpSocket **)(lVar1 + 0x180);
if (*(int *)this_00 != -1) {
ModbusTcpSocket::shutdown(this_00);
/* try { // try from 0010e875 to 0010e879 has its CatchHandler @ 0010e889 */
ModbusTcpSocket::close(*(ModbusTcpSocket **)(lVar1 + 0x180));
}
ModbusPort::~ModbusPort((ModbusPort *)this);
return;
}
| |
24,543 | ModbusTcpPort::~ModbusTcpPort() | serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpPort_unix.cpp | ModbusTcpPort::~ModbusTcpPort()
{
ModbusTcpPortPrivateUnix *d = d_unix(d_ptr);
if (!d->socket->isInvalid())
{
d->socket->shutdown();
d->socket->close();
}
} | O3 | cpp | ModbusTcpPort::~ModbusTcpPort():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11742(%rip), %rax # 0x21ad8
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
movq 0x180(%r14), %rax
movl (%rax), %edi
cmpl $-0x1, %edi
je 0x103cb
movl $0x2, %esi
callq 0x5420
movq 0x180(%r14), %r14
movl (%r14), %edi
callq 0x55a0
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x916c
movq %rax, %rdi
callq 0x5cc1
| _ZN13ModbusTcpPortD2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, off_21AD8
mov [rdi], rax
mov r14, [rdi+8]
mov rax, [r14+180h]
mov edi, [rax]
cmp edi, 0FFFFFFFFh
jz short loc_103CB
mov esi, 2
call _shutdown
mov r14, [r14+180h]
mov edi, [r14]
call _close
mov dword ptr [r14], 0FFFFFFFFh
loc_103CB:
mov rdi, rbx; this
add rsp, 8
pop rbx
pop r14
jmp _ZN10ModbusPortD2Ev; ModbusPort::~ModbusPort()
mov rdi, rax
call __clang_call_terminate
| void ModbusTcpPort::~ModbusTcpPort(ModbusTcpPort *this)
{
long long v2; // r14
long long v3; // rdi
_DWORD *v4; // r14
*(_QWORD *)this = off_21AD8;
v2 = *((_QWORD *)this + 1);
v3 = **(unsigned int **)(v2 + 384);
if ( (_DWORD)v3 != -1 )
{
shutdown(v3, 2LL);
v4 = *(_DWORD **)(v2 + 384);
close((unsigned int)*v4);
*v4 = -1;
}
ModbusPort::~ModbusPort(this);
}
| ~ModbusTcpPort:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x121ad8]
MOV qword ptr [RDI],RAX
MOV R14,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [R14 + 0x180]
MOV EDI,dword ptr [RAX]
CMP EDI,-0x1
JZ 0x001103cb
MOV ESI,0x2
CALL 0x00105420
MOV R14,qword ptr [R14 + 0x180]
MOV EDI,dword ptr [R14]
LAB_001103bf:
CALL 0x001055a0
MOV dword ptr [R14],0xffffffff
LAB_001103cb:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0010916c
|
/* ModbusTcpPort::~ModbusTcpPort() */
void __thiscall ModbusTcpPort::~ModbusTcpPort(ModbusTcpPort *this)
{
int __fd;
long lVar1;
int *piVar2;
*(int ***)this = &PTR__ModbusTcpPort_00121ad8;
lVar1 = *(long *)(this + 8);
__fd = **(int **)(lVar1 + 0x180);
if (__fd != -1) {
shutdown(__fd,2);
piVar2 = *(int **)(lVar1 + 0x180);
/* try { // try from 001103bf to 001103c3 has its CatchHandler @ 001103da */
::close(*piVar2);
*piVar2 = -1;
}
ModbusPort::~ModbusPort((ModbusPort *)this);
return;
}
| |
24,544 | init_one_value | eloqsql/mysys/my_getopt.c | static void init_one_value(const struct my_option *option, void *variable,
longlong value)
{
DBUG_ENTER("init_one_value");
switch ((option->var_type & GET_TYPE_MASK)) {
case GET_BOOL:
*((my_bool*) variable)= (my_bool) value;
break;
case GET_INT:
*((int*) variable)= (int) getopt_ll_limit_value((int) value, option, NULL);
break;
case GET_ENUM:
*((ulong*) variable)= (ulong) value;
break;
case GET_UINT:
*((uint*) variable)= (uint) getopt_ull_limit_value((uint) value, option, NULL);
break;
case GET_LONG:
*((long*) variable)= (long) getopt_ll_limit_value((long) value, option, NULL);
break;
case GET_ULONG:
*((ulong*) variable)= (ulong) getopt_ull_limit_value((ulong) value, option, NULL);
break;
case GET_LL:
*((longlong*) variable)= (longlong) getopt_ll_limit_value((longlong) value, option, NULL);
break;
case GET_ULL:
*((ulonglong*) variable)= (ulonglong) getopt_ull_limit_value((ulonglong) value, option, NULL);
break;
case GET_SET:
case GET_FLAGSET:
*((ulonglong*) variable)= (ulonglong) value;
break;
case GET_BIT:
{
ulonglong bit= (option->block_size >= 0 ?
option->block_size :
-option->block_size);
if (option->block_size < 0)
value= !value;
if (value)
(*(ulonglong*)variable)|= bit;
else
(*(ulonglong*)variable)&= ~bit;
break;
}
case GET_DOUBLE:
*((double*) variable)= getopt_ulonglong2double(value);
break;
case GET_STR:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
*((char**) variable)= (char*) (intptr) value;
break;
case GET_STR_ALLOC:
/*
Do not clear variable value if it has no default value.
The default value may already be set.
NOTE: To avoid compiler warnings, we first cast longlong to intptr,
so that the value has the same size as a pointer.
*/
if ((char*) (intptr) value)
{
char **pstr= (char **) variable;
my_free(*pstr);
*pstr= my_strdup(key_memory_defaults, (char*) (intptr) value, MYF(MY_WME));
}
break;
default: /* dummy default to avoid compiler warnings */
break;
}
DBUG_VOID_RETURN;
} | O0 | c | init_one_value:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
andl $0x3f, %eax
addq $-0x2, %rax
movq %rax, -0x30(%rbp)
subq $0xe, %rax
ja 0xbf03e
movq -0x30(%rbp), %rax
leaq 0xb29b4(%rip), %rcx # 0x171810
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rax
movslq %eax, %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbf800
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rax
movl %eax, %eax
movl %eax, %edi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbfa80
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbf800
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbfa80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbf800
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xbfa80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jl 0xbef72
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xbef80
movq -0x8(%rbp), %rcx
xorl %eax, %eax
subq 0x60(%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jge 0xbefa8
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbefbf
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
jmp 0xbefd1
movq -0x20(%rbp), %rcx
xorq $-0x1, %rcx
movq -0x10(%rbp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rdi
callq 0xbda20
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0xbeffb
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
movq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0xbf03c
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0xc26d0
leaq 0x4074b6(%rip), %rax # 0x4c64d8
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movl $0x10, %edx
callq 0xc27d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbf040
jmp 0xbf040
jmp 0xbf042
jmp 0xbf044
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| init_one_value:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov rax, [rax+30h]
and eax, 3Fh
add rax, 0FFFFFFFFFFFFFFFEh; switch 15 cases
mov [rbp+var_30], rax
sub rax, 0Eh
ja def_BEE63; jumptable 00000000000BEE63 default case, case 11
mov rax, [rbp+var_30]
lea rcx, jpt_BEE63
movsxd rax, ds:(jpt_BEE63 - 171810h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_BEE65:
mov rax, [rbp+var_18]; jumptable 00000000000BEE63 case 2
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
jmp loc_BF040
loc_BEE76:
mov rax, [rbp+var_18]; jumptable 00000000000BEE63 case 3
movsxd rdi, eax
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call getopt_ll_limit_value
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
jmp loc_BF040
loc_BEE97:
mov rcx, [rbp+var_18]; jumptable 00000000000BEE63 case 12
mov rax, [rbp+var_10]
mov [rax], rcx
jmp loc_BF040
loc_BEEA7:
mov rax, [rbp+var_18]; jumptable 00000000000BEE63 case 4
mov eax, eax
mov edi, eax
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call getopt_ull_limit_value
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
jmp loc_BF040
loc_BEEC9:
mov rdi, [rbp+var_18]; jumptable 00000000000BEE63 case 5
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call getopt_ll_limit_value
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
jmp loc_BF040
loc_BEEE9:
mov rdi, [rbp+var_18]; jumptable 00000000000BEE63 case 6
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call getopt_ull_limit_value
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
jmp loc_BF040
loc_BEF09:
mov rdi, [rbp+var_18]; jumptable 00000000000BEE63 case 7
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call getopt_ll_limit_value
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
jmp loc_BF040
loc_BEF29:
mov rdi, [rbp+var_18]; jumptable 00000000000BEE63 case 8
mov rsi, [rbp+var_8]
xor eax, eax
mov edx, eax
call getopt_ull_limit_value
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
jmp loc_BF040
loc_BEF49:
mov rcx, [rbp+var_18]; jumptable 00000000000BEE63 cases 13,15
mov rax, [rbp+var_10]
mov [rax], rcx
jmp loc_BF040
loc_BEF59:
mov rax, [rbp+var_8]; jumptable 00000000000BEE63 case 16
cmp qword ptr [rax+60h], 0
jl short loc_BEF72
mov rax, [rbp+var_8]
mov rax, [rax+60h]
mov [rbp+var_38], rax
jmp short loc_BEF80
loc_BEF72:
mov rcx, [rbp+var_8]
xor eax, eax
sub rax, [rcx+60h]
mov [rbp+var_38], rax
loc_BEF80:
mov rax, [rbp+var_38]
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
cmp qword ptr [rax+60h], 0
jge short loc_BEFA8
cmp [rbp+var_18], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
mov [rbp+var_18], rax
loc_BEFA8:
cmp [rbp+var_18], 0
jz short loc_BEFBF
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
or rcx, [rax]
mov [rax], rcx
jmp short loc_BEFD1
loc_BEFBF:
mov rcx, [rbp+var_20]
xor rcx, 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_10]
and rcx, [rax]
mov [rax], rcx
loc_BEFD1:
jmp short loc_BF040
loc_BEFD3:
mov rdi, [rbp+var_18]; jumptable 00000000000BEE63 case 14
call getopt_ulonglong2double
mov rax, [rbp+var_10]
movsd qword ptr [rax], xmm0
jmp short loc_BF040
loc_BEFE6:
mov rax, [rbp+var_18]; jumptable 00000000000BEE63 case 9
cmp rax, 0
jz short loc_BEFFB
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
loc_BEFFB:
jmp short loc_BF040
loc_BEFFD:
mov rax, [rbp+var_18]; jumptable 00000000000BEE63 case 10
cmp rax, 0
jz short loc_BF03C
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rdi, [rax]
call my_free
lea rax, key_memory_defaults
mov edi, [rax]
mov rsi, [rbp+var_18]
mov edx, 10h
call my_strdup
mov rcx, rax
mov rax, [rbp+var_28]
mov [rax], rcx
loc_BF03C:
jmp short loc_BF040
def_BEE63:
jmp short $+2; jumptable 00000000000BEE63 default case, case 11
loc_BF040:
jmp short $+2
loc_BF042:
jmp short $+2
loc_BF044:
add rsp, 40h
pop rbp
retn
| long long init_one_value(long long a1, long long *a2, long long a3)
{
long long result; // rax
int v4; // ecx
int v5; // ecx
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
double v9; // xmm0_8
long long v10; // rcx
long long v11; // [rsp+8h] [rbp-38h]
_BOOL8 v12; // [rsp+28h] [rbp-18h]
v12 = a3;
result = (*(_QWORD *)(a1 + 48) & 0x3FLL) - 2;
switch ( *(_QWORD *)(a1 + 48) & 0x3FLL )
{
case 2LL:
result = (long long)a2;
*(_BYTE *)a2 = a3;
break;
case 3LL:
v4 = getopt_ll_limit_value((int)a3, a1, 0LL);
result = (long long)a2;
*(_DWORD *)a2 = v4;
break;
case 4LL:
v5 = getopt_ull_limit_value((unsigned int)a3, a1, 0LL);
result = (long long)a2;
*(_DWORD *)a2 = v5;
break;
case 5LL:
case 7LL:
v6 = getopt_ll_limit_value(a3, a1, 0LL);
result = (long long)a2;
*a2 = v6;
break;
case 6LL:
case 8LL:
v7 = getopt_ull_limit_value(a3, a1, 0LL);
result = (long long)a2;
*a2 = v7;
break;
case 9LL:
result = a3;
if ( a3 )
{
result = (long long)a2;
*a2 = a3;
}
break;
case 0xALL:
result = a3;
if ( a3 )
{
my_free(*a2);
v10 = my_strdup(key_memory_defaults, v12, 16LL);
result = (long long)a2;
*a2 = v10;
}
break;
case 0xCLL:
result = (long long)a2;
*a2 = a3;
break;
case 0xDLL:
case 0xFLL:
result = (long long)a2;
*a2 = a3;
break;
case 0xELL:
v9 = getopt_ulonglong2double(a3);
result = (long long)a2;
*(double *)a2 = v9;
break;
case 0x10LL:
if ( *(long long *)(a1 + 96) < 0 )
v11 = -*(_QWORD *)(a1 + 96);
else
v11 = *(_QWORD *)(a1 + 96);
if ( *(long long *)(a1 + 96) < 0 )
v12 = a3 == 0;
result = (long long)a2;
if ( v12 )
v8 = *a2 | v11;
else
v8 = *a2 & ~v11;
*a2 = v8;
break;
default:
return result;
}
return result;
}
| init_one_value:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x30]
AND EAX,0x3f
ADD RAX,-0x2
MOV qword ptr [RBP + -0x30],RAX
SUB RAX,0xe
JA 0x001bf03e
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x271810]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
JMP 0x001bf040
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RDI,EAX
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001bf800
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
JMP 0x001bf040
caseD_c:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x001bf040
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,EAX
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001bfa80
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
JMP 0x001bf040
caseD_5:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001bf800
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x001bf040
caseD_6:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001bfa80
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x001bf040
caseD_7:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001bf800
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x001bf040
caseD_8:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001bfa80
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x001bf040
caseD_d:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
JMP 0x001bf040
caseD_10:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JL 0x001bef72
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001bef80
LAB_001bef72:
MOV RCX,qword ptr [RBP + -0x8]
XOR EAX,EAX
SUB RAX,qword ptr [RCX + 0x60]
MOV qword ptr [RBP + -0x38],RAX
LAB_001bef80:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x60],0x0
JGE 0x001befa8
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
MOV qword ptr [RBP + -0x18],RAX
LAB_001befa8:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001befbf
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
OR RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
JMP 0x001befd1
LAB_001befbf:
MOV RCX,qword ptr [RBP + -0x20]
XOR RCX,-0x1
MOV RAX,qword ptr [RBP + -0x10]
AND RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
LAB_001befd1:
JMP 0x001bf040
caseD_e:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001bda20
MOV RAX,qword ptr [RBP + -0x10]
MOVSD qword ptr [RAX],XMM0
JMP 0x001bf040
caseD_9:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,0x0
JZ 0x001beffb
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
LAB_001beffb:
JMP 0x001bf040
caseD_a:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,0x0
JZ 0x001bf03c
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
CALL 0x001c26d0
LEA RAX,[0x5c64d8]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x10
CALL 0x001c27d0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
LAB_001bf03c:
JMP 0x001bf040
caseD_b:
JMP 0x001bf040
LAB_001bf040:
JMP 0x001bf042
LAB_001bf042:
JMP 0x001bf044
LAB_001bf044:
ADD RSP,0x40
POP RBP
RET
|
void init_one_value(long param_1,ulong *param_2,ulong param_3)
{
int4 uVar1;
ulong uVar2;
ulong local_40;
ulong local_20;
switch((uint)*(int8 *)(param_1 + 0x30) & 0x3f) {
case 2:
*(char *)param_2 = (char)param_3;
break;
case 3:
uVar1 = getopt_ll_limit_value((long)(int)param_3,param_1,0);
*(int4 *)param_2 = uVar1;
break;
case 4:
uVar1 = getopt_ull_limit_value(param_3 & 0xffffffff,param_1,0);
*(int4 *)param_2 = uVar1;
break;
case 5:
uVar2 = getopt_ll_limit_value(param_3,param_1,0);
*param_2 = uVar2;
break;
case 6:
uVar2 = getopt_ull_limit_value(param_3,param_1,0);
*param_2 = uVar2;
break;
case 7:
uVar2 = getopt_ll_limit_value(param_3,param_1,0);
*param_2 = uVar2;
break;
case 8:
uVar2 = getopt_ull_limit_value(param_3,param_1,0);
*param_2 = uVar2;
break;
case 9:
if (param_3 != 0) {
*param_2 = param_3;
}
break;
case 10:
if (param_3 != 0) {
my_free(*param_2);
uVar2 = my_strdup(key_memory_defaults,param_3,0x10);
*param_2 = uVar2;
}
break;
default:
break;
case 0xc:
*param_2 = param_3;
break;
case 0xd:
case 0xf:
*param_2 = param_3;
break;
case 0xe:
uVar2 = getopt_ulonglong2double(param_3);
*param_2 = uVar2;
break;
case 0x10:
if (*(long *)(param_1 + 0x60) < 0) {
local_40 = -*(long *)(param_1 + 0x60);
}
else {
local_40 = *(ulong *)(param_1 + 0x60);
}
local_20 = param_3;
if (*(long *)(param_1 + 0x60) < 0) {
local_20 = (ulong)(int)(uint)((param_3 != 0 ^ 0xffU) & 1);
}
if (local_20 == 0) {
*param_2 = (local_40 ^ 0xffffffffffffffff) & *param_2;
}
else {
*param_2 = local_40 | *param_2;
}
}
return;
}
| |
24,545 | Vector3Perpendicular | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI Vector3 Vector3Perpendicular(Vector3 v)
{
Vector3 result = { 0 };
float min = fabsf(v.x);
Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
if (fabsf(v.y) < min)
{
min = fabsf(v.y);
Vector3 tmp = {0.0f, 1.0f, 0.0f};
cardinalAxis = tmp;
}
if (fabsf(v.z) < min)
{
Vector3 tmp = {0.0f, 0.0f, 1.0f};
cardinalAxis = tmp;
}
// Cross product between vectors
result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y;
result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z;
result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x;
return result;
} | O0 | c | Vector3Perpendicular:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movlpd %xmm0, -0x28(%rbp)
movss %xmm1, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
movl $0xc, %edx
callq 0xa2d0
movss -0x18(%rbp), %xmm0
movaps 0xfae34(%rip), %xmm1 # 0x1b42d0
pand %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq 0xfa620(%rip), %rax # 0x1b3acc
movq %rax, -0x38(%rbp)
movl 0xfa61e(%rip), %eax # 0x1b3ad4
movl %eax, -0x30(%rbp)
movss -0x14(%rbp), %xmm1
movaps 0xfae0b(%rip), %xmm0 # 0x1b42d0
pand %xmm0, %xmm1
movss -0x2c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb950a
movss -0x14(%rbp), %xmm0
movaps 0xfadf1(%rip), %xmm1 # 0x1b42d0
pand %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq 0xfa5e9(%rip), %rax # 0x1b3ad8
movq %rax, -0x44(%rbp)
movl 0xfa5e7(%rip), %eax # 0x1b3ae0
movl %eax, -0x3c(%rbp)
movq -0x44(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x30(%rbp)
movss -0x10(%rbp), %xmm1
movaps 0xfadba(%rip), %xmm0 # 0x1b42d0
pand %xmm0, %xmm1
movss -0x2c(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xb9546
movq 0xfa5b9(%rip), %rax # 0x1b3ae4
movq %rax, -0x50(%rbp)
movl 0xfa5b7(%rip), %eax # 0x1b3aec
movl %eax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x30(%rbp)
movss -0x34(%rbp), %xmm3
movss -0x30(%rbp), %xmm2
movss -0x14(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x18(%rbp), %xmm1
movss -0x10(%rbp), %xmm0
movss -0x38(%rbp), %xmm2
movss -0x30(%rbp), %xmm3
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x38(%rbp), %xmm3
movss -0x34(%rbp), %xmm2
movss -0x18(%rbp), %xmm0
movss -0x14(%rbp), %xmm1
mulss %xmm3, %xmm1
mulss %xmm2, %xmm0
subss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movss -0x58(%rbp), %xmm1
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| Vector3Perpendicular:
push rbp
mov rbp, rsp
sub rsp, 60h
movlpd [rbp+var_28], xmm0
movss [rbp+var_20], xmm1
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov eax, [rbp+var_20]
mov [rbp+var_10], eax
lea rdi, [rbp+var_C]
xor esi, esi
mov edx, 0Ch
call _memset
movss xmm0, dword ptr [rbp+var_18]
movaps xmm1, cs:xmmword_1B42D0
pand xmm0, xmm1
movss [rbp+var_2C], xmm0
mov rax, cs:qword_1B3ACC
mov [rbp+var_38], rax
mov eax, cs:dword_1B3AD4
mov [rbp+var_30], eax
movss xmm1, dword ptr [rbp+var_18+4]
movaps xmm0, cs:xmmword_1B42D0
pand xmm1, xmm0
movss xmm0, [rbp+var_2C]
ucomiss xmm0, xmm1
jbe short loc_B950A
movss xmm0, dword ptr [rbp+var_18+4]
movaps xmm1, cs:xmmword_1B42D0
pand xmm0, xmm1
movss [rbp+var_2C], xmm0
mov rax, cs:qword_1B3AD8
mov [rbp+var_44], rax
mov eax, cs:dword_1B3AE0
mov [rbp+var_3C], eax
mov rax, [rbp+var_44]
mov [rbp+var_38], rax
mov eax, [rbp+var_3C]
mov [rbp+var_30], eax
loc_B950A:
movss xmm1, [rbp+var_10]
movaps xmm0, cs:xmmword_1B42D0
pand xmm1, xmm0
movss xmm0, [rbp+var_2C]
ucomiss xmm0, xmm1
jbe short loc_B9546
mov rax, cs:qword_1B3AE4
mov [rbp+var_50], rax
mov eax, cs:dword_1B3AEC
mov [rbp+var_48], eax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov eax, [rbp+var_48]
mov [rbp+var_30], eax
loc_B9546:
movss xmm3, dword ptr [rbp+var_38+4]
movss xmm2, [rbp+var_30]
movss xmm0, dword ptr [rbp+var_18+4]
movss xmm1, [rbp+var_10]
mulss xmm1, xmm3
mulss xmm0, xmm2
subss xmm0, xmm1
movss dword ptr [rbp+var_C], xmm0
movss xmm1, dword ptr [rbp+var_18]
movss xmm0, [rbp+var_10]
movss xmm2, dword ptr [rbp+var_38]
movss xmm3, [rbp+var_30]
mulss xmm1, xmm3
mulss xmm0, xmm2
subss xmm0, xmm1
movss dword ptr [rbp+var_C+4], xmm0
movss xmm3, dword ptr [rbp+var_38]
movss xmm2, dword ptr [rbp+var_38+4]
movss xmm0, dword ptr [rbp+var_18]
movss xmm1, dword ptr [rbp+var_18+4]
mulss xmm1, xmm3
mulss xmm0, xmm2
subss xmm0, xmm1
movss [rbp+var_4], xmm0
mov eax, [rbp+var_4]
mov [rbp+var_58], eax
mov rax, [rbp+var_C]
mov [rbp+var_60], rax
movsd xmm0, [rbp+var_60]
movss xmm1, [rbp+var_58]
add rsp, 60h
pop rbp
retn
| double Vector3Perpendicular(double a1, float a2)
{
long long v3; // [rsp+28h] [rbp-38h]
float v4; // [rsp+30h] [rbp-30h]
__int32 v5; // [rsp+34h] [rbp-2Ch]
double v6; // [rsp+54h] [rbp-Ch] BYREF
memset(&v6, 0LL, 12LL);
COERCE_FLOAT(v5 = _mm_and_si128((__m128i)LODWORD(a1), (__m128i)xmmword_1B42D0).m128i_i32[0]);
v3 = 1065353216LL;
v4 = 0.0;
if ( *(float *)&v5 > *(float *)_mm_and_si128((__m128i)HIDWORD(a1), (__m128i)xmmword_1B42D0).m128i_i32 )
{
v5 = _mm_and_si128((__m128i)HIDWORD(a1), (__m128i)xmmword_1B42D0).m128i_u32[0];
v3 = 0x3F80000000000000LL;
v4 = 0.0;
}
if ( *(float *)&v5 > *(float *)_mm_and_si128((__m128i)LODWORD(a2), (__m128i)xmmword_1B42D0).m128i_i32 )
{
v3 = 0LL;
v4 = 1.0;
}
*(float *)&v6 = (float)(*((float *)&a1 + 1) * v4) - (float)(a2 * *((float *)&v3 + 1));
*((float *)&v6 + 1) = (float)(a2 * *(float *)&v3) - (float)(*(float *)&a1 * v4);
return v6;
}
| Vector3Perpendicular:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOVLPD qword ptr [RBP + -0x28],XMM0
MOVSS dword ptr [RBP + -0x20],XMM1
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x10],EAX
LEA RDI,[RBP + -0xc]
XOR ESI,ESI
MOV EDX,0xc
CALL 0x0010a2d0
MOVSS XMM0,dword ptr [RBP + -0x18]
MOVAPS XMM1,xmmword ptr [0x002b42d0]
PAND XMM0,XMM1
MOVSS dword ptr [RBP + -0x2c],XMM0
MOV RAX,qword ptr [0x002b3acc]
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [0x002b3ad4]
MOV dword ptr [RBP + -0x30],EAX
MOVSS XMM1,dword ptr [RBP + -0x14]
MOVAPS XMM0,xmmword ptr [0x002b42d0]
PAND XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x2c]
UCOMISS XMM0,XMM1
JBE 0x001b950a
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVAPS XMM1,xmmword ptr [0x002b42d0]
PAND XMM0,XMM1
MOVSS dword ptr [RBP + -0x2c],XMM0
MOV RAX,qword ptr [0x002b3ad8]
MOV qword ptr [RBP + -0x44],RAX
MOV EAX,dword ptr [0x002b3ae0]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x44]
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x30],EAX
LAB_001b950a:
MOVSS XMM1,dword ptr [RBP + -0x10]
MOVAPS XMM0,xmmword ptr [0x002b42d0]
PAND XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x2c]
UCOMISS XMM0,XMM1
JBE 0x001b9546
MOV RAX,qword ptr [0x002b3ae4]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [0x002b3aec]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x30],EAX
LAB_001b9546:
MOVSS XMM3,dword ptr [RBP + -0x34]
MOVSS XMM2,dword ptr [RBP + -0x30]
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVSS XMM1,dword ptr [RBP + -0x10]
MULSS XMM1,XMM3
MULSS XMM0,XMM2
SUBSS XMM0,XMM1
MOVSS dword ptr [RBP + -0xc],XMM0
MOVSS XMM1,dword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RBP + -0x10]
MOVSS XMM2,dword ptr [RBP + -0x38]
MOVSS XMM3,dword ptr [RBP + -0x30]
MULSS XMM1,XMM3
MULSS XMM0,XMM2
SUBSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x8],XMM0
MOVSS XMM3,dword ptr [RBP + -0x38]
MOVSS XMM2,dword ptr [RBP + -0x34]
MOVSS XMM0,dword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RBP + -0x14]
MULSS XMM1,XMM3
MULSS XMM0,XMM2
SUBSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x4],XMM0
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x58],EAX
MOV RAX,qword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x60],RAX
MOVSD XMM0,qword ptr [RBP + -0x60]
MOVSS XMM1,dword ptr [RBP + -0x58]
ADD RSP,0x60
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 Vector3Perpendicular(int8 param_1,float param_2)
{
int8 local_40;
float local_38;
float local_34;
float local_20;
float fStack_1c;
int1 local_14 [12];
memset(local_14,0,0xc);
local_20 = (float)param_1;
local_34 = (float)((uint)local_20 & _DAT_002b42d0);
local_40 = DAT_002b3acc;
local_38 = DAT_002b3ad4;
fStack_1c = (float)((ulong)param_1 >> 0x20);
if ((float)((uint)fStack_1c & _DAT_002b42d0) < local_34) {
local_34 = (float)((uint)fStack_1c & _DAT_002b42d0);
local_40 = DAT_002b3ad8;
local_38 = DAT_002b3ae0;
}
if ((float)((uint)param_2 & _DAT_002b42d0) < local_34) {
local_40 = DAT_002b3ae4;
local_38 = DAT_002b3aec;
}
return CONCAT44(param_2 * (float)local_40 - local_20 * local_38,
fStack_1c * local_38 - param_2 * local_40._4_4_);
}
| |
24,546 | Vector3Perpendicular | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI Vector3 Vector3Perpendicular(Vector3 v)
{
Vector3 result = { 0 };
float min = fabsf(v.x);
Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
if (fabsf(v.y) < min)
{
min = fabsf(v.y);
Vector3 tmp = {0.0f, 1.0f, 0.0f};
cardinalAxis = tmp;
}
if (fabsf(v.z) < min)
{
Vector3 tmp = {0.0f, 0.0f, 1.0f};
cardinalAxis = tmp;
}
// Cross product between vectors
result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y;
result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z;
result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x;
return result;
} | O1 | c | Vector3Perpendicular:
movaps %xmm0, %xmm2
movaps 0x71e32(%rip), %xmm4 # 0xd9d00
andps %xmm4, %xmm0
movaps %xmm2, %xmm3
shufps $0x55, %xmm2, %xmm3 # xmm3 = xmm3[1,1],xmm2[1,1]
movaps %xmm3, %xmm7
andps %xmm4, %xmm7
movaps %xmm7, %xmm8
minss %xmm0, %xmm8
andps %xmm1, %xmm4
ucomiss %xmm4, %xmm8
movss 0x71a4d(%rip), %xmm9 # 0xd9944
xorps %xmm5, %xmm5
xorps %xmm6, %xmm6
xorps %xmm10, %xmm10
ja 0x67f13
movaps %xmm7, %xmm6
cmpltss %xmm0, %xmm6
andps %xmm9, %xmm6
movaps %xmm9, %xmm10
ucomiss %xmm7, %xmm0
cmpltss %xmm8, %xmm4
andps %xmm9, %xmm4
ja 0x67f26
movaps %xmm10, %xmm5
movaps %xmm6, %xmm7
mulss %xmm1, %xmm7
movaps %xmm3, %xmm0
mulss %xmm4, %xmm0
subss %xmm7, %xmm0
mulss %xmm2, %xmm4
mulss %xmm5, %xmm1
subss %xmm4, %xmm1
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
mulss %xmm3, %xmm5
mulss %xmm6, %xmm2
subss %xmm5, %xmm2
movaps %xmm2, %xmm1
retq
| Vector3Perpendicular:
movaps xmm2, xmm0
movaps xmm4, cs:xmmword_D9D00
andps xmm0, xmm4
movaps xmm3, xmm2
shufps xmm3, xmm2, 55h ; 'U'
movaps xmm7, xmm3
andps xmm7, xmm4
movaps xmm8, xmm7
minss xmm8, xmm0
andps xmm4, xmm1
ucomiss xmm8, xmm4
movss xmm9, cs:dword_D9944
xorps xmm5, xmm5
xorps xmm6, xmm6
xorps xmm10, xmm10
ja short loc_67F13
movaps xmm6, xmm7
cmpltss xmm6, xmm0
andps xmm6, xmm9
movaps xmm10, xmm9
loc_67F13:
ucomiss xmm0, xmm7
cmpltss xmm4, xmm8
andps xmm4, xmm9
ja short loc_67F26
movaps xmm5, xmm10
loc_67F26:
movaps xmm7, xmm6
mulss xmm7, xmm1
movaps xmm0, xmm3
mulss xmm0, xmm4
subss xmm0, xmm7
mulss xmm4, xmm2
mulss xmm1, xmm5
subss xmm1, xmm4
unpcklps xmm0, xmm1
mulss xmm5, xmm3
mulss xmm2, xmm6
subss xmm2, xmm5
movaps xmm1, xmm2
retn
| __m128 Vector3Perpendicular(__m128 a1, __m128 a2)
{
__m128 v2; // xmm2
__m128 v3; // xmm3
__m128 v4; // xmm7
__m128 v5; // xmm8
__m128 v6; // xmm4
float v7; // xmm5_4
float v8; // xmm6_4
int v9; // xmm10_4
float v10; // xmm4_4
__m128 v11; // xmm0
v2 = a1;
a1.m128_i32[0] = fabs(a1.m128_f32[0]);
v3 = _mm_shuffle_ps(v2, v2, 85);
v4 = _mm_and_ps(v3, (__m128)xmmword_D9D00);
v5.m128_f32[0] = fminf(v4.m128_f32[0], a1.m128_f32[0]);
v6 = _mm_and_ps((__m128)xmmword_D9D00, a2);
v7 = 0.0;
v8 = 0.0;
v9 = 0;
if ( v5.m128_f32[0] <= v6.m128_f32[0] )
{
LODWORD(v8) = _mm_cmplt_ss(v4, a1).m128_u32[0] & 0x3F800000;
v9 = 1065353216;
}
LODWORD(v10) = _mm_cmplt_ss(v6, v5).m128_u32[0] & 0x3F800000;
if ( a1.m128_f32[0] <= v4.m128_f32[0] )
v7 = *(float *)&v9;
v11 = v3;
v11.m128_f32[0] = (float)(v3.m128_f32[0] * v10) - (float)(v8 * a2.m128_f32[0]);
a2.m128_f32[0] = (float)(a2.m128_f32[0] * v7) - (float)(v10 * v2.m128_f32[0]);
return _mm_unpacklo_ps(v11, a2);
}
| Vector3Perpendicular:
MOVAPS XMM2,XMM0
MOVAPS XMM4,xmmword ptr [0x001d9d00]
ANDPS XMM0,XMM4
MOVAPS XMM3,XMM2
SHUFPS XMM3,XMM2,0x55
MOVAPS XMM7,XMM3
ANDPS XMM7,XMM4
MOVAPS XMM8,XMM7
MINSS XMM8,XMM0
ANDPS XMM4,XMM1
UCOMISS XMM8,XMM4
MOVSS XMM9,dword ptr [0x001d9944]
XORPS XMM5,XMM5
XORPS XMM6,XMM6
XORPS XMM10,XMM10
JA 0x00167f13
MOVAPS XMM6,XMM7
CMPLTSS XMM6,XMM0
ANDPS XMM6,XMM9
MOVAPS XMM10,XMM9
LAB_00167f13:
UCOMISS XMM0,XMM7
CMPLTSS XMM4,XMM8
ANDPS XMM4,XMM9
JA 0x00167f26
MOVAPS XMM5,XMM10
LAB_00167f26:
MOVAPS XMM7,XMM6
MULSS XMM7,XMM1
MOVAPS XMM0,XMM3
MULSS XMM0,XMM4
SUBSS XMM0,XMM7
MULSS XMM4,XMM2
MULSS XMM1,XMM5
SUBSS XMM1,XMM4
UNPCKLPS XMM0,XMM1
MULSS XMM5,XMM3
MULSS XMM2,XMM6
SUBSS XMM2,XMM5
MOVAPS XMM1,XMM2
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 Vector3Perpendicular(int8 param_1,float param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
fVar2 = (float)((ulong)param_1 >> 0x20);
fVar1 = (float)((uint)(float)param_1 & _DAT_001d9d00);
fVar6 = (float)((uint)fVar2 & _DAT_001d9d00);
fVar4 = fVar6;
if (fVar1 <= fVar6) {
fVar4 = fVar1;
}
fVar5 = 0.0;
fVar7 = 0.0;
if (fVar4 <= (float)(_DAT_001d9d00 & (uint)param_2)) {
fVar5 = (float)(-(uint)(fVar6 < fVar1) & (uint)DAT_001d9944);
fVar7 = DAT_001d9944;
}
fVar3 = (float)(-(uint)((float)(_DAT_001d9d00 & (uint)param_2) < fVar4) & (uint)DAT_001d9944);
fVar4 = 0.0;
if (fVar1 <= fVar6) {
fVar4 = fVar7;
}
return CONCAT44(param_2 * fVar4 - fVar3 * (float)param_1,fVar2 * fVar3 - fVar5 * param_2);
}
| |
24,547 | Vector3Perpendicular | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI Vector3 Vector3Perpendicular(Vector3 v)
{
Vector3 result = { 0 };
float min = fabsf(v.x);
Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
if (fabsf(v.y) < min)
{
min = fabsf(v.y);
Vector3 tmp = {0.0f, 1.0f, 0.0f};
cardinalAxis = tmp;
}
if (fabsf(v.z) < min)
{
Vector3 tmp = {0.0f, 0.0f, 1.0f};
cardinalAxis = tmp;
}
// Cross product between vectors
result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y;
result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z;
result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x;
return result;
} | O2 | c | Vector3Perpendicular:
movdqa %xmm0, %xmm2
movdqa 0x636a3(%rip), %xmm3 # 0xb9b00
pand %xmm3, %xmm0
pshufd $0x55, %xmm0, %xmm8 # xmm8 = xmm0[1,1,1,1]
movdqa %xmm8, %xmm7
minss %xmm0, %xmm7
pand %xmm1, %xmm3
ucomiss %xmm3, %xmm7
movss 0x6321c(%rip), %xmm9 # 0xb969c
xorps %xmm4, %xmm4
xorps %xmm5, %xmm5
xorps %xmm10, %xmm10
ja 0x5649e
movdqa %xmm8, %xmm5
cmpltss %xmm0, %xmm5
andps %xmm9, %xmm5
movaps %xmm9, %xmm10
movdqa %xmm2, %xmm6
shufps $0x55, %xmm2, %xmm6 # xmm6 = xmm6[1,1],xmm2[1,1]
ucomiss %xmm8, %xmm0
cmpltss %xmm7, %xmm3
andps %xmm9, %xmm3
ja 0x564b9
movaps %xmm10, %xmm4
movaps %xmm5, %xmm7
mulss %xmm1, %xmm7
movaps %xmm6, %xmm0
mulss %xmm3, %xmm0
subss %xmm7, %xmm0
mulss %xmm2, %xmm3
mulss %xmm4, %xmm1
subss %xmm3, %xmm1
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
mulss %xmm6, %xmm4
mulss %xmm5, %xmm2
subss %xmm4, %xmm2
movaps %xmm2, %xmm1
retq
| Vector3Perpendicular:
movdqa xmm2, xmm0
movdqa xmm3, cs:xmmword_B9B00
pand xmm0, xmm3
pshufd xmm8, xmm0, 55h ; 'U'
movdqa xmm7, xmm8
minss xmm7, xmm0
pand xmm3, xmm1
ucomiss xmm7, xmm3
movss xmm9, cs:dword_B969C
xorps xmm4, xmm4
xorps xmm5, xmm5
xorps xmm10, xmm10
ja short loc_5649E
movdqa xmm5, xmm8
cmpltss xmm5, xmm0
andps xmm5, xmm9
movaps xmm10, xmm9
loc_5649E:
movdqa xmm6, xmm2
shufps xmm6, xmm2, 55h ; 'U'
ucomiss xmm0, xmm8
cmpltss xmm3, xmm7
andps xmm3, xmm9
ja short loc_564B9
movaps xmm4, xmm10
loc_564B9:
movaps xmm7, xmm5
mulss xmm7, xmm1
movaps xmm0, xmm6
mulss xmm0, xmm3
subss xmm0, xmm7
mulss xmm3, xmm2
mulss xmm1, xmm4
subss xmm1, xmm3
unpcklps xmm0, xmm1
mulss xmm4, xmm6
mulss xmm2, xmm5
subss xmm2, xmm4
movaps xmm1, xmm2
retn
| __m128 Vector3Perpendicular(__m128i a1, __m128i a2)
{
__m128i si128; // xmm3
__m128 v4; // xmm0
__m128 v5; // xmm8
__m128 v6; // xmm7
__m128 v7; // xmm3
float v8; // xmm4_4
float v9; // xmm5_4
int v10; // xmm10_4
__m128 v11; // xmm6
float v12; // xmm3_4
__m128 v13; // xmm0
si128 = _mm_load_si128((const __m128i *)&xmmword_B9B00);
v4 = (__m128)_mm_and_si128(a1, si128);
v5 = (__m128)_mm_shuffle_epi32((__m128i)v4, 85);
v6.m128_f32[0] = fminf(v5.m128_f32[0], v4.m128_f32[0]);
v7 = (__m128)_mm_and_si128(si128, a2);
v8 = 0.0;
v9 = 0.0;
v10 = 0;
if ( v6.m128_f32[0] <= v7.m128_f32[0] )
{
LODWORD(v9) = _mm_cmplt_ss(v5, v4).m128_u32[0] & 0x3F800000;
v10 = 1065353216;
}
v11 = _mm_shuffle_ps((__m128)a1, (__m128)a1, 85);
LODWORD(v12) = _mm_cmplt_ss(v7, v6).m128_u32[0] & 0x3F800000;
if ( v4.m128_f32[0] <= v5.m128_f32[0] )
v8 = *(float *)&v10;
v13 = v11;
v13.m128_f32[0] = (float)(v11.m128_f32[0] * v12) - (float)(v9 * *(float *)a2.m128i_i32);
*(float *)a2.m128i_i32 = (float)(*(float *)a2.m128i_i32 * v8) - (float)(v12 * *(float *)a1.m128i_i32);
return _mm_unpacklo_ps(v13, (__m128)a2);
}
| Vector3Perpendicular:
MOVDQA XMM2,XMM0
MOVDQA XMM3,xmmword ptr [0x001b9b00]
PAND XMM0,XMM3
PSHUFD XMM8,XMM0,0x55
MOVDQA XMM7,XMM8
MINSS XMM7,XMM0
PAND XMM3,XMM1
UCOMISS XMM7,XMM3
MOVSS XMM9,dword ptr [0x001b969c]
XORPS XMM4,XMM4
XORPS XMM5,XMM5
XORPS XMM10,XMM10
JA 0x0015649e
MOVDQA XMM5,XMM8
CMPLTSS XMM5,XMM0
ANDPS XMM5,XMM9
MOVAPS XMM10,XMM9
LAB_0015649e:
MOVDQA XMM6,XMM2
SHUFPS XMM6,XMM2,0x55
UCOMISS XMM0,XMM8
CMPLTSS XMM3,XMM7
ANDPS XMM3,XMM9
JA 0x001564b9
MOVAPS XMM4,XMM10
LAB_001564b9:
MOVAPS XMM7,XMM5
MULSS XMM7,XMM1
MOVAPS XMM0,XMM6
MULSS XMM0,XMM3
SUBSS XMM0,XMM7
MULSS XMM3,XMM2
MULSS XMM1,XMM4
SUBSS XMM1,XMM3
UNPCKLPS XMM0,XMM1
MULSS XMM4,XMM6
MULSS XMM2,XMM5
SUBSS XMM2,XMM4
MOVAPS XMM1,XMM2
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void Vector3Perpendicular(void)
{
return;
}
| |
24,548 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x6ac4d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27380
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9a287
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x27998
movq %r14, %rdi
callq 0x27660
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJPKcEEEmS4_DpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(char const*,char const* const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA26_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = nlohmann::json_abi_v3_11_3::detail::concat_length<char const*>(a2, a3);
std::string::reserve(a1, v4);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA26_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_(
a1,
a2,
a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[26],char_const*>:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
MOV RSI,RDX
CALL 0x0016ac4d
LAB_00199fec:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00127380
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0019a287
LAB_0019a005:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [26], char const*>(char const (&) [26], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
concat_length<char_const*>(param_1,param_2);
/* try { // try from 00199fec to 0019a004 has its CatchHandler @ 0019a00e */
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA26_KcJPS9_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSE_OSF_DpOT1_
(this,param_1,param_2);
return this;
}
| |
24,549 | my_copy_8bit | eloqsql/strings/ctype-simple.c | size_t
my_copy_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t dst_length,
const char *src, size_t src_length,
size_t nchars, MY_STRCOPY_STATUS *status)
{
set_if_smaller(src_length, dst_length);
set_if_smaller(src_length, nchars);
if (src_length)
memmove(dst, src, src_length);
status->m_source_end_pos= src + src_length;
status->m_well_formed_error_pos= NULL;
return src_length;
} | O0 | c | my_copy_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xa3686
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xa3688
jmp 0xa368a
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0xa369c
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xa369e
cmpq $0x0, -0x28(%rbp)
je 0xa36b6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x28600
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_copy_8bit:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jbe short loc_A3686
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_A3686:
jmp short $+2
loc_A3688:
jmp short $+2
loc_A368A:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jbe short loc_A369C
mov rax, [rbp+var_30]
mov [rbp+var_28], rax
loc_A369C:
jmp short $+2
loc_A369E:
cmp [rbp+var_28], 0
jz short loc_A36B6
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call _memmove
loc_A36B6:
mov rcx, [rbp+var_20]
add rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax], rcx
mov rax, [rbp+arg_0]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| unsigned long long my_copy_8bit(
long long a1,
long long a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
_QWORD *a7)
{
unsigned long long v8; // [rsp+8h] [rbp-28h]
v8 = a5;
if ( a5 > a3 )
v8 = a3;
if ( v8 > a6 )
v8 = a6;
if ( v8 )
memmove(a2, a4, v8);
*a7 = v8 + a4;
a7[1] = 0LL;
return v8;
}
| my_copy_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x001a3686
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a3686:
JMP 0x001a3688
LAB_001a3688:
JMP 0x001a368a
LAB_001a368a:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x001a369c
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
LAB_001a369c:
JMP 0x001a369e
LAB_001a369e:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x001a36b6
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00128600
LAB_001a36b6:
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
size_t my_copy_8bit(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5,
ulong param_6,long *param_7)
{
ulong local_30;
local_30 = param_5;
if (param_3 < param_5) {
local_30 = param_3;
}
if (param_6 < local_30) {
local_30 = param_6;
}
if (local_30 != 0) {
memmove(param_2,param_4,local_30);
}
*param_7 = (long)param_4 + local_30;
param_7[1] = 0;
return local_30;
}
| |
24,550 | my_strnncollsp_simple | eloqsql/strings/ctype-simple.c | int my_strnncollsp_simple(CHARSET_INFO * cs, const uchar *a, size_t a_length,
const uchar *b, size_t b_length)
{
const uchar *map= cs->sort_order, *end;
size_t length;
int res;
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (map[*a++] != map[*b++])
return ((int) map[a[-1]] - (int) map[b[-1]]);
}
res= 0;
if (a_length != b_length)
{
int swap= 1;
/*
Check the next not space character of the longer key. If it's < ' ',
then it's smaller than the other key.
*/
if (a_length < b_length)
{
/* put shorter key in s */
a_length= b_length;
a= b;
swap= -1; /* swap sign of result */
res= -res;
}
for (end= a + a_length-length; a < end ; a++)
{
if (map[*a] != map[' '])
return (map[*a] < map[' ']) ? -swap : swap;
}
}
return res;
} | O0 | c | my_strnncollsp_simple:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x96510
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x96518
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x48(%rbp)
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x96599
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x96597
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl -0x1(%rdx), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x96663
jmp 0x9652b
movl $0x0, -0x4c(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x9665d
movl $0x1, -0x50(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x965de
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
xorl %eax, %eax
subl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x9665b
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
je 0x9664b
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0x9663d
xorl %eax, %eax
subl -0x50(%rbp), %eax
movl %eax, -0x64(%rbp)
jmp 0x96643
movl -0x50(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x96663
jmp 0x9664d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x965f3
jmp 0x9665d
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_strnncollsp_simple:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_96510
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
jmp short loc_96518
loc_96510:
mov rax, [rbp+var_30]
mov [rbp+var_60], rax
loc_96518:
mov rax, [rbp+var_58]
mov rcx, [rbp+var_60]
mov [rbp+var_48], rcx
add rax, rcx
mov [rbp+var_40], rax
loc_9652B:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_40]
jnb short loc_96599
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 1
mov [rbp+var_18], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
mov rdx, [rbp+var_28]
mov rsi, rdx
add rsi, 1
mov [rbp+var_28], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_96597
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
mov rdx, [rbp+var_28]
movzx edx, byte ptr [rdx-1]
movzx ecx, byte ptr [rcx+rdx]
sub eax, ecx
mov [rbp+var_4], eax
jmp loc_96663
loc_96597:
jmp short loc_9652B
loc_96599:
mov [rbp+var_4C], 0
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jz loc_9665D
mov [rbp+var_50], 1
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jnb short loc_965DE
mov rax, [rbp+var_30]
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
mov [rbp+var_50], 0FFFFFFFFh
xor eax, eax
sub eax, [rbp+var_4C]
mov [rbp+var_4C], eax
loc_965DE:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_48]
add rax, rcx
mov [rbp+var_40], rax
loc_965F3:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_40]
jnb short loc_9665B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+20h]
cmp eax, ecx
jz short loc_9664B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+20h]
cmp eax, ecx
jge short loc_9663D
xor eax, eax
sub eax, [rbp+var_50]
mov [rbp+var_64], eax
jmp short loc_96643
loc_9663D:
mov eax, [rbp+var_50]
mov [rbp+var_64], eax
loc_96643:
mov eax, [rbp+var_64]
mov [rbp+var_4], eax
jmp short loc_96663
loc_9664B:
jmp short $+2
loc_9664D:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_965F3
loc_9665B:
jmp short $+2
loc_9665D:
mov eax, [rbp+var_4C]
mov [rbp+var_4], eax
loc_96663:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_strnncollsp_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5)
{
unsigned __int8 *v5; // rcx
unsigned __int8 *v6; // rdx
unsigned long long v9; // [rsp+4h] [rbp-60h]
unsigned int v10; // [rsp+14h] [rbp-50h]
unsigned __int8 *v11; // [rsp+24h] [rbp-40h]
long long v12; // [rsp+2Ch] [rbp-38h]
unsigned long long v14; // [rsp+44h] [rbp-20h]
unsigned __int8 *v15; // [rsp+4Ch] [rbp-18h]
v15 = a2;
v14 = a3;
v12 = *(_QWORD *)(a1 + 88);
if ( a3 >= a5 )
v9 = a5;
else
v9 = a3;
while ( v15 < &a2[v9] )
{
v5 = v15++;
v6 = a4++;
if ( *(unsigned __int8 *)(v12 + *v5) != *(unsigned __int8 *)(v12 + *v6) )
return (unsigned int)(*(unsigned __int8 *)(v12 + *(v15 - 1)) - *(unsigned __int8 *)(v12 + *(a4 - 1)));
}
if ( v14 != a5 )
{
v10 = 1;
if ( v14 < a5 )
{
v14 = a5;
v15 = a4;
v10 = -1;
}
v11 = &v15[v14 - v9];
while ( v15 < v11 )
{
if ( *(unsigned __int8 *)(v12 + *v15) != *(unsigned __int8 *)(v12 + 32) )
{
if ( *(unsigned __int8 *)(v12 + *v15) >= (int)*(unsigned __int8 *)(v12 + 32) )
return v10;
else
return -v10;
}
++v15;
}
}
return 0;
}
| my_strnncollsp_simple:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00196510
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00196518
LAB_00196510:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x60],RAX
LAB_00196518:
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x48],RCX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_0019652b:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00196599
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x28]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x28],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00196597
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + -0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX EDX,byte ptr [RDX + -0x1]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00196663
LAB_00196597:
JMP 0x0019652b
LAB_00196599:
MOV dword ptr [RBP + -0x4c],0x0
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0019665d
MOV dword ptr [RBP + -0x50],0x1
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001965de
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x50],0xffffffff
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x4c],EAX
LAB_001965de:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x48]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_001965f3:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0019665b
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x20]
CMP EAX,ECX
JZ 0x0019664b
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x20]
CMP EAX,ECX
JGE 0x0019663d
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x64],EAX
JMP 0x00196643
LAB_0019663d:
MOV EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x64],EAX
LAB_00196643:
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00196663
LAB_0019664b:
JMP 0x0019664d
LAB_0019664d:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001965f3
LAB_0019665b:
JMP 0x0019665d
LAB_0019665d:
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00196663:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int my_strnncollsp_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5)
{
long lVar1;
byte *pbVar2;
byte *pbVar3;
int local_6c;
ulong local_68;
int local_58;
byte *local_30;
ulong local_28;
byte *local_20;
lVar1 = *(long *)(param_1 + 0x58);
local_68 = param_5;
if (param_3 < param_5) {
local_68 = param_3;
}
pbVar3 = param_4;
pbVar2 = param_2;
do {
local_20 = pbVar2;
local_30 = pbVar3;
if (param_2 + local_68 <= local_20) {
if (param_3 != param_5) {
local_58 = 1;
local_28 = param_3;
if (param_3 < param_5) {
local_20 = local_30;
local_58 = -1;
local_28 = param_5;
}
pbVar3 = local_20 + (local_28 - local_68);
for (; local_20 < pbVar3; local_20 = local_20 + 1) {
if (*(char *)(lVar1 + (ulong)*local_20) != *(char *)(lVar1 + 0x20)) {
if (*(byte *)(lVar1 + (ulong)*local_20) < *(byte *)(lVar1 + 0x20)) {
local_6c = -local_58;
}
else {
local_6c = local_58;
}
return local_6c;
}
}
}
return 0;
}
pbVar3 = local_30 + 1;
pbVar2 = local_20 + 1;
} while (*(char *)(lVar1 + (ulong)*local_20) == *(char *)(lVar1 + (ulong)*local_30));
return (uint)*(byte *)(lVar1 + (ulong)*local_20) - (uint)*(byte *)(lVar1 + (ulong)*local_30);
}
| |
24,551 | sanitize_file(PFS_file*) | eloqsql/storage/perfschema/pfs_instr.cc | PFS_file *sanitize_file(PFS_file *unsafe)
{
return global_file_container.sanitize(unsafe);
} | O3 | cpp | sanitize_file(PFS_file*):
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorl %ecx, %ecx
leaq 0x360ffb(%rip), %rdx # 0x390d98
movabsq $0x2e8ba2e8ba2e8ba3, %rsi # imm = 0x2E8BA2E8BA2E8BA3
movabsq $0x5d1745d1745d18, %rdi # imm = 0x5D1745D1745D18
movq 0xa8(%rdx,%rcx,8), %r9
testq %r9, %r9
je 0x2fdea
movq 0x48(%r9), %r8
cmpq %rax, %r8
ja 0x2fdea
imulq $0x2c0, 0x50(%r9), %r9 # imm = 0x2C0
addq %r8, %r9
cmpq %rax, %r9
jbe 0x2fdea
movq %rax, %r9
subq %r8, %r9
imulq %rsi, %r9
rorq $0x6, %r9
cmpq %rdi, %r9
jb 0x2fdf8
incq %rcx
cmpq $0x1000, %rcx # imm = 0x1000
jne 0x2fdb1
xorl %eax, %eax
popq %rbp
retq
| _Z13sanitize_fileP8PFS_file:
push rbp
mov rbp, rsp
mov rax, rdi
xor ecx, ecx
lea rdx, global_file_container
mov rsi, 2E8BA2E8BA2E8BA3h
mov rdi, 5D1745D1745D18h
loc_2FDB1:
mov r9, [rdx+rcx*8+0A8h]
test r9, r9
jz short loc_2FDEA
mov r8, [r9+48h]
cmp r8, rax
ja short loc_2FDEA
imul r9, [r9+50h], 2C0h
add r9, r8
cmp r9, rax
jbe short loc_2FDEA
mov r9, rax
sub r9, r8
imul r9, rsi
ror r9, 6
cmp r9, rdi
jb short loc_2FDF8
loc_2FDEA:
inc rcx
cmp rcx, 1000h
jnz short loc_2FDB1
xor eax, eax
loc_2FDF8:
pop rbp
retn
| unsigned long long sanitize_file(unsigned long long a1)
{
unsigned long long result; // rax
long long v2; // rcx
long long v3; // r9
unsigned long long v4; // r8
result = a1;
v2 = 0LL;
while ( 1 )
{
v3 = global_file_container[v2 + 21];
if ( v3 )
{
v4 = *(_QWORD *)(v3 + 72);
if ( v4 <= a1
&& v4 + 704LL * *(_QWORD *)(v3 + 80) > a1
&& __ROR8__(0x2E8BA2E8BA2E8BA3LL * (a1 - v4), 6) < 0x5D1745D1745D18uLL )
{
break;
}
}
if ( ++v2 == 4096 )
return 0LL;
}
return result;
}
| sanitize_file:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
XOR ECX,ECX
LEA RDX,[0x490d98]
MOV RSI,0x2e8ba2e8ba2e8ba3
MOV RDI,0x5d1745d1745d18
LAB_0012fdb1:
MOV R9,qword ptr [RDX + RCX*0x8 + 0xa8]
TEST R9,R9
JZ 0x0012fdea
MOV R8,qword ptr [R9 + 0x48]
CMP R8,RAX
JA 0x0012fdea
IMUL R9,qword ptr [R9 + 0x50],0x2c0
ADD R9,R8
CMP R9,RAX
JBE 0x0012fdea
MOV R9,RAX
SUB R9,R8
IMUL R9,RSI
ROR R9,0x6
CMP R9,RDI
JC 0x0012fdf8
LAB_0012fdea:
INC RCX
CMP RCX,0x1000
JNZ 0x0012fdb1
XOR EAX,EAX
LAB_0012fdf8:
POP RBP
RET
|
/* sanitize_file(PFS_file*) */
PFS_file * sanitize_file(PFS_file *param_1)
{
long lVar1;
PFS_file *pPVar2;
long lVar3;
ulong uVar4;
lVar3 = 0;
while ((((lVar1 = (&DAT_00490e40)[lVar3], lVar1 == 0 ||
(pPVar2 = *(PFS_file **)(lVar1 + 0x48), param_1 < pPVar2)) ||
(pPVar2 + *(long *)(lVar1 + 0x50) * 0x2c0 <= param_1)) ||
(uVar4 = ((long)param_1 - (long)pPVar2) * 0x2e8ba2e8ba2e8ba3,
0x5d1745d1745d17 < (uVar4 >> 6 | uVar4 << 0x3a)))) {
lVar3 = lVar3 + 1;
if (lVar3 == 0x1000) {
return (PFS_file *)0x0;
}
}
return param_1;
}
| |
24,552 | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("ExpressionNode.expr is null");
auto result = expr->evaluate(context);
if (result.is_string()) {
out << result.get<std::string>();
} else if (result.is_boolean()) {
out << (result.get<bool>() ? "True" : "False");
} else if (!result.is_null()) {
out << result.dump();
}
} | O0 | cpp | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x20, %rdi
callq 0x10e9a0
testb $0x1, %al
jne 0x154f27
movl $0x10, %edi
callq 0x5a6b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0xbf5f5(%rip), %rsi # 0x2144da
callq 0x5a490
jmp 0x154eec
movq 0x20(%rsp), %rdi
movq 0x1510b8(%rip), %rsi # 0x2a5fb0
movq 0x151079(%rip), %rdx # 0x2a5f78
callq 0x5ab10
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
callq 0x5af90
jmp 0x1550b6
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x114ad0
movq %rax, %rsi
movq 0xd0(%rsp), %rdx
leaq 0x70(%rsp), %rdi
callq 0x114ae0
leaq 0x70(%rsp), %rdi
callq 0x116840
testb $0x1, %al
jne 0x154f5a
jmp 0x154fd4
movq 0xd8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x116ec0
jmp 0x154f78
movq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x5a560
jmp 0x154f89
leaq 0x50(%rsp), %rdi
callq 0x5b578
jmp 0x15509a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0x1550ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5b578
jmp 0x1550ac
leaq 0x70(%rsp), %rdi
callq 0x116820
testb $0x1, %al
jne 0x154fe4
jmp 0x155028
movq 0xd8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x116d90
movb %al, 0x17(%rsp)
jmp 0x155001
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %cl
leaq 0xbe4e2(%rip), %rax # 0x2134f3
leaq 0xbe4e0(%rip), %rsi # 0x2134f8
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x5aa40
jmp 0x155026
jmp 0x155098
leaq 0x70(%rsp), %rdi
callq 0x116220
testb $0x1, %al
jne 0x155096
movq 0xd8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x1154b0
jmp 0x15505a
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5a560
jmp 0x15506a
leaq 0x30(%rsp), %rdi
callq 0x5b578
jmp 0x155096
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5b578
jmp 0x1550ac
jmp 0x155098
jmp 0x15509a
leaq 0x70(%rsp), %rdi
callq 0x114f80
addq $0xe8, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x114f80
movq 0xc8(%rsp), %rdi
callq 0x5abd0
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK5minja14ExpressionNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov qword ptr [rsp+0E8h+var_10], rsi
mov [rsp+0E8h+var_18], rdx
mov rdi, [rsp+0E8h+var_8]
mov [rsp+0E8h+var_C0], rdi; __int64
add rdi, 20h ; ' '
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 short loc_154F27
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0E8h+var_C8], rax
lea rsi, aExpressionnode; "ExpressionNode.expr is null"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_154EEC:
mov rdi, [rsp+0E8h+var_C8]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+0E8h+var_C8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
call ___cxa_free_exception
jmp loc_1550B6
loc_154F27:
mov rdi, [rsp+0E8h+var_C0]
add rdi, 20h ; ' '
call _ZNKSt19__shared_ptr_accessIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rdx, [rsp+0E8h+var_18]
lea rdi, [rsp+0E8h+var_78]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
lea rdi, [rsp+0E8h+var_78]; this
call _ZNK5minja5Value9is_stringEv; minja::Value::is_string(void)
test al, 1
jnz short loc_154F5A
jmp short loc_154FD4
loc_154F5A:
mov rax, qword ptr [rsp+0E8h+var_10]
mov qword ptr [rsp+0E8h+var_D0], rax; int
lea rdi, [rsp+0E8h+var_98]; int
lea rsi, [rsp+0E8h+var_78]; int
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
jmp short $+2
loc_154F78:
mov rdi, qword ptr [rsp+0E8h+var_D0]
lea rsi, [rsp+0E8h+var_98]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_154F89:
lea rdi, [rsp+0E8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_15509A
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
jmp loc_1550AC
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
lea rdi, [rsp+0E8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_1550AC
loc_154FD4:
lea rdi, [rsp+0E8h+var_78]; this
call _ZNK5minja5Value10is_booleanEv; minja::Value::is_boolean(void)
test al, 1
jnz short loc_154FE4
jmp short loc_155028
loc_154FE4:
mov rax, qword ptr [rsp+0E8h+var_10]
mov [rsp+0E8h+var_E0], rax
lea rdi, [rsp+0E8h+var_78]
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
mov [rsp+0E8h+var_D1], al
jmp short $+2
loc_155001:
mov rdi, [rsp+0E8h+var_E0]
mov cl, [rsp+0E8h+var_D1]
lea rax, aTrue_0; "True"
lea rsi, aFalse; "False"
test cl, 1
cmovnz rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_155026:
jmp short loc_155098
loc_155028:
lea rdi, [rsp+0E8h+var_78]; this
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, 1
jnz short loc_155096
mov rax, qword ptr [rsp+0E8h+var_10]
mov [rsp+0E8h+var_E8], rax
lea rdi, [rsp+0E8h+var_B8]
lea rsi, [rsp+0E8h+var_78]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_15505A:
mov rdi, [rsp+0E8h+var_E8]
lea rsi, [rsp+0E8h+var_B8]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short $+2
loc_15506A:
lea rdi, [rsp+0E8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_155096
mov rcx, rax
mov eax, edx
mov [rsp+0E8h+var_20], rcx
mov [rsp+0E8h+var_24], eax
lea rdi, [rsp+0E8h+var_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_1550AC
loc_155096:
jmp short $+2
loc_155098:
jmp short $+2
loc_15509A:
lea rdi, [rsp+0E8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 0E8h
retn
loc_1550AC:
lea rdi, [rsp+0E8h+var_78]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_1550B6:
mov rdi, [rsp+0E8h+var_20]
call __Unwind_Resume
| void minja::ExpressionNode::do_render(long long a1, long long a2, long long a3)
{
void (***v3)(void); // rax
long long v4; // rdi
const char *v5; // rsi
long long v6; // [rsp+0h] [rbp-E8h]
int v7[2]; // [rsp+18h] [rbp-D0h]
std::runtime_error *exception; // [rsp+20h] [rbp-C8h]
_BYTE v9[32]; // [rsp+30h] [rbp-B8h] BYREF
int v10[8]; // [rsp+50h] [rbp-98h] BYREF
int v11[21]; // [rsp+70h] [rbp-78h] BYREF
long long v12; // [rsp+D0h] [rbp-18h]
int v13[2]; // [rsp+D8h] [rbp-10h]
long long v14; // [rsp+E0h] [rbp-8h]
v14 = a1;
*(_QWORD *)v13 = a2;
v12 = a3;
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool((_QWORD *)(a1 + 32)) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ExpressionNode.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (void (***)(void))std::__shared_ptr_access<minja::Expression,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a1 + 32);
minja::Expression::evaluate((long long)v11, v3);
if ( minja::Value::is_string((minja::Value *)v11) )
{
*(_QWORD *)v7 = *(_QWORD *)v13;
minja::Value::get<std::string>(v10, (minja::Value *)v11);
std::operator<<<char>(*(_QWORD *)v7, v10);
std::string::~string(v10);
}
else if ( (minja::Value::is_boolean((minja::Value *)v11) & 1) != 0 )
{
v4 = *(_QWORD *)v13;
v5 = "False";
if ( (minja::Value::get<bool>((minja::Value *)v11) & 1) != 0 )
v5 = "True";
std::operator<<<std::char_traits<char>>(v4, v5);
}
else if ( (minja::Value::is_null((minja::Value *)v11) & 1) == 0 )
{
v6 = *(_QWORD *)v13;
minja::Value::dump[abi:cxx11]((long long)v9, (long long)v11, 0xFFFFFFFF, 0);
std::operator<<<char>(v6, v9);
std::string::~string(v9);
}
minja::Value::~Value((minja::Value *)v11);
}
| |||
24,553 | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
if (!expr) throw std::runtime_error("ExpressionNode.expr is null");
auto result = expr->evaluate(context);
if (result.is_string()) {
out << result.get<std::string>();
} else if (result.is_boolean()) {
out << (result.get<bool>() ? "True" : "False");
} else if (!result.is_null()) {
out << result.dump();
}
} | O2 | cpp | minja::ExpressionNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x76280
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x635ba
movzbl 0x40(%r14), %eax
cmpl $0x4, %eax
je 0x761ff
cmpl $0x3, %eax
jne 0x76227
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6446c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x237e0
jmp 0x76264
leaq 0x28(%rsp), %rdi
callq 0x643b6
leaq 0x3d8ec(%rip), %rcx # 0xb3afc
leaq 0x3d8ea(%rip), %rsi # 0xb3b01
testb %al, %al
cmovneq %rcx, %rsi
movq %rbx, %rdi
callq 0x238b0
jmp 0x7626e
testb %al, %al
jne 0x76243
cmpq $0x0, 0x48(%rsp)
jne 0x76243
cmpq $0x0, 0x38(%rsp)
jne 0x76243
cmpq $0x0, 0x58(%rsp)
je 0x7626e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $-0x1
popq %rdx
xorl %ecx, %ecx
callq 0x63a38
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x237e0
leaq 0x8(%rsp), %rdi
callq 0x241f8
leaq 0x28(%rsp), %rdi
callq 0x6384a
addq $0x78, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r14
leaq 0x3e851(%rip), %rsi # 0xb4ae3
movq %rax, %rdi
callq 0x23310
movq 0x87d4f(%rip), %rsi # 0xfdff0
movq 0x87cb0(%rip), %rdx # 0xfdf58
movq %r14, %rdi
callq 0x23f20
jmp 0x762b4
jmp 0x762d2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241f8
jmp 0x762d5
jmp 0x762d2
movq %rax, %rbx
movq %r14, %rdi
callq 0x23690
jmp 0x762df
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6384a
movq %rbx, %rdi
callq 0x23fb0
nop
| _ZNK5minja14ExpressionNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r14
push rbx
sub rsp, 78h
mov rbx, rsi
mov rsi, [rdi+20h]
test rsi, rsi
jz loc_76280
lea r14, [rsp+88h+var_60]
mov rdi, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
movzx eax, byte ptr [r14+40h]
cmp eax, 4
jz short loc_761FF
cmp eax, 3
jnz short loc_76227
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_60]
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
lea rsi, [rsp+88h+var_80]
mov rdi, rbx
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
jmp short loc_76264
loc_761FF:
lea rdi, [rsp+88h+var_60]
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
lea rcx, aTrue_0; "True"
lea rsi, aFalse; "False"
test al, al
cmovnz rsi, rcx
mov rdi, rbx
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short loc_7626E
loc_76227:
test al, al
jnz short loc_76243
cmp [rsp+88h+var_40], 0
jnz short loc_76243
cmp [rsp+88h+var_50], 0
jnz short loc_76243
cmp [rsp+88h+var_30], 0
jz short loc_7626E
loc_76243:
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, [rsp+88h+var_80]
mov rdi, rbx
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
loc_76264:
lea rdi, [rsp+88h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_7626E:
lea rdi, [rsp+88h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 78h
pop rbx
pop r14
retn
loc_76280:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpressionnode; "ExpressionNode.expr is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_762B4
jmp short loc_762D2
loc_762B4:
mov rbx, rax
lea rdi, [rsp+88h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_762D5
jmp short loc_762D2
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_762DF
loc_762D2:
mov rbx, rax
loc_762D5:
lea rdi, [rsp+88h+var_60]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_762DF:
mov rdi, rbx
call __Unwind_Resume
| void minja::ExpressionNode::do_render(long long a1, long long a2)
{
void (***v3)(void); // rsi
const char *v4; // rsi
std::runtime_error *exception; // r14
_BYTE v6[32]; // [rsp+8h] [rbp-80h] BYREF
_BYTE v7[16]; // [rsp+28h] [rbp-60h] BYREF
long long v8; // [rsp+38h] [rbp-50h]
long long v9; // [rsp+48h] [rbp-40h]
long long v10; // [rsp+58h] [rbp-30h]
char v11; // [rsp+68h] [rbp-20h]
v3 = *(void (****)(void))(a1 + 32);
if ( !v3 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ExpressionNode.expr is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v7, v3);
if ( v11 == 4 )
{
v4 = "False";
if ( (unsigned __int8)minja::Value::get<bool>((minja::Value *)v7) )
v4 = "True";
std::operator<<<std::char_traits<char>>(a2, v4);
}
else
{
if ( v11 == 3 )
{
minja::Value::get<std::string>((long long)v6, (minja::Value *)v7);
std::operator<<<char>(a2, v6);
LABEL_13:
std::string::~string(v6);
goto LABEL_14;
}
if ( v11 || v9 || v8 || v10 )
{
minja::Value::dump[abi:cxx11]((long long)v6, (long long)v7, 0xFFFFFFFF, 0);
std::operator<<<char>(a2, v6);
goto LABEL_13;
}
}
LABEL_14:
minja::Value::~Value((minja::Value *)v7);
}
| do_render:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV RBX,RSI
MOV RSI,qword ptr [RDI + 0x20]
TEST RSI,RSI
JZ 0x00176280
LEA R14,[RSP + 0x28]
MOV RDI,R14
CALL 0x001635ba
MOVZX EAX,byte ptr [R14 + 0x40]
CMP EAX,0x4
JZ 0x001761ff
CMP EAX,0x3
JNZ 0x00176227
LAB_001761e1:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
CALL 0x0016446c
LAB_001761f0:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001237e0
JMP 0x00176264
LAB_001761ff:
LEA RDI,[RSP + 0x28]
CALL 0x001643b6
LEA RCX,[0x1b3afc]
LEA RSI,[0x1b3b01]
TEST AL,AL
CMOVNZ RSI,RCX
MOV RDI,RBX
CALL 0x001238b0
JMP 0x0017626e
LAB_00176227:
TEST AL,AL
JNZ 0x00176243
CMP qword ptr [RSP + 0x48],0x0
JNZ 0x00176243
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x00176243
CMP qword ptr [RSP + 0x58],0x0
JZ 0x0017626e
LAB_00176243:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
PUSH -0x1
POP RDX
XOR ECX,ECX
CALL 0x00163a38
LAB_00176257:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001237e0
LAB_00176264:
LEA RDI,[RSP + 0x8]
CALL 0x001241f8
LAB_0017626e:
LEA RDI,[RSP + 0x28]
CALL 0x0016384a
ADD RSP,0x78
POP RBX
POP R14
RET
LAB_00176280:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R14,RAX
LAB_0017628b:
LEA RSI,[0x1b4ae3]
MOV RDI,RAX
CALL 0x00123310
LAB_0017629a:
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,R14
CALL 0x00123f20
|
/* minja::ExpressionNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::ExpressionNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
bool bVar1;
runtime_error *this;
char *pcVar2;
string local_80 [32];
Expression local_60 [16];
long local_50;
long local_40;
long local_30;
char local_20;
if (*(shared_ptr **)(param_1 + 0x20) == (shared_ptr *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017628b to 00176299 has its CatchHandler @ 001762c5 */
std::runtime_error::runtime_error(this,"ExpressionNode.expr is null");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
Expression::evaluate(local_60,*(shared_ptr **)(param_1 + 0x20));
if (local_20 == '\x04') {
/* try { // try from 001761ff to 00176224 has its CatchHandler @ 001762d2 */
bVar1 = Value::get<bool>((Value *)local_60);
pcVar2 = "False";
if (bVar1) {
pcVar2 = "True";
}
std::operator<<((ostream *)param_2,pcVar2);
}
else {
if (local_20 == '\x03') {
/* try { // try from 001761e1 to 001761ef has its CatchHandler @ 001762c3 */
Value::get<std::__cxx11::string>();
/* try { // try from 001761f0 to 001761fc has its CatchHandler @ 001762b4 */
std::operator<<((ostream *)param_2,local_80);
}
else {
if ((((local_20 == '\0') && (local_40 == 0)) && (local_50 == 0)) && (local_30 == 0))
goto LAB_0017626e;
/* try { // try from 00176243 to 00176256 has its CatchHandler @ 001762b2 */
Value::dump_abi_cxx11_((int)local_80,SUB81(local_60,0));
/* try { // try from 00176257 to 00176263 has its CatchHandler @ 001762b0 */
std::operator<<((ostream *)param_2,local_80);
}
std::__cxx11::string::~string(local_80);
}
LAB_0017626e:
Value::~Value((Value *)local_60);
return;
}
| |
24,554 | stbi__hdr_test(stbi__context*) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static int stbi__hdr_test(stbi__context* s)
{
int r = stbi__hdr_test_core(s, "#?RADIANCE\n");
stbi__rewind(s);
if(!r) {
r = stbi__hdr_test_core(s, "#?RGBE\n");
stbi__rewind(s);
}
return r;
} | O3 | c | stbi__hdr_test(stbi__context*):
pushq %rbx
movq %rdi, %rbx
leaq 0x2c7ae(%rip), %rsi # 0x4c36c
callq 0x39958
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
testl %eax, %eax
je 0x1fbdc
movl $0x1, %eax
popq %rbx
retq
leaq 0x2c795(%rip), %rsi # 0x4c378
movq %rbx, %rdi
callq 0x39958
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
popq %rbx
retq
| _ZL14stbi__hdr_testP13stbi__context:
push rbx
mov rbx, rdi
lea rsi, aRadiance; "#?RADIANCE\n"
call _ZL19stbi__hdr_test_coreP13stbi__contextPKc; stbi__hdr_test_core(stbi__context *,char const*)
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
test eax, eax
jz short loc_1FBDC
mov eax, 1
pop rbx
retn
loc_1FBDC:
lea rsi, aRgbe; "#?RGBE\n"
mov rdi, rbx
call _ZL19stbi__hdr_test_coreP13stbi__contextPKc; stbi__hdr_test_core(stbi__context *,char const*)
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
pop rbx
retn
| long long stbi__hdr_test(long long a1)
{
int v1; // eax
long long result; // rax
v1 = stbi__hdr_test_core(a1, "#?RADIANCE\n");
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
if ( v1 )
return 1LL;
result = stbi__hdr_test_core(a1, "#?RGBE\n");
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
return result;
}
| stbi__hdr_test:
PUSH RBX
MOV RBX,RDI
LEA RSI,[0x14c36c]
CALL 0x00139958
MOVUPS XMM0,xmmword ptr [RBX + 0xd0]
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
TEST EAX,EAX
JZ 0x0011fbdc
MOV EAX,0x1
POP RBX
RET
LAB_0011fbdc:
LEA RSI,[0x14c378]
MOV RDI,RBX
CALL 0x00139958
MOVUPS XMM0,xmmword ptr [RBX + 0xd0]
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
POP RBX
RET
|
/* stbi__hdr_test(stbi__context*) */
int8 stbi__hdr_test(stbi__context *param_1)
{
int iVar1;
int8 uVar2;
iVar1 = stbi__hdr_test_core(param_1,"#?RADIANCE\n");
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 0xd0);
*(int8 *)(param_1 + 200) = *(int8 *)(param_1 + 0xd8);
if (iVar1 != 0) {
return 1;
}
uVar2 = stbi__hdr_test_core(param_1,"#?RGBE\n");
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 0xd0);
*(int8 *)(param_1 + 200) = *(int8 *)(param_1 + 0xd8);
return uVar2;
}
| |
24,555 | 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 0x1b7fbd(%rip), %rax # 0x229550
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x71606
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x36810
cmpl $0x0, %eax
jne 0x715f6
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x715d0
jmp 0x715c6
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x715de
jmp 0x715ec
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7160e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7160e
movq $0x0, -0x8(%rbp)
jmp 0x7160e
jmp 0x715f8
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x71597
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_71597:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_71606
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_10]
call _strcasecmp
cmp eax, 0
jnz short loc_715F6
mov rax, [rbp+var_18]
mov eax, [rax+10h]
mov [rbp+var_1C], eax
test eax, eax
jz short loc_715D0
jmp short $+2
loc_715C6:
mov eax, [rbp+var_1C]
sub eax, 1
jz short loc_715DE
jmp short loc_715EC
loc_715D0:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_7160E
loc_715DE:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_7160E
loc_715EC:
mov [rbp+var_8], 0
jmp short loc_7160E
loc_715F6:
jmp short $+2
loc_715F8:
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_18], rax
jmp short loc_71597
loc_71606:
mov [rbp+var_8], 0
loc_7160E:
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,[0x329550]
MOV qword ptr [RBP + -0x18],RAX
LAB_00171597:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x00171606
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00136810
CMP EAX,0x0
JNZ 0x001715f6
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x1c],EAX
TEST EAX,EAX
JZ 0x001715d0
JMP 0x001715c6
LAB_001715c6:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
JZ 0x001715de
JMP 0x001715ec
LAB_001715d0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017160e
LAB_001715de:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017160e
LAB_001715ec:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0017160e
LAB_001715f6:
JMP 0x001715f8
LAB_001715f8:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00171597
LAB_00171606:
MOV qword ptr [RBP + -0x8],0x0
LAB_0017160e:
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];
}
| |
24,556 | my_longlong10_to_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_longlong10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix,
longlong val)
{
char buffer[65];
register char *p, *e;
long long_val;
uint sign= 0;
ulonglong uval = (ulonglong)val;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulonglong)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (uval == 0)
{
*--p= '0';
len= 1;
goto cnv;
}
while (uval > (ulonglong) LONG_MAX)
{
ulonglong quo= uval/(uint) 10;
uint rem= (uint) (uval- quo* (uint) 10);
*--p = '0' + rem;
uval= quo;
}
long_val= (long) uval;
while (long_val != 0)
{
long quo= long_val/10;
*--p = (char) ('0' + (long_val - quo*10));
long_val= quo;
}
len= MY_MIN(len, (size_t) (e-p));
cnv:
memcpy(dst, p, len);
return len+sign;
} | O3 | c | my_longlong10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r9
movq %rsi, %rdi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %cl
orb %al, %cl
jne 0x3d4d6
negq %r8
movb $0x2d, (%rdi)
incq %rdi
decq %r9
leaq -0x20(%rbp), %rbx
movb $0x0, (%rbx)
movl $0x1, %r14d
jmp 0x3d4ea
movb $0x0, -0x20(%rbp)
testq %r8, %r8
je 0x3d576
leaq -0x20(%rbp), %rbx
xorl %r14d, %r14d
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
testq %r8, %r8
js 0x3d4fe
movq %rbx, %rsi
jmp 0x3d51f
movq %r8, %rax
mulq %rcx
shrq $0x3, %rdx
leaq -0x21(%rbp), %rsi
imull $0xf6, %edx, %eax
addl %eax, %r8d
addb $0x30, %r8b
movb %r8b, (%rsi)
movq %rdx, %r8
subq %rsi, %rbx
movq %r8, %rax
mulq %rcx
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %r8d, %eax
addb $0x30, %al
movb %al, -0x1(%rsi)
decq %rsi
incq %rbx
cmpq $0x9, %r8
movq %rdx, %r8
ja 0x3d522
cmpq %rbx, %r9
cmovbq %r9, %rbx
movq %rbx, %rdx
callq 0x24230
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0x3d587
addq %r14, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x21(%rbp), %rsi
movb $0x30, (%rsi)
movl $0x1, %ebx
xorl %r14d, %r14d
jmp 0x3d550
callq 0x24360
| my_longlong10_to_str_8bit:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r9, rdx
mov rdi, rsi
mov rax, fs:28h
mov [rbp+var_18], rax
test ecx, ecx
setns al
test r8, r8
setns cl
or cl, al
jnz short loc_3D4D6
neg r8
mov byte ptr [rdi], 2Dh ; '-'
inc rdi
dec r9
lea rbx, [rbp+var_20]
mov byte ptr [rbx], 0
mov r14d, 1
jmp short loc_3D4EA
loc_3D4D6:
mov [rbp+var_20], 0
test r8, r8
jz loc_3D576
lea rbx, [rbp+var_20]
xor r14d, r14d
loc_3D4EA:
mov rcx, 0CCCCCCCCCCCCCCCDh
test r8, r8
js short loc_3D4FE
mov rsi, rbx
jmp short loc_3D51F
loc_3D4FE:
mov rax, r8
mul rcx
shr rdx, 3
lea rsi, [rbp+var_21]
imul eax, edx, 0F6h
add r8d, eax
add r8b, 30h ; '0'
mov [rsi], r8b
mov r8, rdx
loc_3D51F:
sub rbx, rsi
loc_3D522:
mov rax, r8
mul rcx
shr rdx, 3
imul eax, edx, 0F6h
add eax, r8d
add al, 30h ; '0'
mov [rsi-1], al
dec rsi
inc rbx
cmp r8, 9
mov r8, rdx
ja short loc_3D522
cmp r9, rbx
cmovb rbx, r9
loc_3D550:
mov rdx, rbx
call _memcpy
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_3D587
add rbx, r14
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_3D576:
lea rsi, [rbp+var_21]
mov byte ptr [rsi], 30h ; '0'
mov ebx, 1
xor r14d, r14d
jmp short loc_3D550
loc_3D587:
call ___stack_chk_fail
| _BYTE * my_longlong10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, unsigned long long a5)
{
_BYTE *v5; // r9
_BYTE *v6; // rdi
long long v7; // r14
char *v8; // rsi
_BYTE *v9; // rbx
bool v10; // cc
char v12; // [rsp+3Fh] [rbp-21h] BYREF
_BYTE v13[8]; // [rsp+40h] [rbp-20h] BYREF
unsigned long long v14; // [rsp+48h] [rbp-18h]
v5 = a3;
v6 = a2;
v14 = __readfsqword(0x28u);
if ( a4 >= 0 || (a5 & 0x8000000000000000LL) == 0LL )
{
v13[0] = 0;
if ( !a5 )
{
v8 = &v12;
v12 = 48;
v9 = (_BYTE *)(&dword_0 + 1);
v7 = 0LL;
goto LABEL_12;
}
v7 = 0LL;
}
else
{
a5 = -(long long)a5;
*a2 = 45;
v6 = a2 + 1;
v5 = a3 - 1;
v13[0] = 0;
v7 = 1LL;
}
if ( (a5 & 0x8000000000000000LL) != 0LL )
{
v8 = &v12;
v12 = a5 % 0xA + 48;
a5 /= 0xAuLL;
}
else
{
v8 = v13;
}
v9 = (_BYTE *)(v13 - v8);
do
{
*--v8 = a5 % 0xA + 48;
++v9;
v10 = a5 <= 9;
a5 /= 0xAuLL;
}
while ( !v10 );
if ( v5 < v9 )
v9 = v5;
LABEL_12:
memcpy(v6, v8, v9);
return &v9[v7];
}
| my_longlong10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R9,RDX
MOV RDI,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS CL
OR CL,AL
JNZ 0x0013d4d6
NEG R8
MOV byte ptr [RDI],0x2d
INC RDI
DEC R9
LEA RBX,[RBP + -0x20]
MOV byte ptr [RBX],0x0
MOV R14D,0x1
JMP 0x0013d4ea
LAB_0013d4d6:
MOV byte ptr [RBP + -0x20],0x0
TEST R8,R8
JZ 0x0013d576
LEA RBX,[RBP + -0x20]
XOR R14D,R14D
LAB_0013d4ea:
MOV RCX,-0x3333333333333333
TEST R8,R8
JS 0x0013d4fe
MOV RSI,RBX
JMP 0x0013d51f
LAB_0013d4fe:
MOV RAX,R8
MUL RCX
SHR RDX,0x3
LEA RSI,[RBP + -0x21]
IMUL EAX,EDX,0xf6
ADD R8D,EAX
ADD R8B,0x30
MOV byte ptr [RSI],R8B
MOV R8,RDX
LAB_0013d51f:
SUB RBX,RSI
LAB_0013d522:
MOV RAX,R8
MUL RCX
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,R8D
ADD AL,0x30
MOV byte ptr [RSI + -0x1],AL
DEC RSI
INC RBX
CMP R8,0x9
MOV R8,RDX
JA 0x0013d522
CMP R9,RBX
CMOVC RBX,R9
LAB_0013d550:
MOV RDX,RBX
CALL 0x00124230
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0013d587
ADD RBX,R14
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0013d576:
LEA RSI,[RBP + -0x21]
MOV byte ptr [RSI],0x30
MOV EBX,0x1
XOR R14D,R14D
JMP 0x0013d550
LAB_0013d587:
CALL 0x00124360
|
long my_longlong10_to_str_8bit
(int8 param_1,int1 *param_2,ulong param_3,int param_4,ulong param_5)
{
bool bVar1;
ulong __n;
char *__src;
long lVar2;
long in_FS_OFFSET;
char local_29 [9];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_5 < 0 && param_4 < 0) {
param_5 = -param_5;
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_3 = param_3 - 1;
lVar2 = 1;
}
else {
if (param_5 == 0) {
__src = local_29;
local_29[0] = '0';
__n = 1;
lVar2 = 0;
goto LAB_0013d550;
}
lVar2 = 0;
}
__src = local_29 + 1;
if ((long)param_5 < 0) {
local_29[0] = (char)param_5 + (char)(param_5 / 10) * -10 + '0';
__src = local_29;
param_5 = param_5 / 10;
}
__n = (long)(local_29 + 1) - (long)__src;
do {
__src[-1] = (char)(param_5 / 10) * -10 + (char)param_5 + '0';
__src = __src + -1;
__n = __n + 1;
bVar1 = 9 < param_5;
param_5 = param_5 / 10;
} while (bVar1);
if (param_3 < __n) {
__n = param_3;
}
LAB_0013d550:
local_29[1] = 0;
memcpy(param_2,__src,__n);
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __n + lVar2;
}
| |
24,557 | minja::ExpressionTemplateToken::~ExpressionTemplateToken() | monkey531[P]llama/common/minja.hpp | ExpressionTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && e) : TemplateToken(Type::Expression, location, pre, post), expr(std::move(e)) {} | O3 | cpp | minja::ExpressionTemplateToken::~ExpressionTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x920cf(%rip), %rax # 0x129b08
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x97a4e
callq 0x6d1fe
leaq 0x918a3(%rip), %rax # 0x1292f8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x97a6b
popq %rbx
jmp 0x6d1fe
popq %rbx
retq
nop
| _ZN5minja23ExpressionTemplateTokenD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja23ExpressionTemplateTokenE; `vtable for'minja::ExpressionTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_97A4E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_97A4E:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_97A6B
pop rbx
jmp _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_97A6B:
pop rbx
retn
| void minja::ExpressionTemplateToken::~ExpressionTemplateToken(minja::ExpressionTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~ExpressionTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x229b08]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x00197a4e
CALL 0x0016d1fe
LAB_00197a4e:
LEA RAX,[0x2292f8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x00197a6b
POP RBX
JMP 0x0016d1fe
LAB_00197a6b:
POP RBX
RET
|
/* minja::ExpressionTemplateToken::~ExpressionTemplateToken() */
void __thiscall
minja::ExpressionTemplateToken::~ExpressionTemplateToken(ExpressionTemplateToken *this)
{
*(int ***)this = &PTR__ExpressionTemplateToken_00229b18;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38));
}
*(int ***)this = &PTR__TemplateToken_00229308;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
return;
}
return;
}
| |
24,558 | my_uni_utf16le | eloqsql/strings/ctype-ucs2.c | static int
my_uni_utf16le(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
uint32 first, second, total;
if (wc < MY_UTF16_SURROGATE_HIGH_FIRST ||
(wc > MY_UTF16_SURROGATE_LOW_LAST &&
wc <= 0xFFFF))
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
int2store(s, wc);
return 2; /* [0000-D7FF,E000-FFFF] */
}
if (wc < 0xFFFF || wc > 0x10FFFF)
return MY_CS_ILUNI; /* [D800-DFFF,10FFFF+] */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
wc-= 0x10000;
first= (0xD800 | ((wc >> 10) & 0x3FF));
second= (0xDC00 | (wc & 0x3FF));
total= first | (second << 16);
int4store(s, total);
return 4; /* [010000-10FFFF] */
} | O3 | c | my_uni_utf16le:
pushq %rbp
movq %rsp, %rbp
cmpq $0xd800, %rsi # imm = 0xD800
setae %al
movq %rsi, %rdi
andq $-0x2000, %rdi # imm = 0xE000
cmpq $0xe000, %rdi # imm = 0xE000
setne %dil
testb %dil, %al
jne 0x51d0f
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x51d54
movw %si, (%rdx)
movl $0x2, %eax
jmp 0x51d54
leaq -0x110000(%rsi), %rdi
xorl %eax, %eax
cmpq $-0x100001, %rdi # imm = 0xFFEFFFFF
jb 0x51d54
leaq 0x4(%rdx), %rdi
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdi
ja 0x51d54
leal 0xf0000(%rsi), %eax
shrl $0xa, %eax
andl $0x3ff, %eax # imm = 0x3FF
shll $0x10, %esi
andl $0x3ff0000, %esi # imm = 0x3FF0000
addl %esi, %eax
addl $0xdc00d800, %eax # imm = 0xDC00D800
movl %eax, (%rdx)
movl $0x4, %eax
popq %rbp
retq
| my_uni_utf16le:
push rbp
mov rbp, rsp
cmp rsi, 0D800h
setnb al
mov rdi, rsi
and rdi, 0FFFFFFFFFFFFE000h
cmp rdi, 0E000h
setnz dil
test al, dil
jnz short loc_51D0F
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_51D54
mov [rdx], si
mov eax, 2
jmp short loc_51D54
loc_51D0F:
lea rdi, [rsi-110000h]
xor eax, eax
cmp rdi, 0FFFFFFFFFFEFFFFFh
jb short loc_51D54
lea rdi, [rdx+4]
mov eax, 0FFFFFF98h
cmp rdi, rcx
ja short loc_51D54
lea eax, unk_F0000[rsi]
shr eax, 0Ah
and eax, 3FFh
shl esi, 10h
and esi, 3FF0000h
add eax, esi
add eax, 0DC00D800h
mov [rdx], eax
mov eax, 4
loc_51D54:
pop rbp
retn
| long long my_uni_utf16le(long long a1, unsigned long long a2, _DWORD *a3, unsigned long long a4)
{
long long result; // rax
if ( (a2 & 0xFFFFFFFFFFFFE000LL) != 57344 && a2 >= 0xD800 )
{
result = 0LL;
if ( a2 - 1114112 >= 0xFFFFFFFFFFEFFFFFLL )
{
result = 4294967192LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = (((_DWORD)a2 << 16) & 0x3FF0000)
+ (((unsigned int)((unsigned int)&unk_F0000 + a2) >> 10) & 0x3FF)
- 603924480;
return 4LL;
}
}
}
else
{
result = 4294967194LL;
if ( (unsigned long long)a3 + 2 <= a4 )
{
*(_WORD *)a3 = a2;
return 2LL;
}
}
return result;
}
| my_uni_utf16le:
PUSH RBP
MOV RBP,RSP
CMP RSI,0xd800
SETNC AL
MOV RDI,RSI
AND RDI,-0x2000
CMP RDI,0xe000
SETNZ DIL
TEST AL,DIL
JNZ 0x00151d0f
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x00151d54
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x00151d54
LAB_00151d0f:
LEA RDI,[RSI + -0x110000]
XOR EAX,EAX
CMP RDI,-0x100001
JC 0x00151d54
LEA RDI,[RDX + 0x4]
MOV EAX,0xffffff98
CMP RDI,RCX
JA 0x00151d54
LEA EAX,[RSI + 0xf0000]
SHR EAX,0xa
AND EAX,0x3ff
SHL ESI,0x10
AND ESI,0x3ff0000
ADD EAX,ESI
ADD EAX,0xdc00d800
MOV dword ptr [RDX],EAX
MOV EAX,0x4
LAB_00151d54:
POP RBP
RET
|
int8 my_uni_utf16le(int8 param_1,ulong param_2,int *param_3,int *param_4)
{
int8 uVar1;
if (param_2 < 0xd800 || (param_2 & 0xffffffffffffe000) == 0xe000) {
uVar1 = 0xffffff9a;
if ((int *)((long)param_3 + 2U) <= param_4) {
*(short *)param_3 = (short)param_2;
uVar1 = 2;
}
}
else {
uVar1 = 0;
if ((0xffffffffffeffffe < param_2 - 0x110000) && (uVar1 = 0xffffff98, param_3 + 1 <= param_4)) {
*param_3 = ((uint)param_2 + 0xf0000 >> 10 & 0x3ff) + ((uint)param_2 & 0x3ff) * 0x10000 +
-0x23ff2800;
uVar1 = 4;
}
}
return uVar1;
}
| |
24,559 | quantize_row_q4_0_ref | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void quantize_row_q4_0_ref(const float * restrict x, block_q4_0 * restrict y, int64_t k) {
static const int qk = QK4_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
float max = 0.0f;
for (int j = 0; j < qk; j++) {
const float v = x[i*qk + j];
if (amax < fabsf(v)) {
amax = fabsf(v);
max = v;
}
}
const float d = max / -8;
const float id = d ? 1.0f/d : 0.0f;
y[i].d = GGML_FP32_TO_FP16(d);
for (int j = 0; j < qk/2; ++j) {
const float x0 = x[i*qk + 0 + j]*id;
const float x1 = x[i*qk + qk/2 + j]*id;
const uint8_t xi0 = MIN(15, (int8_t)(x0 + 8.5f));
const uint8_t xi1 = MIN(15, (int8_t)(x1 + 8.5f));
y[i].qs[j] = xi0;
y[i].qs[j] |= xi1 << 4;
}
}
} | O0 | c | quantize_row_q4_0_ref:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
jne 0x6d4ba
jmp 0x6d4d9
leaq 0x5388f(%rip), %rdi # 0xc0d50
leaq 0x53894(%rip), %rsi # 0xc0d5c
movl $0x22, %edx
leaq 0x538e1(%rip), %rcx # 0xc0db5
callq 0x44810
movq -0x18(%rbp), %rax
movl $0x20, %ecx
cqto
idivq %rcx
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x6d73e
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x20, -0x2c(%rbp)
jge 0x6d57a
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x5, %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x30(%rbp)
movss -0x24(%rbp), %xmm1
movss -0x30(%rbp), %xmm0
movaps 0x43aeb(%rip), %xmm2 # 0xb1030
pand %xmm2, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x6d56d
movss -0x30(%rbp), %xmm0
movaps 0x43ad6(%rip), %xmm1 # 0xb1030
pand %xmm1, %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x30(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
jmp 0x6d56f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6d514
movss -0x28(%rbp), %xmm0
movss 0x48d9d(%rip), %xmm1 # 0xb6324
divss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x34(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6d5a1
jp 0x6d5a1
jmp 0x6d5b5
movss 0x43e7f(%rip), %xmm0 # 0xb1428
divss -0x34(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
jmp 0x6d5bf
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
jmp 0x6d5bf
movss -0x4c(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x34(%rbp), %xmm0
callq 0x6d750
movw %ax, %cx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rdx
imulq $0x12, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movl $0x0, -0x3c(%rbp)
cmpl $0x10, -0x3c(%rbp)
jge 0x6d72e
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x5, %ecx
movl -0x3c(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x38(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %esi
shll $0x5, %esi
movl -0x3c(%rbp), %ecx
movl %ecx, %edx
movl %esi, %ecx
leal 0x10(%rcx,%rdx), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss -0x38(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x40(%rbp), %xmm0
movss 0x48cd2(%rip), %xmm1 # 0xb6328
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movsbl %al, %ecx
movl $0xf, %eax
cmpl %ecx, %eax
jge 0x6d674
movl $0xf, %eax
movl %eax, -0x50(%rbp)
jmp 0x6d68f
movss -0x40(%rbp), %xmm0
movss 0x48ca7(%rip), %xmm1 # 0xb6328
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movsbl %al, %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movb %al, -0x45(%rbp)
movss -0x44(%rbp), %xmm0
movss 0x48c86(%rip), %xmm1 # 0xb6328
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movsbl %al, %ecx
movl $0xf, %eax
cmpl %ecx, %eax
jge 0x6d6c0
movl $0xf, %eax
movl %eax, -0x54(%rbp)
jmp 0x6d6db
movss -0x44(%rbp), %xmm0
movss 0x48c5b(%rip), %xmm1 # 0xb6328
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movsbl %al, %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movb %al, -0x46(%rbp)
movb -0x45(%rbp), %dl
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x12, %rcx, %rcx
addq %rcx, %rax
movslq -0x3c(%rbp), %rcx
movb %dl, 0x2(%rax,%rcx)
movzbl -0x46(%rbp), %esi
shll $0x4, %esi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
imulq $0x12, %rcx, %rcx
addq %rcx, %rax
movslq -0x3c(%rbp), %rcx
movzbl 0x2(%rax,%rcx), %edx
orl %esi, %edx
movb %dl, 0x2(%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6d5ef
jmp 0x6d730
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6d4f1
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| quantize_row_q4_0_ref:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov ecx, 20h ; ' '
cqo
idiv rcx
cmp rdx, 0
jnz short loc_6D4BA
jmp short loc_6D4D9
loc_6D4BA:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
mov edx, 22h ; '"'
lea rcx, aVoidQuantizeRo; "void quantize_row_q4_0_ref(const float "...
call ___assert_fail
loc_6D4D9:
mov rax, [rbp+var_18]
mov ecx, 20h ; ' '
cqo
idiv rcx
mov [rbp+var_1C], eax
mov [rbp+var_20], 0
loc_6D4F1:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_1C]
jge loc_6D73E
xorps xmm0, xmm0
movss [rbp+var_24], xmm0
xorps xmm0, xmm0
movss [rbp+var_28], xmm0
mov [rbp+var_2C], 0
loc_6D514:
cmp [rbp+var_2C], 20h ; ' '
jge short loc_6D57A
mov rax, [rbp+var_8]
mov ecx, [rbp+var_20]
shl ecx, 5
add ecx, [rbp+var_2C]
movsxd rcx, ecx
movss xmm0, dword ptr [rax+rcx*4]
movss [rbp+var_30], xmm0
movss xmm1, [rbp+var_24]
movss xmm0, [rbp+var_30]
movaps xmm2, cs:xmmword_B1030
pand xmm0, xmm2
ucomiss xmm0, xmm1
jbe short loc_6D56D
movss xmm0, [rbp+var_30]
movaps xmm1, cs:xmmword_B1030
pand xmm0, xmm1
movss [rbp+var_24], xmm0
movss xmm0, [rbp+var_30]
movss [rbp+var_28], xmm0
loc_6D56D:
jmp short $+2
loc_6D56F:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_6D514
loc_6D57A:
movss xmm0, [rbp+var_28]
movss xmm1, cs:dword_B6324
divss xmm0, xmm1
movss [rbp+var_34], xmm0
movss xmm0, [rbp+var_34]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jnz short loc_6D5A1
jp short loc_6D5A1
jmp short loc_6D5B5
loc_6D5A1:
movss xmm0, cs:dword_B1428
divss xmm0, [rbp+var_34]
movss [rbp+var_4C], xmm0
jmp short loc_6D5BF
loc_6D5B5:
xorps xmm0, xmm0
movss [rbp+var_4C], xmm0
jmp short $+2
loc_6D5BF:
movss xmm0, [rbp+var_4C]
movss [rbp+var_38], xmm0
movss xmm0, [rbp+var_34]
call ggml_compute_fp32_to_fp16_0
mov cx, ax
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_20]
imul rdx, 12h
add rax, rdx
mov [rax], cx
mov [rbp+var_3C], 0
loc_6D5EF:
cmp [rbp+var_3C], 10h
jge loc_6D72E
mov rax, [rbp+var_8]
mov ecx, [rbp+var_20]
shl ecx, 5
mov edx, [rbp+var_3C]
add ecx, edx
movsxd rcx, ecx
movss xmm0, dword ptr [rax+rcx*4]
movss xmm1, [rbp+var_38]
mulss xmm0, xmm1
movss [rbp+var_40], xmm0
mov rax, [rbp+var_8]
mov esi, [rbp+var_20]
shl esi, 5
mov ecx, [rbp+var_3C]
mov edx, ecx
mov ecx, esi
lea ecx, [rcx+rdx+10h]
movsxd rcx, ecx
movss xmm0, dword ptr [rax+rcx*4]
movss xmm1, [rbp+var_38]
mulss xmm0, xmm1
movss [rbp+var_44], xmm0
movss xmm0, [rbp+var_40]
movss xmm1, cs:dword_B6328
addss xmm0, xmm1
cvttss2si eax, xmm0
movsx ecx, al
mov eax, 0Fh
cmp eax, ecx
jge short loc_6D674
mov eax, 0Fh
mov [rbp+var_50], eax
jmp short loc_6D68F
loc_6D674:
movss xmm0, [rbp+var_40]
movss xmm1, cs:dword_B6328
addss xmm0, xmm1
cvttss2si eax, xmm0
movsx eax, al
mov [rbp+var_50], eax
loc_6D68F:
mov eax, [rbp+var_50]
mov [rbp+var_45], al
movss xmm0, [rbp+var_44]
movss xmm1, cs:dword_B6328
addss xmm0, xmm1
cvttss2si eax, xmm0
movsx ecx, al
mov eax, 0Fh
cmp eax, ecx
jge short loc_6D6C0
mov eax, 0Fh
mov [rbp+var_54], eax
jmp short loc_6D6DB
loc_6D6C0:
movss xmm0, [rbp+var_44]
movss xmm1, cs:dword_B6328
addss xmm0, xmm1
cvttss2si eax, xmm0
movsx eax, al
mov [rbp+var_54], eax
loc_6D6DB:
mov eax, [rbp+var_54]
mov [rbp+var_46], al
mov dl, [rbp+var_45]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_20]
imul rcx, 12h
add rax, rcx
movsxd rcx, [rbp+var_3C]
mov [rax+rcx+2], dl
movzx esi, [rbp+var_46]
shl esi, 4
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_20]
imul rcx, 12h
add rax, rcx
movsxd rcx, [rbp+var_3C]
movzx edx, byte ptr [rax+rcx+2]
or edx, esi
mov [rax+rcx+2], dl
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp loc_6D5EF
loc_6D72E:
jmp short $+2
loc_6D730:
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
jmp loc_6D4F1
loc_6D73E:
add rsp, 60h
pop rbp
retn
| long long quantize_row_q4_0_ref(long long a1, long long a2, long long a3)
{
long long v3; // rdx
long long result; // rax
__int16 v5; // ax
long long v6; // rax
unsigned __int8 v7; // [rsp+Ch] [rbp-54h]
char v8; // [rsp+10h] [rbp-50h]
float v9; // [rsp+14h] [rbp-4Ch]
float v10; // [rsp+1Ch] [rbp-44h]
float v11; // [rsp+20h] [rbp-40h]
int k; // [rsp+24h] [rbp-3Ch]
float v13; // [rsp+2Ch] [rbp-34h]
unsigned int v14; // [rsp+30h] [rbp-30h]
int j; // [rsp+34h] [rbp-2Ch]
float v16; // [rsp+38h] [rbp-28h]
float v17; // [rsp+3Ch] [rbp-24h]
int i; // [rsp+40h] [rbp-20h]
long long v20; // [rsp+50h] [rbp-10h]
v20 = a2;
if ( a3 % 32 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
34LL,
"void quantize_row_q4_0_ref(const float *restrict, block_q4_0 *restrict, int64_t)");
v3 = a3 % 32;
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= (int)(a3 / 32) )
break;
v17 = 0.0;
v16 = 0.0;
for ( j = 0; j < 32; ++j )
{
v14 = *(_DWORD *)(a1 + 4LL * (j + 32 * i));
if ( *(float *)_mm_and_si128((__m128i)v14, (__m128i)xmmword_B1030).m128i_i32 > v17 )
{
LODWORD(v17) = _mm_and_si128((__m128i)v14, (__m128i)xmmword_B1030).m128i_u32[0];
v16 = *(float *)(a1 + 4LL * (j + 32 * i));
}
}
v13 = v16 / -8.0;
if ( (float)(v16 / -8.0) == 0.0 )
v9 = 0.0;
else
v9 = 1.0 / v13;
v5 = ggml_compute_fp32_to_fp16_0(a1, a2, v3, v13);
v3 = 18LL * i;
*(_WORD *)(v3 + v20) = v5;
for ( k = 0; k < 16; ++k )
{
v11 = *(float *)(a1 + 4LL * (k + 32 * i)) * v9;
v10 = *(float *)(a1 + 4LL * (32 * i + k + 16)) * v9;
if ( (char)(int)(float)(v11 + 8.5) <= 15 )
v8 = (int)(float)(v11 + 8.5);
else
v8 = 15;
if ( (char)(int)(float)(v10 + 8.5) <= 15 )
v7 = (int)(float)(v10 + 8.5);
else
v7 = 15;
*(_BYTE *)(18LL * i + v20 + k + 2) = v8;
a2 = 16 * (unsigned int)v7;
v6 = 18LL * i + v20;
v3 = (unsigned int)a2 | *(unsigned __int8 *)(v6 + k + 2);
*(_BYTE *)(v6 + k + 2) |= 16 * v7;
}
}
return result;
}
| quantize_row_q4_0_ref:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x20
CQO
IDIV RCX
CMP RDX,0x0
JNZ 0x0016d4ba
JMP 0x0016d4d9
LAB_0016d4ba:
LEA RDI,[0x1c0d50]
LEA RSI,[0x1c0d5c]
MOV EDX,0x22
LEA RCX,[0x1c0db5]
CALL 0x00144810
LAB_0016d4d9:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,0x20
CQO
IDIV RCX
MOV dword ptr [RBP + -0x1c],EAX
MOV dword ptr [RBP + -0x20],0x0
LAB_0016d4f1:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x0016d73e
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x24],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x28],XMM0
MOV dword ptr [RBP + -0x2c],0x0
LAB_0016d514:
CMP dword ptr [RBP + -0x2c],0x20
JGE 0x0016d57a
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x20]
SHL ECX,0x5
ADD ECX,dword ptr [RBP + -0x2c]
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS dword ptr [RBP + -0x30],XMM0
MOVSS XMM1,dword ptr [RBP + -0x24]
MOVSS XMM0,dword ptr [RBP + -0x30]
MOVAPS XMM2,xmmword ptr [0x001b1030]
PAND XMM0,XMM2
UCOMISS XMM0,XMM1
JBE 0x0016d56d
MOVSS XMM0,dword ptr [RBP + -0x30]
MOVAPS XMM1,xmmword ptr [0x001b1030]
PAND XMM0,XMM1
MOVSS dword ptr [RBP + -0x24],XMM0
MOVSS XMM0,dword ptr [RBP + -0x30]
MOVSS dword ptr [RBP + -0x28],XMM0
LAB_0016d56d:
JMP 0x0016d56f
LAB_0016d56f:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0016d514
LAB_0016d57a:
MOVSS XMM0,dword ptr [RBP + -0x28]
MOVSS XMM1,dword ptr [0x001b6324]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x34],XMM0
MOVSS XMM0,dword ptr [RBP + -0x34]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JNZ 0x0016d5a1
JP 0x0016d5a1
JMP 0x0016d5b5
LAB_0016d5a1:
MOVSS XMM0,dword ptr [0x001b1428]
DIVSS XMM0,dword ptr [RBP + -0x34]
MOVSS dword ptr [RBP + -0x4c],XMM0
JMP 0x0016d5bf
LAB_0016d5b5:
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4c],XMM0
JMP 0x0016d5bf
LAB_0016d5bf:
MOVSS XMM0,dword ptr [RBP + -0x4c]
MOVSS dword ptr [RBP + -0x38],XMM0
MOVSS XMM0,dword ptr [RBP + -0x34]
CALL 0x0016d750
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x20]
IMUL RDX,RDX,0x12
ADD RAX,RDX
MOV word ptr [RAX],CX
MOV dword ptr [RBP + -0x3c],0x0
LAB_0016d5ef:
CMP dword ptr [RBP + -0x3c],0x10
JGE 0x0016d72e
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0x20]
SHL ECX,0x5
MOV EDX,dword ptr [RBP + -0x3c]
ADD ECX,EDX
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS XMM1,dword ptr [RBP + -0x38]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x40],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x20]
SHL ESI,0x5
MOV ECX,dword ptr [RBP + -0x3c]
MOV EDX,ECX
MOV ECX,ESI
LEA ECX,[RCX + RDX*0x1 + 0x10]
MOVSXD RCX,ECX
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
MOVSS XMM1,dword ptr [RBP + -0x38]
MULSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x44],XMM0
MOVSS XMM0,dword ptr [RBP + -0x40]
MOVSS XMM1,dword ptr [0x001b6328]
ADDSS XMM0,XMM1
CVTTSS2SI EAX,XMM0
MOVSX ECX,AL
MOV EAX,0xf
CMP EAX,ECX
JGE 0x0016d674
MOV EAX,0xf
MOV dword ptr [RBP + -0x50],EAX
JMP 0x0016d68f
LAB_0016d674:
MOVSS XMM0,dword ptr [RBP + -0x40]
MOVSS XMM1,dword ptr [0x001b6328]
ADDSS XMM0,XMM1
CVTTSS2SI EAX,XMM0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x50],EAX
LAB_0016d68f:
MOV EAX,dword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0x45],AL
MOVSS XMM0,dword ptr [RBP + -0x44]
MOVSS XMM1,dword ptr [0x001b6328]
ADDSS XMM0,XMM1
CVTTSS2SI EAX,XMM0
MOVSX ECX,AL
MOV EAX,0xf
CMP EAX,ECX
JGE 0x0016d6c0
MOV EAX,0xf
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0016d6db
LAB_0016d6c0:
MOVSS XMM0,dword ptr [RBP + -0x44]
MOVSS XMM1,dword ptr [0x001b6328]
ADDSS XMM0,XMM1
CVTTSS2SI EAX,XMM0
MOVSX EAX,AL
MOV dword ptr [RBP + -0x54],EAX
LAB_0016d6db:
MOV EAX,dword ptr [RBP + -0x54]
MOV byte ptr [RBP + -0x46],AL
MOV DL,byte ptr [RBP + -0x45]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x20]
IMUL RCX,RCX,0x12
ADD RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOV byte ptr [RAX + RCX*0x1 + 0x2],DL
MOVZX ESI,byte ptr [RBP + -0x46]
SHL ESI,0x4
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x20]
IMUL RCX,RCX,0x12
ADD RAX,RCX
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOVZX EDX,byte ptr [RAX + RCX*0x1 + 0x2]
OR EDX,ESI
MOV byte ptr [RAX + RCX*0x1 + 0x2],DL
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0016d5ef
LAB_0016d72e:
JMP 0x0016d730
LAB_0016d730:
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
JMP 0x0016d4f1
LAB_0016d73e:
ADD RSP,0x60
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q4_0_ref(long param_1,long param_2,long param_3)
{
int1 uVar1;
int2 uVar2;
long lVar3;
float fVar4;
float fVar5;
uint local_5c;
float local_54;
int local_44;
int local_34;
float local_30;
float local_2c;
int local_28;
if (param_3 % 0x20 == 0) {
for (local_28 = 0; local_28 < (int)(param_3 / 0x20); local_28 = local_28 + 1) {
local_2c = 0.0;
local_30 = 0.0;
for (local_34 = 0; local_34 < 0x20; local_34 = local_34 + 1) {
fVar4 = *(float *)(param_1 + (long)(local_28 * 0x20 + local_34) * 4);
if (local_2c < (float)((uint)fVar4 & _DAT_001b1030)) {
local_2c = (float)((uint)fVar4 & _DAT_001b1030);
local_30 = fVar4;
}
}
local_30 = local_30 / DAT_001b6324;
if ((local_30 != 0.0) || (NAN(local_30))) {
local_54 = DAT_001b1428 / local_30;
}
else {
local_54 = 0.0;
}
uVar2 = ggml_compute_fp32_to_fp16();
*(int2 *)(param_2 + (long)local_28 * 0x12) = uVar2;
for (local_44 = 0; local_44 < 0x10; local_44 = local_44 + 1) {
fVar4 = *(float *)(param_1 + (long)(local_28 * 0x20 + local_44) * 4) * local_54;
fVar5 = *(float *)(param_1 + (long)(local_28 * 0x20 + 0x10 + local_44) * 4) * local_54;
if ((char)(int)(fVar4 + DAT_001b6328) < '\x10') {
uVar1 = (int1)(int)(fVar4 + DAT_001b6328);
}
else {
uVar1 = 0xf;
}
if ((char)(int)(fVar5 + DAT_001b6328) < '\x10') {
local_5c = (uint)(char)(int)(fVar5 + DAT_001b6328);
}
else {
local_5c = 0xf;
}
*(int1 *)(param_2 + (long)local_28 * 0x12 + 2 + (long)local_44) = uVar1;
lVar3 = param_2 + (long)local_28 * 0x12;
*(byte *)(lVar3 + 2 + (long)local_44) =
*(byte *)(lVar3 + 2 + (long)local_44) | (byte)((local_5c & 0xff) << 4);
}
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x22,
"void quantize_row_q4_0_ref(const float *restrict, block_q4_0 *restrict, int64_t)");
}
| |
24,560 | quantize_row_q4_0_ref | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void quantize_row_q4_0_ref(const float * restrict x, block_q4_0 * restrict y, int64_t k) {
static const int qk = QK4_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
float max = 0.0f;
for (int j = 0; j < qk; j++) {
const float v = x[i*qk + j];
if (amax < fabsf(v)) {
amax = fabsf(v);
max = v;
}
}
const float d = max / -8;
const float id = d ? 1.0f/d : 0.0f;
y[i].d = GGML_FP32_TO_FP16(d);
for (int j = 0; j < qk/2; ++j) {
const float x0 = x[i*qk + 0 + j]*id;
const float x1 = x[i*qk + qk/2 + j]*id;
const uint8_t xi0 = MIN(15, (int8_t)(x0 + 8.5f));
const uint8_t xi1 = MIN(15, (int8_t)(x1 + 8.5f));
y[i].qs[j] = xi0;
y[i].qs[j] |= xi1 << 4;
}
}
} | O1 | c | quantize_row_q4_0_ref:
pushq %rbp
pushq %rbx
pushq %rax
testb $0x1f, %dl
jne 0x2d994
shrq $0x5, %rdx
testl %edx, %edx
jle 0x2d98d
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
leaq 0x2(%rsi), %rax
xorl %ecx, %ecx
movaps 0x1e809(%rip), %xmm0 # 0x4c020
movss 0x23581(%rip), %xmm1 # 0x50da0
movss 0x1e831(%rip), %xmm2 # 0x4c058
xorps %xmm3, %xmm3
movss 0x1e816(%rip), %xmm4 # 0x4c048
movss 0x1e812(%rip), %xmm5 # 0x4c04c
movl $0x40000000, %r8d # imm = 0x40000000
movl $0x7e00, %r9d # imm = 0x7E00
movss 0x23556(%rip), %xmm6 # 0x50da4
xorl %r10d, %r10d
xorps %xmm7, %xmm7
xorps %xmm8, %xmm8
movss (%rdi,%r10,4), %xmm9
movaps %xmm9, %xmm10
andps %xmm0, %xmm10
movaps %xmm7, %xmm11
cmpltss %xmm10, %xmm11
andps %xmm11, %xmm9
andnps %xmm8, %xmm11
orps %xmm9, %xmm11
movaps %xmm11, %xmm8
maxss %xmm7, %xmm10
incq %r10
movaps %xmm10, %xmm7
cmpq $0x20, %r10
jne 0x2d858
mulss %xmm1, %xmm8
movaps %xmm2, %xmm9
divss %xmm8, %xmm9
movaps %xmm8, %xmm7
cmpneqss %xmm3, %xmm7
andps %xmm9, %xmm7
movd %xmm8, %r10d
andps %xmm0, %xmm8
mulss %xmm4, %xmm8
mulss %xmm5, %xmm8
leal (%r10,%r10), %r11d
movl %r10d, %ebx
andl $0x7f800000, %ebx # imm = 0x7F800000
addl $0x7800000, %ebx # imm = 0x7800000
cmpl $0x71000000, %r11d # imm = 0x71000000
cmovbl %r8d, %ebx
movd %ebx, %xmm9
addss %xmm8, %xmm9
movd %xmm9, %ebx
movl %ebx, %ebp
shrl $0xd, %ebp
andl $0x7c00, %ebp # imm = 0x7C00
andl $0xfff, %ebx # imm = 0xFFF
addl %ebp, %ebx
shrl $0x10, %r10d
andl $0x8000, %r10d # imm = 0x8000
cmpl $0xff000001, %r11d # imm = 0xFF000001
cmovael %r9d, %ebx
orl %r10d, %ebx
leaq (%rcx,%rcx,8), %r10
movw %bx, (%rsi,%r10,2)
xorl %r10d, %r10d
movss (%rdi,%r10,4), %xmm8
mulss %xmm7, %xmm8
addss %xmm6, %xmm8
cvttss2si %xmm8, %r11d
cmpb $0xf, %r11b
jl 0x2d946
movl $0xf, %r11d
movss 0x40(%rdi,%r10,4), %xmm8
mulss %xmm7, %xmm8
addss %xmm6, %xmm8
cvttss2si %xmm8, %ebx
cmpb $0xf, %bl
jl 0x2d966
movl $0xf, %ebx
shlb $0x4, %bl
orb %r11b, %bl
movb %bl, (%rax,%r10)
incq %r10
cmpq $0x10, %r10
jne 0x2d925
incq %rcx
subq $-0x80, %rdi
addq $0x12, %rax
cmpq %rdx, %rcx
jne 0x2d84e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2de5d(%rip), %rdi # 0x5b7f8
leaq 0x2de62(%rip), %rsi # 0x5b804
leaq 0x2deb4(%rip), %rcx # 0x5b85d
movl $0x22, %edx
callq 0x17b00
| quantize_row_q4_0_ref:
push rbp
push rbx
push rax
test dl, 1Fh
jnz loc_2D994
shr rdx, 5
test edx, edx
jle loc_2D98D
and edx, 7FFFFFFFh
lea rax, [rsi+2]
xor ecx, ecx
movaps xmm0, cs:xmmword_4C020
movss xmm1, cs:dword_50DA0
movss xmm2, cs:dword_4C058
xorps xmm3, xmm3
movss xmm4, cs:dword_4C048
movss xmm5, cs:dword_4C04C
mov r8d, 40000000h
mov r9d, 7E00h
movss xmm6, cs:dword_50DA4
loc_2D84E:
xor r10d, r10d
xorps xmm7, xmm7
xorps xmm8, xmm8
loc_2D858:
movss xmm9, dword ptr [rdi+r10*4]
movaps xmm10, xmm9
andps xmm10, xmm0
movaps xmm11, xmm7
cmpltss xmm11, xmm10
andps xmm9, xmm11
andnps xmm11, xmm8
orps xmm11, xmm9
movaps xmm8, xmm11
maxss xmm10, xmm7
inc r10
movaps xmm7, xmm10
cmp r10, 20h ; ' '
jnz short loc_2D858
mulss xmm8, xmm1
movaps xmm9, xmm2
divss xmm9, xmm8
movaps xmm7, xmm8
cmpneqss xmm7, xmm3
andps xmm7, xmm9
movd r10d, xmm8
andps xmm8, xmm0
mulss xmm8, xmm4
mulss xmm8, xmm5
lea r11d, [r10+r10]
mov ebx, r10d
and ebx, 7F800000h
add ebx, 7800000h
cmp r11d, 71000000h
cmovb ebx, r8d
movd xmm9, ebx
addss xmm9, xmm8
movd ebx, xmm9
mov ebp, ebx
shr ebp, 0Dh
and ebp, 7C00h
and ebx, 0FFFh
add ebx, ebp
shr r10d, 10h
and r10d, 8000h
cmp r11d, 0FF000001h
cmovnb ebx, r9d
or ebx, r10d
lea r10, [rcx+rcx*8]
mov [rsi+r10*2], bx
xor r10d, r10d
loc_2D925:
movss xmm8, dword ptr [rdi+r10*4]
mulss xmm8, xmm7
addss xmm8, xmm6
cvttss2si r11d, xmm8
cmp r11b, 0Fh
jl short loc_2D946
mov r11d, 0Fh
loc_2D946:
movss xmm8, dword ptr [rdi+r10*4+40h]
mulss xmm8, xmm7
addss xmm8, xmm6
cvttss2si ebx, xmm8
cmp bl, 0Fh
jl short loc_2D966
mov ebx, 0Fh
loc_2D966:
shl bl, 4
or bl, r11b
mov [rax+r10], bl
inc r10
cmp r10, 10h
jnz short loc_2D925
inc rcx
sub rdi, 0FFFFFFFFFFFFFF80h
add rax, 12h
cmp rcx, rdx
jnz loc_2D84E
loc_2D98D:
add rsp, 8
pop rbx
pop rbp
retn
loc_2D994:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidQuantizeRo; "void quantize_row_q4_0_ref(const float "...
mov edx, 22h ; '"'
call ___assert_fail
| long long quantize_row_q4_0_ref(long long a1, long long a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rdx
long long v5; // rdx
long long v6; // rcx
__m128 v7; // xmm3
long long v8; // r10
__m128 v9; // xmm7
__m128 v10; // xmm8
__m128 v11; // xmm10
__m128 v12; // xmm11
__m128 v13; // xmm11
float v14; // xmm7_4
unsigned int v15; // r10d
float v16; // xmm8_4
unsigned int v17; // r11d
unsigned int v18; // ebx
__m128i v19; // xmm9
unsigned int v20; // ebx
int v21; // ebx
int v22; // r10d
long long i; // r10
int v24; // r11d
int v25; // ebx
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
34LL,
"void quantize_row_q4_0_ref(const float *restrict, block_q4_0 *restrict, int64_t)");
v4 = a3 >> 5;
if ( (int)v4 > 0 )
{
v5 = v4 & 0x7FFFFFFF;
result = a2 + 2;
v6 = 0LL;
v7.m128_i32[0] = 0;
do
{
v8 = 0LL;
v9 = 0LL;
v10 = 0LL;
do
{
v11 = _mm_and_ps((__m128)*(unsigned int *)(a1 + 4 * v8), (__m128)xmmword_4C020);
v12 = _mm_cmplt_ss(v9, v11);
v13 = _mm_or_ps(_mm_andnot_ps(v12, v10), _mm_and_ps((__m128)*(unsigned int *)(a1 + 4 * v8), v12));
v10 = v13;
v11.m128_f32[0] = fmaxf(v11.m128_f32[0], v9.m128_f32[0]);
++v8;
v9 = v11;
}
while ( v8 != 32 );
v10.m128_f32[0] = v13.m128_f32[0] * -0.125;
LODWORD(v14) = _mm_cmpneq_ss(v10, v7).m128_u32[0] & COERCE_UNSIGNED_INT(1.0 / (float)(v13.m128_f32[0] * -0.125));
v15 = _mm_cvtsi128_si32((__m128i)v10);
v16 = (float)(fabs(v13.m128_f32[0] * -0.125) * 5.1922969e33) * 7.7037198e-34;
v17 = 2 * v15;
v18 = (v15 & 0x7F800000) + 125829120;
if ( 2 * v15 < 0x71000000 )
v18 = 0x40000000;
v19 = _mm_cvtsi32_si128(v18);
*(float *)v19.m128i_i32 = *(float *)v19.m128i_i32 + v16;
v20 = _mm_cvtsi128_si32(v19);
v21 = ((v20 >> 13) & 0x7C00) + (v20 & 0xFFF);
v22 = HIWORD(v15) & 0x8000;
if ( v17 >= 0xFF000001 )
LOWORD(v21) = 32256;
*(_WORD *)(a2 + 18 * v6) = v22 | v21;
for ( i = 0LL; i != 16; ++i )
{
v24 = (int)(float)((float)(*(float *)(a1 + 4 * i) * v14) + 8.5);
if ( (char)v24 >= 15 )
LOBYTE(v24) = 15;
v25 = (int)(float)((float)(*(float *)(a1 + 4 * i + 64) * v14) + 8.5);
if ( (char)v25 >= 15 )
LOBYTE(v25) = 15;
*(_BYTE *)(result + i) = v24 | (16 * v25);
}
++v6;
a1 += 128LL;
result += 18LL;
}
while ( v6 != v5 );
}
return result;
}
| quantize_row_q4_0_ref:
PUSH RBP
PUSH RBX
PUSH RAX
TEST DL,0x1f
JNZ 0x0012d994
SHR RDX,0x5
TEST EDX,EDX
JLE 0x0012d98d
AND EDX,0x7fffffff
LEA RAX,[RSI + 0x2]
XOR ECX,ECX
MOVAPS XMM0,xmmword ptr [0x0014c020]
MOVSS XMM1,dword ptr [0x00150da0]
MOVSS XMM2,dword ptr [0x0014c058]
XORPS XMM3,XMM3
MOVSS XMM4,dword ptr [0x0014c048]
MOVSS XMM5,dword ptr [0x0014c04c]
MOV R8D,0x40000000
MOV R9D,0x7e00
MOVSS XMM6,dword ptr [0x00150da4]
LAB_0012d84e:
XOR R10D,R10D
XORPS XMM7,XMM7
XORPS XMM8,XMM8
LAB_0012d858:
MOVSS XMM9,dword ptr [RDI + R10*0x4]
MOVAPS XMM10,XMM9
ANDPS XMM10,XMM0
MOVAPS XMM11,XMM7
CMPLTSS XMM11,XMM10
ANDPS XMM9,XMM11
ANDNPS XMM11,XMM8
ORPS XMM11,XMM9
MOVAPS XMM8,XMM11
MAXSS XMM10,XMM7
INC R10
MOVAPS XMM7,XMM10
CMP R10,0x20
JNZ 0x0012d858
MULSS XMM8,XMM1
MOVAPS XMM9,XMM2
DIVSS XMM9,XMM8
MOVAPS XMM7,XMM8
CMPNEQSS XMM7,XMM3
ANDPS XMM7,XMM9
MOVD R10D,XMM8
ANDPS XMM8,XMM0
MULSS XMM8,XMM4
MULSS XMM8,XMM5
LEA R11D,[R10 + R10*0x1]
MOV EBX,R10D
AND EBX,0x7f800000
ADD EBX,0x7800000
CMP R11D,0x71000000
CMOVC EBX,R8D
MOVD XMM9,EBX
ADDSS XMM9,XMM8
MOVD EBX,XMM9
MOV EBP,EBX
SHR EBP,0xd
AND EBP,0x7c00
AND EBX,0xfff
ADD EBX,EBP
SHR R10D,0x10
AND R10D,0x8000
CMP R11D,0xff000001
CMOVNC EBX,R9D
OR EBX,R10D
LEA R10,[RCX + RCX*0x8]
MOV word ptr [RSI + R10*0x2],BX
XOR R10D,R10D
LAB_0012d925:
MOVSS XMM8,dword ptr [RDI + R10*0x4]
MULSS XMM8,XMM7
ADDSS XMM8,XMM6
CVTTSS2SI R11D,XMM8
CMP R11B,0xf
JL 0x0012d946
MOV R11D,0xf
LAB_0012d946:
MOVSS XMM8,dword ptr [RDI + R10*0x4 + 0x40]
MULSS XMM8,XMM7
ADDSS XMM8,XMM6
CVTTSS2SI EBX,XMM8
CMP BL,0xf
JL 0x0012d966
MOV EBX,0xf
LAB_0012d966:
SHL BL,0x4
OR BL,R11B
MOV byte ptr [RAX + R10*0x1],BL
INC R10
CMP R10,0x10
JNZ 0x0012d925
INC RCX
SUB RDI,-0x80
ADD RAX,0x12
CMP RCX,RDX
JNZ 0x0012d84e
LAB_0012d98d:
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0012d994:
LEA RDI,[0x15b7f8]
LEA RSI,[0x15b804]
LEA RCX,[0x15b85d]
MOV EDX,0x22
CALL 0x00117b00
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q4_0_ref(long param_1,long param_2,ulong param_3)
{
uint uVar1;
uint uVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
long lVar8;
ulong uVar9;
uint uVar10;
char cVar11;
ushort uVar12;
long lVar13;
byte bVar14;
float fVar15;
float fVar16;
float fVar17;
fVar7 = DAT_00150da4;
fVar6 = DAT_00150da0;
fVar5 = DAT_0014c058;
fVar4 = DAT_0014c04c;
fVar3 = DAT_0014c048;
uVar2 = _DAT_0014c020;
if ((param_3 & 0x1f) == 0) {
uVar10 = (uint)(param_3 >> 5);
if (0 < (int)uVar10) {
lVar8 = param_2 + 2;
uVar9 = 0;
do {
lVar13 = 0;
fVar15 = 0.0;
fVar16 = 0.0;
do {
uVar1 = *(uint *)(param_1 + lVar13 * 4);
fVar17 = (float)(uVar1 & uVar2);
fVar16 = (float)(~-(uint)(fVar15 < fVar17) & (uint)fVar16 |
uVar1 & -(uint)(fVar15 < fVar17));
if (fVar17 <= fVar15) {
fVar17 = fVar15;
}
fVar15 = fVar17;
lVar13 = lVar13 + 1;
} while (lVar13 != 0x20);
fVar16 = fVar16 * fVar6;
fVar17 = (float)(-(uint)(fVar16 != 0.0) & (uint)(fVar5 / fVar16));
fVar15 = (float)(((uint)fVar16 & 0x7f800000) + 0x7800000);
if ((uint)((int)fVar16 * 2) < 0x71000000) {
fVar15 = 2.0;
}
fVar15 = fVar15 + (float)((uint)fVar16 & uVar2) * fVar3 * fVar4;
uVar12 = (SUB42(fVar15,0) & 0xfff) + ((ushort)((uint)fVar15 >> 0xd) & 0x7c00);
if (0xff000000 < (uint)((int)fVar16 * 2)) {
uVar12 = 0x7e00;
}
*(ushort *)(param_2 + uVar9 * 0x12) = uVar12 | (ushort)((uint)fVar16 >> 0x10) & 0x8000;
lVar13 = 0;
do {
bVar14 = (byte)(int)(*(float *)(param_1 + lVar13 * 4) * fVar17 + fVar7);
if ('\x0e' < (char)bVar14) {
bVar14 = 0xf;
}
cVar11 = (char)(int)(*(float *)(param_1 + 0x40 + lVar13 * 4) * fVar17 + fVar7);
if ('\x0e' < cVar11) {
cVar11 = '\x0f';
}
*(byte *)(lVar8 + lVar13) = cVar11 << 4 | bVar14;
lVar13 = lVar13 + 1;
} while (lVar13 != 0x10);
uVar9 = uVar9 + 1;
param_1 = param_1 + 0x80;
lVar8 = lVar8 + 0x12;
} while (uVar9 != (uVar10 & 0x7fffffff));
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x22,
"void quantize_row_q4_0_ref(const float *restrict, block_q4_0 *restrict, int64_t)");
}
| |
24,561 | quantize_row_q4_0_ref | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c | void quantize_row_q4_0_ref(const float * restrict x, block_q4_0 * restrict y, int64_t k) {
static const int qk = QK4_0;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
float amax = 0.0f; // absolute max
float max = 0.0f;
for (int j = 0; j < qk; j++) {
const float v = x[i*qk + j];
if (amax < fabsf(v)) {
amax = fabsf(v);
max = v;
}
}
const float d = max / -8;
const float id = d ? 1.0f/d : 0.0f;
y[i].d = GGML_FP32_TO_FP16(d);
for (int j = 0; j < qk/2; ++j) {
const float x0 = x[i*qk + 0 + j]*id;
const float x1 = x[i*qk + qk/2 + j]*id;
const uint8_t xi0 = MIN(15, (int8_t)(x0 + 8.5f));
const uint8_t xi1 = MIN(15, (int8_t)(x1 + 8.5f));
y[i].qs[j] = xi0;
y[i].qs[j] |= xi1 << 4;
}
}
} | O2 | c | quantize_row_q4_0_ref:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testb $0x1f, %dl
jne 0x31dcc
movq %rsi, %r13
movq %rdi, %rbx
shrq $0x5, %rdx
xorl %r12d, %r12d
testl %edx, %edx
cmovlel %r12d, %edx
leaq 0x40(%rdi), %rax
movq %rax, (%rsp)
leaq 0x2(%rsi), %rbp
pushq $0xf
popq %r14
movaps 0x1c367(%rip), %xmm5 # 0x4e020
movq %rdx, 0x8(%rsp)
cmpq %rdx, %r12
je 0x31dbd
movl %r12d, %eax
andl $0x7ffffff, %eax # imm = 0x7FFFFFF
shlq $0x7, %rax
movq (%rsp), %rcx
leaq (%rcx,%rax), %r15
addq %rbx, %rax
xorps %xmm0, %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cmpq $0x20, %rcx
je 0x31d17
movss (%rax,%rcx,4), %xmm2
movaps %xmm2, %xmm3
andps %xmm5, %xmm3
movaps %xmm1, %xmm4
cmpltss %xmm3, %xmm4
andps %xmm4, %xmm2
andnps %xmm0, %xmm4
orps %xmm2, %xmm4
maxss %xmm1, %xmm3
incq %rcx
movaps %xmm4, %xmm0
movaps %xmm3, %xmm1
jmp 0x31ce6
mulss 0x21301(%rip), %xmm0 # 0x53020
movss 0x1c339(%rip), %xmm1 # 0x4e060
divss %xmm0, %xmm1
movaps %xmm0, %xmm2
cmpneqss 0x212f1(%rip), %xmm2 # 0x53028
andps %xmm1, %xmm2
movaps %xmm2, 0x10(%rsp)
callq 0x31de9
imulq $0x12, %r12, %rcx
movw %ax, (%r13,%rcx)
xorl %eax, %eax
movss 0x212cc(%rip), %xmm1 # 0x53024
cmpq $0x10, %rax
je 0x31da5
movss -0x40(%r15,%rax,4), %xmm0
mulss 0x10(%rsp), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
cmpb $0xf, %cl
jl 0x31d7b
movl %r14d, %ecx
movss (%r15,%rax,4), %xmm0
mulss 0x10(%rsp), %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %edx
cmpb $0xf, %dl
jl 0x31d97
movl %r14d, %edx
shlb $0x4, %dl
orb %cl, %dl
movb %dl, (%rbp,%rax)
incq %rax
jmp 0x31d58
incq %r12
addq $0x12, %rbp
movq 0x8(%rsp), %rdx
movaps 0x1c268(%rip), %xmm5 # 0x4e020
jmp 0x31cbe
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bc85(%rip), %rdi # 0x5da58
leaq 0x2bc8a(%rip), %rsi # 0x5da64
leaq 0x2bcdc(%rip), %rcx # 0x5dabd
pushq $0x22
popq %rdx
callq 0x1dfb0
| quantize_row_q4_0_ref:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
test dl, 1Fh
jnz loc_31DCC
mov r13, rsi
mov rbx, rdi
shr rdx, 5
xor r12d, r12d
test edx, edx
cmovle edx, r12d
lea rax, [rdi+40h]
mov [rsp+58h+var_58], rax
lea rbp, [rsi+2]
push 0Fh
pop r14
movaps xmm5, cs:xmmword_4E020
mov [rsp+58h+var_50], rdx
loc_31CBE:
cmp r12, rdx
jz loc_31DBD
mov eax, r12d
and eax, 7FFFFFFh
shl rax, 7
mov rcx, [rsp+58h+var_58]
lea r15, [rcx+rax]
add rax, rbx
xorps xmm0, xmm0
xor ecx, ecx
xorps xmm1, xmm1
loc_31CE6:
cmp rcx, 20h ; ' '
jz short loc_31D17
movss xmm2, dword ptr [rax+rcx*4]
movaps xmm3, xmm2
andps xmm3, xmm5
movaps xmm4, xmm1
cmpltss xmm4, xmm3
andps xmm2, xmm4
andnps xmm4, xmm0
orps xmm4, xmm2
maxss xmm3, xmm1
inc rcx
movaps xmm0, xmm4
movaps xmm1, xmm3
jmp short loc_31CE6
loc_31D17:
mulss xmm0, cs:dword_53020
movss xmm1, cs:dword_4E060
divss xmm1, xmm0
movaps xmm2, xmm0
cmpneqss xmm2, cs:dword_53028
andps xmm2, xmm1
movaps [rsp+58h+var_48], xmm2
call ggml_compute_fp32_to_fp16_0
imul rcx, r12, 12h
mov [r13+rcx+0], ax
xor eax, eax
movss xmm1, cs:dword_53024
loc_31D58:
cmp rax, 10h
jz short loc_31DA5
movss xmm0, dword ptr [r15+rax*4-40h]
mulss xmm0, dword ptr [rsp+58h+var_48]
addss xmm0, xmm1
cvttss2si ecx, xmm0
cmp cl, 0Fh
jl short loc_31D7B
mov ecx, r14d
loc_31D7B:
movss xmm0, dword ptr [r15+rax*4]
mulss xmm0, dword ptr [rsp+58h+var_48]
addss xmm0, xmm1
cvttss2si edx, xmm0
cmp dl, 0Fh
jl short loc_31D97
mov edx, r14d
loc_31D97:
shl dl, 4
or dl, cl
mov [rbp+rax+0], dl
inc rax
jmp short loc_31D58
loc_31DA5:
inc r12
add rbp, 12h
mov rdx, [rsp+58h+var_50]
movaps xmm5, cs:xmmword_4E020
jmp loc_31CBE
loc_31DBD:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_31DCC:
lea rdi, aKQk0; "k % qk == 0"
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidQuantizeRo; "void quantize_row_q4_0_ref(const float "...
push 22h ; '"'
pop rdx
call ___assert_fail
| long long quantize_row_q4_0_ref(
long long a1,
long long a2,
unsigned long long a3,
double a4,
double a5,
double a6,
__m128 a7,
__m128 a8)
{
unsigned long long v8; // rdx
long long v9; // r12
long long result; // rax
long long v11; // rbp
__m128 v12; // xmm5
unsigned long long v13; // rax
unsigned long long v14; // r15
long long v15; // rax
__m128 v16; // xmm0
long long v17; // rcx
__m128 v18; // xmm1
__m128 v19; // xmm4
long long v20; // xmm1_8
__m128 v21; // rt1
int v22; // ecx
int v23; // edx
unsigned long long v24; // [rsp+8h] [rbp-50h]
double v25; // [rsp+10h] [rbp-48h]
if ( (a3 & 0x1F) != 0 )
__assert_fail(
"k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c",
34LL,
"void quantize_row_q4_0_ref(const float *restrict, block_q4_0 *restrict, int64_t)");
v8 = a3 >> 5;
v9 = 0LL;
if ( (int)v8 <= 0 )
v8 = 0LL;
result = a1 + 64;
v11 = a2 + 2;
v12 = (__m128)xmmword_4E020;
v24 = v8;
while ( v9 != v8 )
{
v13 = (unsigned long long)(v9 & 0x7FFFFFF) << 7;
v14 = a1 + 64 + v13;
v15 = a1 + v13;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
while ( v17 != 32 )
{
a7 = _mm_and_ps((__m128)*(unsigned int *)(v15 + 4 * v17), v12);
v19 = _mm_cmplt_ss(v18, a7);
a8 = _mm_or_ps(_mm_andnot_ps(v19, v16), _mm_and_ps((__m128)*(unsigned int *)(v15 + 4 * v17), v19));
a7.m128_f32[0] = fmaxf(a7.m128_f32[0], v18.m128_f32[0]);
++v17;
v16 = a8;
v18 = a7;
}
v16.m128_f32[0] = v16.m128_f32[0] * -0.125;
HIDWORD(v20) = 0;
*(float *)&v20 = 1.0 / v16.m128_f32[0];
v21.m128_i32[0] = 0;
*(_QWORD *)&v25 = _mm_cmpneq_ss(v16, v21).m128_u64[0] & v20;
*(_WORD *)(a2 + 18 * v9) = ggml_compute_fp32_to_fp16_0(
v16.m128_f32[0],
1.0 / v16.m128_f32[0],
v25,
*(double *)a7.m128_u64,
*(double *)a8.m128_u64,
*(double *)v12.m128_u64);
for ( result = 0LL; result != 16; ++result )
{
v22 = (int)(float)((float)(*(float *)(v14 + 4 * result - 64) * *(float *)&v25) + 8.5);
if ( (char)v22 >= 15 )
LOBYTE(v22) = 15;
v23 = (int)(float)((float)(*(float *)(v14 + 4 * result) * *(float *)&v25) + 8.5);
if ( (char)v23 >= 15 )
LOBYTE(v23) = 15;
*(_BYTE *)(v11 + result) = v22 | (16 * v23);
}
++v9;
v11 += 18LL;
v8 = v24;
v12 = (__m128)xmmword_4E020;
}
return result;
}
| quantize_row_q4_0_ref:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
TEST DL,0x1f
JNZ 0x00131dcc
MOV R13,RSI
MOV RBX,RDI
SHR RDX,0x5
XOR R12D,R12D
TEST EDX,EDX
CMOVLE EDX,R12D
LEA RAX,[RDI + 0x40]
MOV qword ptr [RSP],RAX
LEA RBP,[RSI + 0x2]
PUSH 0xf
POP R14
MOVAPS XMM5,xmmword ptr [0x0014e020]
MOV qword ptr [RSP + 0x8],RDX
LAB_00131cbe:
CMP R12,RDX
JZ 0x00131dbd
MOV EAX,R12D
AND EAX,0x7ffffff
SHL RAX,0x7
MOV RCX,qword ptr [RSP]
LEA R15,[RCX + RAX*0x1]
ADD RAX,RBX
XORPS XMM0,XMM0
XOR ECX,ECX
XORPS XMM1,XMM1
LAB_00131ce6:
CMP RCX,0x20
JZ 0x00131d17
MOVSS XMM2,dword ptr [RAX + RCX*0x4]
MOVAPS XMM3,XMM2
ANDPS XMM3,XMM5
MOVAPS XMM4,XMM1
CMPLTSS XMM4,XMM3
ANDPS XMM2,XMM4
ANDNPS XMM4,XMM0
ORPS XMM4,XMM2
MAXSS XMM3,XMM1
INC RCX
MOVAPS XMM0,XMM4
MOVAPS XMM1,XMM3
JMP 0x00131ce6
LAB_00131d17:
MULSS XMM0,dword ptr [0x00153020]
MOVSS XMM1,dword ptr [0x0014e060]
DIVSS XMM1,XMM0
MOVAPS XMM2,XMM0
CMPNEQSS XMM2,dword ptr [0x00153028]
ANDPS XMM2,XMM1
MOVAPS xmmword ptr [RSP + 0x10],XMM2
CALL 0x00131de9
IMUL RCX,R12,0x12
MOV word ptr [R13 + RCX*0x1],AX
XOR EAX,EAX
MOVSS XMM1,dword ptr [0x00153024]
LAB_00131d58:
CMP RAX,0x10
JZ 0x00131da5
MOVSS XMM0,dword ptr [R15 + RAX*0x4 + -0x40]
MULSS XMM0,dword ptr [RSP + 0x10]
ADDSS XMM0,XMM1
CVTTSS2SI ECX,XMM0
CMP CL,0xf
JL 0x00131d7b
MOV ECX,R14D
LAB_00131d7b:
MOVSS XMM0,dword ptr [R15 + RAX*0x4]
MULSS XMM0,dword ptr [RSP + 0x10]
ADDSS XMM0,XMM1
CVTTSS2SI EDX,XMM0
CMP DL,0xf
JL 0x00131d97
MOV EDX,R14D
LAB_00131d97:
SHL DL,0x4
OR DL,CL
MOV byte ptr [RBP + RAX*0x1],DL
INC RAX
JMP 0x00131d58
LAB_00131da5:
INC R12
ADD RBP,0x12
MOV RDX,qword ptr [RSP + 0x8]
MOVAPS XMM5,xmmword ptr [0x0014e020]
JMP 0x00131cbe
LAB_00131dbd:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00131dcc:
LEA RDI,[0x15da58]
LEA RSI,[0x15da64]
LEA RCX,[0x15dabd]
PUSH 0x22
POP RDX
CALL 0x0011dfb0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q4_0_ref(long param_1,long param_2,ulong param_3)
{
long lVar1;
uint uVar2;
int2 uVar3;
long lVar4;
byte bVar5;
long lVar6;
byte bVar7;
ulong uVar8;
long lVar9;
ulong uVar10;
float fVar11;
float fVar12;
float fVar13;
if ((param_3 & 0x1f) == 0) {
uVar10 = 0;
uVar8 = param_3 >> 5 & 0xffffffff;
if ((int)(param_3 >> 5) < 1) {
uVar8 = uVar10;
}
lVar9 = param_2 + 2;
for (; uVar10 != uVar8; uVar10 = uVar10 + 1) {
lVar4 = (ulong)((uint)uVar10 & 0x7ffffff) * 0x80;
lVar1 = param_1 + 0x40 + lVar4;
fVar11 = 0.0;
fVar12 = 0.0;
for (lVar6 = 0; lVar6 != 0x20; lVar6 = lVar6 + 1) {
uVar2 = *(uint *)(lVar4 + param_1 + lVar6 * 4);
fVar13 = (float)(uVar2 & _DAT_0014e020);
fVar11 = (float)(~-(uint)(fVar12 < fVar13) & (uint)fVar11 | uVar2 & -(uint)(fVar12 < fVar13)
);
if (fVar13 <= fVar12) {
fVar13 = fVar12;
}
fVar12 = fVar13;
}
fVar12 = (float)(-(uint)(fVar11 * DAT_00153020 != DAT_00153028) &
(uint)(DAT_0014e060 / (fVar11 * DAT_00153020)));
uVar3 = ggml_compute_fp32_to_fp16();
*(int2 *)(param_2 + uVar10 * 0x12) = uVar3;
fVar11 = DAT_00153024;
for (lVar4 = 0; lVar4 != 0x10; lVar4 = lVar4 + 1) {
bVar5 = (byte)(int)(*(float *)(lVar1 + -0x40 + lVar4 * 4) * fVar12 + fVar11);
if ('\x0e' < (char)bVar5) {
bVar5 = 0xf;
}
bVar7 = (byte)(int)(*(float *)(lVar1 + lVar4 * 4) * fVar12 + fVar11);
if ('\x0e' < (char)bVar7) {
bVar7 = 0xf;
}
*(byte *)(lVar9 + lVar4) = bVar7 << 4 | bVar5;
}
lVar9 = lVar9 + 0x12;
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("k % qk == 0",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-quants.c"
,0x22,
"void quantize_row_q4_0_ref(const float *restrict, block_q4_0 *restrict, int64_t)");
}
| |
24,562 | mi_delete_static_record | eloqsql/storage/myisam/mi_statrec.c | int _mi_delete_static_record(MI_INFO *info)
{
uchar temp[9]; /* 1+sizeof(uint32) */
info->state->del++;
info->state->empty+=info->s->base.pack_reclength;
temp[0]= '\0'; /* Mark that record is deleted */
_mi_dpointer(info,temp+1,info->s->state.dellink);
info->s->state.dellink = info->lastpos;
info->rec_cache.seek_not_done=1;
return (info->s->file_write(info,(uchar*) temp, 1+info->s->rec_reflength,
info->lastpos, MYF(MY_NABP)) != 0);
} | O0 | c | mi_delete_static_record:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
incq %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq 0x148(%rcx), %rdx
movq 0x10(%rax), %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movb $0x0, -0x11(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x58(%rax), %rdx
callq 0xc0a20
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movq 0x170(%rcx), %rcx
movq %rcx, 0x58(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x300(%rax)
movq -0x20(%rbp), %rdi
movq (%rdi), %rdx
movq 0x170(%rdi), %rcx
movq 0x2e8(%rdx), %rax
movl 0x338(%rdx), %edx
incl %edx
leaq -0x11(%rbp), %rsi
movl $0x4, %r8d
callq *%rax
testq %rax, %rax
setne %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xc4091
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
callq 0x2a260
nopw %cs:(%rax,%rax)
| _mi_delete_static_record:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov rcx, [rax+8]
inc rcx
mov [rax+8], rcx
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rax+8]
mov rdx, [rcx+148h]
mov rcx, [rax+10h]
add rcx, rdx
mov [rax+10h], rcx
mov [rbp+var_11], 0
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_10]
mov rax, [rdi]
mov rdx, [rax+58h]
call _mi_dpointer
mov rcx, [rbp+var_20]
mov rax, [rcx]
mov rcx, [rcx+170h]
mov [rax+58h], rcx
mov rax, [rbp+var_20]
mov dword ptr [rax+300h], 1
mov rdi, [rbp+var_20]
mov rdx, [rdi]
mov rcx, [rdi+170h]
mov rax, [rdx+2E8h]
mov edx, [rdx+338h]
inc edx
lea rsi, [rbp+var_11]
mov r8d, 4
call rax
test rax, rax
setnz al
movzx eax, al
mov [rbp+var_24], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_C4091
mov eax, [rbp+var_24]
add rsp, 30h
pop rbp
retn
loc_C4091:
call ___stack_chk_fail
| _BOOL8 mi_delete_static_record(_QWORD *a1)
{
char v2; // [rsp+1Fh] [rbp-11h] BYREF
_BYTE v3[8]; // [rsp+20h] [rbp-10h] BYREF
unsigned long long v4; // [rsp+28h] [rbp-8h]
v4 = __readfsqword(0x28u);
++*(_QWORD *)(a1[1] + 8LL);
*(_QWORD *)(a1[1] + 16LL) += *(_QWORD *)(*a1 + 328LL);
v2 = 0;
mi_dpointer((long long)a1, v3, *(_QWORD *)(*a1 + 88LL));
*(_QWORD *)(*a1 + 88LL) = a1[46];
*((_DWORD *)a1 + 192) = 1;
return (*(long long ( **)(_QWORD *, char *, _QWORD, _QWORD, long long))(*a1 + 744LL))(
a1,
&v2,
(unsigned int)(*(_DWORD *)(*a1 + 824LL) + 1),
a1[46],
4LL) != 0;
}
| _mi_delete_static_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x8]
INC RCX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDX,qword ptr [RCX + 0x148]
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,RDX
MOV qword ptr [RAX + 0x10],RCX
MOV byte ptr [RBP + -0x11],0x0
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x10]
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RAX + 0x58]
CALL 0x001c0a20
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x170]
MOV qword ptr [RAX + 0x58],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x300],0x1
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x170]
MOV RAX,qword ptr [RDX + 0x2e8]
MOV EDX,dword ptr [RDX + 0x338]
INC EDX
LEA RSI,[RBP + -0x11]
MOV R8D,0x4
CALL RAX
TEST RAX,RAX
SETNZ AL
MOVZX EAX,AL
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001c4091
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x30
POP RBP
RET
LAB_001c4091:
CALL 0x0012a260
|
bool _mi_delete_static_record(long *param_1)
{
long lVar1;
long in_FS_OFFSET;
int1 local_19;
int1 local_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + 1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) + *(long *)(*param_1 + 0x148);
local_19 = 0;
_mi_dpointer(param_1,local_18,*(int8 *)(*param_1 + 0x58));
*(long *)(*param_1 + 0x58) = param_1[0x2e];
*(int4 *)(param_1 + 0x60) = 1;
lVar1 = (**(code **)(*param_1 + 0x2e8))
(param_1,&local_19,*(int *)(*param_1 + 0x338) + 1,param_1[0x2e],4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return lVar1 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,563 | my_long10_to_str_8bit | eloqsql/strings/ctype-simple.c | size_t my_long10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *e;
long int new_val;
uint sign=0;
unsigned long int uval = (unsigned long int) val;
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval= (unsigned long int)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
len= MY_MIN(len, (size_t) (e-p));
memcpy(dst, p, len);
return len+sign;
} | O3 | c | my_long10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r10
movq %rsi, %rdi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x1f(%rbp)
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %cl
orb %al, %cl
jne 0xb84a7
negq %r8
movb $0x2d, (%rdi)
incq %rdi
decq %r10
movl $0x1, %r14d
jmp 0xb84aa
xorl %r14d, %r14d
leaq -0x1f(%rbp), %rbx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %r8, %rax
mulq %rcx
movq %rdx, %r9
shrq $0x3, %r9
imull $0xf6, %r9d, %eax
addl %r8d, %eax
addb $0x30, %al
leaq -0x20(%rbp), %rsi
movb %al, (%rsi)
cmpq $0xa, %r8
jb 0xb8501
movq %r9, %rax
mulq %rcx
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %r9d, %eax
addb $0x30, %al
movb %al, -0x1(%rsi)
decq %rsi
cmpq $0x9, %r9
movq %rdx, %r9
ja 0xb84dd
subq %rsi, %rbx
cmpq %rbx, %r10
cmovbq %r10, %rbx
movq %rbx, %rdx
callq 0x29090
movq %fs:0x28, %rax
cmpq -0x18(%rbp), %rax
jne 0xb8531
addq %r14, %rbx
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29240
| my_long10_to_str_8bit:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r10, rdx
mov rdi, rsi
mov rax, fs:28h
mov [rbp+var_18], rax
mov [rbp+var_1F], 0
test ecx, ecx
setns al
test r8, r8
setns cl
or cl, al
jnz short loc_B84A7
neg r8
mov byte ptr [rdi], 2Dh ; '-'
inc rdi
dec r10
mov r14d, 1
jmp short loc_B84AA
loc_B84A7:
xor r14d, r14d
loc_B84AA:
lea rbx, [rbp+var_1F]
mov rcx, 0CCCCCCCCCCCCCCCDh
mov rax, r8
mul rcx
mov r9, rdx
shr r9, 3
imul eax, r9d, 0F6h
add eax, r8d
add al, 30h ; '0'
lea rsi, [rbp+var_20]
mov [rsi], al
cmp r8, 0Ah
jb short loc_B8501
loc_B84DD:
mov rax, r9
mul rcx
shr rdx, 3
imul eax, edx, 0F6h
add eax, r9d
add al, 30h ; '0'
mov [rsi-1], al
dec rsi
cmp r9, 9
mov r9, rdx
ja short loc_B84DD
loc_B8501:
sub rbx, rsi
cmp r10, rbx
cmovb rbx, r10
mov rdx, rbx
call _memcpy
mov rax, fs:28h
cmp rax, [rbp+var_18]
jnz short loc_B8531
add rbx, r14
mov rax, rbx
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_B8531:
call ___stack_chk_fail
| _BYTE * my_long10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, unsigned long long a5)
{
_BYTE *v5; // r10
_BYTE *v6; // rdi
long long v7; // r14
unsigned long long v8; // r9
char *v9; // rsi
bool v10; // cf
bool v11; // zf
_BYTE *v12; // rbx
char v14; // [rsp+40h] [rbp-20h] BYREF
_BYTE v15[7]; // [rsp+41h] [rbp-1Fh] BYREF
unsigned long long v16; // [rsp+48h] [rbp-18h]
v5 = a3;
v6 = a2;
v16 = __readfsqword(0x28u);
v15[0] = 0;
if ( a4 >= 0 || (a5 & 0x8000000000000000LL) == 0LL )
{
v7 = 0LL;
}
else
{
a5 = -(long long)a5;
*a2 = 45;
v6 = a2 + 1;
v5 = a3 - 1;
v7 = 1LL;
}
v8 = a5 / 0xA;
v9 = &v14;
v14 = a5 % 0xA + 48;
if ( a5 >= 0xA )
{
do
{
*--v9 = v8 % 0xA + 48;
v10 = v8 < 9;
v11 = v8 == 9;
v8 /= 0xAuLL;
}
while ( !v10 && !v11 );
}
v12 = (_BYTE *)(v15 - v9);
if ( (unsigned long long)v5 < v15 - v9 )
v12 = v5;
memcpy(v6, v9, v12);
return &v12[v7];
}
| my_long10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R10,RDX
MOV RDI,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
MOV byte ptr [RBP + -0x1f],0x0
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS CL
OR CL,AL
JNZ 0x001b84a7
NEG R8
MOV byte ptr [RDI],0x2d
INC RDI
DEC R10
MOV R14D,0x1
JMP 0x001b84aa
LAB_001b84a7:
XOR R14D,R14D
LAB_001b84aa:
LEA RBX,[RBP + -0x1f]
MOV RCX,-0x3333333333333333
MOV RAX,R8
MUL RCX
MOV R9,RDX
SHR R9,0x3
IMUL EAX,R9D,0xf6
ADD EAX,R8D
ADD AL,0x30
LEA RSI,[RBP + -0x20]
MOV byte ptr [RSI],AL
CMP R8,0xa
JC 0x001b8501
LAB_001b84dd:
MOV RAX,R9
MUL RCX
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,R9D
ADD AL,0x30
MOV byte ptr [RSI + -0x1],AL
DEC RSI
CMP R9,0x9
MOV R9,RDX
JA 0x001b84dd
LAB_001b8501:
SUB RBX,RSI
CMP R10,RBX
CMOVC RBX,R10
MOV RDX,RBX
CALL 0x00129090
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x001b8531
ADD RBX,R14
MOV RAX,RBX
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_001b8531:
CALL 0x00129240
|
char * my_long10_to_str_8bit
(int8 param_1,int1 *param_2,char *param_3,int param_4,ulong param_5)
{
ulong uVar1;
ulong uVar2;
char *__n;
char *__src;
long in_FS_OFFSET;
bool bVar3;
char local_29 [9];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_29[2] = 0;
bVar3 = (long)param_5 < 0;
if (bVar3 && param_4 < 0) {
param_5 = -param_5;
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_3 = param_3 + -1;
}
local_29[1] = (char)(param_5 / 10) * -10 + (char)param_5 + '0';
__src = local_29 + 1;
uVar2 = param_5 / 10;
while (uVar1 = uVar2, 9 < param_5) {
__src[-1] = (char)(uVar1 / 10) * -10 + (char)uVar1 + '0';
__src = __src + -1;
uVar2 = uVar1 / 10;
param_5 = uVar1;
}
__n = local_29 + (2 - (long)__src);
if (param_3 < local_29 + (2 - (long)__src)) {
__n = param_3;
}
memcpy(param_2,__src,(size_t)__n);
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return __n + (bVar3 && param_4 < 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,564 | maria_ft_parse_internal | eloqsql/storage/maria/ma_ft_parser.c | static int maria_ft_parse_internal(MYSQL_FTPARSER_PARAM *param,
const char *doc_arg,
int doc_len)
{
uchar *doc= (uchar*) doc_arg;
uchar *end= doc + doc_len;
MY_FT_PARSER_PARAM *ft_param=param->mysql_ftparam;
TREE *wtree= ft_param->wtree;
FT_WORD w;
DBUG_ENTER("maria_ft_parse_internal");
while (maria_ft_simple_get_word(wtree->custom_arg, &doc, end, &w, TRUE))
if (param->mysql_add_word(param, (char*)w.pos, w.len, 0))
DBUG_RETURN(1);
DBUG_RETURN(0);
} | O3 | c | maria_ft_parse_internal:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r14
movq %rsi, (%r14)
movslq %edx, %r15
addq %rsi, %r15
movq 0x18(%rdi), %rax
movq (%rax), %r12
leaq -0x40(%rbp), %r13
movq 0x230(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
movl $0x1, %r8d
callq 0x5f583
testb %al, %al
je 0x5f7bf
movq -0x40(%rbp), %rsi
movl -0x38(%rbp), %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq *0x8(%rbx)
testl %eax, %eax
je 0x5f785
movl $0x1, %eax
jmp 0x5f7c1
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| maria_ft_parse_internal:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
lea r14, [rbp+var_48]
mov [r14], rsi
movsxd r15, edx
add r15, rsi
mov rax, [rdi+18h]
mov r12, [rax]
lea r13, [rbp+var_40]
loc_5F785:
mov rdi, [r12+230h]
mov rsi, r14
mov rdx, r15
mov rcx, r13
mov r8d, 1
call maria_ft_simple_get_word
test al, al
jz short loc_5F7BF
mov rsi, [rbp+var_40]
mov edx, [rbp+var_38]
mov rdi, rbx
xor ecx, ecx
call qword ptr [rbx+8]
test eax, eax
jz short loc_5F785
mov eax, 1
jmp short loc_5F7C1
loc_5F7BF:
xor eax, eax
loc_5F7C1:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long maria_ft_parse_internal(long long a1, _BYTE *a2, int a3)
{
unsigned long long v3; // r15
long long v4; // r12
_BYTE *v6; // [rsp+8h] [rbp-48h] BYREF
long long v7; // [rsp+10h] [rbp-40h] BYREF
unsigned int v8; // [rsp+18h] [rbp-38h]
v6 = a2;
v3 = (unsigned long long)&a2[a3];
v4 = **(_QWORD **)(a1 + 24);
while ( maria_ft_simple_get_word(*(_QWORD *)(v4 + 560), &v6, v3, &v7, 1) )
{
if ( (*(unsigned int ( **)(long long, long long, _QWORD, _QWORD))(a1 + 8))(a1, v7, v8, 0LL) )
return 1LL;
}
return 0LL;
}
| maria_ft_parse_internal:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA R14,[RBP + -0x48]
MOV qword ptr [R14],RSI
MOVSXD R15,EDX
ADD R15,RSI
MOV RAX,qword ptr [RDI + 0x18]
MOV R12,qword ptr [RAX]
LEA R13,[RBP + -0x40]
LAB_0015f785:
MOV RDI,qword ptr [R12 + 0x230]
MOV RSI,R14
MOV RDX,R15
MOV RCX,R13
MOV R8D,0x1
CALL 0x0015f583
TEST AL,AL
JZ 0x0015f7bf
MOV RSI,qword ptr [RBP + -0x40]
MOV EDX,dword ptr [RBP + -0x38]
MOV RDI,RBX
XOR ECX,ECX
CALL qword ptr [RBX + 0x8]
TEST EAX,EAX
JZ 0x0015f785
MOV EAX,0x1
JMP 0x0015f7c1
LAB_0015f7bf:
XOR EAX,EAX
LAB_0015f7c1:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 maria_ft_parse_internal(long param_1,long param_2,int param_3)
{
long lVar1;
char cVar2;
int iVar3;
long local_50;
int8 local_48;
int4 local_40;
lVar1 = **(long **)(param_1 + 0x18);
local_50 = param_2;
do {
cVar2 = maria_ft_simple_get_word
(*(int8 *)(lVar1 + 0x230),&local_50,param_3 + param_2,&local_48,1);
if (cVar2 == '\0') {
return 0;
}
iVar3 = (**(code **)(param_1 + 8))(param_1,local_48,local_40,0);
} while (iVar3 == 0);
return 1;
}
| |
24,565 | init_timers() | eloqsql/storage/perfschema/pfs_timer.cc | void init_timers(void)
{
double pico_frequency= 1.0e12;
cycle_v0= my_timer_cycles();
nanosec_v0= my_timer_nanoseconds();
microsec_v0= my_timer_microseconds();
millisec_v0= my_timer_milliseconds();
tick_v0= my_timer_ticks();
if (sys_timer_info.cycles.frequency > 0)
cycle_to_pico= round_to_ulong(pico_frequency/
(double)sys_timer_info.cycles.frequency);
else
cycle_to_pico= 0;
if (sys_timer_info.nanoseconds.frequency > 0)
nanosec_to_pico= round_to_ulong(pico_frequency/
(double)sys_timer_info.nanoseconds.frequency);
else
nanosec_to_pico= 0;
if (sys_timer_info.microseconds.frequency > 0)
microsec_to_pico= round_to_ulong(pico_frequency/
(double)sys_timer_info.microseconds.frequency);
else
microsec_to_pico= 0;
if (sys_timer_info.milliseconds.frequency > 0)
millisec_to_pico= round_to_ulong(pico_frequency/
(double)sys_timer_info.milliseconds.frequency);
else
millisec_to_pico= 0;
if (sys_timer_info.ticks.frequency > 0)
tick_to_pico= round_to_ulonglong(pico_frequency/
(double)sys_timer_info.ticks.frequency);
else
tick_to_pico= 0;
to_pico_data[TIMER_NAME_CYCLE].m_v0= cycle_v0;
to_pico_data[TIMER_NAME_CYCLE].m_factor= cycle_to_pico;
to_pico_data[TIMER_NAME_NANOSEC].m_v0= nanosec_v0;
to_pico_data[TIMER_NAME_NANOSEC].m_factor= nanosec_to_pico;
to_pico_data[TIMER_NAME_MICROSEC].m_v0= microsec_v0;
to_pico_data[TIMER_NAME_MICROSEC].m_factor= microsec_to_pico;
to_pico_data[TIMER_NAME_MILLISEC].m_v0= millisec_v0;
to_pico_data[TIMER_NAME_MILLISEC].m_factor= millisec_to_pico;
to_pico_data[TIMER_NAME_TICK].m_v0= tick_v0;
to_pico_data[TIMER_NAME_TICK].m_factor= tick_to_pico;
/*
Depending on the platform and build options,
some timers may not be available.
Pick best replacements.
*/
/*
For WAIT, the cycle timer is used by default. However, it is not available
on all architectures. Fall back to the nanosecond timer in this case. It is
unlikely that neither cycle nor nanosecond are available, but we continue
probing less resolution timers anyway for consistency with other events.
*/
if (cycle_to_pico != 0)
{
/* Normal case. */
wait_timer= TIMER_NAME_CYCLE;
}
else if (nanosec_to_pico != 0)
{
/* Robustness, no known cases. */
wait_timer= TIMER_NAME_NANOSEC;
}
else if (microsec_to_pico != 0)
{
/* Robustness, no known cases. */
wait_timer= TIMER_NAME_MICROSEC;
}
else if (millisec_to_pico != 0)
{
/* Robustness, no known cases. */
wait_timer= TIMER_NAME_MILLISEC;
}
else
{
/*
Will never be reached on any architecture, but must provide a default if
no other timers are available.
*/
wait_timer= TIMER_NAME_TICK;
}
/*
For STAGE and STATEMENT, a timer with a fixed frequency is better.
The prefered timer is nanosecond, or lower resolutions.
*/
if (nanosec_to_pico != 0)
{
/* Normal case. */
stage_timer= TIMER_NAME_NANOSEC;
statement_timer= TIMER_NAME_NANOSEC;
transaction_timer= TIMER_NAME_NANOSEC;
}
else if (microsec_to_pico != 0)
{
/* Windows. */
stage_timer= TIMER_NAME_MICROSEC;
statement_timer= TIMER_NAME_MICROSEC;
transaction_timer= TIMER_NAME_MICROSEC;
}
else if (millisec_to_pico != 0)
{
/* Robustness, no known cases. */
stage_timer= TIMER_NAME_MILLISEC;
statement_timer= TIMER_NAME_MILLISEC;
transaction_timer= TIMER_NAME_MILLISEC;
}
else if (tick_to_pico != 0)
{
/* Robustness, no known cases. */
stage_timer= TIMER_NAME_TICK;
statement_timer= TIMER_NAME_TICK;
transaction_timer= TIMER_NAME_TICK;
}
else
{
/* Robustness, no known cases. */
stage_timer= TIMER_NAME_CYCLE;
statement_timer= TIMER_NAME_CYCLE;
transaction_timer= TIMER_NAME_CYCLE;
}
/*
For IDLE, a timer with a fixed frequency is critical,
as the CPU clock may slow down a lot if the server is completely idle.
The prefered timer is microsecond, or lower resolutions.
*/
if (microsec_to_pico != 0)
{
/* Normal case. */
idle_timer= TIMER_NAME_MICROSEC;
}
else if (millisec_to_pico != 0)
{
/* Robustness, no known cases. */
wait_timer= TIMER_NAME_MILLISEC;
}
else if (tick_to_pico != 0)
{
/* Robustness, no known cases. */
idle_timer= TIMER_NAME_TICK;
}
else
{
/* Robustness, no known cases. */
idle_timer= TIMER_NAME_CYCLE;
}
} | O3 | cpp | init_timers():
pushq %rbp
movq %rsp, %rbp
rdtsc
shlq $0x20, %rdx
orq %rax, %rdx
movq %rdx, 0x35e29c(%rip) # 0x391dc0
callq 0x492a4
movq %rax, 0x35e298(%rip) # 0x391dc8
callq 0x492cd
movq %rax, 0x35e294(%rip) # 0x391dd0
callq 0x49309
movq %rax, 0x35e290(%rip) # 0x391dd8
callq 0x49349
movq %rax, 0x35e28c(%rip) # 0x391de0
leaq 0x3a98bd(%rip), %rdx # 0x3dd418
movq 0x10(%rdx), %rsi
movq 0x30(%rdx), %rdi
movq %rsi, %xmm0
movq 0x4fa20(%rip), %xmm1 # 0x83590
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x4fa24(%rip), %xmm2 # 0x835a0
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3 # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movsd 0x4fb04(%rip), %xmm0 # 0x83698
movapd %xmm0, %xmm5
divsd %xmm3, %xmm5
movsd 0x4fafc(%rip), %xmm3 # 0x836a0
addsd %xmm3, %xmm5
cvttsd2si %xmm5, %r8
movq %r8, %r9
movsd 0x4fab0(%rip), %xmm4 # 0x83668
subsd %xmm4, %xmm5
cvttsd2si %xmm5, %rcx
sarq $0x3f, %r9
andq %r9, %rcx
orq %r8, %rcx
testq %rsi, %rsi
cmoveq %rsi, %rcx
movq %rcx, 0x35e20f(%rip) # 0x391de8
movq %rdi, %xmm5
punpckldq %xmm1, %xmm5 # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1]
subpd %xmm2, %xmm5
movapd %xmm5, %xmm6
unpckhpd %xmm5, %xmm6 # xmm6 = xmm6[1],xmm5[1]
addsd %xmm5, %xmm6
movapd %xmm0, %xmm5
divsd %xmm6, %xmm5
addsd %xmm3, %xmm5
cvttsd2si %xmm5, %r8
movq %r8, %r9
sarq $0x3f, %r9
subsd %xmm4, %xmm5
cvttsd2si %xmm5, %rsi
andq %r9, %rsi
orq %r8, %rsi
testq %rdi, %rdi
cmoveq %rdi, %rsi
movq 0x50(%rdx), %r8
movq %r8, %xmm5
punpckldq %xmm1, %xmm5 # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1]
subpd %xmm2, %xmm5
movapd %xmm5, %xmm6
unpckhpd %xmm5, %xmm6 # xmm6 = xmm6[1],xmm5[1]
addsd %xmm5, %xmm6
movapd %xmm0, %xmm5
divsd %xmm6, %xmm5
addsd %xmm3, %xmm5
cvttsd2si %xmm5, %r9
movq %rsi, 0x35e19b(%rip) # 0x391df0
movq %r9, %r10
sarq $0x3f, %r10
subsd %xmm4, %xmm5
cvttsd2si %xmm5, %rdi
andq %r10, %rdi
orq %r9, %rdi
testq %r8, %r8
cmoveq %r8, %rdi
movq %rdi, 0x35e17f(%rip) # 0x391df8
movq 0x70(%rdx), %r9
movq %r9, %xmm5
punpckldq %xmm1, %xmm5 # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1]
subpd %xmm2, %xmm5
movapd %xmm5, %xmm6
unpckhpd %xmm5, %xmm6 # xmm6 = xmm6[1],xmm5[1]
addsd %xmm5, %xmm6
movapd %xmm0, %xmm5
divsd %xmm6, %xmm5
addsd %xmm3, %xmm5
cvttsd2si %xmm5, %r10
movq %r10, %r11
subsd %xmm4, %xmm5
cvttsd2si %xmm5, %r8
sarq $0x3f, %r11
andq %r11, %r8
orq %r10, %r8
testq %r9, %r9
cmoveq %r9, %r8
movq %r8, 0x35e135(%rip) # 0x391e00
movq 0x90(%rdx), %r9
movq %r9, %xmm5
punpckldq %xmm1, %xmm5 # xmm5 = xmm5[0],xmm1[0],xmm5[1],xmm1[1]
subpd %xmm2, %xmm5
movapd %xmm5, %xmm1
unpckhpd %xmm5, %xmm1 # xmm1 = xmm1[1],xmm5[1]
addsd %xmm5, %xmm1
divsd %xmm1, %xmm0
addsd %xmm3, %xmm0
cvttsd2si %xmm0, %r10
movq %r10, %r11
sarq $0x3f, %r11
subsd %xmm4, %xmm0
cvttsd2si %xmm0, %rdx
andq %r11, %rdx
orq %r10, %rdx
testq %r9, %r9
cmoveq %r9, %rdx
movq %rdx, 0x35e0ec(%rip) # 0x391e08
movq 0x35e09d(%rip), %r9 # 0x391dc0
movq %r9, 0x35e0f6(%rip) # 0x391e20
movq %rcx, 0x35e0f7(%rip) # 0x391e28
movq 0x35e090(%rip), %r9 # 0x391dc8
movq %r9, 0x35e0f1(%rip) # 0x391e30
movq %rsi, 0x35e0f2(%rip) # 0x391e38
movq 0x35e083(%rip), %r9 # 0x391dd0
movq %r9, 0x35e0ec(%rip) # 0x391e40
movq %rdi, 0x35e0ed(%rip) # 0x391e48
movq 0x35e076(%rip), %r9 # 0x391dd8
movq %r9, 0x35e0e7(%rip) # 0x391e50
movq %r8, 0x35e0e8(%rip) # 0x391e58
movq %rax, 0x35e0e9(%rip) # 0x391e60
movq %rdx, 0x35e0ea(%rip) # 0x391e68
testq %rcx, %rcx
je 0x33da1
movl $0x1, 0x2e631f(%rip) # 0x31a0ac
testq %rsi, %rsi
jne 0x33db0
testq %rdi, %rdi
jne 0x33dee
testq %r8, %r8
jne 0x33e16
jmp 0x33e43
testq %rsi, %rsi
je 0x33ddf
movl $0x2, 0x2e62fc(%rip) # 0x31a0ac
movl $0x2, %eax
movl %eax, 0x2e62f5(%rip) # 0x31a0b0
movl %eax, 0x2e62f3(%rip) # 0x31a0b4
movl %eax, 0x2e62f1(%rip) # 0x31a0b8
testq %rdi, %rdi
jne 0x33e05
testq %r8, %r8
jne 0x33e2d
testq %rdx, %rdx
jne 0x33e5f
jmp 0x33e82
testq %rdi, %rdi
je 0x33e11
movl $0x3, 0x2e62be(%rip) # 0x31a0ac
movl $0x3, %eax
movl %eax, 0x2e62b7(%rip) # 0x31a0b0
movl %eax, 0x2e62b5(%rip) # 0x31a0b4
movl %eax, 0x2e62b3(%rip) # 0x31a0b8
movl $0x3, 0x2e6299(%rip) # 0x31a0a8
jmp 0x33e8c
testq %r8, %r8
je 0x33e39
movl $0x4, %eax
movl %eax, 0x2e628f(%rip) # 0x31a0b0
movl %eax, 0x2e628d(%rip) # 0x31a0b4
movl %eax, 0x2e628b(%rip) # 0x31a0b8
movl $0x4, 0x2e6275(%rip) # 0x31a0ac
jmp 0x33e8c
movl $0x5, 0x2e6269(%rip) # 0x31a0ac
testq %rdx, %rdx
je 0x33e6b
movl $0x5, %eax
movl %eax, 0x2e625d(%rip) # 0x31a0b0
movl %eax, 0x2e625b(%rip) # 0x31a0b4
movl %eax, 0x2e6259(%rip) # 0x31a0b8
movl $0x5, 0x2e623f(%rip) # 0x31a0a8
jmp 0x33e8c
movl $0x1, %eax
movl %eax, 0x2e623a(%rip) # 0x31a0b0
movl %eax, 0x2e6238(%rip) # 0x31a0b4
movl %eax, 0x2e6236(%rip) # 0x31a0b8
movl $0x1, 0x2e621c(%rip) # 0x31a0a8
popq %rbp
retq
| _Z11init_timersv:
push rbp
mov rbp, rsp
rdtsc
shl rdx, 20h
or rdx, rax
mov cs:_ZL8cycle_v0, rdx; cycle_v0
call my_timer_nanoseconds
mov cs:_ZL10nanosec_v0, rax; nanosec_v0
call my_timer_microseconds
mov cs:_ZL11microsec_v0, rax; microsec_v0
call my_timer_milliseconds
mov cs:_ZL11millisec_v0, rax; millisec_v0
call my_timer_ticks
mov cs:_ZL7tick_v0, rax; tick_v0
lea rdx, sys_timer_info
mov rsi, [rdx+10h]
mov rdi, [rdx+30h]
movq xmm0, rsi
movq xmm1, qword ptr cs:xmmword_83590
punpckldq xmm0, xmm1
movapd xmm2, cs:xmmword_835A0
subpd xmm0, xmm2
movapd xmm3, xmm0
unpckhpd xmm3, xmm0
addsd xmm3, xmm0
movsd xmm0, cs:qword_83698
movapd xmm5, xmm0
divsd xmm5, xmm3
movsd xmm3, cs:qword_836A0
addsd xmm5, xmm3
cvttsd2si r8, xmm5
mov r9, r8
movsd xmm4, cs:qword_83668
subsd xmm5, xmm4
cvttsd2si rcx, xmm5
sar r9, 3Fh
and rcx, r9
or rcx, r8
test rsi, rsi
cmovz rcx, rsi
mov cs:_ZL13cycle_to_pico, rcx; cycle_to_pico
movq xmm5, rdi
punpckldq xmm5, xmm1
subpd xmm5, xmm2
movapd xmm6, xmm5
unpckhpd xmm6, xmm5
addsd xmm6, xmm5
movapd xmm5, xmm0
divsd xmm5, xmm6
addsd xmm5, xmm3
cvttsd2si r8, xmm5
mov r9, r8
sar r9, 3Fh
subsd xmm5, xmm4
cvttsd2si rsi, xmm5
and rsi, r9
or rsi, r8
test rdi, rdi
cmovz rsi, rdi
mov r8, [rdx+50h]
movq xmm5, r8
punpckldq xmm5, xmm1
subpd xmm5, xmm2
movapd xmm6, xmm5
unpckhpd xmm6, xmm5
addsd xmm6, xmm5
movapd xmm5, xmm0
divsd xmm5, xmm6
addsd xmm5, xmm3
cvttsd2si r9, xmm5
mov cs:_ZL15nanosec_to_pico, rsi; nanosec_to_pico
mov r10, r9
sar r10, 3Fh
subsd xmm5, xmm4
cvttsd2si rdi, xmm5
and rdi, r10
or rdi, r9
test r8, r8
cmovz rdi, r8
mov cs:_ZL16microsec_to_pico, rdi; microsec_to_pico
mov r9, [rdx+70h]
movq xmm5, r9
punpckldq xmm5, xmm1
subpd xmm5, xmm2
movapd xmm6, xmm5
unpckhpd xmm6, xmm5
addsd xmm6, xmm5
movapd xmm5, xmm0
divsd xmm5, xmm6
addsd xmm5, xmm3
cvttsd2si r10, xmm5
mov r11, r10
subsd xmm5, xmm4
cvttsd2si r8, xmm5
sar r11, 3Fh
and r8, r11
or r8, r10
test r9, r9
cmovz r8, r9
mov cs:_ZL16millisec_to_pico, r8; millisec_to_pico
mov r9, [rdx+90h]
movq xmm5, r9
punpckldq xmm5, xmm1
subpd xmm5, xmm2
movapd xmm1, xmm5
unpckhpd xmm1, xmm5
addsd xmm1, xmm5
divsd xmm0, xmm1
addsd xmm0, xmm3
cvttsd2si r10, xmm0
mov r11, r10
sar r11, 3Fh
subsd xmm0, xmm4
cvttsd2si rdx, xmm0
and rdx, r11
or rdx, r10
test r9, r9
cmovz rdx, r9
mov cs:_ZL12tick_to_pico, rdx; tick_to_pico
mov r9, cs:_ZL8cycle_v0; cycle_v0
mov cs:qword_391E20, r9
mov cs:qword_391E28, rcx
mov r9, cs:_ZL10nanosec_v0; nanosec_v0
mov cs:qword_391E30, r9
mov cs:qword_391E38, rsi
mov r9, cs:_ZL11microsec_v0; microsec_v0
mov cs:qword_391E40, r9
mov cs:qword_391E48, rdi
mov r9, cs:_ZL11millisec_v0; millisec_v0
mov cs:qword_391E50, r9
mov cs:qword_391E58, r8
mov cs:qword_391E60, rax
mov cs:qword_391E68, rdx
test rcx, rcx
jz short loc_33DA1
mov cs:wait_timer, 1
test rsi, rsi
jnz short loc_33DB0
test rdi, rdi
jnz short loc_33DEE
test r8, r8
jnz short loc_33E16
jmp loc_33E43
loc_33DA1:
test rsi, rsi
jz short loc_33DDF
mov cs:wait_timer, 2
loc_33DB0:
mov eax, 2
mov cs:stage_timer, eax
mov cs:statement_timer, eax
mov cs:transaction_timer, eax
test rdi, rdi
jnz short loc_33E05
test r8, r8
jnz short loc_33E2D
test rdx, rdx
jnz loc_33E5F
jmp loc_33E82
loc_33DDF:
test rdi, rdi
jz short loc_33E11
mov cs:wait_timer, 3
loc_33DEE:
mov eax, 3
mov cs:stage_timer, eax
mov cs:statement_timer, eax
mov cs:transaction_timer, eax
loc_33E05:
mov cs:idle_timer, 3
jmp short loc_33E8C
loc_33E11:
test r8, r8
jz short loc_33E39
loc_33E16:
mov eax, 4
mov cs:stage_timer, eax
mov cs:statement_timer, eax
mov cs:transaction_timer, eax
loc_33E2D:
mov cs:wait_timer, 4
jmp short loc_33E8C
loc_33E39:
mov cs:wait_timer, 5
loc_33E43:
test rdx, rdx
jz short loc_33E6B
mov eax, 5
mov cs:stage_timer, eax
mov cs:statement_timer, eax
mov cs:transaction_timer, eax
loc_33E5F:
mov cs:idle_timer, 5
jmp short loc_33E8C
loc_33E6B:
mov eax, 1
mov cs:stage_timer, eax
mov cs:statement_timer, eax
mov cs:transaction_timer, eax
loc_33E82:
mov cs:idle_timer, 1
loc_33E8C:
pop rbp
retn
| long long init_timers(void)
{
long long v0; // rax
unsigned long long v1; // rsi
unsigned long long v2; // rdi
__m128i v3; // xmm1
__m128d v4; // xmm0
long long v5; // rcx
__m128d v6; // xmm5
long long v7; // rsi
unsigned long long v8; // r8
__m128d v9; // xmm5
long long v10; // rdi
unsigned long long v11; // r9
__m128d v12; // xmm5
long long v13; // r8
unsigned long long v14; // r9
__m128d v15; // xmm5
long long v16; // rdx
long long result; // rax
cycle_v0 = __rdtsc();
nanosec_v0 = my_timer_nanoseconds();
microsec_v0 = my_timer_microseconds();
millisec_v0 = my_timer_milliseconds();
v0 = my_timer_ticks();
tick_v0 = v0;
v1 = sys_timer_info[2];
v2 = sys_timer_info[6];
v3 = _mm_loadl_epi64((const __m128i *)&xmmword_83590);
v4 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)v1, v3), (__m128d)xmmword_835A0);
v5 = (unsigned int)(int)(1.0e12 / (_mm_unpackhi_pd(v4, v4).m128d_f64[0] + v4.m128d_f64[0]) + 0.5);
if ( !v1 )
v5 = 0LL;
cycle_to_pico = v5;
v6 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)v2, v3), (__m128d)xmmword_835A0);
v7 = (unsigned int)(int)(1.0e12 / (_mm_unpackhi_pd(v6, v6).m128d_f64[0] + v6.m128d_f64[0]) + 0.5);
if ( !v2 )
v7 = 0LL;
v8 = sys_timer_info[10];
v9 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)v8, v3), (__m128d)xmmword_835A0);
nanosec_to_pico = v7;
v10 = (unsigned int)(int)(1.0e12 / (_mm_unpackhi_pd(v9, v9).m128d_f64[0] + v9.m128d_f64[0]) + 0.5);
if ( !v8 )
v10 = 0LL;
microsec_to_pico = v10;
v11 = sys_timer_info[14];
v12 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)v11, v3), (__m128d)xmmword_835A0);
v13 = (unsigned int)(int)(1.0e12 / (_mm_unpackhi_pd(v12, v12).m128d_f64[0] + v12.m128d_f64[0]) + 0.5);
if ( !v11 )
v13 = 0LL;
millisec_to_pico = v13;
v14 = sys_timer_info[18];
v15 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)v14, v3), (__m128d)xmmword_835A0);
v16 = (unsigned int)(int)(1.0e12 / (_mm_unpackhi_pd(v15, v15).m128d_f64[0] + v15.m128d_f64[0]) + 0.5);
if ( !v14 )
v16 = 0LL;
tick_to_pico = v16;
qword_391E20 = cycle_v0;
qword_391E28 = v5;
qword_391E30 = nanosec_v0;
qword_391E38 = v7;
qword_391E40 = microsec_v0;
qword_391E48 = v10;
qword_391E50 = millisec_v0;
qword_391E58 = v13;
qword_391E60 = v0;
qword_391E68 = v16;
if ( v5 )
{
wait_timer = 1;
if ( !v7 )
{
if ( !v10 )
{
if ( !v13 )
goto LABEL_30;
LABEL_27:
result = 4LL;
stage_timer = 4;
statement_timer = 4;
transaction_timer = 4;
goto LABEL_28;
}
LABEL_24:
result = 3LL;
stage_timer = 3;
statement_timer = 3;
transaction_timer = 3;
goto LABEL_25;
}
}
else
{
if ( !v7 )
{
if ( !v10 )
{
if ( !v13 )
{
wait_timer = 5;
LABEL_30:
if ( v16 )
{
result = 5LL;
stage_timer = 5;
statement_timer = 5;
transaction_timer = 5;
goto LABEL_32;
}
result = 1LL;
stage_timer = 1;
statement_timer = 1;
transaction_timer = 1;
goto LABEL_34;
}
goto LABEL_27;
}
wait_timer = 3;
goto LABEL_24;
}
wait_timer = 2;
}
result = 2LL;
stage_timer = 2;
statement_timer = 2;
transaction_timer = 2;
if ( v10 )
{
LABEL_25:
idle_timer = 3;
return result;
}
if ( v13 )
{
LABEL_28:
wait_timer = 4;
return result;
}
if ( v16 )
{
LABEL_32:
idle_timer = 5;
return result;
}
LABEL_34:
idle_timer = 1;
return result;
}
| init_timers:
PUSH RBP
MOV RBP,RSP
RDTSC
SHL RDX,0x20
OR RDX,RAX
MOV qword ptr [0x00491dc0],RDX
CALL 0x001492a4
MOV qword ptr [0x00491dc8],RAX
CALL 0x001492cd
MOV qword ptr [0x00491dd0],RAX
CALL 0x00149309
MOV qword ptr [0x00491dd8],RAX
CALL 0x00149349
MOV qword ptr [0x00491de0],RAX
LEA RDX,[0x4dd418]
MOV RSI,qword ptr [RDX + 0x10]
MOV RDI,qword ptr [RDX + 0x30]
MOVQ XMM0,RSI
MOVQ XMM1,qword ptr [0x00183590]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM2,xmmword ptr [0x001835a0]
SUBPD XMM0,XMM2
MOVAPD XMM3,XMM0
UNPCKHPD XMM3,XMM0
ADDSD XMM3,XMM0
MOVSD XMM0,qword ptr [0x00183698]
MOVAPD XMM5,XMM0
DIVSD XMM5,XMM3
MOVSD XMM3,qword ptr [0x001836a0]
ADDSD XMM5,XMM3
CVTTSD2SI R8,XMM5
MOV R9,R8
MOVSD XMM4,qword ptr [0x00183668]
SUBSD XMM5,XMM4
CVTTSD2SI RCX,XMM5
SAR R9,0x3f
AND RCX,R9
OR RCX,R8
TEST RSI,RSI
CMOVZ RCX,RSI
MOV qword ptr [0x00491de8],RCX
MOVQ XMM5,RDI
PUNPCKLDQ XMM5,XMM1
SUBPD XMM5,XMM2
MOVAPD XMM6,XMM5
UNPCKHPD XMM6,XMM5
ADDSD XMM6,XMM5
MOVAPD XMM5,XMM0
DIVSD XMM5,XMM6
ADDSD XMM5,XMM3
CVTTSD2SI R8,XMM5
MOV R9,R8
SAR R9,0x3f
SUBSD XMM5,XMM4
CVTTSD2SI RSI,XMM5
AND RSI,R9
OR RSI,R8
TEST RDI,RDI
CMOVZ RSI,RDI
MOV R8,qword ptr [RDX + 0x50]
MOVQ XMM5,R8
PUNPCKLDQ XMM5,XMM1
SUBPD XMM5,XMM2
MOVAPD XMM6,XMM5
UNPCKHPD XMM6,XMM5
ADDSD XMM6,XMM5
MOVAPD XMM5,XMM0
DIVSD XMM5,XMM6
ADDSD XMM5,XMM3
CVTTSD2SI R9,XMM5
MOV qword ptr [0x00491df0],RSI
MOV R10,R9
SAR R10,0x3f
SUBSD XMM5,XMM4
CVTTSD2SI RDI,XMM5
AND RDI,R10
OR RDI,R9
TEST R8,R8
CMOVZ RDI,R8
MOV qword ptr [0x00491df8],RDI
MOV R9,qword ptr [RDX + 0x70]
MOVQ XMM5,R9
PUNPCKLDQ XMM5,XMM1
SUBPD XMM5,XMM2
MOVAPD XMM6,XMM5
UNPCKHPD XMM6,XMM5
ADDSD XMM6,XMM5
MOVAPD XMM5,XMM0
DIVSD XMM5,XMM6
ADDSD XMM5,XMM3
CVTTSD2SI R10,XMM5
MOV R11,R10
SUBSD XMM5,XMM4
CVTTSD2SI R8,XMM5
SAR R11,0x3f
AND R8,R11
OR R8,R10
TEST R9,R9
CMOVZ R8,R9
MOV qword ptr [0x00491e00],R8
MOV R9,qword ptr [RDX + 0x90]
MOVQ XMM5,R9
PUNPCKLDQ XMM5,XMM1
SUBPD XMM5,XMM2
MOVAPD XMM1,XMM5
UNPCKHPD XMM1,XMM5
ADDSD XMM1,XMM5
DIVSD XMM0,XMM1
ADDSD XMM0,XMM3
CVTTSD2SI R10,XMM0
MOV R11,R10
SAR R11,0x3f
SUBSD XMM0,XMM4
CVTTSD2SI RDX,XMM0
AND RDX,R11
OR RDX,R10
TEST R9,R9
CMOVZ RDX,R9
MOV qword ptr [0x00491e08],RDX
MOV R9,qword ptr [0x00491dc0]
MOV qword ptr [0x00491e20],R9
MOV qword ptr [0x00491e28],RCX
MOV R9,qword ptr [0x00491dc8]
MOV qword ptr [0x00491e30],R9
MOV qword ptr [0x00491e38],RSI
MOV R9,qword ptr [0x00491dd0]
MOV qword ptr [0x00491e40],R9
MOV qword ptr [0x00491e48],RDI
MOV R9,qword ptr [0x00491dd8]
MOV qword ptr [0x00491e50],R9
MOV qword ptr [0x00491e58],R8
MOV qword ptr [0x00491e60],RAX
MOV qword ptr [0x00491e68],RDX
TEST RCX,RCX
JZ 0x00133da1
MOV dword ptr [0x0041a0ac],0x1
TEST RSI,RSI
JNZ 0x00133db0
TEST RDI,RDI
JNZ 0x00133dee
TEST R8,R8
JNZ 0x00133e16
JMP 0x00133e43
LAB_00133da1:
TEST RSI,RSI
JZ 0x00133ddf
MOV dword ptr [0x0041a0ac],0x2
LAB_00133db0:
MOV EAX,0x2
MOV dword ptr [0x0041a0b0],EAX
MOV dword ptr [0x0041a0b4],EAX
MOV dword ptr [0x0041a0b8],EAX
TEST RDI,RDI
JNZ 0x00133e05
TEST R8,R8
JNZ 0x00133e2d
TEST RDX,RDX
JNZ 0x00133e5f
JMP 0x00133e82
LAB_00133ddf:
TEST RDI,RDI
JZ 0x00133e11
MOV dword ptr [0x0041a0ac],0x3
LAB_00133dee:
MOV EAX,0x3
MOV dword ptr [0x0041a0b0],EAX
MOV dword ptr [0x0041a0b4],EAX
MOV dword ptr [0x0041a0b8],EAX
LAB_00133e05:
MOV dword ptr [0x0041a0a8],0x3
JMP 0x00133e8c
LAB_00133e11:
TEST R8,R8
JZ 0x00133e39
LAB_00133e16:
MOV EAX,0x4
MOV dword ptr [0x0041a0b0],EAX
MOV dword ptr [0x0041a0b4],EAX
MOV dword ptr [0x0041a0b8],EAX
LAB_00133e2d:
MOV dword ptr [0x0041a0ac],0x4
JMP 0x00133e8c
LAB_00133e39:
MOV dword ptr [0x0041a0ac],0x5
LAB_00133e43:
TEST RDX,RDX
JZ 0x00133e6b
MOV EAX,0x5
MOV dword ptr [0x0041a0b0],EAX
MOV dword ptr [0x0041a0b4],EAX
MOV dword ptr [0x0041a0b8],EAX
LAB_00133e5f:
MOV dword ptr [0x0041a0a8],0x5
JMP 0x00133e8c
LAB_00133e6b:
MOV EAX,0x1
MOV dword ptr [0x0041a0b0],EAX
MOV dword ptr [0x0041a0b4],EAX
MOV dword ptr [0x0041a0b8],EAX
LAB_00133e82:
MOV dword ptr [0x0041a0a8],0x1
LAB_00133e8c:
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* init_timers() */
void init_timers(void)
{
int8 in_RAX;
ulong uVar1;
int1 auVar2 [16];
double dVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
uVar1 = rdtsc();
cycle_v0 = uVar1 & 0xffffffff00000000 | CONCAT44((int)((ulong)in_RAX >> 0x20),(int)uVar1);
nanosec_v0 = my_timer_nanoseconds();
microsec_v0 = my_timer_microseconds();
millisec_v0 = my_timer_milliseconds();
tick_v0 = my_timer_ticks();
auVar2._8_4_ = SUB84(sys_timer_info._16_8_,4);
auVar2._0_8_ = sys_timer_info._16_8_;
auVar2._12_4_ = DAT_00183590._4_4_;
dVar3 = DAT_00183698 /
((auVar2._8_8_ - _UNK_001835a8) +
((double)CONCAT44((int4)DAT_00183590,(int)sys_timer_info._16_8_) - _DAT_001835a0)) +
DAT_001836a0;
uVar1 = (ulong)dVar3;
cycle_to_pico = (long)(dVar3 - DAT_00183668) & (long)uVar1 >> 0x3f | uVar1;
if (sys_timer_info._16_8_ == 0) {
cycle_to_pico = 0;
}
auVar4._8_4_ = SUB84(sys_timer_info._48_8_,4);
auVar4._0_8_ = sys_timer_info._48_8_;
auVar4._12_4_ = DAT_00183590._4_4_;
dVar3 = DAT_00183698 /
((auVar4._8_8_ - _UNK_001835a8) +
((double)CONCAT44((int4)DAT_00183590,(int)sys_timer_info._48_8_) - _DAT_001835a0)) +
DAT_001836a0;
uVar1 = (ulong)dVar3;
nanosec_to_pico = (long)(dVar3 - DAT_00183668) & (long)uVar1 >> 0x3f | uVar1;
if (sys_timer_info._48_8_ == 0) {
nanosec_to_pico = 0;
}
auVar5._8_4_ = SUB84(sys_timer_info._80_8_,4);
auVar5._0_8_ = sys_timer_info._80_8_;
auVar5._12_4_ = DAT_00183590._4_4_;
dVar3 = DAT_00183698 /
((auVar5._8_8_ - _UNK_001835a8) +
((double)CONCAT44((int4)DAT_00183590,(int)sys_timer_info._80_8_) - _DAT_001835a0)) +
DAT_001836a0;
uVar1 = (ulong)dVar3;
microsec_to_pico = (long)(dVar3 - DAT_00183668) & (long)uVar1 >> 0x3f | uVar1;
if (sys_timer_info._80_8_ == 0) {
microsec_to_pico = 0;
}
auVar6._8_4_ = SUB84(sys_timer_info._112_8_,4);
auVar6._0_8_ = sys_timer_info._112_8_;
auVar6._12_4_ = DAT_00183590._4_4_;
dVar3 = DAT_00183698 /
((auVar6._8_8_ - _UNK_001835a8) +
((double)CONCAT44((int4)DAT_00183590,(int)sys_timer_info._112_8_) - _DAT_001835a0))
+ DAT_001836a0;
uVar1 = (ulong)dVar3;
millisec_to_pico = (long)(dVar3 - DAT_00183668) & (long)uVar1 >> 0x3f | uVar1;
if (sys_timer_info._112_8_ == 0) {
millisec_to_pico = 0;
}
auVar7._8_4_ = SUB84(sys_timer_info._144_8_,4);
auVar7._0_8_ = sys_timer_info._144_8_;
auVar7._12_4_ = DAT_00183590._4_4_;
dVar3 = DAT_00183698 /
((auVar7._8_8_ - _UNK_001835a8) +
((double)CONCAT44((int4)DAT_00183590,(int)sys_timer_info._144_8_) - _DAT_001835a0))
+ DAT_001836a0;
uVar1 = (ulong)dVar3;
tick_to_pico = (long)(dVar3 - DAT_00183668) & (long)uVar1 >> 0x3f | uVar1;
if (sys_timer_info._144_8_ == 0) {
tick_to_pico = 0;
}
to_pico_data._16_8_ = cycle_v0;
to_pico_data._24_8_ = cycle_to_pico;
to_pico_data._32_8_ = nanosec_v0;
to_pico_data._40_8_ = nanosec_to_pico;
to_pico_data._48_8_ = microsec_v0;
to_pico_data._56_8_ = microsec_to_pico;
to_pico_data._64_8_ = millisec_v0;
to_pico_data._72_8_ = millisec_to_pico;
to_pico_data._80_8_ = tick_v0;
to_pico_data._88_8_ = tick_to_pico;
if (cycle_to_pico == 0) {
if (nanosec_to_pico != 0) {
wait_timer = 2;
goto LAB_00133db0;
}
if (microsec_to_pico != 0) {
wait_timer = 3;
goto LAB_00133dee;
}
if (millisec_to_pico == 0) {
wait_timer = 5;
goto LAB_00133e43;
}
LAB_00133e16:
stage_timer = 4;
statement_timer = 4;
transaction_timer = 4;
LAB_00133e2d:
wait_timer = 4;
}
else {
wait_timer = 1;
if (nanosec_to_pico == 0) {
if (microsec_to_pico == 0) {
if (millisec_to_pico == 0) {
LAB_00133e43:
if (tick_to_pico != 0) {
idle_timer = 5;
stage_timer = 5;
statement_timer = 5;
transaction_timer = 5;
to_pico_data._16_8_ = cycle_v0;
to_pico_data._32_8_ = nanosec_v0;
to_pico_data._48_8_ = microsec_v0;
to_pico_data._64_8_ = millisec_v0;
return;
}
idle_timer = 1;
stage_timer = 1;
statement_timer = 1;
transaction_timer = 1;
to_pico_data._16_8_ = cycle_v0;
to_pico_data._32_8_ = nanosec_v0;
to_pico_data._48_8_ = microsec_v0;
to_pico_data._64_8_ = millisec_v0;
return;
}
goto LAB_00133e16;
}
LAB_00133dee:
stage_timer = 3;
statement_timer = 3;
transaction_timer = 3;
}
else {
LAB_00133db0:
stage_timer = 2;
statement_timer = 2;
transaction_timer = 2;
if (microsec_to_pico == 0) {
if (millisec_to_pico == 0) {
if (tick_to_pico != 0) {
idle_timer = 5;
stage_timer = 2;
statement_timer = 2;
transaction_timer = 2;
to_pico_data._16_8_ = cycle_v0;
to_pico_data._32_8_ = nanosec_v0;
to_pico_data._48_8_ = microsec_v0;
to_pico_data._64_8_ = millisec_v0;
return;
}
idle_timer = 1;
stage_timer = 2;
statement_timer = 2;
transaction_timer = 2;
to_pico_data._16_8_ = cycle_v0;
to_pico_data._32_8_ = nanosec_v0;
to_pico_data._48_8_ = microsec_v0;
to_pico_data._64_8_ = millisec_v0;
return;
}
goto LAB_00133e2d;
}
}
idle_timer = 3;
}
return;
}
| |
24,566 | mysql_find_charset_nr | eloqsql/libmariadb/libmariadb/ma_charset.c | const MARIADB_CHARSET_INFO * mysql_find_charset_nr(unsigned int charsetnr)
{
const MARIADB_CHARSET_INFO * c = mariadb_compiled_charsets;
if (my_collation_id_is_uca1400(charsetnr))
charsetnr= my_uca1400_collation_id_uca400_compat(charsetnr);
do {
if (c->nr == charsetnr) {
return(c);
}
++c;
} while (c[0].nr != 0);
return(NULL);
} | O0 | c | mysql_find_charset_nr:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
leaq 0x152ce(%rip), %rax # 0x60fb0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x4bd40
cmpb $0x0, %al
je 0x4bcfd
movl -0xc(%rbp), %edi
callq 0x4bd70
movl %eax, -0xc(%rbp)
jmp 0x4bcff
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x4bd14
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4bd31
movq -0x18(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x4bcff
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_find_charset_nr:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
lea rax, mariadb_compiled_charsets
mov [rbp+var_18], rax
mov edi, [rbp+var_C]
call my_collation_id_is_uca1400
cmp al, 0
jz short loc_4BCFD
mov edi, [rbp+var_C]
call my_uca1400_collation_id_uca400_compat
mov [rbp+var_C], eax
loc_4BCFD:
jmp short $+2
loc_4BCFF:
mov rax, [rbp+var_18]
mov eax, [rax]
cmp eax, [rbp+var_C]
jnz short loc_4BD14
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_4BD31
loc_4BD14:
mov rax, [rbp+var_18]
add rax, 48h ; 'H'
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0
jnz short loc_4BCFF
mov [rbp+var_8], 0
loc_4BD31:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_find_charset_nr(unsigned int a1)
{
_DWORD *v2; // [rsp+8h] [rbp-18h]
unsigned int v3; // [rsp+14h] [rbp-Ch]
v3 = a1;
v2 = &mariadb_compiled_charsets;
if ( (unsigned __int8)my_collation_id_is_uca1400(a1) )
v3 = my_uca1400_collation_id_uca400_compat(a1);
do
{
if ( *v2 == v3 )
return v2;
v2 += 18;
}
while ( *v2 );
return 0LL;
}
| mysql_find_charset_nr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
LEA RAX,[0x160fb0]
MOV qword ptr [RBP + -0x18],RAX
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x0014bd40
CMP AL,0x0
JZ 0x0014bcfd
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x0014bd70
MOV dword ptr [RBP + -0xc],EAX
LAB_0014bcfd:
JMP 0x0014bcff
LAB_0014bcff:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x0014bd14
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014bd31
LAB_0014bd14:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x48
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x0
JNZ 0x0014bcff
MOV qword ptr [RBP + -0x8],0x0
LAB_0014bd31:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * mysql_find_charset_nr(int param_1)
{
char cVar1;
int *local_20;
int local_14;
local_20 = &mariadb_compiled_charsets;
cVar1 = my_collation_id_is_uca1400(param_1);
local_14 = param_1;
if (cVar1 != '\0') {
local_14 = my_uca1400_collation_id_uca400_compat(param_1);
}
do {
if (*local_20 == local_14) {
return local_20;
}
local_20 = local_20 + 0x12;
} while (*local_20 != 0);
return (int *)0x0;
}
| |
24,567 | flux::common::Source::positionToOffset(flux::common::SourcePosition const&) const | kvthweatt[P]FluxLang/src/common/source.cpp | size_t Source::positionToOffset(const SourcePosition& position) const {
if (position.line < 1 || position.line > line_offsets_.size()) {
return 0;
}
size_t line_offset = line_offsets_[position.line - 1];
size_t column = position.column;
// Get the line
std::string_view line;
getLine(position.line, line);
// Adjust column if needed
if (column > line.size()) {
column = line.size() + 1;
}
return line_offset + column - 1;
} | O0 | cpp | flux::common::Source::positionToOffset(flux::common::SourcePosition const&) const:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x1, (%rax)
jb 0x10a16
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
addq $0x30, %rdi
callq 0x10fe0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jbe 0x10a23
movq $0x0, -0x8(%rbp)
jmp 0x10aa9
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
subq $0x1, %rsi
callq 0x11000
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd180
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdx
callq 0x107f0
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xbbf0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jbe 0x10a99
leaq -0x38(%rbp), %rdi
callq 0xbbf0
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZNK4flux6common6Source16positionToOffsetERKNS0_14SourcePositionE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp qword ptr [rax], 1
jb short loc_10A16
mov rdi, [rbp+var_40]
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_48], rax
add rdi, 30h ; '0'
call _ZNKSt6vectorImSaImEE4sizeEv; std::vector<ulong>::size(void)
mov rcx, rax
mov rax, [rbp+var_48]
cmp rax, rcx
jbe short loc_10A23
loc_10A16:
mov [rbp+var_8], 0
jmp loc_10AA9
loc_10A23:
mov rdi, [rbp+var_40]
add rdi, 30h ; '0'
mov rax, [rbp+var_18]
mov rsi, [rax]
sub rsi, 1
call _ZNKSt6vectorImSaImEEixEm; std::vector<ulong>::operator[](ulong)
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_28], rax
lea rdi, [rbp+var_38]
call _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2Ev; std::string_view::basic_string_view(void)
mov rdi, [rbp+var_40]
mov rax, [rbp+var_18]
mov rsi, [rax]
lea rdx, [rbp+var_38]
call _ZNK4flux6common6Source7getLineEmRSt17basic_string_viewIcSt11char_traitsIcEE; flux::common::Source::getLine(ulong,std::string_view &)
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
lea rdi, [rbp+var_38]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4sizeEv; std::string_view::size(void)
mov rcx, rax
mov rax, [rbp+var_50]
cmp rax, rcx
jbe short loc_10A99
lea rdi, [rbp+var_38]
call _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4sizeEv; std::string_view::size(void)
add rax, 1
mov [rbp+var_28], rax
loc_10A99:
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
sub rax, 1
mov [rbp+var_8], rax
loc_10AA9:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long flux::common::Source::positionToOffset(
flux::common::Source *this,
const flux::common::SourcePosition *a2)
{
unsigned long long v3; // [rsp+0h] [rbp-50h]
unsigned long long v4; // [rsp+8h] [rbp-48h]
_QWORD v5[2]; // [rsp+18h] [rbp-38h] BYREF
long long v6; // [rsp+28h] [rbp-28h]
long long v7; // [rsp+30h] [rbp-20h]
unsigned long long *v8; // [rsp+38h] [rbp-18h]
flux::common::Source *v9; // [rsp+40h] [rbp-10h]
v9 = this;
v8 = (unsigned long long *)a2;
if ( !*(_QWORD *)a2 )
return 0LL;
v4 = *v8;
if ( v4 > std::vector<unsigned long>::size((char *)this + 48) )
return 0LL;
v7 = *(_QWORD *)std::vector<unsigned long>::operator[]((char *)this + 48, *v8 - 1);
v6 = v8[1];
std::string_view::basic_string_view(v5);
flux::common::Source::getLine((long long)this, *v8, v5);
v3 = v6;
if ( v3 > std::string_view::size((long long)v5) )
v6 = std::string_view::size((long long)v5) + 1;
return v6 + v7 - 1;
}
| positionToOffset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x1
JC 0x00110a16
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
ADD RDI,0x30
CALL 0x00110fe0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,RCX
JBE 0x00110a23
LAB_00110a16:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00110aa9
LAB_00110a23:
MOV RDI,qword ptr [RBP + -0x40]
ADD RDI,0x30
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
SUB RSI,0x1
CALL 0x00111000
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[RBP + -0x38]
CALL 0x0010d180
MOV RDI,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
LEA RDX,[RBP + -0x38]
CALL 0x001107f0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
LEA RDI,[RBP + -0x38]
CALL 0x0010bbf0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,RCX
JBE 0x00110a99
LEA RDI,[RBP + -0x38]
CALL 0x0010bbf0
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_00110a99:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
LAB_00110aa9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
/* flux::common::Source::positionToOffset(flux::common::SourcePosition const&) const */
long __thiscall flux::common::Source::positionToOffset(Source *this,SourcePosition *param_1)
{
ulong uVar1;
ulong uVar2;
long *plVar3;
long lVar4;
basic_string_view<char,std::char_traits<char>> local_40 [16];
ulong local_30;
long local_28;
SourcePosition *local_20;
Source *local_18;
if ((*(long *)param_1 != 0) &&
(uVar1 = *(ulong *)param_1, local_20 = param_1, local_18 = this,
uVar2 = std::vector<unsigned_long,std::allocator<unsigned_long>>::size
((vector<unsigned_long,std::allocator<unsigned_long>> *)(this + 0x30)),
uVar1 <= uVar2)) {
plVar3 = (long *)std::vector<unsigned_long,std::allocator<unsigned_long>>::operator[]
((vector<unsigned_long,std::allocator<unsigned_long>> *)(this + 0x30)
,*(ulong *)local_20 - 1);
local_28 = *plVar3;
local_30 = *(ulong *)(local_20 + 8);
std::basic_string_view<char,std::char_traits<char>>::basic_string_view(local_40);
getLine(this,*(ulong *)local_20,local_40);
uVar1 = local_30;
uVar2 = std::basic_string_view<char,std::char_traits<char>>::size(local_40);
if (uVar2 < uVar1) {
lVar4 = std::basic_string_view<char,std::char_traits<char>>::size(local_40);
local_30 = lVar4 + 1;
}
return local_28 + local_30 + -1;
}
return 0;
}
| |
24,568 | rlMatrixTranspose | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h | static Matrix rlMatrixTranspose(Matrix mat)
{
Matrix result = { 0 };
result.m0 = mat.m0;
result.m1 = mat.m4;
result.m2 = mat.m8;
result.m3 = mat.m12;
result.m4 = mat.m1;
result.m5 = mat.m5;
result.m6 = mat.m9;
result.m7 = mat.m13;
result.m8 = mat.m2;
result.m9 = mat.m6;
result.m10 = mat.m10;
result.m11 = mat.m14;
result.m12 = mat.m3;
result.m13 = mat.m7;
result.m14 = mat.m11;
result.m15 = mat.m15;
return result;
} | O0 | c | rlMatrixTranspose:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0xa2d0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movss (%rcx), %xmm0
movss %xmm0, (%rdi)
movss 0x4(%rcx), %xmm0
movss %xmm0, 0x10(%rdi)
movss 0x8(%rcx), %xmm0
movss %xmm0, 0x20(%rdi)
movss 0xc(%rcx), %xmm0
movss %xmm0, 0x30(%rdi)
movss 0x10(%rcx), %xmm0
movss %xmm0, 0x4(%rdi)
movss 0x14(%rcx), %xmm0
movss %xmm0, 0x14(%rdi)
movss 0x18(%rcx), %xmm0
movss %xmm0, 0x24(%rdi)
movss 0x1c(%rcx), %xmm0
movss %xmm0, 0x34(%rdi)
movss 0x20(%rcx), %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x24(%rcx), %xmm0
movss %xmm0, 0x18(%rdi)
movss 0x28(%rcx), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x2c(%rcx), %xmm0
movss %xmm0, 0x38(%rdi)
movss 0x30(%rcx), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0x34(%rcx), %xmm0
movss %xmm0, 0x1c(%rdi)
movss 0x38(%rcx), %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0x3c(%rcx), %xmm0
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| rlMatrixTranspose:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, rdi
mov [rbp+var_8], rax
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov rcx, [rbp+var_18]
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
movss xmm0, dword ptr [rcx]
movss dword ptr [rdi], xmm0
movss xmm0, dword ptr [rcx+4]
movss dword ptr [rdi+10h], xmm0
movss xmm0, dword ptr [rcx+8]
movss dword ptr [rdi+20h], xmm0
movss xmm0, dword ptr [rcx+0Ch]
movss dword ptr [rdi+30h], xmm0
movss xmm0, dword ptr [rcx+10h]
movss dword ptr [rdi+4], xmm0
movss xmm0, dword ptr [rcx+14h]
movss dword ptr [rdi+14h], xmm0
movss xmm0, dword ptr [rcx+18h]
movss dword ptr [rdi+24h], xmm0
movss xmm0, dword ptr [rcx+1Ch]
movss dword ptr [rdi+34h], xmm0
movss xmm0, dword ptr [rcx+20h]
movss dword ptr [rdi+8], xmm0
movss xmm0, dword ptr [rcx+24h]
movss dword ptr [rdi+18h], xmm0
movss xmm0, dword ptr [rcx+28h]
movss dword ptr [rdi+28h], xmm0
movss xmm0, dword ptr [rcx+2Ch]
movss dword ptr [rdi+38h], xmm0
movss xmm0, dword ptr [rcx+30h]
movss dword ptr [rdi+0Ch], xmm0
movss xmm0, dword ptr [rcx+34h]
movss dword ptr [rdi+1Ch], xmm0
movss xmm0, dword ptr [rcx+38h]
movss dword ptr [rdi+2Ch], xmm0
movss xmm0, dword ptr [rcx+3Ch]
movss dword ptr [rdi+3Ch], xmm0
add rsp, 20h
pop rbp
retn
| _DWORD * rlMatrixTranspose(
_DWORD *a1,
_DWORD a2,
_DWORD a3,
_DWORD a4,
_DWORD a5,
_DWORD a6,
long long a7,
long long a8,
long long a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
_DWORD *result; // rax
memset(a1, 0LL, 64LL);
result = a1;
*a1 = a7;
a1[4] = HIDWORD(a7);
a1[8] = a8;
a1[12] = HIDWORD(a8);
a1[1] = a9;
a1[5] = HIDWORD(a9);
a1[9] = a10;
a1[13] = HIDWORD(a10);
a1[2] = a11;
a1[6] = HIDWORD(a11);
a1[10] = a12;
a1[14] = HIDWORD(a12);
a1[3] = a13;
a1[7] = HIDWORD(a13);
a1[11] = a14;
a1[15] = HIDWORD(a14);
return result;
}
| rlMatrixTranspose:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0010a2d0
MOV RCX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RCX]
MOVSS dword ptr [RDI],XMM0
MOVSS XMM0,dword ptr [RCX + 0x4]
MOVSS dword ptr [RDI + 0x10],XMM0
MOVSS XMM0,dword ptr [RCX + 0x8]
MOVSS dword ptr [RDI + 0x20],XMM0
MOVSS XMM0,dword ptr [RCX + 0xc]
MOVSS dword ptr [RDI + 0x30],XMM0
MOVSS XMM0,dword ptr [RCX + 0x10]
MOVSS dword ptr [RDI + 0x4],XMM0
MOVSS XMM0,dword ptr [RCX + 0x14]
MOVSS dword ptr [RDI + 0x14],XMM0
MOVSS XMM0,dword ptr [RCX + 0x18]
MOVSS dword ptr [RDI + 0x24],XMM0
MOVSS XMM0,dword ptr [RCX + 0x1c]
MOVSS dword ptr [RDI + 0x34],XMM0
MOVSS XMM0,dword ptr [RCX + 0x20]
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM0,dword ptr [RCX + 0x24]
MOVSS dword ptr [RDI + 0x18],XMM0
MOVSS XMM0,dword ptr [RCX + 0x28]
MOVSS dword ptr [RDI + 0x28],XMM0
MOVSS XMM0,dword ptr [RCX + 0x2c]
MOVSS dword ptr [RDI + 0x38],XMM0
MOVSS XMM0,dword ptr [RCX + 0x30]
MOVSS dword ptr [RDI + 0xc],XMM0
MOVSS XMM0,dword ptr [RCX + 0x34]
MOVSS dword ptr [RDI + 0x1c],XMM0
MOVSS XMM0,dword ptr [RCX + 0x38]
MOVSS dword ptr [RDI + 0x2c],XMM0
MOVSS XMM0,dword ptr [RCX + 0x3c]
MOVSS dword ptr [RDI + 0x3c],XMM0
ADD RSP,0x20
POP RBP
RET
|
int4 * rlMatrixTranspose(int4 *param_1)
{
int4 uStack0000000000000008;
int4 uStack000000000000000c;
int4 uStack0000000000000010;
int4 uStack0000000000000014;
int4 uStack0000000000000018;
int4 uStack000000000000001c;
int4 uStack0000000000000020;
int4 uStack0000000000000024;
int4 uStack0000000000000028;
int4 uStack000000000000002c;
int4 uStack0000000000000030;
int4 uStack0000000000000034;
int4 uStack0000000000000038;
int4 uStack000000000000003c;
int4 uStack0000000000000040;
int4 uStack0000000000000044;
memset(param_1,0,0x40);
*param_1 = uStack0000000000000008;
param_1[4] = uStack000000000000000c;
param_1[8] = uStack0000000000000010;
param_1[0xc] = uStack0000000000000014;
param_1[1] = uStack0000000000000018;
param_1[5] = uStack000000000000001c;
param_1[9] = uStack0000000000000020;
param_1[0xd] = uStack0000000000000024;
param_1[2] = uStack0000000000000028;
param_1[6] = uStack000000000000002c;
param_1[10] = uStack0000000000000030;
param_1[0xe] = uStack0000000000000034;
param_1[3] = uStack0000000000000038;
param_1[7] = uStack000000000000003c;
param_1[0xb] = uStack0000000000000040;
param_1[0xf] = uStack0000000000000044;
return param_1;
}
| |
24,569 | js_iterator_proto_toArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_toArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, method, result;
int64_t idx;
BOOL done;
result = JS_UNDEFINED;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
result = JS_NewArray(ctx);
if (JS_IsException(result))
goto exception;
for (idx = 0; /*empty*/; idx++) {
item = JS_IteratorNext(ctx, this_val, method, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done)
break;
if (JS_DefinePropertyValueInt64(ctx, result, idx, item,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
if (JS_SetProperty(ctx, result, JS_ATOM_length, js_uint32(idx)) < 0)
goto exception;
JS_FreeValue(ctx, method);
return result;
exception:
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
} | O0 | c | js_iterator_proto_toArray:
subq $0xe8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movl %ecx, 0xbc(%rsp)
movq %r8, 0xb0(%rsp)
movl $0x0, 0x60(%rsp)
movq $0x3, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0xc54b0
cmpl $0x0, %eax
jge 0xc4fe7
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
jmp 0xc5287
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movl $0x6b, %ecx
callq 0x29d80
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc5063
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
jmp 0xc5287
movq 0xc0(%rsp), %rdi
callq 0x2a520
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc50b3
jmp 0xc5236
movq $0x0, 0x78(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
leaq 0x74(%rsp), %rax
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x6eeb0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc5143
jmp 0xc5236
cmpl $0x0, 0x74(%rsp)
je 0xc514c
jmp 0xc51a4
movq 0xc0(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0xa0(%rsp), %r8
movq 0xa8(%rsp), %r9
movl $0x4007, (%rsp) # imm = 0x4007
callq 0x373f0
cmpl $0x0, %eax
jge 0xc518f
jmp 0xc5236
jmp 0xc5191
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xc50bc
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rax
movl %eax, %edi
callq 0x33b60
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movl $0x32, %ecx
callq 0x31f00
cmpl $0x0, %eax
jge 0xc51f7
jmp 0xc5236
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movq 0x80(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0xc5287
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x23c90
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nop
| js_iterator_proto_toArray:
sub rsp, 0E8h
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov [rsp+0E8h+var_2C], ecx
mov [rsp+0E8h+var_38], r8
mov dword ptr [rsp+0E8h+var_88], 0
mov [rsp+0E8h+var_80], 3
mov rax, [rsp+0E8h+var_88]
mov [rsp+0E8h+var_68], rax
mov rax, [rsp+0E8h+var_80]
mov [rsp+0E8h+var_60], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call check_iterator
cmp eax, 0
jge short loc_C4FE7
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
jmp loc_C5287
loc_C4FE7:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
mov ecx, 6Bh ; 'k'
call JS_GetProperty
mov [rsp+0E8h+var_98], rax
mov [rsp+0E8h+var_90], rdx
mov rax, [rsp+0E8h+var_98]
mov [rsp+0E8h+var_58], rax
mov rax, [rsp+0E8h+var_90]
mov [rsp+0E8h+var_50], rax
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_C5063
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
jmp loc_C5287
loc_C5063:
mov rdi, [rsp+0E8h+var_28]
call JS_NewArray
mov [rsp+0E8h+var_A8], rax
mov [rsp+0E8h+var_A0], rdx
mov rax, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_68], rax
mov rax, [rsp+0E8h+var_A0]
mov [rsp+0E8h+var_60], rax
mov rdi, [rsp+0E8h+var_68]
mov rsi, [rsp+0E8h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_C50B3
jmp loc_C5236
loc_C50B3:
mov [rsp+0E8h+var_70], 0
loc_C50BC:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
mov rcx, [rsp+0E8h+var_58]
mov r8, [rsp+0E8h+var_50]
xor r9d, r9d
xor eax, eax
lea rax, [rsp+0E8h+var_74]
mov [rsp+0E8h+var_E8], 0
mov [rsp+0E8h+var_E0], rax
call JS_IteratorNext
mov [rsp+0E8h+var_B8], rax
mov [rsp+0E8h+var_B0], rdx
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_C5143
jmp loc_C5236
loc_C5143:
cmp [rsp+0E8h+var_74], 0
jz short loc_C514C
jmp short loc_C51A4
loc_C514C:
mov rdi, [rsp+0E8h+var_28]
mov rcx, [rsp+0E8h+var_70]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
mov r8, [rsp+0E8h+var_48]
mov r9, [rsp+0E8h+var_40]
mov dword ptr [rsp+0E8h+var_E8], 4007h
call JS_DefinePropertyValueInt64
cmp eax, 0
jge short loc_C518F
jmp loc_C5236
loc_C518F:
jmp short $+2
loc_C5191:
mov rax, [rsp+0E8h+var_70]
add rax, 1
mov [rsp+0E8h+var_70], rax
jmp loc_C50BC
loc_C51A4:
mov rax, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_D0], rax
mov rax, [rsp+0E8h+var_70]
mov edi, eax
call js_uint32
mov rdi, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_C8], rax
mov [rsp+0E8h+var_C0], rdx
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
mov r8, [rsp+0E8h+var_C8]
mov r9, [rsp+0E8h+var_C0]
mov ecx, 32h ; '2'
call JS_SetProperty
cmp eax, 0
jge short loc_C51F7
jmp short loc_C5236
loc_C51F7:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov rax, [rsp+0E8h+var_68]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_8], rax
jmp short loc_C5287
loc_C5236:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
loc_C5287:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
| long long js_iterator_proto_toArray(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rdx
double v16; // xmm4_8
double v17; // xmm5_8
int v18; // edx
int v20; // [rsp+18h] [rbp-D0h]
int v21; // [rsp+20h] [rbp-C8h]
long long v22; // [rsp+60h] [rbp-88h]
int v23; // [rsp+74h] [rbp-74h] BYREF
long long i; // [rsp+78h] [rbp-70h]
long long v25; // [rsp+80h] [rbp-68h]
long long v26; // [rsp+88h] [rbp-60h]
long long Property; // [rsp+90h] [rbp-58h]
long long v28; // [rsp+98h] [rbp-50h]
_DWORD *v29; // [rsp+A0h] [rbp-48h]
long long v30; // [rsp+A8h] [rbp-40h]
long long v31; // [rsp+B0h] [rbp-38h]
int v32; // [rsp+BCh] [rbp-2Ch]
long long v33; // [rsp+C0h] [rbp-28h]
long long v34; // [rsp+C8h] [rbp-20h]
long long v35; // [rsp+D0h] [rbp-18h]
long long v36; // [rsp+D8h] [rbp-10h]
long long v37; // [rsp+E0h] [rbp-8h]
v34 = a2;
v35 = a3;
v33 = a1;
v32 = a4;
v31 = a5;
LODWORD(v22) = 0;
v25 = v22;
v26 = 3LL;
if ( (int)check_iterator(a1, a2, a3) >= 0 )
{
Property = JS_GetProperty(v33, v34, v35, 107);
v28 = v13;
if ( JS_IsException_1(Property, v13) )
{
LODWORD(v36) = 0;
v37 = 6LL;
}
else
{
v25 = JS_NewArray(v33);
v26 = v14;
if ( !JS_IsException_1(v25, v14) )
{
for ( i = 0LL; ; ++i )
{
v29 = (_DWORD *)JS_IteratorNext(v33, v34, v35, Property, v28, 0, 0LL, &v23);
v30 = v15;
if ( JS_IsException_1((long long)v29, v15) )
break;
if ( v23 )
{
v20 = v33;
v21 = js_uint32(i);
if ( (int)JS_SetProperty(v20, v25, v26, 50, v21, v18) < 0 )
break;
JS_FreeValue(v33, Property, v28);
v36 = v25;
v37 = v26;
return v36;
}
if ( (int)JS_DefinePropertyValueInt64(v33, v25, v26, i, v29, v30, a6, a7, a8, a9, v16, v17, a12, a13, 16391) < 0 )
break;
}
}
JS_FreeValue(v33, v25, v26);
JS_FreeValue(v33, Property, v28);
LODWORD(v36) = 0;
v37 = 6LL;
}
}
else
{
LODWORD(v36) = 0;
v37 = 6LL;
}
return v36;
}
| js_iterator_proto_toArray:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],ECX
MOV qword ptr [RSP + 0xb0],R8
MOV dword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x3
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x001c54b0
CMP EAX,0x0
JGE 0x001c4fe7
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
JMP 0x001c5287
LAB_001c4fe7:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
MOV ECX,0x6b
CALL 0x00129d80
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c5063
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
JMP 0x001c5287
LAB_001c5063:
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x0012a520
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c50b3
JMP 0x001c5236
LAB_001c50b3:
MOV qword ptr [RSP + 0x78],0x0
LAB_001c50bc:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
MOV RCX,qword ptr [RSP + 0x90]
MOV R8,qword ptr [RSP + 0x98]
XOR R9D,R9D
XOR EAX,EAX
LEA RAX,[RSP + 0x74]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0016eeb0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c5143
JMP 0x001c5236
LAB_001c5143:
CMP dword ptr [RSP + 0x74],0x0
JZ 0x001c514c
JMP 0x001c51a4
LAB_001c514c:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV R8,qword ptr [RSP + 0xa0]
MOV R9,qword ptr [RSP + 0xa8]
MOV dword ptr [RSP],0x4007
CALL 0x001373f0
CMP EAX,0x0
JGE 0x001c518f
JMP 0x001c5236
LAB_001c518f:
JMP 0x001c5191
LAB_001c5191:
MOV RAX,qword ptr [RSP + 0x78]
ADD RAX,0x1
MOV qword ptr [RSP + 0x78],RAX
JMP 0x001c50bc
LAB_001c51a4:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV EDI,EAX
CALL 0x00133b60
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV R8,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
MOV ECX,0x32
CALL 0x00131f00
CMP EAX,0x0
JGE 0x001c51f7
JMP 0x001c5236
LAB_001c51f7:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x001c5287
LAB_001c5236:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
LAB_001c5287:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16]
js_iterator_proto_toArray
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5)
{
int8 uVar1;
int iVar2;
int1 auVar3 [16];
int4 uVar4;
uint uStack_84;
int local_74;
ulong local_70;
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int8 local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_68._0_8_ = (ulong)uStack_84 << 0x20;
local_68._8_8_ = 3;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar2 = check_iterator(param_1,param_2,param_3);
if (iVar2 < 0) {
local_10 = 0;
local_8 = 6;
}
else {
local_58 = JS_GetProperty(local_28,local_20,local_18,0x6b);
iVar2 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar2 == 0) {
local_68 = JS_NewArray(local_28);
iVar2 = JS_IsException(local_68._0_8_,local_68._8_8_);
if (iVar2 == 0) {
local_70 = 0;
while( true ) {
uVar4 = 0;
auVar3 = JS_IteratorNext(local_28,local_20,local_18,local_58._0_8_,local_58._8_8_,0,0,
&local_74);
local_48 = auVar3;
iVar2 = JS_IsException(auVar3._0_8_,auVar3._8_8_);
uVar1 = local_28;
if (iVar2 != 0) break;
if (local_74 != 0) {
auVar3 = js_uint32(local_70 & 0xffffffff);
iVar2 = JS_SetProperty(uVar1,local_68._0_8_,local_68._8_8_,0x32,auVar3._0_8_,
auVar3._8_8_);
if (-1 < iVar2) {
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = local_68._0_4_;
uStack_c = local_68._4_4_;
local_8 = local_68._8_8_;
goto LAB_001c5287;
}
break;
}
iVar2 = JS_DefinePropertyValueInt64
(local_28,local_68._0_8_,local_68._8_8_,local_70,local_48._0_8_,
local_48._8_8_,CONCAT44(uVar4,0x4007));
if (iVar2 < 0) break;
local_70 = local_70 + 1;
}
}
JS_FreeValue(local_28,local_68._0_8_,local_68._8_8_);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = 0;
local_8 = 6;
}
else {
local_10 = 0;
local_8 = 6;
}
}
LAB_001c5287:
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
| |
24,570 | js_iterator_proto_toArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_toArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, method, result;
int64_t idx;
BOOL done;
result = JS_UNDEFINED;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
result = JS_NewArray(ctx);
if (JS_IsException(result))
goto exception;
for (idx = 0; /*empty*/; idx++) {
item = JS_IteratorNext(ctx, this_val, method, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done)
break;
if (JS_DefinePropertyValueInt64(ctx, result, idx, item,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
if (JS_SetProperty(ctx, result, JS_ATOM_length, js_uint32(idx)) < 0)
goto exception;
JS_FreeValue(ctx, method);
return result;
exception:
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
} | O1 | c | js_iterator_proto_toArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbp
movq %rdi, %r14
cmpl $-0x1, %ebp
jne 0x72e83
movq %rsi, %r13
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %rbp, %rdx
movl $0x6b, %ecx
movq %rsi, %r8
movq %rbp, %r9
callq 0x22fa3
movq %rdx, %r15
movl $0x6, %ebx
cmpl $0x6, %r15d
jne 0x72eb6
xorl %r15d, %r15d
jmp 0x72e9c
leaq 0x2c19b(%rip), %rsi # 0x9f025
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %ebx
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x40(%rsp)
movq 0x38(%r14), %rsi
incl (%rsi)
movq %r14, %rdi
movl $0x2, %edx
callq 0xf516
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
cmpl $0x6, %edx
je 0x7304b
leaq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x40(%rsp), %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x41afc
cmpl $0x6, %edx
je 0x7304b
xorl %r12d, %r12d
cmpl $0x0, 0x2c(%rsp)
jne 0x72fb6
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %r12, %r8
shrq $0x1f, %r8
movl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
movq %xmm0, %rcx
cmoveq %rax, %rcx
movl $0x7, %eax
cmovneq %rax, %r8
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl $0x4007, %r9d # imm = 0x4007
callq 0x26b2d
testl %eax, %eax
js 0x7304b
incq %r12
leaq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x40(%rsp), %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x41afc
cmpl $0x6, %edx
jne 0x72f18
jmp 0x7304b
xorl %eax, %eax
testl %r12d, %r12d
movl %r12d, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movq %xmm0, %r8
cmovnsq %rcx, %r8
movl $0x7, %r9d
cmovnsq %rax, %r9
movq 0x30(%rsp), %rsi
movq %rsi, 0x48(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, 0x50(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %r14, %rdi
movl $0x32, %ecx
callq 0x24388
testl %eax, %eax
js 0x7304b
movq 0x18(%r14), %rdi
movq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0x1d8c6
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq 0x30(%rsp), %rdx
movq %rdx, %rax
andq %rcx, %rax
movl %edx, %r15d
movq 0x38(%rsp), %rbx
jmp 0x72e9e
movq 0x18(%r14), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x1d8c6
movq 0x18(%r14), %rdi
movq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0x1d8c6
jmp 0x72e7e
| js_iterator_proto_toArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbp, rdx
mov r14, rdi
cmp ebp, 0FFFFFFFFh
jnz short loc_72E83
mov r13, rsi
mov dword ptr [rsp+88h+var_88+8], 0
mov qword ptr [rsp+88h+var_88], 0
mov rdi, r14
mov rdx, rbp
mov ecx, 6Bh ; 'k'
mov r8, rsi
mov r9, rbp
call JS_GetPropertyInternal2
mov r15, rdx
mov ebx, 6
cmp r15d, 6
jnz short loc_72EB6
loc_72E7E:
xor r15d, r15d
jmp short loc_72E9C
loc_72E83:
lea rsi, aOperandPrototy+20h; "not an object"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov ebx, 6
loc_72E9C:
xor eax, eax
loc_72E9E:
or r15, rax
mov rax, r15
mov rdx, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_72EB6:
mov [rsp+88h+var_48], rax
mov rsi, [r14+38h]
inc dword ptr [rsi]
mov rdi, r14
mov edx, 2
call JS_NewObjectFromShape
mov [rsp+88h+var_58], rax
mov [rsp+88h+var_50], rdx
cmp edx, 6
jz loc_7304B
lea rax, [rsp+88h+var_5C]
mov qword ptr [rsp+88h+var_88+8], rax
mov qword ptr [rsp+88h+var_88], 0
mov rdi, r14
mov rsi, r13
mov rdx, rbp
mov rcx, [rsp+88h+var_48]
mov r8, r15
xor r9d, r9d
call JS_IteratorNext
cmp edx, 6
jz loc_7304B
xor r12d, r12d
loc_72F18:
cmp [rsp+88h+var_5C], 0
jnz loc_72FB6
mov qword ptr [rsp+88h+var_40], rax
mov qword ptr [rsp+88h+var_40+8], rdx
mov r8, r12
shr r8, 1Fh
mov eax, r12d
xorps xmm0, xmm0
cvtsi2sd xmm0, r12
movq rcx, xmm0
cmovz rcx, rax
mov eax, 7
cmovnz r8, rax
movups xmm0, [rsp+88h+var_40]
movups [rsp+88h+var_88], xmm0
mov rdi, r14
mov rsi, [rsp+88h+var_58]
mov rdx, [rsp+88h+var_50]
mov r9d, 4007h
call JS_DefinePropertyValueValue
test eax, eax
js loc_7304B
inc r12
lea rax, [rsp+88h+var_5C]
mov qword ptr [rsp+88h+var_88+8], rax
mov qword ptr [rsp+88h+var_88], 0
mov rdi, r14
mov rsi, r13
mov rdx, rbp
mov rcx, [rsp+88h+var_48]
mov r8, r15
xor r9d, r9d
call JS_IteratorNext
cmp edx, 6
jnz loc_72F18
jmp loc_7304B
loc_72FB6:
xor eax, eax
test r12d, r12d
mov ecx, r12d
xorps xmm0, xmm0
cvtsi2sd xmm0, rcx
movq r8, xmm0
cmovns r8, rcx
mov r9d, 7
cmovns r9, rax
mov rsi, [rsp+88h+var_58]
mov qword ptr [rsp+88h+var_40], rsi
mov rdx, [rsp+88h+var_50]
mov qword ptr [rsp+88h+var_40+8], rdx
movups xmm0, [rsp+88h+var_40]
movups [rsp+88h+var_88], xmm0
mov [rsp+88h+var_70], 0
mov [rsp+88h+var_78], 4000h
mov rdi, r14
mov ecx, 32h ; '2'
call JS_SetPropertyInternal2
test eax, eax
js short loc_7304B
mov rdi, [r14+18h]
mov rsi, [rsp+88h+var_48]
mov rdx, r15
call JS_FreeValueRT
mov rcx, 0FFFFFFFF00000000h
mov rdx, [rsp+88h+var_58]
mov rax, rdx
and rax, rcx
mov r15d, edx
mov rbx, [rsp+88h+var_50]
jmp loc_72E9E
loc_7304B:
mov rdi, [r14+18h]
mov rsi, [rsp+88h+var_58]
mov rdx, [rsp+88h+var_50]
call JS_FreeValueRT
mov rdi, [r14+18h]
mov rsi, [rsp+88h+var_48]
mov rdx, r15
call JS_FreeValueRT
jmp loc_72E7E
| unsigned long long js_iterator_proto_toArray(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
int v14; // r13d
_DWORD *PropertyInternal2; // rax
long long v16; // rdx
long long v17; // r15
long long v18; // r15
unsigned long long v19; // rax
_DWORD *v21; // rsi
__m128 v22; // rax
__m128 v23; // rax
double v24; // xmm4_8
double v25; // xmm5_8
unsigned long long v26; // r12
long long v27; // r8
double v28; // rcx
double v29; // r8
long long v30; // r9
char v31; // [rsp+0h] [rbp-88h]
int v32; // [rsp+2Ch] [rbp-5Ch] BYREF
__m128 v33; // [rsp+30h] [rbp-58h]
_DWORD *v34; // [rsp+40h] [rbp-48h]
__m128 v35; // [rsp+48h] [rbp-40h]
if ( (_DWORD)a3 == -1 )
{
v14 = a2;
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(a1, a2, a3, 0x6Bu, a2, a3, 0LL, 0);
v17 = v16;
if ( (_DWORD)v16 != 6 )
{
v34 = PropertyInternal2;
v21 = *(_DWORD **)(a1 + 56);
++*v21;
v22.m128_u64[0] = JS_NewObjectFromShape(a1, v21, 2u);
v33 = v22;
if ( v22.m128_i32[2] != 6 )
{
v23.m128_u64[0] = JS_IteratorNext(a1, v14, -1, (int)v34, v17, 0, 0LL, &v32);
if ( v23.m128_i32[2] != 6 )
{
v26 = 0LL;
while ( !v32 )
{
v35 = v23;
v27 = v26 >> 31;
v28 = (double)(int)v26;
if ( v26 >> 31 )
v27 = 7LL;
else
*(_QWORD *)&v28 = (unsigned int)v26;
if ( (int)JS_DefinePropertyValueValue(
a1,
v33.m128_u64[0],
v33.m128_i64[1],
*(_DWORD **)&v28,
v27,
16391,
*(double *)v35.m128_u64,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v35.m128_u64[0],
v35.m128_i64[1]) >= 0 )
{
++v26;
v23.m128_u64[0] = JS_IteratorNext(a1, v14, -1, (int)v34, v17, 0, 0LL, &v32);
if ( v23.m128_i32[2] != 6 )
continue;
}
goto LABEL_23;
}
v29 = (double)(int)v26;
if ( (v26 & 0x80000000) == 0LL )
*(_QWORD *)&v29 = (unsigned int)v26;
v30 = 7LL;
if ( (v26 & 0x80000000) == 0LL )
v30 = 0LL;
v35 = v33;
if ( (int)JS_SetPropertyInternal2(
a1,
v33.m128_i64[0],
v33.m128_i64[1],
0x32u,
*(_DWORD **)&v29,
v30,
v33,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v33.m128_i64[0],
v33.m128_i32[2],
0x4000u,
0LL) >= 0 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v34, v17);
v19 = v33.m128_u64[0] & 0xFFFFFFFF00000000LL;
v18 = v33.m128_u32[0];
return v19 | v18;
}
}
}
LABEL_23:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v33.m128_u64[0], v33.m128_i64[1]);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v34, v17);
}
v18 = 0LL;
}
else
{
v18 = 0LL;
JS_ThrowTypeError(a1, (long long)"not an object", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v31);
}
v19 = 0LL;
return v19 | v18;
}
| js_iterator_proto_toArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBP,RDX
MOV R14,RDI
CMP EBP,-0x1
JNZ 0x00172e83
MOV R13,RSI
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV RDI,R14
MOV RDX,RBP
MOV ECX,0x6b
MOV R8,RSI
MOV R9,RBP
CALL 0x00122fa3
MOV R15,RDX
MOV EBX,0x6
CMP R15D,0x6
JNZ 0x00172eb6
LAB_00172e7e:
XOR R15D,R15D
JMP 0x00172e9c
LAB_00172e83:
LEA RSI,[0x19f025]
XOR R15D,R15D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
MOV EBX,0x6
LAB_00172e9c:
XOR EAX,EAX
LAB_00172e9e:
OR R15,RAX
MOV RAX,R15
MOV RDX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00172eb6:
MOV qword ptr [RSP + 0x40],RAX
MOV RSI,qword ptr [R14 + 0x38]
INC dword ptr [RSI]
MOV RDI,R14
MOV EDX,0x2
CALL 0x0010f516
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
CMP EDX,0x6
JZ 0x0017304b
LEA RAX,[RSP + 0x2c]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],0x0
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBP
MOV RCX,qword ptr [RSP + 0x40]
MOV R8,R15
XOR R9D,R9D
CALL 0x00141afc
CMP EDX,0x6
JZ 0x0017304b
XOR R12D,R12D
LAB_00172f18:
CMP dword ptr [RSP + 0x2c],0x0
JNZ 0x00172fb6
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV R8,R12
SHR R8,0x1f
MOV EAX,R12D
XORPS XMM0,XMM0
CVTSI2SD XMM0,R12
MOVQ RCX,XMM0
CMOVZ RCX,RAX
MOV EAX,0x7
CMOVNZ R8,RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
MOV R9D,0x4007
CALL 0x00126b2d
TEST EAX,EAX
JS 0x0017304b
INC R12
LEA RAX,[RSP + 0x2c]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],0x0
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBP
MOV RCX,qword ptr [RSP + 0x40]
MOV R8,R15
XOR R9D,R9D
CALL 0x00141afc
CMP EDX,0x6
JNZ 0x00172f18
JMP 0x0017304b
LAB_00172fb6:
XOR EAX,EAX
TEST R12D,R12D
MOV ECX,R12D
XORPS XMM0,XMM0
CVTSI2SD XMM0,RCX
MOVQ R8,XMM0
CMOVNS R8,RCX
MOV R9D,0x7
CMOVNS R9,RAX
MOV RSI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x48],RSI
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x50],RDX
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x10],0x4000
MOV RDI,R14
MOV ECX,0x32
CALL 0x00124388
TEST EAX,EAX
JS 0x0017304b
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,R15
CALL 0x0011d8c6
MOV RCX,-0x100000000
MOV RDX,qword ptr [RSP + 0x30]
MOV RAX,RDX
AND RAX,RCX
MOV R15D,EDX
MOV RBX,qword ptr [RSP + 0x38]
JMP 0x00172e9e
LAB_0017304b:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x0011d8c6
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,R15
CALL 0x0011d8c6
JMP 0x00172e7e
|
int1 [16] js_iterator_proto_toArray(long param_1,int8 param_2,int8 param_3)
{
int *piVar1;
int iVar2;
int8 uVar4;
double dVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
int1 auVar9 [16];
ulong in_stack_ffffffffffffff80;
int local_5c;
int1 local_58 [16];
int8 local_48;
int1 local_40 [16];
int8 uVar3;
if ((int)param_3 == -1) {
auVar9 = JS_GetPropertyInternal2
(param_1,param_2,param_3,0x6b,param_2,param_3,0,
in_stack_ffffffffffffff80 & 0xffffffff00000000);
uVar3 = auVar9._8_8_;
local_48 = auVar9._0_8_;
if (auVar9._8_4_ != 6) {
piVar1 = *(int **)(param_1 + 0x38);
*piVar1 = *piVar1 + 1;
local_58 = JS_NewObjectFromShape(param_1,piVar1,2);
if (local_58._8_4_ != 6) {
auVar9 = JS_IteratorNext(param_1,param_2,param_3,local_48,uVar3,0,0,&local_5c);
if (auVar9._8_4_ != 6) {
uVar6 = 0;
do {
if (local_5c != 0) {
bVar8 = -1 < (int)uVar6;
dVar5 = (double)(uVar6 & 0xffffffff);
if (bVar8) {
dVar5 = (double)(uVar6 & 0xffffffff);
}
uVar4 = 7;
if (bVar8) {
uVar4 = 0;
}
local_40 = local_58;
iVar2 = JS_SetPropertyInternal2
(param_1,local_58._0_8_,local_58._8_8_,0x32,dVar5,uVar4,local_58,
0x4000,0);
if (-1 < iVar2) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_48,uVar3);
uVar6 = local_58._0_8_ & 0xffffffff00000000;
uVar7 = local_58._0_8_ & 0xffffffff;
goto LAB_00172e9e;
}
break;
}
dVar5 = (double)(long)uVar6;
if (uVar6 >> 0x1f == 0) {
uVar4 = 0;
dVar5 = (double)(uVar6 & 0xffffffff);
}
else {
uVar4 = 7;
}
local_40 = auVar9;
iVar2 = JS_DefinePropertyValueValue
(param_1,local_58._0_8_,local_58._8_8_,dVar5,uVar4,0x4007,auVar9);
if (iVar2 < 0) break;
uVar6 = uVar6 + 1;
auVar9 = JS_IteratorNext(param_1,param_2,param_3,local_48,uVar3,0,0,&local_5c);
} while (auVar9._8_4_ != 6);
}
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_58._0_8_,local_58._8_8_);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_48,uVar3);
}
}
else {
JS_ThrowTypeError(param_1,"not an object");
}
uVar7 = 0;
local_58._8_8_ = 6;
uVar6 = 0;
LAB_00172e9e:
auVar9._8_8_ = local_58._8_8_;
auVar9._0_8_ = uVar7 | uVar6;
return auVar9;
}
| |
24,571 | js_iterator_proto_toArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_toArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, method, result;
int64_t idx;
BOOL done;
result = JS_UNDEFINED;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
result = JS_NewArray(ctx);
if (JS_IsException(result))
goto exception;
for (idx = 0; /*empty*/; idx++) {
item = JS_IteratorNext(ctx, this_val, method, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done)
break;
if (JS_DefinePropertyValueInt64(ctx, result, idx, item,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
if (JS_SetProperty(ctx, result, JS_ATOM_length, js_uint32(idx)) < 0)
goto exception;
JS_FreeValue(ctx, method);
return result;
exception:
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
} | O2 | c | js_iterator_proto_toArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x60e07
pushq $0x6
popq %r13
testl %eax, %eax
js 0x60bf2
pushq $0x6b
popq %rcx
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1b043
movq %rax, 0x8(%rsp)
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x60bf8
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x60c34
movq %r14, %rdi
callq 0x1b2bb
movq %rax, (%rsp)
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x60c49
movq %r14, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x1801e
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1801e
xorl %eax, %eax
xorl %ecx, %ecx
pushq $0x6
popq %r13
orq %rcx, %rax
movq %r13, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
movq %r15, %r8
xorl %r9d, %r9d
leaq 0x14(%rsp), %rax
pushq %rax
pushq $0x0
callq 0x398cc
addq $0x10, %rsp
movq %rdx, %r9
cmpl $0x6, %r9d
je 0x60c0d
cmpl $0x0, 0x14(%rsp)
jne 0x60caf
subq $0x8, %rsp
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
pushq $0x4007 # imm = 0x4007
callq 0x209b7
popq %rcx
popq %rdx
testl %eax, %eax
js 0x60c0d
incq %r12
jmp 0x60c4c
xorl %eax, %eax
movl %r12d, %ecx
cvtsi2sd %rcx, %xmm0
testl %r12d, %r12d
movq %xmm0, %r8
cmovnsq %rcx, %r8
pushq $0x7
popq %r9
cmovnsq %rax, %r9
pushq $0x32
popq %rcx
movq %r14, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x1e446
testl %eax, %eax
js 0x60c0d
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1801e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq (%rsp), %rdx
movq %rdx, %rcx
andq %rax, %rcx
movl %edx, %eax
jmp 0x60c34
| js_iterator_proto_toArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov rbp, rsi
mov r14, rdi
mov rsi, rdx
call check_iterator
push 6
pop r13
test eax, eax
js short loc_60BF2
push 6Bh ; 'k'
pop rcx
mov rdi, r14
mov rsi, rbp
mov rdx, rbx
call JS_GetProperty
mov [rsp+48h+var_40], rax
mov r15, rdx
cmp r15d, 6
jnz short loc_60BF8
loc_60BF2:
xor eax, eax
xor ecx, ecx
jmp short loc_60C34
loc_60BF8:
mov rdi, r14
call JS_NewArray
mov [rsp+48h+var_48], rax
mov r13, rdx
cmp r13d, 6
jnz short loc_60C49
loc_60C0D:
mov rdi, r14
mov rsi, [rsp+48h+var_48]
mov rdx, r13
call JS_FreeValue
mov rdi, r14
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call JS_FreeValue
xor eax, eax
xor ecx, ecx
push 6
pop r13
loc_60C34:
or rax, rcx
mov rdx, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60C49:
xor r12d, r12d
loc_60C4C:
mov rdi, r14
mov rsi, rbp
mov rdx, rbx
mov rcx, [rsp+48h+var_40]
mov r8, r15
xor r9d, r9d
lea rax, [rsp+48h+var_34]
push rax
push 0
call JS_IteratorNext
add rsp, 10h
mov r9, rdx
cmp r9d, 6
jz short loc_60C0D
cmp [rsp+48h+var_34], 0
jnz short loc_60CAF
sub rsp, 8
mov rdi, r14
mov rsi, [rsp+50h+var_48]
mov rdx, r13
mov rcx, r12
mov r8, rax
push 4007h
call JS_DefinePropertyValueInt64
pop rcx
pop rdx
test eax, eax
js loc_60C0D
inc r12
jmp short loc_60C4C
loc_60CAF:
xor eax, eax
mov ecx, r12d
cvtsi2sd xmm0, rcx
test r12d, r12d
movq r8, xmm0
cmovns r8, rcx
push 7
pop r9
cmovns r9, rax
push 32h ; '2'
pop rcx
mov rdi, r14
mov rsi, [rsp+48h+var_48]
mov rdx, r13
call JS_SetProperty
test eax, eax
js loc_60C0D
mov rdi, r14
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call JS_FreeValue
mov rax, 0FFFFFFFF00000000h
mov rdx, [rsp+48h+var_48]
mov rcx, rdx
and rcx, rax
mov eax, edx
jmp loc_60C34
| unsigned long long js_iterator_proto_toArray(
long long a1,
int a2,
long long a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
int v11; // ebx
long long v12; // rdx
long long v13; // r15
long long v14; // rax
unsigned long long v15; // rcx
long long v16; // rdx
long long v17; // r13
long long i; // r12
_DWORD *v20; // rax
long long v21; // rdx
double v22; // xmm4_8
double v23; // xmm5_8
double v24; // r8
int v25; // r9d
long long v26; // [rsp+0h] [rbp-48h]
long long Property; // [rsp+8h] [rbp-40h]
_DWORD v28[13]; // [rsp+14h] [rbp-34h] BYREF
v11 = a3;
if ( (int)check_iterator(a1, a3) < 0 || (Property = JS_GetProperty(a1, a2, v11, 107), v13 = v12, (_DWORD)v12 == 6) )
{
v14 = 0LL;
v15 = 0LL;
}
else
{
v26 = JS_NewArray(a1);
v17 = v16;
if ( (_DWORD)v16 != 6 )
{
for ( i = 0LL; ; ++i )
{
v20 = (_DWORD *)JS_IteratorNext(a1, a2, v11, Property, v13, 0, 0LL, v28);
if ( (_DWORD)v21 == 6 )
break;
if ( v28[0] )
{
v24 = (double)(int)i;
if ( (int)i >= 0 )
LODWORD(v24) = i;
v25 = 7;
if ( (int)i >= 0 )
v25 = 0;
if ( (int)JS_SetProperty(a1, v26, v17, 50, SLODWORD(v24), v25) >= 0 )
{
JS_FreeValue(a1, Property, v13);
v15 = v26 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v26;
return v15 | v14;
}
break;
}
if ( (int)JS_DefinePropertyValueInt64(a1, v26, v17, i, v20, v21, a4, a5, a6, a7, v22, v23, a10, a11, 16391) < 0 )
break;
}
}
JS_FreeValue(a1, v26, v17);
JS_FreeValue(a1, Property, v13);
v14 = 0LL;
v15 = 0LL;
}
return v15 | v14;
}
| js_iterator_proto_toArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV RBP,RSI
MOV R14,RDI
MOV RSI,RDX
CALL 0x00160e07
PUSH 0x6
POP R13
TEST EAX,EAX
JS 0x00160bf2
PUSH 0x6b
POP RCX
MOV RDI,R14
MOV RSI,RBP
MOV RDX,RBX
CALL 0x0011b043
MOV qword ptr [RSP + 0x8],RAX
MOV R15,RDX
CMP R15D,0x6
JNZ 0x00160bf8
LAB_00160bf2:
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00160c34
LAB_00160bf8:
MOV RDI,R14
CALL 0x0011b2bb
MOV qword ptr [RSP],RAX
MOV R13,RDX
CMP R13D,0x6
JNZ 0x00160c49
LAB_00160c0d:
MOV RDI,R14
MOV RSI,qword ptr [RSP]
MOV RDX,R13
CALL 0x0011801e
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x0011801e
XOR EAX,EAX
XOR ECX,ECX
PUSH 0x6
POP R13
LAB_00160c34:
OR RAX,RCX
MOV RDX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00160c49:
XOR R12D,R12D
LAB_00160c4c:
MOV RDI,R14
MOV RSI,RBP
MOV RDX,RBX
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,R15
XOR R9D,R9D
LEA RAX,[RSP + 0x14]
PUSH RAX
PUSH 0x0
CALL 0x001398cc
ADD RSP,0x10
MOV R9,RDX
CMP R9D,0x6
JZ 0x00160c0d
CMP dword ptr [RSP + 0x14],0x0
JNZ 0x00160caf
SUB RSP,0x8
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R13
MOV RCX,R12
MOV R8,RAX
PUSH 0x4007
CALL 0x001209b7
POP RCX
POP RDX
TEST EAX,EAX
JS 0x00160c0d
INC R12
JMP 0x00160c4c
LAB_00160caf:
XOR EAX,EAX
MOV ECX,R12D
CVTSI2SD XMM0,RCX
TEST R12D,R12D
MOVQ R8,XMM0
CMOVNS R8,RCX
PUSH 0x7
POP R9
CMOVNS R9,RAX
PUSH 0x32
POP RCX
MOV RDI,R14
MOV RSI,qword ptr [RSP]
MOV RDX,R13
CALL 0x0011e446
TEST EAX,EAX
JS 0x00160c0d
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x0011801e
MOV RAX,-0x100000000
MOV RDX,qword ptr [RSP]
MOV RCX,RDX
AND RCX,RAX
MOV EAX,EDX
JMP 0x00160c34
|
int1 [16] js_iterator_proto_toArray(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
ulong uVar3;
double dVar5;
int8 uVar6;
ulong uVar7;
int8 uVar8;
bool bVar9;
int1 auVar10 [16];
int local_34;
int8 uVar4;
iVar1 = check_iterator(param_1,param_3);
uVar8 = 6;
if (-1 < iVar1) {
auVar10 = JS_GetProperty(param_1,param_2,param_3,0x6b);
uVar4 = auVar10._8_8_;
uVar2 = auVar10._0_8_;
if (auVar10._8_4_ != 6) {
auVar10 = JS_NewArray(param_1);
uVar8 = auVar10._8_8_;
uVar3 = auVar10._0_8_;
if (auVar10._8_4_ != 6) {
uVar7 = 0;
while( true ) {
auVar10 = JS_IteratorNext(param_1,param_2,param_3,uVar2,uVar4,0,0,&local_34);
if (auVar10._8_4_ == 6) break;
if (local_34 != 0) {
bVar9 = -1 < (int)uVar7;
dVar5 = (double)(uVar7 & 0xffffffff);
if (bVar9) {
dVar5 = (double)(uVar7 & 0xffffffff);
}
uVar6 = 7;
if (bVar9) {
uVar6 = 0;
}
iVar1 = JS_SetProperty(param_1,uVar3,uVar8,0x32,dVar5,uVar6);
if (-1 < iVar1) {
JS_FreeValue(param_1,uVar2,uVar4);
uVar7 = uVar3 & 0xffffffff00000000;
uVar3 = uVar3 & 0xffffffff;
goto LAB_00160c34;
}
break;
}
iVar1 = JS_DefinePropertyValueInt64
(param_1,uVar3,uVar8,uVar7,auVar10._0_8_,auVar10._8_8_,0x4007);
if (iVar1 < 0) break;
uVar7 = uVar7 + 1;
}
}
JS_FreeValue(param_1,uVar3,uVar8);
JS_FreeValue(param_1,uVar2,uVar4);
uVar3 = 0;
uVar7 = 0;
uVar8 = 6;
goto LAB_00160c34;
}
}
uVar3 = 0;
uVar7 = 0;
LAB_00160c34:
auVar10._0_8_ = uVar3 | uVar7;
auVar10._8_8_ = uVar8;
return auVar10;
}
| |
24,572 | httplib::ThreadPool::shutdown() | hkr04[P]cpp-mcp/common/httplib.h | void shutdown() override {
// Stop all worker threads...
{
std::unique_lock<std::mutex> lock(mutex_);
shutdown_ = true;
}
cond_.notify_all();
// Join...
for (auto &t : threads_) {
t.join();
}
} | O0 | c | httplib::ThreadPool::shutdown():
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x78, %rsi
leaq 0x30(%rsp), %rdi
callq 0x99520
movq 0x8(%rsp), %rax
movb $0x1, 0x38(%rax)
leaq 0x30(%rsp), %rdi
callq 0x996e0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0xcda0
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x99dc0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x98f90
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x9b210
testb $0x1, %al
jne 0xa84c3
jmp 0xa84e8
leaq 0x20(%rsp), %rdi
callq 0x9a490
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xcdb0
leaq 0x20(%rsp), %rdi
callq 0x9b250
jmp 0xa84ae
addq $0x48, %rsp
retq
nopl (%rax)
| _ZN7httplib10ThreadPool8shutdownEv:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov rsi, [rsp+48h+var_8]
mov [rsp+48h+var_40], rsi
add rsi, 78h ; 'x'
lea rdi, [rsp+48h+var_18]
call _ZNSt11unique_lockISt5mutexEC2ERS0_; std::unique_lock<std::mutex>::unique_lock(std::mutex&)
mov rax, [rsp+48h+var_40]
mov byte ptr [rax+38h], 1
lea rdi, [rsp+48h+var_18]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rdi, [rsp+48h+var_40]
add rdi, 48h ; 'H'; this
call __ZNSt18condition_variable10notify_allEv; std::condition_variable::notify_all(void)
mov rax, [rsp+48h+var_40]
add rax, 8
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_20]
call _ZNSt6vectorISt6threadSaIS0_EE5beginEv; std::vector<std::thread>::begin(void)
mov [rsp+48h+var_28], rax
mov rdi, [rsp+48h+var_20]
call _ZNSt6vectorISt6threadSaIS0_EE3endEv; std::vector<std::thread>::end(void)
mov [rsp+48h+var_30], rax
loc_A84AE:
lea rdi, [rsp+48h+var_28]
lea rsi, [rsp+48h+var_30]
call _ZN9__gnu_cxxneIPSt6threadSt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<std::thread *,std::vector<std::thread>>(__gnu_cxx::__normal_iterator<std::thread *,std::vector<std::thread>> const&,__gnu_cxx::__normal_iterator<std::thread *,std::vector<std::thread>> const&)
test al, 1
jnz short loc_A84C3
jmp short loc_A84E8
loc_A84C3:
lea rdi, [rsp+48h+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt6threadSt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<std::thread *,std::vector<std::thread>>::operator*(void)
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_38]; this
call __ZNSt6thread4joinEv; std::thread::join(void)
lea rdi, [rsp+48h+var_28]
call _ZN9__gnu_cxx17__normal_iteratorIPSt6threadSt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<std::thread *,std::vector<std::thread>>::operator++(void)
jmp short loc_A84AE
loc_A84E8:
add rsp, 48h
retn
| bool httplib::ThreadPool::shutdown(httplib::ThreadPool *this)
{
bool result; // al
std::thread *v2; // [rsp+10h] [rbp-38h]
long long v3; // [rsp+18h] [rbp-30h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-28h] BYREF
_BYTE v5[16]; // [rsp+30h] [rbp-18h] BYREF
httplib::ThreadPool *v6; // [rsp+40h] [rbp-8h]
v6 = this;
std::unique_lock<std::mutex>::unique_lock((long long)v5, (long long)this + 120);
*((_BYTE *)this + 56) = 1;
std::unique_lock<std::mutex>::~unique_lock((long long)v5);
std::condition_variable::notify_all((httplib::ThreadPool *)((char *)this + 72));
v4[1] = (char *)this + 8;
v4[0] = std::vector<std::thread>::begin((long long)this + 8);
v3 = std::vector<std::thread>::end((long long)this + 8);
while ( 1 )
{
result = __gnu_cxx::operator!=<std::thread *,std::vector<std::thread>>((long long)v4, (long long)&v3);
if ( !result )
break;
v2 = (std::thread *)__gnu_cxx::__normal_iterator<std::thread *,std::vector<std::thread>>::operator*((long long)v4);
std::thread::join(v2);
__gnu_cxx::__normal_iterator<std::thread *,std::vector<std::thread>>::operator++(v4);
}
return result;
}
| shutdown:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV RSI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x8],RSI
ADD RSI,0x78
LEA RDI,[RSP + 0x30]
CALL 0x00199520
MOV RAX,qword ptr [RSP + 0x8]
MOV byte ptr [RAX + 0x38],0x1
LEA RDI,[RSP + 0x30]
CALL 0x001996e0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x48
CALL 0x0010cda0
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x8
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00199dc0
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00198f90
MOV qword ptr [RSP + 0x18],RAX
LAB_001a84ae:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x18]
CALL 0x0019b210
TEST AL,0x1
JNZ 0x001a84c3
JMP 0x001a84e8
LAB_001a84c3:
LEA RDI,[RSP + 0x20]
CALL 0x0019a490
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0010cdb0
LEA RDI,[RSP + 0x20]
CALL 0x0019b250
JMP 0x001a84ae
LAB_001a84e8:
ADD RSP,0x48
RET
|
/* httplib::ThreadPool::shutdown() */
void __thiscall httplib::ThreadPool::shutdown(ThreadPool *this)
{
bool bVar1;
int8 local_30;
int8 local_28;
vector<std::thread,std::allocator<std::thread>> *local_20;
unique_lock<std::mutex> local_18 [16];
ThreadPool *local_8;
local_8 = this;
std::unique_lock<std::mutex>::unique_lock(local_18,(mutex *)(this + 0x78));
this[0x38] = (ThreadPool)0x1;
std::unique_lock<std::mutex>::~unique_lock(local_18);
std::condition_variable::notify_all();
local_20 = (vector<std::thread,std::allocator<std::thread>> *)(this + 8);
local_28 = std::vector<std::thread,std::allocator<std::thread>>::begin(local_20);
local_30 = std::vector<std::thread,std::allocator<std::thread>>::end(local_20);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_28,(__normal_iterator *)&local_30);
if (!bVar1) break;
__gnu_cxx::__normal_iterator<std::thread*,std::vector<std::thread,std::allocator<std::thread>>>
::operator*((__normal_iterator<std::thread*,std::vector<std::thread,std::allocator<std::thread>>>
*)&local_28);
std::thread::join();
__gnu_cxx::__normal_iterator<std::thread*,std::vector<std::thread,std::allocator<std::thread>>>
::operator++((__normal_iterator<std::thread*,std::vector<std::thread,std::allocator<std::thread>>>
*)&local_28);
}
return;
}
| |
24,573 | js_method_set_properties | bluesky950520[P]quickjs/quickjs.c | static int js_method_set_properties(JSContext *ctx, JSValue func_obj,
JSAtom name, int flags, JSValue home_obj)
{
JSValue name_str;
name_str = js_get_function_name(ctx, name);
if (flags & JS_PROP_HAS_GET) {
name_str = JS_ConcatString3(ctx, "get ", name_str, "");
} else if (flags & JS_PROP_HAS_SET) {
name_str = JS_ConcatString3(ctx, "set ", name_str, "");
}
if (JS_IsException(name_str))
return -1;
if (JS_DefinePropertyValue(ctx, func_obj, JS_ATOM_name, name_str,
JS_PROP_CONFIGURABLE) < 0)
return -1;
js_method_set_home_object(ctx, func_obj, home_obj);
return 0;
} | O0 | c | js_method_set_properties:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movl %r8d, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x75ad0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x48(%rsp)
movl 0x50(%rsp), %eax
andl $0x800, %eax # imm = 0x800
cmpl $0x0, %eax
je 0x6f315
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0xa54a4(%rip), %rsi # 0x11478d
leaq 0xa04bf(%rip), %r8 # 0x10f7af
callq 0x75c60
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x6f365
movl 0x50(%rsp), %eax
andl $0x1000, %eax # imm = 0x1000
cmpl $0x0, %eax
je 0x6f363
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
leaq 0xa5459(%rip), %rsi # 0x114792
leaq 0xa046f(%rip), %r8 # 0x10f7af
callq 0x75c60
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x6f365
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x6f383
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x6f3e4
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x40(%rsp), %r8
movq 0x48(%rsp), %r9
movl $0x37, %ecx
movl $0x1, (%rsp)
callq 0x3d4a0
cmpl $0x0, %eax
jge 0x6f3bc
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x6f3e4
movq 0x8(%rsp), %rax
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq (%rax), %rcx
movq 0x8(%rax), %r8
callq 0x6f170
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax)
| js_method_set_properties:
sub rsp, 78h
lea rax, [rsp+78h+arg_0]
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_18], rsi
mov [rsp+78h+var_10], rdx
mov [rsp+78h+var_20], rdi
mov [rsp+78h+var_24], ecx
mov [rsp+78h+var_28], r8d
mov rdi, [rsp+78h+var_20]
mov esi, [rsp+78h+var_24]
call js_get_function_name
mov [rsp+78h+var_48], rax
mov [rsp+78h+var_40], rdx
mov rax, [rsp+78h+var_48]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_40]
mov [rsp+78h+var_30], rax
mov eax, [rsp+78h+var_28]
and eax, 800h
cmp eax, 0
jz short loc_6F315
mov rdi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_38]
mov rcx, [rsp+78h+var_30]
lea rsi, aGet; "get "
lea r8, aMaximumMemoryS+24h; ""
call JS_ConcatString3
mov [rsp+78h+var_58], rax
mov [rsp+78h+var_50], rdx
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_50]
mov [rsp+78h+var_30], rax
jmp short loc_6F365
loc_6F315:
mov eax, [rsp+78h+var_28]
and eax, 1000h
cmp eax, 0
jz short loc_6F363
mov rdi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_38]
mov rcx, [rsp+78h+var_30]
lea rsi, aSet; "set "
lea r8, aMaximumMemoryS+24h; ""
call JS_ConcatString3
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], rdx
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_30], rax
loc_6F363:
jmp short $+2
loc_6F365:
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_6F383
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp short loc_6F3E4
loc_6F383:
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_18]
mov rdx, [rsp+78h+var_10]
mov r8, [rsp+78h+var_38]
mov r9, [rsp+78h+var_30]
mov ecx, 37h ; '7'
mov [rsp+78h+var_78], 1
call JS_DefinePropertyValue
cmp eax, 0
jge short loc_6F3BC
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp short loc_6F3E4
loc_6F3BC:
mov rax, [rsp+78h+var_70]
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_18]
mov rdx, [rsp+78h+var_10]
mov rcx, [rax]
mov r8, [rax+8]
call js_method_set_home_object
mov [rsp+78h+var_4], 0
loc_6F3E4:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
| long long js_method_set_properties(
long long a1,
long long a2,
long long a3,
unsigned int a4,
__int16 a5,
_DWORD a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
_DWORD *a15,
int a16)
{
long long v16; // rdx
long long v17; // rdx
BOOL IsException_1; // eax
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v21; // rdx
long long function_name; // [rsp+30h] [rbp-48h]
_DWORD *v24; // [rsp+40h] [rbp-38h]
long long v25; // [rsp+48h] [rbp-30h]
function_name = js_get_function_name(a1, a4);
v24 = (_DWORD *)function_name;
v25 = v16;
if ( (a5 & 0x800) != 0 )
{
v24 = (_DWORD *)JS_ConcatString3(a1, "get ", function_name, v16, "");
v25 = v17;
IsException_1 = JS_IsException_1((long long)v24, v17);
}
else
{
if ( (a5 & 0x1000) != 0 )
{
v24 = (_DWORD *)JS_ConcatString3(a1, "set ", function_name, v16, "");
v25 = v21;
}
IsException_1 = JS_IsException_1((long long)v24, v25);
}
if ( IsException_1 )
{
return (unsigned int)-1;
}
else if ( (int)JS_DefinePropertyValue(a1, a2, a3, 0x37u, v24, v25, a7, a8, a9, a10, v19, v20, a13, a14, 1) >= 0 )
{
js_method_set_home_object(a1, a2, a3, a15, a16);
return 0;
}
else
{
return (unsigned int)-1;
}
}
| js_method_set_properties:
SUB RSP,0x78
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x68],RDX
MOV qword ptr [RSP + 0x58],RDI
MOV dword ptr [RSP + 0x54],ECX
MOV dword ptr [RSP + 0x50],R8D
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x00175ad0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x48],RAX
MOV EAX,dword ptr [RSP + 0x50]
AND EAX,0x800
CMP EAX,0x0
JZ 0x0016f315
MOV RDI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x48]
LEA RSI,[0x21478d]
LEA R8,[0x20f7af]
CALL 0x00175c60
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x48],RAX
JMP 0x0016f365
LAB_0016f315:
MOV EAX,dword ptr [RSP + 0x50]
AND EAX,0x1000
CMP EAX,0x0
JZ 0x0016f363
MOV RDI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x48]
LEA RSI,[0x214792]
LEA R8,[0x20f7af]
CALL 0x00175c60
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x48],RAX
LAB_0016f363:
JMP 0x0016f365
LAB_0016f365:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0016f383
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x0016f3e4
LAB_0016f383:
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
MOV R8,qword ptr [RSP + 0x40]
MOV R9,qword ptr [RSP + 0x48]
MOV ECX,0x37
MOV dword ptr [RSP],0x1
CALL 0x0013d4a0
CMP EAX,0x0
JGE 0x0016f3bc
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x0016f3e4
LAB_0016f3bc:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x8]
CALL 0x0016f170
MOV dword ptr [RSP + 0x74],0x0
LAB_0016f3e4:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4
js_method_set_properties
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,uint param_5,
int8 param_6,int8 param_7,int8 param_8)
{
int iVar1;
int1 auVar2 [16];
int8 local_38;
int8 local_30;
int4 local_4;
auVar2 = js_get_function_name(param_1,param_4);
if ((param_5 & 0x800) == 0) {
if ((param_5 & 0x1000) != 0) {
auVar2 = JS_ConcatString3(param_1,&DAT_00214792,auVar2._0_8_,auVar2._8_8_,"");
}
}
else {
auVar2 = JS_ConcatString3(param_1,&DAT_0021478d,auVar2._0_8_,auVar2._8_8_,"");
}
local_30 = auVar2._8_8_;
local_38 = auVar2._0_8_;
iVar1 = JS_IsException(local_38,local_30);
if (iVar1 == 0) {
iVar1 = JS_DefinePropertyValue(param_1,param_2,param_3,0x37,local_38,local_30,1);
if (iVar1 < 0) {
local_4 = 0xffffffff;
}
else {
js_method_set_home_object(param_1,param_2,param_3,param_7,param_8);
local_4 = 0;
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
24,574 | rtree_get_first | eloqsql/storage/myisam/rt_index.c | int rtree_get_first(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
info->rtree_recursion_depth = -1;
info->buff_used = 1;
return rtree_get_req(info, keyinfo, key_length, root, 0);
} | O0 | c | rtree_get_first:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0xc8881
callq 0xfc1b0
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc88b4
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x3c0(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xc88c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| rtree_get_first:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_C8881
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C88B4
loc_C8881:
mov rax, [rbp+var_10]
mov dword ptr [rax+3C0h], 0FFFFFFFFh
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_18]
mov rcx, [rbp+var_20]
xor r8d, r8d
call rtree_get_req
mov [rbp+var_4], eax
loc_C88B4:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long rtree_get_first(long long a1, const char *a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v4 = 112LL * (unsigned int)a2 + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * (unsigned int)a2);
if ( v5 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
else
{
*(_DWORD *)(a1 + 960) = -1;
*(_BYTE *)(a1 + 829) = 1;
return (unsigned int)rtree_get_req(a1, v4, a3, v5, 0LL);
}
}
| rtree_get_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,-0x1
JNZ 0x001c8881
CALL 0x001fc1b0
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c88b4
LAB_001c8881:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c0],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
XOR R8D,R8D
CALL 0x001c88c0
MOV dword ptr [RBP + -0x4],EAX
LAB_001c88b4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 rtree_get_first(long *param_1,uint param_2,int4 param_3)
{
long lVar1;
long lVar2;
int4 *puVar3;
int4 local_c;
lVar1 = *(long *)(*param_1 + 0x218);
lVar2 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
if (lVar2 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else {
*(int4 *)(param_1 + 0x78) = 0xffffffff;
*(int1 *)((long)param_1 + 0x33d) = 1;
local_c = rtree_get_req(param_1,lVar1 + (ulong)param_2 * 0x70,param_3,lVar2,0);
}
return local_c;
}
| |
24,575 | get_hash_link | eloqsql/mysys/mf_keycache.c | static HASH_LINK *get_hash_link(SIMPLE_KEY_CACHE_CB *keycache,
int file, my_off_t filepos)
{
reg1 HASH_LINK *hash_link, **start;
#if defined(KEYCACHE_DEBUG)
int cnt;
#endif
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) file,(ulong) filepos));
restart:
/*
Find the bucket in the hash table for the pair (file, filepos);
start contains the head of the bucket list,
hash_link points to the first member of the list
*/
hash_link= *(start= &keycache->hash_root[KEYCACHE_HASH(file, filepos)]);
#if defined(KEYCACHE_DEBUG)
cnt= 0;
#endif
/* Look for an element for the pair (file, filepos) in the bucket chain */
while (hash_link &&
(hash_link->diskpos != filepos || hash_link->file != file))
{
hash_link= hash_link->next;
#if defined(KEYCACHE_DEBUG)
cnt++;
if (! (cnt <= keycache->hash_links_used))
{
int i;
for (i=0, hash_link= *start ;
i < cnt ; i++, hash_link= hash_link->next)
{
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) hash_link->file,(ulong) hash_link->diskpos));
}
}
KEYCACHE_DBUG_ASSERT(cnt <= keycache->hash_links_used);
#endif
}
if (! hash_link)
{
/* There is no hash link in the hash table for the pair (file, filepos) */
if (keycache->free_hash_list)
{
hash_link= keycache->free_hash_list;
keycache->free_hash_list= hash_link->next;
}
else if (keycache->hash_links_used < keycache->hash_links)
{
hash_link= &keycache->hash_link_root[keycache->hash_links_used++];
}
else
{
/* Wait for a free hash link */
struct st_my_thread_var *thread= my_thread_var;
KEYCACHE_PAGE page;
KEYCACHE_DBUG_PRINT("get_hash_link", ("waiting"));
page.file= file;
page.filepos= filepos;
thread->keycache_link= (void *) &page;
link_into_queue(&keycache->waiting_for_hash_link, thread);
KEYCACHE_DBUG_PRINT("get_hash_link: wait",
("suspend thread %ld", (ulong) thread->id));
keycache_pthread_cond_wait(&thread->suspend,
&keycache->cache_lock);
thread->keycache_link= NULL;
goto restart;
}
hash_link->file= file;
hash_link->diskpos= filepos;
link_hash(start, hash_link);
}
/* Register the request for the page */
hash_link->requests++;
return hash_link;
} | O0 | c | get_hash_link:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xe4c25
jmp 0xe4c27
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl 0x164(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x38(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
andq %rdx, %rcx
movq %rcx, %rsi
shlq $0x3, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x49(%rbp)
je 0xe4cc0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x4a(%rbp)
jne 0xe4cba
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xe4cc9
jmp 0xe4cd6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe4c8b
cmpq $0x0, -0x20(%rbp)
jne 0xe4dea
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0xe4d15
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0xe4dc7
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0xe4d4f
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x44(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x44(%rdx)
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xe4dc5
callq 0xf6080
movq %rax, -0x30(%rbp)
jmp 0xe4d5a
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x30(%rbp), %rsi
callq 0xe4fc0
jmp 0xe4d8d
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
leaq 0x6f235(%rip), %rdx # 0x153fdc
movl $0x71e, %ecx # imm = 0x71E
callq 0xe4ba0
movq -0x30(%rbp), %rax
movq $0x0, 0xa8(%rax)
jmp 0xe4c27
jmp 0xe4dc7
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe52f0
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_hash_link_0:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_E4C25:
jmp short $+2
loc_E4C27:
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov ecx, [rcx+18h]
xor edx, edx
div rcx
movsxd rcx, [rbp+var_C]
add rax, rcx
mov rcx, [rbp+var_8]
mov ecx, [rcx+164h]
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_48]
mov rdx, [rbp+var_8]
mov edx, [rdx+38h]
sub edx, 1
mov edx, edx
and rcx, rdx
mov rsi, rcx
shl rsi, 3
mov rdx, rax
add rdx, rsi
mov [rbp+var_28], rdx
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
loc_E4C8B:
xor eax, eax
cmp [rbp+var_20], 0
mov [rbp+var_49], al
jz short loc_E4CC0
mov rax, [rbp+var_20]
mov rcx, [rax+20h]
mov al, 1
cmp rcx, [rbp+var_18]
mov [rbp+var_4A], al
jnz short loc_E4CBA
mov rax, [rbp+var_20]
mov eax, [rax+18h]
cmp eax, [rbp+var_C]
setnz al
mov [rbp+var_4A], al
loc_E4CBA:
mov al, [rbp+var_4A]
mov [rbp+var_49], al
loc_E4CC0:
mov al, [rbp+var_49]
test al, 1
jnz short loc_E4CC9
jmp short loc_E4CD6
loc_E4CC9:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_E4C8B
loc_E4CD6:
cmp [rbp+var_20], 0
jnz loc_E4DEA
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
jz short loc_E4D15
mov rax, [rbp+var_8]
mov rax, [rax+90h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+90h], rcx
jmp loc_E4DC7
loc_E4D15:
mov rax, [rbp+var_8]
mov eax, [rax+44h]
mov rcx, [rbp+var_8]
cmp eax, [rcx+40h]
jge short loc_E4D4F
mov rax, [rbp+var_8]
mov rax, [rax+88h]
mov rdx, [rbp+var_8]
mov ecx, [rdx+44h]
mov esi, ecx
add esi, 1
mov [rdx+44h], esi
movsxd rcx, ecx
imul rcx, 30h ; '0'
add rax, rcx
mov [rbp+var_20], rax
jmp short loc_E4DC5
loc_E4D4F:
call _my_thread_var
mov [rbp+var_30], rax
jmp short $+2
loc_E4D5A:
mov eax, [rbp+var_C]
mov [rbp+var_40], eax
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
lea rcx, [rbp+var_40]
mov [rax+0A8h], rcx
mov rdi, [rbp+var_8]
add rdi, 118h
mov rsi, [rbp+var_30]
call link_into_queue
jmp short $+2
loc_E4D8D:
mov rdi, [rbp+var_30]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C0h
lea rdx, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 71Eh
call inline_mysql_cond_wait_4
mov rax, [rbp+var_30]
mov qword ptr [rax+0A8h], 0
jmp loc_E4C27
loc_E4DC5:
jmp short $+2
loc_E4DC7:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_20]
mov [rax+18h], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+20h], rcx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call link_hash_0
loc_E4DEA:
mov rax, [rbp+var_20]
mov ecx, [rax+28h]
add ecx, 1
mov [rax+28h], ecx
mov rax, [rbp+var_20]
add rsp, 50h
pop rbp
retn
| long long * get_hash_link_0(long long a1, int a2, unsigned long long a3)
{
const char *v3; // rsi
long long v4; // rax
int v5; // ecx
bool v7; // [rsp+6h] [rbp-4Ah]
bool v8; // [rsp+7h] [rbp-49h]
int v9; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-38h]
long long v11; // [rsp+20h] [rbp-30h]
const char *v12; // [rsp+28h] [rbp-28h]
long long *i; // [rsp+30h] [rbp-20h]
unsigned long long v14; // [rsp+38h] [rbp-18h]
int v15; // [rsp+44h] [rbp-Ch]
long long v16; // [rsp+48h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
while ( 1 )
{
v3 = (const char *)(8
* ((unsigned int)(*(_DWORD *)(v16 + 56) - 1) & ((v15 + v14 / *(unsigned int *)(v16 + 24))
/ *(unsigned int *)(v16 + 356))));
v12 = &v3[*(_QWORD *)(v16 + 128)];
for ( i = *(long long **)v12; ; i = (long long *)*i )
{
v8 = 0;
if ( i )
{
v7 = 1;
if ( i[4] == v14 )
v7 = *((_DWORD *)i + 6) != v15;
v8 = v7;
}
if ( !v8 )
break;
}
if ( i )
break;
if ( *(_QWORD *)(v16 + 144) )
{
i = *(long long **)(v16 + 144);
*(_QWORD *)(v16 + 144) = *i;
LABEL_15:
*((_DWORD *)i + 6) = v15;
i[4] = v14;
link_hash_0(v12, i);
break;
}
if ( *(_DWORD *)(v16 + 68) < *(_DWORD *)(v16 + 64) )
{
v4 = *(_QWORD *)(v16 + 136);
v5 = *(_DWORD *)(v16 + 68);
*(_DWORD *)(v16 + 68) = v5 + 1;
i = (long long *)(48LL * v5 + v4);
goto LABEL_15;
}
v11 = my_thread_var(a1, v3);
v9 = v15;
v10 = v14;
*(_QWORD *)(v11 + 168) = &v9;
link_into_queue(v16 + 280, v11);
a1 = v11 + 8;
inline_mysql_cond_wait_4(
v11 + 8,
v16 + 192,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x71Eu);
*(_QWORD *)(v11 + 168) = 0LL;
}
++*((_DWORD *)i + 10);
return i;
}
| get_hash_link:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001e4c25
LAB_001e4c25:
JMP 0x001e4c27
LAB_001e4c27:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x18]
XOR EDX,EDX
DIV RCX
MOVSXD RCX,dword ptr [RBP + -0xc]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x164]
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RDX + 0x38]
SUB EDX,0x1
MOV EDX,EDX
AND RCX,RDX
MOV RSI,RCX
SHL RSI,0x3
MOV RDX,RAX
ADD RDX,RSI
MOV qword ptr [RBP + -0x28],RDX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001e4c8b:
XOR EAX,EAX
CMP qword ptr [RBP + -0x20],0x0
MOV byte ptr [RBP + -0x49],AL
JZ 0x001e4cc0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x20]
MOV AL,0x1
CMP RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x4a],AL
JNZ 0x001e4cba
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
CMP EAX,dword ptr [RBP + -0xc]
SETNZ AL
MOV byte ptr [RBP + -0x4a],AL
LAB_001e4cba:
MOV AL,byte ptr [RBP + -0x4a]
MOV byte ptr [RBP + -0x49],AL
LAB_001e4cc0:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x001e4cc9
JMP 0x001e4cd6
LAB_001e4cc9:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e4c8b
LAB_001e4cd6:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001e4dea
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x001e4d15
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x001e4dc7
LAB_001e4d15:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x44]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x40]
JGE 0x001e4d4f
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV RDX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RDX + 0x44]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x44],ESI
MOVSXD RCX,ECX
IMUL RCX,RCX,0x30
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e4dc5
LAB_001e4d4f:
CALL 0x001f6080
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001e4d5a
LAB_001e4d5a:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x40]
MOV qword ptr [RAX + 0xa8],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x118
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001e4fc0
JMP 0x001e4d8d
LAB_001e4d8d:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc0
LEA RDX,[0x253fdc]
MOV ECX,0x71e
CALL 0x001e4ba0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xa8],0x0
JMP 0x001e4c27
LAB_001e4dc5:
JMP 0x001e4dc7
LAB_001e4dc7:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x18],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001e52f0
LAB_001e4dea:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x28]
ADD ECX,0x1
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x50
POP RBP
RET
|
int8 * get_hash_link(long param_1,int param_2,ulong param_3)
{
int iVar1;
ulong uVar2;
bool bVar3;
int local_48 [2];
ulong local_40;
long local_38;
long local_30;
int8 *local_28;
ulong local_20;
int local_14;
long local_10;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
while( true ) {
uVar2 = (local_20 / *(uint *)(local_10 + 0x18) + (long)local_14) /
(ulong)*(uint *)(local_10 + 0x164) & (ulong)(*(int *)(local_10 + 0x38) - 1);
local_30 = *(long *)(local_10 + 0x80) + uVar2 * 8;
local_28 = *(int8 **)(*(long *)(local_10 + 0x80) + uVar2 * 8);
while( true ) {
bVar3 = false;
if ((local_28 != (int8 *)0x0) && (bVar3 = true, local_28[4] == local_20)) {
bVar3 = *(int *)(local_28 + 3) != local_14;
}
if (!bVar3) break;
local_28 = (int8 *)*local_28;
}
if (local_28 != (int8 *)0x0) goto LAB_001e4dea;
if (*(long *)(local_10 + 0x90) != 0) break;
if (*(int *)(local_10 + 0x44) < *(int *)(local_10 + 0x40)) {
iVar1 = *(int *)(local_10 + 0x44);
*(int *)(local_10 + 0x44) = iVar1 + 1;
local_28 = (int8 *)(*(long *)(local_10 + 0x88) + (long)iVar1 * 0x30);
LAB_001e4dc7:
*(int *)(local_28 + 3) = local_14;
local_28[4] = local_20;
link_hash(local_30,local_28);
LAB_001e4dea:
*(int *)(local_28 + 5) = *(int *)(local_28 + 5) + 1;
return local_28;
}
local_38 = _my_thread_var();
local_48[0] = local_14;
local_40 = local_20;
*(int **)(local_38 + 0xa8) = local_48;
link_into_queue(local_10 + 0x118,local_38);
inline_mysql_cond_wait
(local_38 + 8,local_10 + 0xc0,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x71e);
*(int8 *)(local_38 + 0xa8) = 0;
}
local_28 = *(int8 **)(local_10 + 0x90);
*(int8 *)(local_10 + 0x90) = *local_28;
goto LAB_001e4dc7;
}
| |
24,576 | d2b | eloqsql/strings/dtoa.c | static Bigint *d2b(U *d, int *e, int *bits, Stack_alloc *alloc)
{
Bigint *b;
int de, k;
ULong *x, y, z;
int i;
#define d0 word0(d)
#define d1 word1(d)
b= Balloc(1, alloc);
x= b->p.x;
z= d0 & Frac_mask;
d0 &= 0x7fffffff; /* clear sign bit, which we ignore */
if ((de= (int)(d0 >> Exp_shift)))
z|= Exp_msk1;
if ((y= d1))
{
if ((k= lo0bits(&y)))
{
x[0]= y | z << (32 - k);
z>>= k;
}
else
x[0]= y;
i= b->wds= (x[1]= z) ? 2 : 1;
}
else
{
k= lo0bits(&z);
x[0]= z;
i= b->wds= 1;
k+= 32;
}
if (de)
{
*e= de - Bias - (P-1) + k;
*bits= P - k;
}
else
{
*e= de - Bias - (P-1) + 1 + k;
*bits= 32*i - hi0bits(x[i-1]);
}
return b;
#undef d0
#undef d1
} | O0 | c | d2b:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x81420
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0xfffff, %eax # imm = 0xFFFFF
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
shrl $0x14, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x815a1
movl -0x40(%rbp), %eax
orl $0x100000, %eax # imm = 0x100000
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x8161a
leaq -0x3c(%rbp), %rdi
callq 0x821e0
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
je 0x815eb
movl -0x3c(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl $0x20, %ecx
subl -0x30(%rbp), %ecx
shll %cl, %eax
movl -0x48(%rbp), %ecx
orl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movl -0x40(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x40(%rbp)
jmp 0x815f4
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rax
movl %edx, 0x4(%rax)
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movq -0x28(%rbp), %rcx
movl %eax, 0x14(%rcx)
movl %eax, -0x44(%rbp)
jmp 0x8164a
leaq -0x40(%rbp), %rdi
callq 0x821e0
movl %eax, -0x30(%rbp)
movl -0x40(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x14(%rax)
movl $0x1, -0x44(%rbp)
movl -0x30(%rbp), %eax
addl $0x20, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x81675
movl -0x2c(%rbp), %ecx
subl $0x3ff, %ecx # imm = 0x3FF
subl $0x34, %ecx
addl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x35, %ecx
subl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x816b6
movl -0x2c(%rbp), %ecx
subl $0x3ff, %ecx # imm = 0x3FF
subl $0x34, %ecx
addl $0x1, %ecx
addl -0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x44(%rbp), %eax
shll $0x5, %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edi
callq 0x82310
movl -0x4c(%rbp), %ecx
subl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
| d2b:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rsi, [rbp+var_20]
mov edi, 1
call Balloc
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
mov eax, [rax+4]
and eax, 0FFFFFh
mov [rbp+var_40], eax
mov rax, [rbp+var_8]
mov ecx, [rax+4]
and ecx, 7FFFFFFFh
mov [rax+4], ecx
mov rax, [rbp+var_8]
mov eax, [rax+4]
shr eax, 14h
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_815A1
mov eax, [rbp+var_40]
or eax, 100000h
mov [rbp+var_40], eax
loc_815A1:
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_3C], eax
cmp eax, 0
jz short loc_8161A
lea rdi, [rbp+var_3C]
call lo0bits
mov [rbp+var_30], eax
cmp eax, 0
jz short loc_815EB
mov eax, [rbp+var_3C]
mov [rbp+var_48], eax
mov eax, [rbp+var_40]
mov ecx, 20h ; ' '
sub ecx, [rbp+var_30]
shl eax, cl
mov ecx, [rbp+var_48]
or ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov ecx, [rbp+var_30]
mov eax, [rbp+var_40]
shr eax, cl
mov [rbp+var_40], eax
jmp short loc_815F4
loc_815EB:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_38]
mov [rax], ecx
loc_815F4:
mov edx, [rbp+var_40]
mov rax, [rbp+var_38]
mov [rax+4], edx
mov eax, 1
mov ecx, 2
cmp edx, 0
cmovnz eax, ecx
mov rcx, [rbp+var_28]
mov [rcx+14h], eax
mov [rbp+var_44], eax
jmp short loc_8164A
loc_8161A:
lea rdi, [rbp+var_40]
call lo0bits
mov [rbp+var_30], eax
mov ecx, [rbp+var_40]
mov rax, [rbp+var_38]
mov [rax], ecx
mov rax, [rbp+var_28]
mov dword ptr [rax+14h], 1
mov [rbp+var_44], 1
mov eax, [rbp+var_30]
add eax, 20h ; ' '
mov [rbp+var_30], eax
loc_8164A:
cmp [rbp+var_2C], 0
jz short loc_81675
mov ecx, [rbp+var_2C]
sub ecx, 3FFh
sub ecx, 34h ; '4'
add ecx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], ecx
mov ecx, 35h ; '5'
sub ecx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], ecx
jmp short loc_816B6
loc_81675:
mov ecx, [rbp+var_2C]
sub ecx, 3FFh
sub ecx, 34h ; '4'
add ecx, 1
add ecx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], ecx
mov eax, [rbp+var_44]
shl eax, 5
mov [rbp+var_4C], eax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_44]
sub ecx, 1
movsxd rcx, ecx
mov edi, [rax+rcx*4]
call hi0bits
mov ecx, [rbp+var_4C]
sub ecx, eax
mov rax, [rbp+var_18]
mov [rax], ecx
loc_816B6:
mov rax, [rbp+var_28]
add rsp, 50h
pop rbp
retn
| long long d2b(unsigned int *a1, _DWORD *a2, _DWORD *a3, long long a4)
{
unsigned int v4; // edx
int v5; // eax
int v7; // [rsp+Ch] [rbp-44h]
unsigned int v8; // [rsp+10h] [rbp-40h] BYREF
unsigned int v9; // [rsp+14h] [rbp-3Ch] BYREF
unsigned int *v10; // [rsp+18h] [rbp-38h]
int v11; // [rsp+20h] [rbp-30h]
unsigned int v12; // [rsp+24h] [rbp-2Ch]
long long v13; // [rsp+28h] [rbp-28h]
long long v14; // [rsp+30h] [rbp-20h]
_DWORD *v15; // [rsp+38h] [rbp-18h]
_DWORD *v16; // [rsp+40h] [rbp-10h]
unsigned int *v17; // [rsp+48h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = Balloc(1, a4);
v10 = *(unsigned int **)v13;
v8 = a1[1] & 0xFFFFF;
a1[1] &= ~0x80000000;
v12 = v17[1] >> 20;
if ( v12 )
v8 |= 0x100000u;
v9 = *v17;
if ( v9 )
{
v11 = lo0bits(&v9);
if ( v11 )
{
*v10 = (v8 << (32 - v11)) | v9;
v8 >>= v11;
}
else
{
*v10 = v9;
}
v4 = v8;
v10[1] = v8;
v5 = 1;
if ( v4 )
v5 = 2;
*(_DWORD *)(v13 + 20) = v5;
v7 = v5;
}
else
{
v11 = lo0bits(&v8);
*v10 = v8;
*(_DWORD *)(v13 + 20) = 1;
v7 = 1;
v11 += 32;
}
if ( v12 )
{
*v16 = v11 + v12 - 1075;
*v15 = 53 - v11;
}
else
{
*v16 = v11 - 1074;
*v15 = 32 * v7 - hi0bits(v10[v7 - 1]);
}
return v13;
}
| d2b:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 RSI,qword ptr [RBP + -0x20]
MOV EDI,0x1
CALL 0x00181420
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x4]
AND EAX,0xfffff
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x4]
AND ECX,0x7fffffff
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x4]
SHR EAX,0x14
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x001815a1
MOV EAX,dword ptr [RBP + -0x40]
OR EAX,0x100000
MOV dword ptr [RBP + -0x40],EAX
LAB_001815a1:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JZ 0x0018161a
LEA RDI,[RBP + -0x3c]
CALL 0x001821e0
MOV dword ptr [RBP + -0x30],EAX
CMP EAX,0x0
JZ 0x001815eb
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x40]
MOV ECX,0x20
SUB ECX,dword ptr [RBP + -0x30]
SHL EAX,CL
MOV ECX,dword ptr [RBP + -0x48]
OR ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV ECX,dword ptr [RBP + -0x30]
MOV EAX,dword ptr [RBP + -0x40]
SHR EAX,CL
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001815f4
LAB_001815eb:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
LAB_001815f4:
MOV EDX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],EDX
MOV EAX,0x1
MOV ECX,0x2
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV RCX,qword ptr [RBP + -0x28]
MOV dword ptr [RCX + 0x14],EAX
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0018164a
LAB_0018161a:
LEA RDI,[RBP + -0x40]
CALL 0x001821e0
MOV dword ptr [RBP + -0x30],EAX
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x14],0x1
MOV dword ptr [RBP + -0x44],0x1
MOV EAX,dword ptr [RBP + -0x30]
ADD EAX,0x20
MOV dword ptr [RBP + -0x30],EAX
LAB_0018164a:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00181675
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x3ff
SUB ECX,0x34
ADD ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV ECX,0x35
SUB ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],ECX
JMP 0x001816b6
LAB_00181675:
MOV ECX,dword ptr [RBP + -0x2c]
SUB ECX,0x3ff
SUB ECX,0x34
ADD ECX,0x1
ADD ECX,dword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x44]
SHL EAX,0x5
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x44]
SUB ECX,0x1
MOVSXD RCX,ECX
MOV EDI,dword ptr [RAX + RCX*0x4]
CALL 0x00182310
MOV ECX,dword ptr [RBP + -0x4c]
SUB ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],ECX
LAB_001816b6:
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x50
POP RBP
RET
|
int8 * d2b(uint *param_1,int *param_2,int *param_3,int8 param_4)
{
int iVar1;
int local_4c;
uint local_48;
uint local_44;
uint *local_40;
int local_38;
uint local_34;
int8 *local_30;
int8 local_28;
int *local_20;
int *local_18;
uint *local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_30 = (int8 *)Balloc(1,param_4);
local_40 = (uint *)*local_30;
local_48 = local_10[1] & 0xfffff;
local_10[1] = local_10[1] & 0x7fffffff;
local_34 = local_10[1] >> 0x14;
if (local_34 != 0) {
local_48 = local_48 | 0x100000;
}
local_44 = *local_10;
if (local_44 == 0) {
local_38 = lo0bits(&local_48);
*local_40 = local_48;
*(int4 *)((long)local_30 + 0x14) = 1;
local_4c = 1;
local_38 = local_38 + 0x20;
}
else {
local_38 = lo0bits(&local_44);
if (local_38 == 0) {
*local_40 = local_44;
}
else {
*local_40 = local_44 | local_48 << (0x20 - (byte)local_38 & 0x1f);
local_48 = local_48 >> ((byte)local_38 & 0x1f);
}
local_40[1] = local_48;
local_4c = 1;
if (local_48 != 0) {
local_4c = 2;
}
*(int *)((long)local_30 + 0x14) = local_4c;
}
if (local_34 == 0) {
*local_18 = local_38 + -0x432;
iVar1 = hi0bits(local_40[local_4c + -1]);
*local_20 = local_4c * 0x20 - iVar1;
}
else {
*local_18 = (local_34 - 0x433) + local_38;
*local_20 = 0x35 - local_38;
}
return local_30;
}
| |
24,577 | std::pair<__gnu_cxx::__normal_iterator<std::pair<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, minja::Value>*, std::vector<std::pair<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, minja::Value>, std::allocator<std::pair<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, minja::Value>>>>, bool> 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::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Value&&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> emplace(KeyType && key, T && t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
return {std::prev(this->end()), true};
} | O1 | cpp | std::pair<__gnu_cxx::__normal_iterator<std::pair<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, minja::Value>*, std::vector<std::pair<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, minja::Value>, std::allocator<std::pair<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, minja::Value>>>>, bool> 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::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Value&&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%rdi), %rbx
sete %bpl
je 0x53e78
leaq 0x18(%r14), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x53ea6
testb %al, %al
jne 0x53e73
addq $0x60, %rbx
cmpq 0x8(%r14), %rbx
sete %bpl
jne 0x53e51
jmp 0x53e78
testb %bpl, %bpl
je 0x53e92
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x53eea
movq 0x8(%r14), %rbx
addq $-0x60, %rbx
movb $0x1, %dl
jmp 0x53e94
xorl %edx, %edx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
cmp rbx, [rdi+8]
setz bpl
jz short loc_53E78
lea r13, [r14+18h]
loc_53E51:
mov rdi, r13
mov rsi, rbx
mov rdx, r12
call _ZNKSt8equal_toIvEclIRKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEERKSC_EEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSL_OSM_
test al, al
jnz short loc_53E73
add rbx, 60h ; '`'
cmp rbx, [r14+8]
setz bpl
jnz short loc_53E51
jmp short loc_53E78
loc_53E73:
test bpl, bpl
jz short loc_53E92
loc_53E78:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRKSA_SH_EEERSI_DpOT_; std::vector<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>>::emplace_back<std::string const&,minja::Value>(std::string const&,minja::Value &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFA0h
mov dl, 1
jmp short loc_53E94
loc_53E92:
xor edx, edx
loc_53E94:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_(
long long *a1,
long long a2,
long long a3)
{
long long v4; // rbx
bool v5; // bp
v4 = *a1;
v5 = *a1 == a1[1];
if ( *a1 == a1[1] )
goto LABEL_6;
while ( !(unsigned __int8)std::equal_to<void>::operator()<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&,std::string const&>(
a1 + 3,
v4,
a2) )
{
v4 += 96LL;
v5 = v4 == a1[1];
if ( v4 == a1[1] )
goto LABEL_6;
}
if ( v5 )
{
LABEL_6:
std::vector<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>>::emplace_back<std::string const&,minja::Value>(
a1,
a2,
a3);
return a1[1] - 96;
}
return v4;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
CMP RBX,qword ptr [RDI + 0x8]
SETZ BPL
JZ 0x00153e78
LEA R13,[R14 + 0x18]
LAB_00153e51:
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R12
CALL 0x00153ea6
TEST AL,AL
JNZ 0x00153e73
ADD RBX,0x60
CMP RBX,qword ptr [R14 + 0x8]
SETZ BPL
JNZ 0x00153e51
JMP 0x00153e78
LAB_00153e73:
TEST BPL,BPL
JZ 0x00153e92
LAB_00153e78:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x00153eea
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x60
MOV DL,0x1
JMP 0x00153e94
LAB_00153e92:
XOR EDX,EDX
LAB_00153e94:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
(vector<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::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>>>
*param_1,string *param_2,Value *param_3)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
basic_json *pbVar3;
bool bVar4;
int1 auVar5 [16];
pbVar3 = *(basic_json **)param_1;
bVar4 = pbVar3 == *(basic_json **)(param_1 + 8);
if (!bVar4) {
do {
cVar1 = std::equal_to<void>::operator()((equal_to<void> *)(param_1 + 0x18),pbVar3,param_2);
if (cVar1 != '\0') {
if (!bVar4) {
uVar2 = 0;
goto LAB_00153e94;
}
break;
}
pbVar3 = pbVar3 + 0x60;
bVar4 = pbVar3 == *(basic_json **)(param_1 + 8);
} while (!bVar4);
}
std::
vector<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::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>>>
::emplace_back<std::__cxx11::string_const&,minja::Value>(param_1,param_2,param_3);
pbVar3 = (basic_json *)(*(long *)(param_1 + 8) + -0x60);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_00153e94:
auVar5._8_8_ = uVar2;
auVar5._0_8_ = pbVar3;
return auVar5;
}
| |
24,578 | std::pair<__gnu_cxx::__normal_iterator<std::pair<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, minja::Value>*, std::vector<std::pair<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, minja::Value>, std::allocator<std::pair<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, minja::Value>>>>, bool> 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::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Value&&) | monkey531[P]llama/common/json.hpp | std::pair<iterator, bool> emplace(KeyType && key, T && t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
return {std::prev(this->end()), true};
} | O3 | cpp | std::pair<__gnu_cxx::__normal_iterator<std::pair<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, minja::Value>*, std::vector<std::pair<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, minja::Value>, std::allocator<std::pair<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, minja::Value>>>>, bool> 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::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<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, minja::Value>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Value&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%rdi), %rbx
je 0x51855
leaq 0x18(%r14), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5187e
testb %al, %al
jne 0x5186f
addq $0x60, %rbx
cmpq 0x8(%r14), %rbx
jne 0x51839
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x518c2
movq 0x8(%r14), %rbx
addq $-0x60, %rbx
movb $0x1, %dl
jmp 0x51871
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
cmp rbx, [rdi+8]
jz short loc_51855
lea r13, [r14+18h]
loc_51839:
mov rdi, r13
mov rsi, rbx
mov rdx, r12
call _ZNKSt8equal_toIvEclIRKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEERKSC_EEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSL_OSM_
test al, al
jnz short loc_5186F
add rbx, 60h ; '`'
cmp rbx, [r14+8]
jnz short loc_51839
loc_51855:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRKSA_SH_EEERSI_DpOT_; std::vector<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>>::emplace_back<std::string const&,minja::Value>(std::string const&,minja::Value &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFA0h
mov dl, 1
jmp short loc_51871
loc_5186F:
xor edx, edx
loc_51871:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_(
long long *a1,
long long a2,
long long a3)
{
long long v4; // rbx
v4 = *a1;
if ( *a1 == a1[1] )
{
LABEL_4:
std::vector<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>>::emplace_back<std::string const&,minja::Value>(
a1,
a2,
a3);
return a1[1] - 96;
}
else
{
while ( !(unsigned __int8)std::equal_to<void>::operator()<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&,std::string const&>(
a1 + 3,
v4,
a2) )
{
v4 += 96LL;
if ( v4 == a1[1] )
goto LABEL_4;
}
}
return v4;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
CMP RBX,qword ptr [RDI + 0x8]
JZ 0x00151855
LEA R13,[R14 + 0x18]
LAB_00151839:
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R12
CALL 0x0015187e
TEST AL,AL
JNZ 0x0015186f
ADD RBX,0x60
CMP RBX,qword ptr [R14 + 0x8]
JNZ 0x00151839
LAB_00151855:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x001518c2
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x60
MOV DL,0x1
JMP 0x00151871
LAB_0015186f:
XOR EDX,EDX
LAB_00151871:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16]
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
(vector<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::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>>>
*param_1,string *param_2,Value *param_3)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
basic_json *pbVar3;
int1 auVar4 [16];
pbVar3 = *(basic_json **)param_1;
if (pbVar3 != *(basic_json **)(param_1 + 8)) {
do {
cVar1 = std::equal_to<void>::operator()((equal_to<void> *)(param_1 + 0x18),pbVar3,param_2);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_00151871;
}
pbVar3 = pbVar3 + 0x60;
} while (pbVar3 != *(basic_json **)(param_1 + 8));
}
std::
vector<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::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>>>
::emplace_back<std::__cxx11::string_const&,minja::Value>(param_1,param_2,param_3);
pbVar3 = (basic_json *)(*(long *)(param_1 + 8) + -0x60);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_00151871:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = pbVar3;
return auVar4;
}
| |
24,579 | trnman_new_trn | eloqsql/storage/maria/trnman.c | TRN *trnman_new_trn(WT_THD *wt)
{
int res;
TRN *trn;
union { TRN *trn; void *v; } tmp;
DBUG_ENTER("trnman_new_trn");
/*
we have a mutex, to do simple things under it - allocate a TRN,
increment trnman_active_transactions, set trn->min_read_from.
Note that all the above is fast. generating short_id may be slow,
as it involves scanning a large array - so it's done outside of the
mutex.
*/
DBUG_PRINT("info", ("mysql_mutex_lock LOCK_trn_list"));
mysql_mutex_lock(&LOCK_trn_list);
/* Allocating a new TRN structure */
tmp.trn= pool;
/*
Popping an unused TRN from the pool
(ABA isn't possible, we're behind a mutex
*/
while (tmp.trn && !my_atomic_casptr((void **)(char*) &pool, &tmp.v,
(void *)tmp.trn->next))
/* no-op */;
/* Nothing in the pool ? Allocate a new one */
if (!(trn= tmp.trn))
{
/*
trn should be completely initialized at create time to allow
one to keep a known state on it.
(Like redo_lns, which is assumed to be 0 at start of row handling
and reset to zero before end of row handling)
*/
trn= (TRN *)my_malloc(PSI_INSTRUMENT_ME, sizeof(TRN), MYF(MY_WME | MY_ZEROFILL));
if (unlikely(!trn))
{
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
return 0;
}
trnman_allocated_transactions++;
mysql_mutex_init(key_TRN_state_lock, &trn->state_lock, MY_MUTEX_INIT_FAST);
}
trn->wt= wt;
trn->pins= lf_hash_get_pins(&trid_to_trn);
if (!trn->pins)
{
trnman_free_trn(trn);
mysql_mutex_unlock(&LOCK_trn_list);
return 0;
}
trnman_active_transactions++;
trn->min_read_from= active_list_min.next->trid;
trn->trid= new_trid();
trn->next= &active_list_max;
trn->prev= active_list_max.prev;
active_list_max.prev= trn->prev->next= trn;
trid_min_read_from= active_list_min.next->min_read_from;
DBUG_PRINT("info", ("mysql_mutex_unlock LOCK_trn_list"));
mysql_mutex_unlock(&LOCK_trn_list);
if (unlikely(!trn->min_read_from))
{
/*
We are the only transaction. Set min_read_from so that we can read
our own rows
*/
trn->min_read_from= trn->trid + 1;
}
/* no other transaction can read changes done by this one */
trn->commit_trid= MAX_TRID;
trn->rec_lsn= trn->undo_lsn= trn->first_undo_lsn= 0;
trn->used_tables= 0;
trn->used_instances= 0;
trn->locked_tables= 0;
trn->flags= 0;
/*
only after the following function TRN is considered initialized,
so it must be done the last
*/
mysql_mutex_lock(&trn->state_lock);
trn->short_id= get_short_trid(trn);
mysql_mutex_unlock(&trn->state_lock);
res= lf_hash_insert(&trid_to_trn, trn->pins, &trn);
DBUG_ASSERT(res <= 0);
if (res)
{
trnman_end_trn(trn, 0);
return 0;
}
DBUG_PRINT("exit", ("trn: %p trid: 0x%lu min_read_from: 0x%lu",
trn, (ulong) trn->trid, (ulong) trn->min_read_from));
DBUG_RETURN(trn);
} | O0 | c | trnman_new_trn:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x2b61e
leaq 0x44ad8b(%rip), %rdi # 0x4763b0
leaq 0x124c65(%rip), %rsi # 0x150291
movl $0x128, %edx # imm = 0x128
callq 0x2b950
movq 0x44ac9b(%rip), %rax # 0x4762d8
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x32(%rbp)
je 0x2b693
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
lock
cmpxchgq %rcx, 0x44ac6e(%rip) # 0x4762d8
movq %rax, %rcx
sete %al
movb %al, -0x41(%rbp)
movq %rcx, -0x40(%rbp)
testb $0x1, %al
jne 0x2b683
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
xorb $-0x1, %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x2b69c
jmp 0x2b69e
jmp 0x2b641
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2b730
xorl %edi, %edi
movl $0xb0, %esi
movl $0x30, %edx
callq 0xf2e30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2b704
jmp 0x2b6e9
jmp 0x2b6eb
leaq 0x44acbe(%rip), %rdi # 0x4763b0
callq 0x2b9c0
movq $0x0, -0x8(%rbp)
jmp 0x2b940
movl 0x44abc6(%rip), %eax # 0x4762d0
addl $0x1, %eax
movl %eax, 0x44abbd(%rip) # 0x4762d0
leaq 0x44b32a(%rip), %rax # 0x476a44
movl (%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
leaq 0xc56895(%rip), %rdx # 0xc81fc0
callq 0x2b490
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x44aba5(%rip), %rdi # 0x4762e8
addq $0x28, %rdi
callq 0xfb700
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2b782
movq -0x20(%rbp), %rdi
callq 0x2ba20
leaq 0x44ac40(%rip), %rdi # 0x4763b0
callq 0x2b9c0
movq $0x0, -0x8(%rbp)
jmp 0x2b940
movl 0x44ab40(%rip), %eax # 0x4762c8
addl $0x1, %eax
movl %eax, 0x44ab37(%rip) # 0x4762c8
movq 0x44a8d8(%rip), %rax # 0x476070
movq 0x78(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
callq 0x2ca60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rax
leaq 0x44a8f6(%rip), %rcx # 0x4760b8
movq %rcx, 0x68(%rax)
movq 0x44a95b(%rip), %rcx # 0x476128
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x70(%rcx), %rcx
movq %rax, 0x68(%rcx)
movq %rax, 0x44a93c(%rip) # 0x476128
movq 0x44a87d(%rip), %rax # 0x476070
movq 0x80(%rax), %rax
movq %rax, 0x29084f(%rip) # 0x2bc050
jmp 0x2b803
leaq 0x44aba6(%rip), %rdi # 0x4763b0
callq 0x2b9c0
movq -0x20(%rbp), %rax
cmpq $0x0, 0x80(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2b84f
movq -0x20(%rbp), %rax
movq 0x78(%rax), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rax
movq $-0x1, 0x88(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0xa0(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0xa8(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0xae(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq 0x1249c4(%rip), %rsi # 0x150291
movl $0x173, %edx # imm = 0x173
callq 0x2b950
movq -0x20(%rbp), %rdi
callq 0x2bad0
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0xac(%rax)
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x2b9c0
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq 0x44a9df(%rip), %rdi # 0x4762e8
leaq -0x20(%rbp), %rdx
callq 0xfca90
movl %eax, -0x14(%rbp)
jmp 0x2b917
cmpl $0x0, -0x14(%rbp)
je 0x2b932
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x2bbb0
movq $0x0, -0x8(%rbp)
jmp 0x2b940
jmp 0x2b934
jmp 0x2b936
jmp 0x2b938
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| trnman_new_trn:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
jmp short $+2
loc_2B61E:
lea rdi, LOCK_trn_list
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 128h
call inline_mysql_mutex_lock
mov rax, cs:pool
mov [rbp+var_28], rax
loc_2B641:
xor eax, eax
cmp [rbp+var_28], 0
mov [rbp+var_32], al
jz short loc_2B693
mov rax, [rbp+var_28]
mov rax, [rax+68h]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
lock cmpxchg cs:pool, rcx
mov rcx, rax
setz al
mov [rbp+var_41], al
mov [rbp+var_40], rcx
test al, 1
jnz short loc_2B683
mov rax, [rbp+var_40]
mov [rbp+var_28], rax
loc_2B683:
mov al, [rbp+var_41]
and al, 1
mov [rbp+var_31], al
mov al, [rbp+var_31]
xor al, 0FFh
mov [rbp+var_32], al
loc_2B693:
mov al, [rbp+var_32]
test al, 1
jnz short loc_2B69C
jmp short loc_2B69E
loc_2B69C:
jmp short loc_2B641
loc_2B69E:
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
cmp rax, 0
jnz loc_2B730
xor edi, edi
mov esi, 0B0h
mov edx, 30h ; '0'
call my_malloc
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2B704
jmp short $+2
loc_2B6E9:
jmp short $+2
loc_2B6EB:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock
mov [rbp+var_8], 0
jmp loc_2B940
loc_2B704:
mov eax, cs:trnman_allocated_transactions
add eax, 1
mov cs:trnman_allocated_transactions, eax
lea rax, key_TRN_state_lock
mov edi, [rax]
mov rsi, [rbp+var_20]
add rsi, 10h
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init
loc_2B730:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_20]
mov [rax+8], rcx
lea rdi, trid_to_trn
add rdi, 28h ; '('
call lf_pinbox_get_pins
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax], rcx
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jnz short loc_2B782
mov rdi, [rbp+var_20]
call trnman_free_trn
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock
mov [rbp+var_8], 0
jmp loc_2B940
loc_2B782:
mov eax, cs:trnman_active_transactions
add eax, 1
mov cs:trnman_active_transactions, eax
mov rax, cs:qword_476070
mov rcx, [rax+78h]
mov rax, [rbp+var_20]
mov [rax+80h], rcx
call new_trid
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+78h], rcx
mov rax, [rbp+var_20]
lea rcx, active_list_max
mov [rax+68h], rcx
mov rcx, cs:qword_476128
mov rax, [rbp+var_20]
mov [rax+70h], rcx
mov rax, [rbp+var_20]
mov rcx, [rbp+var_20]
mov rcx, [rcx+70h]
mov [rcx+68h], rax
mov cs:qword_476128, rax
mov rax, cs:qword_476070
mov rax, [rax+80h]
mov cs:trid_min_read_from, rax
jmp short $+2
loc_2B803:
lea rdi, LOCK_trn_list
call inline_mysql_mutex_unlock
mov rax, [rbp+var_20]
cmp qword ptr [rax+80h], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_2B84F
mov rax, [rbp+var_20]
mov rcx, [rax+78h]
add rcx, 1
mov rax, [rbp+var_20]
mov [rax+80h], rcx
loc_2B84F:
mov rax, [rbp+var_20]
mov qword ptr [rax+88h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_20]
mov qword ptr [rax+0A0h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+98h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+90h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+58h], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+60h], 0
mov rax, [rbp+var_20]
mov dword ptr [rax+0A8h], 0
mov rax, [rbp+var_20]
mov word ptr [rax+0AEh], 0
mov rdi, [rbp+var_20]
add rdi, 10h
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 173h
call inline_mysql_mutex_lock
mov rdi, [rbp+var_20]
call get_short_trid
mov cx, ax
mov rax, [rbp+var_20]
mov [rax+0ACh], cx
mov rdi, [rbp+var_20]
add rdi, 10h
call inline_mysql_mutex_unlock
mov rax, [rbp+var_20]
mov rsi, [rax]
lea rdi, trid_to_trn
lea rdx, [rbp+var_20]
call lf_hash_insert
mov [rbp+var_14], eax
jmp short $+2
loc_2B917:
cmp [rbp+var_14], 0
jz short loc_2B932
mov rdi, [rbp+var_20]
xor esi, esi
call trnman_end_trn
mov [rbp+var_8], 0
jmp short loc_2B940
loc_2B932:
jmp short $+2
loc_2B934:
jmp short $+2
loc_2B936:
jmp short $+2
loc_2B938:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_2B940:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long trnman_new_trn(long long a1)
{
signed long long v1; // rcx
long long v2; // rax
bool v4; // [rsp+Fh] [rbp-41h]
char v5; // [rsp+1Eh] [rbp-32h]
signed long long v6; // [rsp+28h] [rbp-28h]
long long v7; // [rsp+30h] [rbp-20h] BYREF
long long v9; // [rsp+40h] [rbp-10h]
v9 = a1;
inline_mysql_mutex_lock(&LOCK_trn_list, "/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 296LL);
v6 = pool;
do
{
v5 = 0;
if ( v6 )
{
v1 = _InterlockedCompareExchange64(&pool, *(_QWORD *)(v6 + 104), v6);
v4 = v6 == v1;
if ( v6 != v1 )
v6 = v1;
v5 = ~v4;
}
}
while ( (v5 & 1) != 0 );
v7 = v6;
if ( !v6 )
{
v7 = my_malloc(0LL, 176LL, 48LL);
if ( !v7 )
{
inline_mysql_mutex_unlock(&LOCK_trn_list);
return 0LL;
}
++trnman_allocated_transactions;
inline_mysql_mutex_init(key_TRN_state_lock, (_QWORD *)(v7 + 16), (long long)&my_fast_mutexattr);
}
*(_QWORD *)(v7 + 8) = v9;
*(_QWORD *)v7 = lf_pinbox_get_pins((char *)&trid_to_trn + 40);
if ( *(_QWORD *)v7 )
{
++trnman_active_transactions;
*(_QWORD *)(v7 + 128) = *(_QWORD *)(qword_476070 + 120);
*(_QWORD *)(v7 + 120) = new_trid();
*(_QWORD *)(v7 + 104) = &active_list_max;
*(_QWORD *)(v7 + 112) = qword_476128;
v2 = v7;
*(_QWORD *)(*(_QWORD *)(v7 + 112) + 104LL) = v7;
qword_476128 = v2;
trid_min_read_from = *(_QWORD *)(qword_476070 + 128);
inline_mysql_mutex_unlock(&LOCK_trn_list);
if ( !*(_QWORD *)(v7 + 128) )
*(_QWORD *)(v7 + 128) = *(_QWORD *)(v7 + 120) + 1LL;
*(_QWORD *)(v7 + 136) = -1LL;
*(_QWORD *)(v7 + 160) = 0LL;
*(_QWORD *)(v7 + 152) = 0LL;
*(_QWORD *)(v7 + 144) = 0LL;
*(_QWORD *)(v7 + 88) = 0LL;
*(_QWORD *)(v7 + 96) = 0LL;
*(_DWORD *)(v7 + 168) = 0;
*(_WORD *)(v7 + 174) = 0;
inline_mysql_mutex_lock(v7 + 16, "/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c", 371LL);
*(_WORD *)(v7 + 172) = get_short_trid(v7);
inline_mysql_mutex_unlock(v7 + 16);
if ( (unsigned int)lf_hash_insert(&trid_to_trn, *(_QWORD *)v7, &v7) )
{
trnman_end_trn(v7, 0LL);
return 0LL;
}
else
{
return v7;
}
}
else
{
trnman_free_trn(v7);
inline_mysql_mutex_unlock(&LOCK_trn_list);
return 0LL;
}
}
| trnman_new_trn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
JMP 0x0012b61e
LAB_0012b61e:
LEA RDI,[0x5763b0]
LEA RSI,[0x250291]
MOV EDX,0x128
CALL 0x0012b950
MOV RAX,qword ptr [0x005762d8]
MOV qword ptr [RBP + -0x28],RAX
LAB_0012b641:
XOR EAX,EAX
CMP qword ptr [RBP + -0x28],0x0
MOV byte ptr [RBP + -0x32],AL
JZ 0x0012b693
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x68]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CMPXCHG.LOCK qword ptr [0x005762d8],RCX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x41],AL
MOV qword ptr [RBP + -0x40],RCX
TEST AL,0x1
JNZ 0x0012b683
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x28],RAX
LAB_0012b683:
MOV AL,byte ptr [RBP + -0x41]
AND AL,0x1
MOV byte ptr [RBP + -0x31],AL
MOV AL,byte ptr [RBP + -0x31]
XOR AL,0xff
MOV byte ptr [RBP + -0x32],AL
LAB_0012b693:
MOV AL,byte ptr [RBP + -0x32]
TEST AL,0x1
JNZ 0x0012b69c
JMP 0x0012b69e
LAB_0012b69c:
JMP 0x0012b641
LAB_0012b69e:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0012b730
XOR EDI,EDI
MOV ESI,0xb0
MOV EDX,0x30
CALL 0x001f2e30
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012b704
JMP 0x0012b6e9
LAB_0012b6e9:
JMP 0x0012b6eb
LAB_0012b6eb:
LEA RDI,[0x5763b0]
CALL 0x0012b9c0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012b940
LAB_0012b704:
MOV EAX,dword ptr [0x005762d0]
ADD EAX,0x1
MOV dword ptr [0x005762d0],EAX
LEA RAX,[0x576a44]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x10
LEA RDX,[0xd81fc0]
CALL 0x0012b490
LAB_0012b730:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
LEA RDI,[0x5762e8]
ADD RDI,0x28
CALL 0x001fb700
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JNZ 0x0012b782
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012ba20
LEA RDI,[0x5763b0]
CALL 0x0012b9c0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012b940
LAB_0012b782:
MOV EAX,dword ptr [0x005762c8]
ADD EAX,0x1
MOV dword ptr [0x005762c8],EAX
MOV RAX,qword ptr [0x00576070]
MOV RCX,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x80],RCX
CALL 0x0012ca60
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x78],RCX
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x5760b8]
MOV qword ptr [RAX + 0x68],RCX
MOV RCX,qword ptr [0x00576128]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RCX + 0x70]
MOV qword ptr [RCX + 0x68],RAX
MOV qword ptr [0x00576128],RAX
MOV RAX,qword ptr [0x00576070]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [0x003bc050],RAX
JMP 0x0012b803
LAB_0012b803:
LEA RDI,[0x5763b0]
CALL 0x0012b9c0
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x80],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0012b84f
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x78]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x80],RCX
LAB_0012b84f:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x88],-0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0xa0],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x98],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x60],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0xa8],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX + 0xae],0x0
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x10
LEA RSI,[0x250291]
MOV EDX,0x173
CALL 0x0012b950
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0012bad0
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x20]
MOV word ptr [RAX + 0xac],CX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x10
CALL 0x0012b9c0
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x5762e8]
LEA RDX,[RBP + -0x20]
CALL 0x001fca90
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0012b917
LAB_0012b917:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x0012b932
MOV RDI,qword ptr [RBP + -0x20]
XOR ESI,ESI
CALL 0x0012bbb0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0012b940
LAB_0012b932:
JMP 0x0012b934
LAB_0012b934:
JMP 0x0012b936
LAB_0012b936:
JMP 0x0012b938
LAB_0012b938:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0012b940:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
long * trnman_new_trn(long param_1)
{
long *plVar1;
int2 uVar2;
long *plVar3;
long lVar4;
bool bVar5;
long *local_30;
long *local_28;
int local_1c;
long local_18;
long *local_10;
local_18 = param_1;
inline_mysql_mutex_lock
(LOCK_trn_list,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x128);
local_30 = pool;
do {
bVar5 = false;
if (local_30 != (long *)0x0) {
LOCK();
bVar5 = local_30 != pool;
plVar3 = local_30;
plVar1 = (long *)local_30[0xd];
if (bVar5) {
plVar3 = pool;
plVar1 = pool;
}
pool = plVar1;
UNLOCK();
if (bVar5) {
local_30 = plVar3;
}
}
} while (bVar5);
local_28 = local_30;
if (local_30 == (long *)0x0) {
local_28 = (long *)my_malloc(0,0xb0,0x30);
if (local_28 == (long *)0x0) {
inline_mysql_mutex_unlock(LOCK_trn_list);
return (long *)0x0;
}
trnman_allocated_transactions = trnman_allocated_transactions + 1;
inline_mysql_mutex_init(key_TRN_state_lock,local_28 + 2,&my_fast_mutexattr);
}
local_28[1] = local_18;
lVar4 = lf_pinbox_get_pins(0x576310);
*local_28 = lVar4;
if (*local_28 == 0) {
trnman_free_trn(local_28);
inline_mysql_mutex_unlock(LOCK_trn_list);
local_10 = (long *)0x0;
}
else {
trnman_active_transactions = trnman_active_transactions + 1;
local_28[0x10] = *(long *)(active_list_min._104_8_ + 0x78);
lVar4 = new_trid();
local_28[0xf] = lVar4;
local_28[0xd] = (long)active_list_max;
local_28[0xe] = active_list_max._112_8_;
*(long **)(local_28[0xe] + 0x68) = local_28;
active_list_max._112_8_ = local_28;
trid_min_read_from = *(int8 *)(active_list_min._104_8_ + 0x80);
inline_mysql_mutex_unlock(LOCK_trn_list);
if (local_28[0x10] == 0) {
local_28[0x10] = local_28[0xf] + 1;
}
local_28[0x11] = -1;
local_28[0x14] = 0;
local_28[0x13] = 0;
local_28[0x12] = 0;
local_28[0xb] = 0;
local_28[0xc] = 0;
*(int4 *)(local_28 + 0x15) = 0;
*(int2 *)((long)local_28 + 0xae) = 0;
inline_mysql_mutex_lock
(local_28 + 2,"/workspace/llm4binary/github2025/eloqsql/storage/maria/trnman.c",0x173)
;
uVar2 = get_short_trid(local_28);
*(int2 *)((long)local_28 + 0xac) = uVar2;
inline_mysql_mutex_unlock(local_28 + 2);
local_1c = lf_hash_insert(trid_to_trn,*local_28,&local_28);
if (local_1c == 0) {
local_10 = local_28;
}
else {
trnman_end_trn(local_28,0);
local_10 = (long *)0x0;
}
}
return local_10;
}
| |
24,580 | stbi_loadf | monkey531[P]llama/examples/llava/../../common/stb_image.h | STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
float *result;
FILE *f = stbi__fopen(filename, "rb");
if (!f) return stbi__errpf("can't fopen", "Unable to open file");
result = stbi_loadf_from_file(f,x,y,comp,req_comp);
fclose(f);
return result;
} | O0 | c | stbi_loadf:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1dbacc(%rip), %rsi # 0x252625
callq 0x75990
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x76b89
leaq 0x1d870e(%rip), %rdi # 0x24f280
callq 0x759c0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
movq %rax, 0x40(%rsp)
jmp 0x76bc0
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0x1c(%rsp), %r8d
callq 0x76bd0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x619d0
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| stbi_loadf:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_20], rdx
mov [rsp+48h+var_28], rcx
mov [rsp+48h+var_2C], r8d
mov rdi, [rsp+48h+var_10]; char *
lea rsi, aCrb+2; char *
call _ZL11stbi__fopenPKcS0_; stbi__fopen(char const*,char const*)
mov [rsp+48h+var_40], rax
cmp [rsp+48h+var_40], 0
jnz short loc_76B89
lea rdi, aCanTFopen; "can't fopen"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov ecx, eax
xor eax, eax
cmp ecx, 0
cmovnz rax, rax
mov [rsp+48h+var_8], rax
jmp short loc_76BC0
loc_76B89:
mov rdi, [rsp+48h+var_40]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_20]
mov rcx, [rsp+48h+var_28]
mov r8d, [rsp+48h+var_2C]
call stbi_loadf_from_file
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_40]
call _fclose
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_8], rax
loc_76BC0:
mov rax, [rsp+48h+var_8]
add rsp, 48h
retn
| long long stbi_loadf(const char *a1, long long a2, long long a3, long long a4, unsigned int a5)
{
long long v6; // [rsp+8h] [rbp-40h]
long long v7; // [rsp+10h] [rbp-38h]
v6 = stbi__fopen(a1, "rb");
if ( v6 )
{
v7 = stbi_loadf_from_file(v6, a2, a3, a4, a5);
fclose(v6);
return v7;
}
else
{
stbi__err("can't fopen");
return 0LL;
}
}
| stbi_loadf:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x28],RDX
MOV qword ptr [RSP + 0x20],RCX
MOV dword ptr [RSP + 0x1c],R8D
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[0x352625]
CALL 0x00175990
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00176b89
LEA RDI,[0x34f280]
CALL 0x001759c0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ RAX,RAX
MOV qword ptr [RSP + 0x40],RAX
JMP 0x00176bc0
LAB_00176b89:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x20]
MOV R8D,dword ptr [RSP + 0x1c]
CALL 0x00176bd0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001619d0
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x40],RAX
LAB_00176bc0:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int8
stbi_loadf(char *param_1,int8 param_2,int8 param_3,int8 param_4,int4 param_5
)
{
FILE *__stream;
int8 local_8;
__stream = (FILE *)stbi__fopen(param_1,"rb");
if (__stream == (FILE *)0x0) {
stbi__err("can\'t fopen");
local_8 = 0;
}
else {
local_8 = stbi_loadf_from_file(__stream,param_2,param_3,param_4,param_5);
fclose(__stream);
}
return local_8;
}
| |
24,581 | sort_locks | eloqsql/mysys/thr_lock.c | static void sort_locks(THR_LOCK_DATA **data,uint count)
{
THR_LOCK_DATA **pos,**end,**prev,*tmp;
/* Sort locks with insertion sort (fast because almost always few locks) */
for (pos=data+1,end=data+count; pos < end ; pos++)
{
tmp= *pos;
if (LOCK_CMP(tmp,pos[-1]))
{
prev=pos;
do {
prev[0]=prev[-1];
} while (--prev != data && LOCK_CMP(tmp,prev[-1]));
prev[0]=tmp;
}
}
} | O0 | c | sort_locks:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x100029
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x8(%rax), %rsi
callq 0x101870
cmpl $0x0, %eax
je 0x100016
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $-0x8, %rcx
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x31(%rbp)
je 0x100004
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq -0x8(%rax), %rsi
callq 0x101870
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xfffc4
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x100018
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0xfff8d
addq $0x40, %rsp
popq %rbp
retq
nop
| sort_locks:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov rax, [rbp+var_8]
add rax, 8
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
shl rcx, 3
add rax, rcx
mov [rbp+var_20], rax
loc_FFF8D:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb loc_100029
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rax, [rbp+var_18]
mov rsi, [rax-8]
call LOCK_CMP
cmp eax, 0
jz short loc_100016
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
loc_FFFC4:
mov rax, [rbp+var_28]
mov rcx, [rax-8]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rcx, [rbp+var_28]
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_28], rcx
xor eax, eax
cmp rcx, [rbp+var_8]
mov [rbp+var_31], al
jz short loc_100004
mov rdi, [rbp+var_30]
mov rax, [rbp+var_28]
mov rsi, [rax-8]
call LOCK_CMP
cmp eax, 0
loc_FFFFE:
setnz al
mov [rbp+var_31], al
loc_100004:
mov al, [rbp+var_31]
test al, 1
jnz short loc_FFFC4
mov rcx, [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax], rcx
loc_100016:
jmp short $+2
loc_100018:
mov rax, [rbp+var_18]
add rax, 8
loc_100020:
mov [rbp+var_18], rax
jmp loc_FFF8D
loc_100029:
add rsp, 40h
pop rbp
retn
| _QWORD * sort_locks(_QWORD *a1, int a2)
{
_QWORD *result; // rax
bool v3; // [rsp+Fh] [rbp-31h]
long long v4; // [rsp+10h] [rbp-30h]
_QWORD *v5; // [rsp+18h] [rbp-28h]
_QWORD *i; // [rsp+28h] [rbp-18h]
for ( i = a1 + 1; ; ++i )
{
result = i;
if ( i >= &a1[a2] )
break;
v4 = *i;
if ( (unsigned int)LOCK_CMP(*i, *(i - 1)) )
{
v5 = i;
do
{
*v5 = *(v5 - 1);
--v5;
v3 = 0;
if ( v5 != a1 )
v3 = (unsigned int)LOCK_CMP(v4, *(v5 - 1)) != 0;
}
while ( v3 );
*v5 = v4;
}
}
return result;
}
| sort_locks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x8
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001fff8d:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00200029
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + -0x8]
CALL 0x00201870
CMP EAX,0x0
JZ 0x00200016
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
LAB_001fffc4:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,-0x8
MOV qword ptr [RBP + -0x28],RCX
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RBP + -0x31],AL
JZ 0x00200004
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RAX + -0x8]
CALL 0x00201870
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_00200004:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x001fffc4
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
LAB_00200016:
JMP 0x00200018
LAB_00200018:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001fff8d
LAB_00200029:
ADD RSP,0x40
POP RBP
RET
|
void sort_locks(int8 *param_1,uint param_2)
{
int8 uVar1;
int iVar2;
int8 *puVar3;
bool bVar4;
int8 *local_30;
int8 *local_20;
for (local_20 = param_1 + 1; local_20 < param_1 + param_2; local_20 = local_20 + 1) {
uVar1 = *local_20;
iVar2 = LOCK_CMP(uVar1,local_20[-1]);
if (iVar2 != 0) {
local_30 = local_20;
do {
*local_30 = local_30[-1];
puVar3 = local_30 + -1;
bVar4 = false;
if (puVar3 != param_1) {
iVar2 = LOCK_CMP(uVar1,local_30[-2]);
bVar4 = iVar2 != 0;
}
local_30 = puVar3;
} while (bVar4);
*puVar3 = uVar1;
}
}
return;
}
| |
24,582 | sort_locks | eloqsql/mysys/thr_lock.c | static void sort_locks(THR_LOCK_DATA **data,uint count)
{
THR_LOCK_DATA **pos,**end,**prev,*tmp;
/* Sort locks with insertion sort (fast because almost always few locks) */
for (pos=data+1,end=data+count; pos < end ; pos++)
{
tmp= *pos;
if (LOCK_CMP(tmp,pos[-1]))
{
prev=pos;
do {
prev[0]=prev[-1];
} while (--prev != data && LOCK_CMP(tmp,prev[-1]));
prev[0]=tmp;
}
}
} | O3 | c | sort_locks:
cmpl $0x2, %esi
jb 0xa94fb
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
leaq (%rdi,%rax,8), %rax
leaq 0x8(%rdi), %rsi
xorl %ecx, %ecx
movq %rdi, %rdx
movq %rdx, %r8
movq %rsi, %rdx
movq (%r8), %r9
movq 0x8(%r8), %rsi
movq 0x18(%r9), %r10
cmpq %r10, 0x18(%rsi)
jne 0xa947c
movl 0x40(%r9), %r10d
cmpl %r10d, 0x40(%rsi)
jne 0xa94d8
movl 0x48(%rsi), %r10d
cmpl 0x48(%r9), %r10d
jae 0xa94e2
leaq -0x8(%rdx), %r9
movq -0x8(%rdx), %r10
movq %r10, 0x8(%r8)
movq %rdi, %r8
cmpq %rdi, %r9
je 0xa94df
movq %rcx, %r8
movq -0x8(%rdi,%r8), %r10
movq 0x18(%r10), %r11
cmpq %r11, 0x18(%rsi)
je 0xa94a8
jb 0xa94c0
jmp 0xa94dc
movl 0x40(%r10), %r11d
cmpl %r11d, 0x40(%rsi)
jne 0xa94be
movl 0x48(%rsi), %r11d
cmpl 0x48(%r10), %r11d
jb 0xa94c0
jmp 0xa94dc
jle 0xa94f5
addq $-0x8, %r9
movq -0x8(%rdi,%r8), %r10
movq %r10, (%rdi,%r8)
addq $-0x8, %r8
jne 0xa9495
movq %rdi, %r8
jmp 0xa94df
jg 0xa947e
jmp 0xa94e2
movq %r9, %r8
movq %rsi, (%r8)
leaq 0x8(%rdx), %rsi
addq $0x8, %rcx
cmpq %rax, %rsi
jb 0xa9453
jmp 0xa94fa
addq %rdi, %r8
jmp 0xa94df
popq %rbp
retq
| sort_locks:
cmp esi, 2
jb locret_A94FB
push rbp
mov rbp, rsp
mov eax, esi
lea rax, [rdi+rax*8]
lea rsi, [rdi+8]
xor ecx, ecx
mov rdx, rdi
loc_A9453:
mov r8, rdx
mov rdx, rsi
mov r9, [r8]
mov rsi, [r8+8]
mov r10, [r9+18h]
cmp [rsi+18h], r10
jnz short loc_A947C
mov r10d, [r9+40h]
cmp [rsi+40h], r10d
jnz short loc_A94D8
mov r10d, [rsi+48h]
cmp r10d, [r9+48h]
loc_A947C:
jnb short loc_A94E2
loc_A947E:
lea r9, [rdx-8]
mov r10, [rdx-8]
mov [r8+8], r10
mov r8, rdi
cmp r9, rdi
jz short loc_A94DF
mov r8, rcx
loc_A9495:
mov r10, [rdi+r8-8]
mov r11, [r10+18h]
cmp [rsi+18h], r11
jz short loc_A94A8
jb short loc_A94C0
jmp short loc_A94DC
loc_A94A8:
mov r11d, [r10+40h]
cmp [rsi+40h], r11d
jnz short loc_A94BE
mov r11d, [rsi+48h]
cmp r11d, [r10+48h]
jb short loc_A94C0
jmp short loc_A94DC
loc_A94BE:
jle short loc_A94F5
loc_A94C0:
add r9, 0FFFFFFFFFFFFFFF8h
mov r10, [rdi+r8-8]
mov [rdi+r8], r10
add r8, 0FFFFFFFFFFFFFFF8h
jnz short loc_A9495
mov r8, rdi
jmp short loc_A94DF
loc_A94D8:
jg short loc_A947E
jmp short loc_A94E2
loc_A94DC:
mov r8, r9
loc_A94DF:
mov [r8], rsi
loc_A94E2:
lea rsi, [rdx+8]
add rcx, 8
cmp rsi, rax
jb loc_A9453
jmp short loc_A94FA
loc_A94F5:
add r8, rdi
jmp short loc_A94DF
loc_A94FA:
pop rbp
locret_A94FB:
retn
| void sort_locks(_QWORD *a1, unsigned int a2)
{
unsigned long long v2; // rax
_QWORD *v3; // rsi
long long v4; // rcx
_QWORD *v5; // rdx
_QWORD *v6; // r8
long long v7; // r9
long long v8; // rsi
unsigned long long v9; // r10
bool v10; // cf
int v11; // r10d
_QWORD *v12; // r9
_QWORD *v13; // r8
long long v14; // r8
long long v15; // r10
unsigned long long v16; // r11
int v17; // r11d
if ( a2 < 2 )
return;
v2 = (unsigned long long)&a1[a2];
v3 = a1 + 1;
v4 = 0LL;
v5 = a1;
do
{
v6 = v5;
v5 = v3;
v7 = *v6;
v8 = v6[1];
v9 = *(_QWORD *)(*v6 + 24LL);
v10 = *(_QWORD *)(v8 + 24) < v9;
if ( *(_QWORD *)(v8 + 24) == v9 )
{
v11 = *(_DWORD *)(v7 + 64);
if ( *(_DWORD *)(v8 + 64) != v11 )
{
if ( *(_DWORD *)(v8 + 64) <= v11 )
goto LABEL_22;
goto LABEL_7;
}
v10 = *(_DWORD *)(v8 + 72) < *(_DWORD *)(v7 + 72);
}
if ( !v10 )
goto LABEL_22;
LABEL_7:
v12 = v5 - 1;
v6[1] = *(v5 - 1);
v13 = a1;
if ( v5 - 1 == a1 )
goto LABEL_21;
v14 = v4;
while ( 1 )
{
v15 = *(_QWORD *)((char *)a1 + v14 - 8);
v16 = *(_QWORD *)(v15 + 24);
if ( *(_QWORD *)(v8 + 24) != v16 )
{
if ( *(_QWORD *)(v8 + 24) >= v16 )
goto LABEL_20;
goto LABEL_16;
}
v17 = *(_DWORD *)(v15 + 64);
if ( *(_DWORD *)(v8 + 64) != v17 )
break;
if ( *(_DWORD *)(v8 + 72) >= *(_DWORD *)(v15 + 72) )
{
LABEL_20:
v13 = v12;
goto LABEL_21;
}
LABEL_16:
--v12;
*(_QWORD *)((char *)a1 + v14) = *(_QWORD *)((char *)a1 + v14 - 8);
v14 -= 8LL;
if ( !v14 )
{
v13 = a1;
goto LABEL_21;
}
}
if ( *(_DWORD *)(v8 + 64) > v17 )
goto LABEL_16;
v13 = (_QWORD *)((char *)a1 + v14);
LABEL_21:
*v13 = v8;
LABEL_22:
v3 = v5 + 1;
v4 += 8LL;
}
while ( (unsigned long long)(v5 + 1) < v2 );
}
| sort_locks:
CMP ESI,0x2
JC 0x001a94fb
PUSH RBP
MOV RBP,RSP
MOV EAX,ESI
LEA RAX,[RDI + RAX*0x8]
LEA RSI,[RDI + 0x8]
XOR ECX,ECX
MOV RDX,RDI
LAB_001a9453:
MOV R8,RDX
MOV RDX,RSI
MOV R9,qword ptr [R8]
MOV RSI,qword ptr [R8 + 0x8]
MOV R10,qword ptr [R9 + 0x18]
CMP qword ptr [RSI + 0x18],R10
JNZ 0x001a947c
MOV R10D,dword ptr [R9 + 0x40]
CMP dword ptr [RSI + 0x40],R10D
JNZ 0x001a94d8
MOV R10D,dword ptr [RSI + 0x48]
CMP R10D,dword ptr [R9 + 0x48]
LAB_001a947c:
JNC 0x001a94e2
LAB_001a947e:
LEA R9,[RDX + -0x8]
MOV R10,qword ptr [RDX + -0x8]
MOV qword ptr [R8 + 0x8],R10
MOV R8,RDI
CMP R9,RDI
JZ 0x001a94df
MOV R8,RCX
LAB_001a9495:
MOV R10,qword ptr [RDI + R8*0x1 + -0x8]
MOV R11,qword ptr [R10 + 0x18]
CMP qword ptr [RSI + 0x18],R11
JZ 0x001a94a8
JC 0x001a94c0
JMP 0x001a94dc
LAB_001a94a8:
MOV R11D,dword ptr [R10 + 0x40]
CMP dword ptr [RSI + 0x40],R11D
JNZ 0x001a94be
MOV R11D,dword ptr [RSI + 0x48]
CMP R11D,dword ptr [R10 + 0x48]
JC 0x001a94c0
JMP 0x001a94dc
LAB_001a94be:
JLE 0x001a94f5
LAB_001a94c0:
ADD R9,-0x8
MOV R10,qword ptr [RDI + R8*0x1 + -0x8]
MOV qword ptr [RDI + R8*0x1],R10
ADD R8,-0x8
JNZ 0x001a9495
MOV R8,RDI
JMP 0x001a94df
LAB_001a94d8:
JG 0x001a947e
JMP 0x001a94e2
LAB_001a94dc:
MOV R8,R9
LAB_001a94df:
MOV qword ptr [R8],RSI
LAB_001a94e2:
LEA RSI,[RDX + 0x8]
ADD RCX,0x8
CMP RSI,RAX
JC 0x001a9453
JMP 0x001a94fa
LAB_001a94f5:
ADD R8,RDI
JMP 0x001a94df
LAB_001a94fa:
POP RBP
LAB_001a94fb:
RET
|
void sort_locks(long *param_1,uint param_2)
{
long lVar1;
long lVar2;
long lVar3;
long *plVar4;
long *plVar5;
long lVar6;
long *plVar7;
bool bVar8;
if (1 < param_2) {
lVar3 = 0;
plVar4 = param_1;
plVar5 = param_1 + 1;
do {
lVar6 = *plVar4;
lVar1 = plVar4[1];
bVar8 = *(ulong *)(lVar1 + 0x18) < *(ulong *)(lVar6 + 0x18);
if (*(ulong *)(lVar1 + 0x18) == *(ulong *)(lVar6 + 0x18)) {
if (*(int *)(lVar1 + 0x40) == *(int *)(lVar6 + 0x40)) {
bVar8 = *(uint *)(lVar1 + 0x48) < *(uint *)(lVar6 + 0x48);
goto LAB_001a947c;
}
if (*(int *)(lVar6 + 0x40) < *(int *)(lVar1 + 0x40)) goto LAB_001a947e;
}
else {
LAB_001a947c:
if (bVar8) {
LAB_001a947e:
plVar7 = plVar5 + -1;
plVar4[1] = plVar5[-1];
plVar4 = param_1;
lVar6 = lVar3;
if (plVar7 != param_1) {
do {
lVar2 = *(long *)((long)param_1 + lVar6 + -8);
plVar4 = plVar7;
if (*(ulong *)(lVar1 + 0x18) == *(ulong *)(lVar2 + 0x18)) {
if (*(int *)(lVar1 + 0x40) == *(int *)(lVar2 + 0x40)) {
if (*(uint *)(lVar2 + 0x48) <= *(uint *)(lVar1 + 0x48)) break;
}
else if (*(int *)(lVar1 + 0x40) <= *(int *)(lVar2 + 0x40)) {
plVar4 = (long *)(lVar6 + (long)param_1);
break;
}
}
else if (*(ulong *)(lVar2 + 0x18) <= *(ulong *)(lVar1 + 0x18)) break;
plVar7 = plVar7 + -1;
*(int8 *)((long)param_1 + lVar6) = *(int8 *)((long)param_1 + lVar6 + -8);
lVar6 = lVar6 + -8;
plVar4 = param_1;
} while (lVar6 != 0);
}
*plVar4 = lVar1;
}
}
plVar7 = plVar5 + 1;
lVar3 = lVar3 + 8;
plVar4 = plVar5;
plVar5 = plVar7;
} while (plVar7 < param_1 + param_2);
}
return;
}
| |
24,583 | my_strntoll_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static longlong
my_strntoll_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative=0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register ulonglong cutoff;
register unsigned int cutlim;
register ulonglong res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr+l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0] = (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+=cnv;
} while (1);
bs:
overflow = 0;
res = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
do {
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+=cnv;
if ( wc>='0' && wc<='9')
wc -= '0';
else if ( wc>='A' && wc<='Z')
wc = wc - 'A' + 10;
else if ( wc>='a' && wc<='z')
wc = wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res *= (ulonglong) base;
res += wc;
}
}
else if (cnv==MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]=EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]=EDOM;
return 0L;
}
if (negative)
{
if (res > (ulonglong) LONGLONG_MIN)
overflow = 1;
}
else if (res > (ulonglong) LONGLONG_MAX)
overflow = 1;
if (overflow)
{
err[0]=ERANGE;
return negative ? LONGLONG_MIN : LONGLONG_MAX;
}
return (negative ? -((longlong)res) : (longlong)res);
} | O3 | c | my_strntoll_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r12
addq %rsi, %r13
movq %r9, -0x50(%rbp)
movl $0x0, (%r9)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0x4be56
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0x4be26
cmpq $0x9, %rcx
je 0x4be3e
cmpq $0x20, %rcx
je 0x4be3e
jmp 0x4be88
cmpq $0x2b, %rcx
je 0x4be3e
cmpq $0x2d, %rcx
jne 0x4be88
xorl %ecx, %ecx
cmpl $0x0, -0x34(%rbp)
sete %cl
movl %ecx, -0x34(%rbp)
movl %eax, %eax
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jg 0x4be0e
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x4be62
movq %r15, (%rcx)
testl %eax, %eax
movl $0x54, %eax
movl $0x21, %ecx
cmovel %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq -0x44(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
movq %rcx, -0x60(%rbp)
divq %rcx
movq %rdx, %rbx
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0x4bf69
movl %ebx, %ecx
movq %rcx, -0x68(%rbp)
xorl %ecx, %ecx
movq %r15, %rbx
xorl %r9d, %r9d
movq %rbx, %rsi
movl %eax, %ebx
addq %rsi, %rbx
movq -0x30(%rbp), %rsi
leaq -0x30(%rsi), %rax
cmpq $0x9, %rax
ja 0x4bee5
movq %rax, -0x30(%rbp)
jmp 0x4bf0a
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0x4bef5
addq $-0x37, %rsi
jmp 0x4bf03
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0x4bf7a
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x44(%rbp), %eax
jge 0x4bf7a
movl $0x1, %esi
cmpq -0x58(%rbp), %rcx
jbe 0x4bf1f
movq %rcx, %rdi
jmp 0x4bf39
jne 0x4bf2b
movq -0x58(%rbp), %rdi
cmpq -0x68(%rbp), %rax
ja 0x4bf39
imulq -0x60(%rbp), %rcx
addq %rcx, %rax
movl %r9d, %esi
movq %rax, %rdi
movq %rdi, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *%r12
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rdi, %rcx
movl %esi, %r9d
testl %eax, %eax
jg 0x4bec9
jmp 0x4bf70
xorl %edi, %edi
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0x4bfe3
movl %esi, %r9d
movq %rdi, %rcx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x4bf86
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0x4bfd4
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
cmpq %rsi, %rcx
movl $0x1, %eax
movl %r9d, %edi
cmoval %eax, %edi
testq %rcx, %rcx
cmovsl %eax, %r9d
movl -0x34(%rbp), %r8d
testl %r8d, %r8d
cmovnel %edi, %r9d
testl %r9d, %r9d
je 0x4bffe
leaq -0x1(%rsi), %rax
testl %r8d, %r8d
movq -0x50(%rbp), %rcx
movl $0x22, (%rcx)
cmovneq %rsi, %rax
jmp 0x4be79
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0x4be77
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x4bfef
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0x4be77
movq %rcx, %rax
negq %rax
testl %r8d, %r8d
cmoveq %rcx, %rax
jmp 0x4be79
| my_strntoll_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_40], r8
mov [rbp+var_44], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi+0B8h]
mov r12, [rax+28h]
add r13, rsi
mov [rbp+var_50], r9
mov dword ptr [r9], 0
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle short loc_4BE56
mov [rbp+var_34], 0
lea rbx, [rbp+var_30]
loc_4BE0E:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_4BE26
cmp rcx, 9
jz short loc_4BE3E
cmp rcx, 20h ; ' '
jz short loc_4BE3E
jmp short loc_4BE88
loc_4BE26:
cmp rcx, 2Bh ; '+'
jz short loc_4BE3E
cmp rcx, 2Dh ; '-'
jnz short loc_4BE88
xor ecx, ecx
cmp [rbp+var_34], 0
setz cl
mov [rbp+var_34], ecx
loc_4BE3E:
mov eax, eax
add r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jg short loc_4BE0E
loc_4BE56:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_4BE62
mov [rcx], r15
loc_4BE62:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_4BE77:
xor eax, eax
loc_4BE79:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4BE88:
movsxd rcx, [rbp+var_44]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_60], rcx
div rcx
mov rbx, rdx
mov [rbp+var_58], rax
lea rsi, [rbp+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle loc_4BF69
mov ecx, ebx
mov [rbp+var_68], rcx
xor ecx, ecx
mov rbx, r15
xor r9d, r9d
loc_4BEC9:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_4BEE5
mov [rbp+var_30], rax
jmp short loc_4BF0A
loc_4BEE5:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_4BEF5
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_4BF03
loc_4BEF5:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_4BF7A
add rsi, 0FFFFFFFFFFFFFFA9h
loc_4BF03:
mov [rbp+var_30], rsi
mov rax, rsi
loc_4BF0A:
cmp eax, [rbp+var_44]
jge short loc_4BF7A
mov esi, 1
cmp rcx, [rbp+var_58]
jbe short loc_4BF1F
mov rdi, rcx
jmp short loc_4BF39
loc_4BF1F:
jnz short loc_4BF2B
mov rdi, [rbp+var_58]
cmp rax, [rbp+var_68]
ja short loc_4BF39
loc_4BF2B:
imul rcx, [rbp+var_60]
add rax, rcx
mov esi, r9d
mov rdi, rax
loc_4BF39:
mov [rbp+var_70], rdi
mov [rbp+var_78], rsi
mov rdi, r14
lea rsi, [rbp+var_30]
mov rdx, rbx
mov rcx, r13
call r12
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_78]
mov rcx, rdi
mov r9d, esi
test eax, eax
jg loc_4BEC9
jmp short loc_4BF70
loc_4BF69:
xor edi, edi
mov rbx, r15
xor esi, esi
loc_4BF70:
test eax, eax
jz short loc_4BFE3
mov r9d, esi
mov rcx, rdi
loc_4BF7A:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_4BF86
mov [rax], rbx
loc_4BF86:
cmp rbx, r15
jz short loc_4BFD4
mov rsi, 8000000000000000h
cmp rcx, rsi
mov eax, 1
mov edi, r9d
cmova edi, eax
test rcx, rcx
cmovs r9d, eax
mov r8d, [rbp+var_34]
test r8d, r8d
cmovnz r9d, edi
test r9d, r9d
jz short loc_4BFFE
lea rax, [rsi-1]
test r8d, r8d
mov rcx, [rbp+var_50]
mov dword ptr [rcx], 22h ; '"'
cmovnz rax, rsi
jmp loc_4BE79
loc_4BFD4:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_4BE77
loc_4BFE3:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_4BFEF
mov [rax], rbx
loc_4BFEF:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_4BE77
loc_4BFFE:
mov rax, rcx
neg rax
test r8d, r8d
cmovz rax, rcx
jmp loc_4BE79
| unsigned long long my_strntoll_mb2_or_mb4(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int *a6)
{
long long v6; // r15
long long ( *v8)(long long, _QWORD *, long long, long long); // r12
long long v9; // r13
int v10; // eax
int v11; // ecx
unsigned long long result; // rax
int v13; // eax
long long v14; // r8
long long v15; // rcx
long long v16; // rbx
long long v17; // r9
unsigned long long v18; // rax
long long v19; // rsi
unsigned int v20; // esi
unsigned long long v21; // rdi
int v22; // edi
unsigned long long v23; // [rsp+28h] [rbp-58h]
BOOL v27; // [rsp+4Ch] [rbp-34h]
_QWORD v28[6]; // [rsp+50h] [rbp-30h] BYREF
v6 = a2;
v8 = *(long long ( **)(long long, _QWORD *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v9 = a2 + a3;
*a6 = 0;
v10 = v8(a1, v28, a2, a2 + a3);
if ( v10 <= 0 )
{
LABEL_11:
if ( a5 )
*a5 = v6;
v11 = 33;
if ( !v10 )
v11 = 84;
*a6 = v11;
return 0LL;
}
v27 = 0;
while ( v28[0] > 42LL )
{
if ( v28[0] != 43LL )
{
if ( v28[0] != 45LL )
goto LABEL_17;
v27 = !v27;
}
LABEL_10:
v6 += (unsigned int)v10;
v10 = v8(a1, v28, v6, v9);
if ( v10 <= 0 )
goto LABEL_11;
}
if ( v28[0] == 9LL || v28[0] == 32LL )
goto LABEL_10;
LABEL_17:
v23 = 0xFFFFFFFFFFFFFFFFLL / a4;
v13 = v8(a1, v28, v6, v9);
if ( v13 <= 0 )
{
v21 = 0LL;
v16 = v6;
v20 = 0;
LABEL_35:
if ( v13 )
{
LODWORD(v17) = v20;
v15 = v21;
goto LABEL_37;
}
if ( a5 )
*a5 = v16;
*a6 = 84;
return 0LL;
}
v15 = 0LL;
v16 = v6;
v17 = 0LL;
while ( 1 )
{
v16 += (unsigned int)v13;
v18 = v28[0] - 48LL;
if ( (unsigned long long)(v28[0] - 48LL) > 9 )
{
if ( (unsigned long long)(v28[0] - 65LL) > 0x19 )
{
if ( (unsigned long long)(v28[0] - 97LL) > 0x19 )
break;
v19 = v28[0] - 87LL;
}
else
{
v19 = v28[0] - 55LL;
}
v28[0] = v19;
v18 = v19;
}
else
{
v28[0] -= 48LL;
}
if ( (int)v18 >= a4 )
break;
v20 = 1;
if ( v15 <= v23 )
{
if ( v15 != v23 || (v21 = 0xFFFFFFFFFFFFFFFFLL / a4, v18 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v20 = v17;
v21 = a4 * v15 + v18;
}
}
else
{
v21 = v15;
}
v13 = ((long long ( *)(long long, _QWORD *, long long, long long, long long, long long))v8)(
a1,
v28,
v16,
v9,
v14,
v17);
v15 = v21;
v17 = v20;
if ( v13 <= 0 )
goto LABEL_35;
}
LABEL_37:
if ( a5 )
*a5 = v16;
if ( v16 == v6 )
{
*a6 = 33;
return 0LL;
}
v22 = v17;
if ( (unsigned long long)v15 > 0x8000000000000000LL )
v22 = 1;
if ( v15 < 0 )
LODWORD(v17) = 1;
if ( v27 )
LODWORD(v17) = v22;
if ( (_DWORD)v17 )
{
result = 0x7FFFFFFFFFFFFFFFLL;
*a6 = 34;
if ( v27 )
return 0x8000000000000000LL;
}
else
{
result = -v15;
if ( !v27 )
return v15;
}
return result;
}
| my_strntoll_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R12,qword ptr [RAX + 0x28]
ADD R13,RSI
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [R9],0x0
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x0014be56
MOV dword ptr [RBP + -0x34],0x0
LEA RBX,[RBP + -0x30]
LAB_0014be0e:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x0014be26
CMP RCX,0x9
JZ 0x0014be3e
CMP RCX,0x20
JZ 0x0014be3e
JMP 0x0014be88
LAB_0014be26:
CMP RCX,0x2b
JZ 0x0014be3e
CMP RCX,0x2d
JNZ 0x0014be88
XOR ECX,ECX
CMP dword ptr [RBP + -0x34],0x0
SETZ CL
MOV dword ptr [RBP + -0x34],ECX
LAB_0014be3e:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x0014be0e
LAB_0014be56:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x0014be62
MOV qword ptr [RCX],R15
LAB_0014be62:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_0014be77:
XOR EAX,EAX
LAB_0014be79:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014be88:
MOVSXD RCX,dword ptr [RBP + -0x44]
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x60],RCX
DIV RCX
MOV RBX,RDX
MOV qword ptr [RBP + -0x58],RAX
LEA RSI,[RBP + -0x30]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x0014bf69
MOV ECX,EBX
MOV qword ptr [RBP + -0x68],RCX
XOR ECX,ECX
MOV RBX,R15
XOR R9D,R9D
LAB_0014bec9:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x0014bee5
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0014bf0a
LAB_0014bee5:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x0014bef5
ADD RSI,-0x37
JMP 0x0014bf03
LAB_0014bef5:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x0014bf7a
ADD RSI,-0x57
LAB_0014bf03:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_0014bf0a:
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x0014bf7a
MOV ESI,0x1
CMP RCX,qword ptr [RBP + -0x58]
JBE 0x0014bf1f
MOV RDI,RCX
JMP 0x0014bf39
LAB_0014bf1f:
JNZ 0x0014bf2b
MOV RDI,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JA 0x0014bf39
LAB_0014bf2b:
IMUL RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV ESI,R9D
MOV RDI,RAX
LAB_0014bf39:
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x78],RSI
MOV RDI,R14
LEA RSI,[RBP + -0x30]
MOV RDX,RBX
MOV RCX,R13
CALL R12
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
MOV RCX,RDI
MOV R9D,ESI
TEST EAX,EAX
JG 0x0014bec9
JMP 0x0014bf70
LAB_0014bf69:
XOR EDI,EDI
MOV RBX,R15
XOR ESI,ESI
LAB_0014bf70:
TEST EAX,EAX
JZ 0x0014bfe3
MOV R9D,ESI
MOV RCX,RDI
LAB_0014bf7a:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x0014bf86
MOV qword ptr [RAX],RBX
LAB_0014bf86:
CMP RBX,R15
JZ 0x0014bfd4
MOV RSI,-0x8000000000000000
CMP RCX,RSI
MOV EAX,0x1
MOV EDI,R9D
CMOVA EDI,EAX
TEST RCX,RCX
CMOVS R9D,EAX
MOV R8D,dword ptr [RBP + -0x34]
TEST R8D,R8D
CMOVNZ R9D,EDI
TEST R9D,R9D
JZ 0x0014bffe
LEA RAX,[RSI + -0x1]
TEST R8D,R8D
MOV RCX,qword ptr [RBP + -0x50]
MOV dword ptr [RCX],0x22
CMOVNZ RAX,RSI
JMP 0x0014be79
LAB_0014bfd4:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x0014be77
LAB_0014bfe3:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x0014bfef
MOV qword ptr [RAX],RBX
LAB_0014bfef:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x0014be77
LAB_0014bffe:
MOV RAX,RCX
NEG RAX
TEST R8D,R8D
CMOVZ RAX,RCX
JMP 0x0014be79
|
ulong my_strntoll_mb2_or_mb4
(long param_1,long param_2,long param_3,int param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
int1 auVar2 [16];
int1 auVar3 [16];
bool bVar4;
bool bVar5;
bool bVar6;
ulong uVar7;
uint uVar8;
ulong uVar9;
int4 uVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
ulong local_38;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
param_3 = param_3 + param_2;
*param_6 = 0;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
if (0 < (int)uVar8) {
bVar4 = false;
do {
if ((long)local_38 < 0x2b) {
if ((local_38 != 9) && (local_38 != 0x20)) {
LAB_0014be88:
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
auVar3 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar9 = SUB168(auVar3 / auVar2,0);
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
lVar12 = param_2;
if ((int)uVar8 < 1) {
uVar11 = 0;
bVar5 = false;
goto LAB_0014bf70;
}
uVar11 = 0;
bVar5 = false;
goto LAB_0014bec9;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_0014be88;
bVar4 = !bVar4;
}
param_2 = param_2 + (ulong)uVar8;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
} while (0 < (int)uVar8);
}
if (param_5 != (long *)0x0) {
*param_5 = param_2;
}
uVar10 = 0x21;
if (uVar8 == 0) {
uVar10 = 0x54;
}
*param_6 = uVar10;
return 0;
while( true ) {
if (param_4 <= (int)uVar13) goto LAB_0014bf7a;
uVar7 = uVar11;
bVar6 = true;
if ((uVar11 <= uVar9) &&
((uVar11 != uVar9 || (uVar7 = uVar9, uVar13 <= (SUB168(auVar3 % auVar2,0) & 0xffffffff))))) {
uVar7 = uVar13 + uVar11 * (long)param_4;
bVar6 = bVar5;
}
bVar5 = bVar6;
uVar11 = uVar7;
local_38 = uVar13;
uVar8 = (*pcVar1)(param_1,&local_38,lVar12,param_3);
if ((int)uVar8 < 1) break;
LAB_0014bec9:
lVar12 = (ulong)uVar8 + lVar12;
uVar13 = local_38 - 0x30;
if (9 < uVar13) {
if (local_38 - 0x41 < 0x1a) {
uVar13 = local_38 - 0x37;
}
else {
if (0x19 < local_38 - 0x61) goto LAB_0014bf7a;
uVar13 = local_38 - 0x57;
}
}
}
LAB_0014bf70:
if (uVar8 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
*param_6 = 0x54;
}
else {
LAB_0014bf7a:
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
if (lVar12 != param_2) {
bVar6 = bVar5;
if (0x8000000000000000 < uVar11) {
bVar6 = true;
}
if ((long)uVar11 < 0) {
bVar5 = true;
}
if (bVar4) {
bVar5 = bVar6;
}
if (!bVar5) {
if (!bVar4) {
return uVar11;
}
return -uVar11;
}
*param_6 = 0x22;
if (bVar4) {
return 0x8000000000000000;
}
return 0x7fffffffffffffff;
}
*param_6 = 0x21;
}
return 0;
}
| |
24,584 | ft_parse | eloqsql/storage/myisam/ft_parser.c | int ft_parse(TREE *wtree, uchar *doc, int doclen,
struct st_mysql_ftparser *parser,
MYSQL_FTPARSER_PARAM *param, MEM_ROOT *mem_root)
{
MY_FT_PARSER_PARAM my_param;
DBUG_ENTER("ft_parse");
DBUG_ASSERT(parser);
my_param.wtree= wtree;
my_param.mem_root= mem_root;
param->mysql_parse= ft_parse_internal;
param->mysql_add_word= ft_add_word;
param->mysql_ftparam= &my_param;
param->cs= wtree->custom_arg;
param->doc= (char*) doc;
param->length= doclen;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
DBUG_RETURN(parser->parse(param));
} | O3 | c | ft_parse:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x10(%rbp), %rax
movq %rdi, (%rax)
movq %r9, 0x8(%rax)
leaq 0x39(%rip), %r9 # 0x73d89
movq %r9, (%r8)
leaq 0xa6(%rip), %r9 # 0x73e00
movq %r9, 0x8(%r8)
movq %rax, 0x18(%r8)
movq 0x230(%rdi), %rax
movq %rax, 0x20(%r8)
movq %rsi, 0x28(%r8)
movl %edx, 0x30(%r8)
movl $0x0, 0x38(%r8)
movq %r8, %rdi
callq *0x8(%rcx)
addq $0x10, %rsp
popq %rbp
retq
| ft_parse:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rax, [rbp+var_10]
mov [rax], rdi
mov [rax+8], r9
lea r9, ft_parse_internal
mov [r8], r9
lea r9, ft_add_word
mov [r8+8], r9
mov [r8+18h], rax
mov rax, [rdi+230h]
mov [r8+20h], rax
mov [r8+28h], rsi
mov [r8+30h], edx
mov dword ptr [r8+38h], 0
mov rdi, r8
call qword ptr [rcx+8]
add rsp, 10h
pop rbp
retn
| long long ft_parse(long long a1, long long a2, int a3, long long a4, long long a5, long long a6)
{
_QWORD v7[2]; // [rsp+0h] [rbp-10h] BYREF
v7[0] = a1;
v7[1] = a6;
*(_QWORD *)a5 = ft_parse_internal;
*(_QWORD *)(a5 + 8) = ft_add_word;
*(_QWORD *)(a5 + 24) = v7;
*(_QWORD *)(a5 + 32) = *(_QWORD *)(a1 + 560);
*(_QWORD *)(a5 + 40) = a2;
*(_DWORD *)(a5 + 48) = a3;
*(_DWORD *)(a5 + 56) = 0;
return (*(long long ( **)(long long))(a4 + 8))(a5);
}
| ft_parse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RAX,[RBP + -0x10]
MOV qword ptr [RAX],RDI
MOV qword ptr [RAX + 0x8],R9
LEA R9,[0x173d89]
MOV qword ptr [R8],R9
LEA R9,[0x173e00]
MOV qword ptr [R8 + 0x8],R9
MOV qword ptr [R8 + 0x18],RAX
MOV RAX,qword ptr [RDI + 0x230]
MOV qword ptr [R8 + 0x20],RAX
MOV qword ptr [R8 + 0x28],RSI
MOV dword ptr [R8 + 0x30],EDX
MOV dword ptr [R8 + 0x38],0x0
MOV RDI,R8
CALL qword ptr [RCX + 0x8]
ADD RSP,0x10
POP RBP
RET
|
void ft_parse(long param_1,int8 param_2,int4 param_3,long param_4,int8 *param_5,
int8 param_6)
{
long local_18;
int8 local_10;
*param_5 = ft_parse_internal;
param_5[1] = ft_add_word;
param_5[3] = &local_18;
param_5[4] = *(int8 *)(param_1 + 0x230);
param_5[5] = param_2;
*(int4 *)(param_5 + 6) = param_3;
*(int4 *)(param_5 + 7) = 0;
local_18 = param_1;
local_10 = param_6;
(**(code **)(param_4 + 8))(param_5);
return;
}
| |
24,585 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [8], 0>(char const (&) [8]) | monkey531[P]llama/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O0 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [8], 0>(char const (&) [8]):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xa2790
movq %rax, 0x30(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa27c0
movq %rax, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xa27f0
testb $0x1, %al
jne 0x1b1f06
jmp 0x1b1f46
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xbb6f0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x1b1f60
testb $0x1, %al
jne 0x1b1f36
jmp 0x1b1f38
jmp 0x1b1f55
jmp 0x1b1f3a
leaq 0x30(%rsp), %rdi
callq 0xa2870
jmp 0x1b1ee2
movq 0x10(%rsp), %rdi
callq 0xa27c0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA17_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov rdi, [rsp+38h+var_10]
mov [rsp+38h+var_28], rdi
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; 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>>>::begin(void)
mov [rsp+38h+var_8], rax
loc_1B1EE2:
mov rdi, [rsp+38h+var_28]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; 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>>>::end(void)
mov [rsp+38h+var_20], rax
lea rdi, [rsp+38h+var_8]
lea rsi, [rsp+38h+var_20]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<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>> *,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>>>>(__gnu_cxx::__normal_iterator<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>> *,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>>>> const&,__gnu_cxx::__normal_iterator<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>> *,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>>>> const&)
test al, 1
jnz short loc_1B1F06
jmp short loc_1B1F46
loc_1B1F06:
mov rax, [rsp+38h+var_28]
add rax, 18h
mov [rsp+38h+var_30], rax
lea rdi, [rsp+38h+var_8]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<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>> *,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>>>>::operator->(void)
mov rdi, [rsp+38h+var_30]
mov rsi, rax
mov rdx, [rsp+38h+var_18]
call _ZNKSt8equal_toIvEclIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA17_KcEEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSD_OSE_
test al, 1
jnz short loc_1B1F36
jmp short loc_1B1F38
loc_1B1F36:
jmp short loc_1B1F55
loc_1B1F38:
jmp short $+2
loc_1B1F3A:
lea rdi, [rsp+38h+var_8]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<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>> *,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>>>>::operator++(void)
jmp short loc_1B1EE2
loc_1B1F46:
mov rdi, [rsp+38h+var_28]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; 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>>>::end(void)
mov [rsp+38h+var_8], rax
loc_1B1F55:
mov rax, [rsp+38h+var_8]
add rsp, 38h
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA17_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long a1,
long long a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-20h] BYREF
long long v5; // [rsp+20h] [rbp-18h]
long long v6; // [rsp+28h] [rbp-10h]
long long i; // [rsp+30h] [rbp-8h] BYREF
v6 = a1;
v5 = a2;
for ( 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>>>::begin(a1);
;
__gnu_cxx::__normal_iterator<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>> *,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>>>>::operator++(&i) )
{
v4 = 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>>>::end(a1);
if ( !__gnu_cxx::operator!=<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>> *,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>>>>(
(long long)&i,
(long long)&v4) )
break;
v2 = __gnu_cxx::__normal_iterator<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>> *,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>>>>::operator->((long long)&i);
if ( (std::equal_to<void>::operator()<std::string const&,char const(&)[17]>(a1 + 24, v2, v5) & 1) != 0 )
return i;
}
return 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>>>::end(a1);
}
| |||
24,586 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [8], 0>(char const (&) [8]) | monkey531[P]llama/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O2 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [8], 0>(char const (&) [8]):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x88189
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2300f
testb %al, %al
jne 0x88186
addq $0x30, %r14
jmp 0x88168
movq %r14, %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_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
push r15
push r14
push rbx
mov rbx, rsi
mov r15, rdi
mov r14, [rdi]
loc_88168:
mov rax, [r15+8]
cmp r14, rax
jz short loc_88189
mov rdi, r14
mov rsi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_88186
add r14, 30h ; '0'
jmp short loc_88168
loc_88186:
mov rax, r14
loc_88189:
pop rbx
pop r14
pop r15
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long *a1)
{
long long i; // r14
long long result; // rax
for ( i = *a1; ; i += 48LL )
{
result = a1[1];
if ( i == result )
break;
if ( std::operator==<char>(i) )
return i;
}
return result;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R14,qword ptr [RDI]
LAB_00188168:
MOV RAX,qword ptr [R15 + 0x8]
CMP R14,RAX
JZ 0x00188189
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012300f
TEST AL,AL
JNZ 0x00188186
ADD R14,0x30
JMP 0x00188168
LAB_00188186:
MOV RAX,R14
LAB_00188189:
POP RBX
POP R14
POP R15
RET
|
string * _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA21_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(int8 *param_1,char *param_2)
{
bool bVar1;
string *psVar2;
string *psVar3;
psVar3 = (string *)*param_1;
while ((psVar2 = (string *)param_1[1], psVar3 != (string *)param_1[1] &&
(bVar1 = std::operator==(psVar3,param_2), psVar2 = psVar3, !bVar1))) {
psVar3 = psVar3 + 0x30;
}
return psVar2;
}
| |
24,587 | 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(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, 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&) | llama.cpp/common/json.hpp | iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
// insert to array and return iterator
return insert_iterator(pos, val);
}
JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
} | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
cmpb $0x2, (%rsi)
jne 0x73d7a
movq (%rdx), %rsi
cmpq %r14, %rsi
jne 0x73dd6
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq %r14, %rsi
movq %rax, %rdx
callq 0x73e78
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1c460
movq %rax, %rbx
movq %r14, %rdi
callq 0x30fda
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x580f2(%rip), %rsi # 0xcbe90
movq %rsp, %rdi
callq 0x73eec
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x135, %esi # imm = 0x135
movq %r14, %rcx
callq 0x30d7e
xorl %ebp, %ebp
leaq 0x8a11b(%rip), %rsi # 0xfdee0
leaq -0x465c6(%rip), %rdx # 0x2d806
movq %rbx, %rdi
callq 0x1c7b0
jmp 0x73e30
movl $0x20, %edi
callq 0x1c460
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x530ab(%rip), %rsi # 0xc6e9e
leaq 0x530c7(%rip), %rdx # 0xc6ec1
movq %rsp, %rdi
callq 0x3fe82
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x30b7c
xorl %ebp, %ebp
leaq 0x8a07f(%rip), %rsi # 0xfdea0
leaq -0x46622(%rip), %rdx # 0x2d806
movq %rbx, %rdi
callq 0x1c7b0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x73e51
jmp 0x73e5e
jmp 0x73e65
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73e5e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x73e68
jmp 0x73e70
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
movq %r14, %rdi
callq 0x1c7d0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6insertENS0_6detail9iter_implIKSD_EERSG_:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 48h
mov r14, rsi
cmp byte ptr [rsi], 2
jnz short loc_73D7A
mov rsi, [rdx]
cmp rsi, r14
jnz loc_73DD6
mov rbx, rdi
lea rax, [rsp+68h+var_40]
mov [rax], rsi
movups xmm0, xmmword ptr [rdx+8]
movups xmmword ptr [rax+8], xmm0
mov rdx, [rdx+18h]
mov [rax+18h], rdx
mov rsi, r14
mov rdx, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_73D7A:
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)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseInser; "cannot use insert() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 135h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
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_73E30
loc_73DD6:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_73E30:
mov r14, rax
mov rdi, [rsp+68h+var_68]
cmp rdi, r15
jnz short loc_73E51
jmp short loc_73E5E
jmp short loc_73E65
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_73E5E
loc_73E51:
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_73E5E:
test bpl, bpl
jnz short loc_73E68
jmp short loc_73E70
loc_73E65:
mov r14, rax
loc_73E68:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_73E70:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::insert(
long long a1,
unsigned __int8 *a2,
long long a3)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v5; // rbx
_QWORD v6[2]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v7[3]; // [rsp+10h] [rbp-58h] BYREF
unsigned __int8 *v8; // [rsp+28h] [rbp-40h] BYREF
__int128 v9; // [rsp+30h] [rbp-38h]
long long v10; // [rsp+40h] [rbp-28h]
if ( *a2 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v7[2] = 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(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
v6,
"cannot use insert() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
309,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( *(unsigned __int8 **)a3 != a2 )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v6[0] = v7;
std::string::_M_construct<char const*>((long long)v6, "iterator does not fit current value", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v5,
202,
v6);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v8 = *(unsigned __int8 **)a3;
v9 = *(_OWORD *)(a3 + 8);
v10 = *(_QWORD *)(a3 + 24);
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_iterator<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&>(
a1,
a2,
&v8);
return a1;
}
| insert:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
CMP byte ptr [RSI],0x2
JNZ 0x00173d7a
MOV RSI,qword ptr [RDX]
CMP RSI,R14
JNZ 0x00173dd6
MOV RBX,RDI
LEA RAX,[RSP + 0x28]
MOV qword ptr [RAX],RSI
MOVUPS XMM0,xmmword ptr [RDX + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + 0x18],RDX
MOV RSI,R14
MOV RDX,RAX
CALL 0x00173e78
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00173d7a:
MOV EDI,0x20
CALL 0x0011c460
MOV RBX,RAX
MOV RDI,R14
CALL 0x00130fda
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_00173d97:
LEA RSI,[0x1cbe90]
MOV RDI,RSP
CALL 0x00173eec
MOV BPL,0x1
LAB_00173da9:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x135
MOV RCX,R14
CALL 0x00130d7e
XOR EBP,EBP
LEA RSI,[0x1fdee0]
LEA RDX,[0x12d806]
MOV RDI,RBX
CALL 0x0011c7b0
LAB_00173dd6:
MOV EDI,0x20
CALL 0x0011c460
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_00173dec:
LEA RSI,[0x1c6e9e]
LEA RDX,[0x1c6ec1]
MOV RDI,RSP
CALL 0x0013fe82
MOV BPL,0x1
LAB_00173e05:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x00130b7c
XOR EBP,EBP
LEA RSI,[0x1fdea0]
LEA RDX,[0x12d806]
MOV RDI,RBX
CALL 0x0011c7b0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __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>
::insert(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_2,long *param_3)
{
int8 uVar1;
int1 *local_68 [2];
int1 local_58 [16];
char *local_48;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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;
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
long local_28;
if (*param_2 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name(param_2);
/* try { // try from 00173d97 to 00173da5 has its CatchHandler @ 00173e65 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)local_68,"cannot use insert() with ",&local_48);
/* try { // try from 00173da9 to 00173dd3 has its CatchHandler @ 00173e40 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x135,local_68,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
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>
*)*param_3;
if (local_40 == param_2) {
local_38 = (int4)param_3[1];
uStack_34 = *(int4 *)((long)param_3 + 0xc);
uStack_30 = (int4)param_3[2];
uStack_2c = *(int4 *)((long)param_3 + 0x14);
local_28 = param_3[3];
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>
(this,param_2,&local_40);
return this;
}
uVar1 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
/* try { // try from 00173dec to 00173e01 has its CatchHandler @ 00173e3e */
std::__cxx11::string::_M_construct<char_const*>(local_68,"iterator does not fit current value","")
;
/* try { // try from 00173e05 to 00173e2f has its CatchHandler @ 00173e30 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xca,local_68,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
| |
24,588 | translog_walk_filenames | eloqsql/storage/maria/ma_loghandler.c | my_bool translog_walk_filenames(const char *directory,
my_bool (*callback)(const char *,
const char *))
{
MY_DIR *dirp;
uint i;
my_bool rc= FALSE;
/* Finds and removes transaction log files */
if (!(dirp = my_dir(directory, MYF(MY_DONT_SORT))))
return FALSE;
for (i= 0; i < dirp->number_of_files; i++)
{
char *file= dirp->dir_entry[i].name;
if (strncmp(file, "aria_log.", 10) == 0 &&
file[10] >= '0' && file[10] <= '9' &&
file[11] >= '0' && file[11] <= '9' &&
file[12] >= '0' && file[12] <= '9' &&
file[13] >= '0' && file[13] <= '9' &&
file[14] >= '0' && file[14] <= '9' &&
file[15] >= '0' && file[15] <= '9' &&
file[16] >= '0' && file[16] <= '9' &&
file[17] >= '0' && file[17] <= '9' &&
file[18] == '\0' && (*callback)(directory, file))
{
rc= TRUE;
break;
}
}
my_dirend(dirp);
return rc;
} | O0 | c | translog_walk_filenames:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf9130
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2c504
movb $0x0, -0x1(%rbp)
jmp 0x2c68d
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x2c67e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x24(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x12aeb3(%rip), %rsi # 0x1573f1
movl $0xa, %edx
callq 0x2a1d0
cmpl $0x0, %eax
jne 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xa(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xa(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xb(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xb(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xc(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xd(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xd(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xe(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xe(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0xf(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0x10(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0x11(%rax), %eax
cmpl $0x30, %eax
jl 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0x11(%rax), %eax
cmpl $0x39, %eax
jg 0x2c66e
movq -0x30(%rbp), %rax
movsbl 0x12(%rax), %eax
cmpl $0x0, %eax
jne 0x2c66e
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movsbl %al, %eax
cmpl $0x0, %eax
je 0x2c66e
movb $0x1, -0x25(%rbp)
jmp 0x2c67e
jmp 0x2c670
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2c50b
movq -0x20(%rbp), %rdi
callq 0xf90e0
movb -0x25(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_walk_filenames:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_25], 0
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call my_dir
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_2C504
mov [rbp+var_1], 0
jmp loc_2C68D
loc_2C504:
mov [rbp+var_24], 0
loc_2C50B:
mov eax, [rbp+var_24]
mov rcx, [rbp+var_20]
cmp eax, [rcx+8]
jnb loc_2C67E
mov rax, [rbp+var_20]
mov rax, [rax]
mov ecx, [rbp+var_24]
shl rcx, 4
add rax, rcx
mov rax, [rax]
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
lea rsi, aAriaLog; "aria_log."
mov edx, 0Ah
call _strncmp
cmp eax, 0
jnz loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Ah]
cmp eax, 30h ; '0'
jl loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Ah]
cmp eax, 39h ; '9'
jg loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Bh]
cmp eax, 30h ; '0'
jl loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Bh]
cmp eax, 39h ; '9'
jg loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Ch]
cmp eax, 30h ; '0'
jl loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Ch]
cmp eax, 39h ; '9'
jg loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Dh]
cmp eax, 30h ; '0'
jl loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Dh]
cmp eax, 39h ; '9'
jg loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Eh]
cmp eax, 30h ; '0'
jl loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Eh]
cmp eax, 39h ; '9'
jg short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Fh]
cmp eax, 30h ; '0'
jl short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+0Fh]
cmp eax, 39h ; '9'
jg short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+10h]
cmp eax, 30h ; '0'
jl short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+10h]
cmp eax, 39h ; '9'
jg short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+11h]
cmp eax, 30h ; '0'
jl short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+11h]
cmp eax, 39h ; '9'
jg short loc_2C66E
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax+12h]
cmp eax, 0
jnz short loc_2C66E
mov rax, [rbp+var_18]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
call rax
movsx eax, al
cmp eax, 0
jz short loc_2C66E
mov [rbp+var_25], 1
jmp short loc_2C67E
loc_2C66E:
jmp short $+2
loc_2C670:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_2C50B
loc_2C67E:
mov rdi, [rbp+var_20]
call my_dirend
mov al, [rbp+var_25]
mov [rbp+var_1], al
loc_2C68D:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char translog_walk_filenames(long long a1, unsigned __int8 ( *a2)(long long, char *))
{
char *v3; // [rsp+0h] [rbp-30h]
char v4; // [rsp+Bh] [rbp-25h]
unsigned int i; // [rsp+Ch] [rbp-24h]
long long v6; // [rsp+10h] [rbp-20h]
v4 = 0;
v6 = my_dir(a1, 0LL);
if ( !v6 )
return 0;
for ( i = 0; i < *(_DWORD *)(v6 + 8); ++i )
{
v3 = *(char **)(16LL * i + *(_QWORD *)v6);
if ( !(unsigned int)strncmp(v3, "aria_log.", 10LL)
&& v3[10] >= 48
&& v3[10] <= 57
&& v3[11] >= 48
&& v3[11] <= 57
&& v3[12] >= 48
&& v3[12] <= 57
&& v3[13] >= 48
&& v3[13] <= 57
&& v3[14] >= 48
&& v3[14] <= 57
&& v3[15] >= 48
&& v3[15] <= 57
&& v3[16] >= 48
&& v3[16] <= 57
&& v3[17] >= 48
&& v3[17] <= 57
&& !v3[18]
&& a2(a1, v3) )
{
v4 = 1;
break;
}
}
my_dirend(v6);
return v4;
}
| translog_walk_filenames:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV byte ptr [RBP + -0x25],0x0
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001f9130
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0012c504
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0012c68d
LAB_0012c504:
MOV dword ptr [RBP + -0x24],0x0
LAB_0012c50b:
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x20]
CMP EAX,dword ptr [RCX + 0x8]
JNC 0x0012c67e
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x24]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
LEA RSI,[0x2573f1]
MOV EDX,0xa
CALL 0x0012a1d0
CMP EAX,0x0
JNZ 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xa]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xa]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xb]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xb]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xc]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xc]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xd]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xd]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xe]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xe]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xf]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0xf]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x10]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x10]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x11]
CMP EAX,0x30
JL 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x11]
CMP EAX,0x39
JG 0x0012c66e
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX + 0x12]
CMP EAX,0x0
JNZ 0x0012c66e
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
CALL RAX
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0012c66e
MOV byte ptr [RBP + -0x25],0x1
JMP 0x0012c67e
LAB_0012c66e:
JMP 0x0012c670
LAB_0012c670:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0012c50b
LAB_0012c67e:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001f90e0
MOV AL,byte ptr [RBP + -0x25]
MOV byte ptr [RBP + -0x1],AL
LAB_0012c68d:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8 translog_walk_filenames(int8 param_1,code *param_2)
{
char *__s1;
char cVar1;
int iVar2;
long *plVar3;
int8 uVar4;
int7 uVar5;
int1 local_2d;
uint local_2c;
int1 local_9;
local_2d = 0;
plVar3 = (long *)my_dir(param_1,0);
if (plVar3 == (long *)0x0) {
local_9 = 0;
uVar5 = 0;
}
else {
for (local_2c = 0; local_2c < *(uint *)(plVar3 + 1); local_2c = local_2c + 1) {
__s1 = *(char **)(*plVar3 + (ulong)local_2c * 0x10);
iVar2 = strncmp(__s1,"aria_log.",10);
if (((((((iVar2 == 0) && ('/' < __s1[10])) && (__s1[10] < ':')) &&
(('/' < __s1[0xb] && (__s1[0xb] < ':')))) &&
(('/' < __s1[0xc] && ((__s1[0xc] < ':' && ('/' < __s1[0xd])))))) && (__s1[0xd] < ':')) &&
((((('/' < __s1[0xe] && (__s1[0xe] < ':')) && ('/' < __s1[0xf])) &&
(((__s1[0xf] < ':' && ('/' < __s1[0x10])) &&
((__s1[0x10] < ':' && (('/' < __s1[0x11] && (__s1[0x11] < ':')))))))) &&
(__s1[0x12] == '\0')))) {
cVar1 = (*param_2)(param_1,__s1);
if (cVar1 != '\0') {
local_2d = 1;
break;
}
}
}
uVar4 = my_dirend(plVar3);
uVar5 = (int7)((ulong)uVar4 >> 8);
local_9 = local_2d;
}
return CONCAT71(uVar5,local_9);
}
| |
24,589 | ggml_set_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_set_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset,
bool inplace) {
GGML_ASSERT(ggml_nelements(a) >= ggml_nelements(b));
bool is_node = false;
if (a->grad || b->grad) {
is_node = true;
}
// make a view of the destination
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_SET;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_set_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rax
imulq 0x10(%rsi), %rax
imulq 0x20(%rsi), %rax
movq %rdx, %r14
imulq 0x28(%rsi), %rax
movq 0x18(%rdx), %rdx
imulq 0x10(%r14), %rdx
imulq 0x20(%r14), %rdx
imulq 0x28(%r14), %rdx
cmpq %rdx, %rax
jl 0x6b6f7
movq %rsi, %rbx
cmpq $0x0, 0x98(%rsi)
jne 0x6b64c
cmpq $0x0, 0x98(%r14)
je 0x6b6ea
movb $0x1, %al
movl %eax, 0x4(%rsp)
movq %rcx, %r12
movq %r8, %r13
movq %r9, %rbp
cmpb $0x0, 0x68(%rsp)
movq %rdi, 0x8(%rsp)
movq %rbx, %rsi
je 0x6b671
callq 0x69922
jmp 0x6b676
callq 0x68a65
movq %rax, %r15
leaq 0x10(%rsp), %rsi
movl %r12d, (%rsi)
movl %r13d, 0x4(%rsi)
movl %ebp, 0x8(%rsi)
movq 0x60(%rsp), %rax
movl %eax, 0xc(%rsi)
movzbl 0x68(%rsp), %eax
movl %eax, 0x10(%rsi)
pushq $0x14
popq %rdx
movq %r15, %rdi
callq 0x6ab3d
movl $0x1b, 0x50(%r15)
cmpb $0x0, 0x4(%rsp)
je 0x6b6c1
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x68a65
jmp 0x6b6c3
xorl %eax, %eax
movq %rax, 0x98(%r15)
movq %rbx, 0xa0(%r15)
movq %r14, 0xa8(%r15)
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x4(%rsp)
jmp 0x6b652
movq 0x6a84a(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6a89b(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2eb07(%rip), %rsi # 0x9a21e
leaq 0x36160(%rip), %rdx # 0xa187e
leaq 0x37e37(%rip), %r8 # 0xa355c
movl $0x107b, %ecx # imm = 0x107B
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_set_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+18h]
imul rax, [rsi+10h]
imul rax, [rsi+20h]
mov r14, rdx
imul rax, [rsi+28h]
mov rdx, [rdx+18h]
imul rdx, [r14+10h]
imul rdx, [r14+20h]
imul rdx, [r14+28h]
cmp rax, rdx
jl loc_6B6F7
mov rbx, rsi
cmp qword ptr [rsi+98h], 0
jnz short loc_6B64C
cmp qword ptr [r14+98h], 0
jz loc_6B6EA
loc_6B64C:
mov al, 1
mov [rsp+58h+var_54], eax
loc_6B652:
mov r12, rcx
mov r13, r8
mov rbp, r9
cmp [rsp+58h+arg_8], 0
mov [rsp+58h+var_50], rdi
mov rsi, rbx
jz short loc_6B671
call ggml_view_tensor
jmp short loc_6B676
loc_6B671:
call ggml_dup_tensor
loc_6B676:
mov r15, rax
lea rsi, [rsp+58h+var_48]
mov [rsi], r12d
mov [rsi+4], r13d
mov [rsi+8], ebp
mov rax, [rsp+58h+arg_0]
mov [rsi+0Ch], eax
movzx eax, [rsp+58h+arg_8]
mov [rsi+10h], eax
push 14h
pop rdx
mov rdi, r15
call ggml_set_op_params
mov dword ptr [r15+50h], 1Bh
cmp byte ptr [rsp+58h+var_54], 0
jz short loc_6B6C1
mov rdi, [rsp+58h+var_50]
mov rsi, r15
call ggml_dup_tensor
jmp short loc_6B6C3
loc_6B6C1:
xor eax, eax
loc_6B6C3:
mov [r15+98h], rax
mov [r15+0A0h], rbx
mov [r15+0A8h], r14
mov rax, r15
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6B6EA:
mov [rsp+58h+var_54], 0
jmp loc_6B652
loc_6B6F7:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlNelementsA_0; "ggml_nelements(a) >= ggml_nelements(b)"
mov ecx, 107Bh
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long ggml_set_impl(
long long a1,
long long a2,
_QWORD *a3,
int a4,
int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
unsigned __int8 a16)
{
long long v20; // rax
long long v21; // r15
long long v22; // rax
long long v24; // rdi
bool v25; // [rsp+4h] [rbp-54h]
_DWORD v26[18]; // [rsp+10h] [rbp-48h] BYREF
if ( *(_QWORD *)(a2 + 40) * *(_QWORD *)(a2 + 32) * *(_QWORD *)(a2 + 16) * *(_QWORD *)(a2 + 24) < a3[5]
* a3[4]
* a3[2]
* a3[3] )
{
fflush(stdout);
v24 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
4219,
"ggml_nelements(a) >= ggml_nelements(b)");
ggml_print_backtrace();
abort(v24);
}
v25 = *(_QWORD *)(a2 + 152) || a3[19];
if ( a16 )
v20 = ggml_view_tensor(a1, a2, a7, a8, a9, a10, a11, a12, a13, a14);
else
v20 = ggml_dup_tensor(a1, (unsigned int *)a2);
v21 = v20;
v26[0] = a4;
v26[1] = a5;
v26[2] = a6;
v26[3] = a15;
v26[4] = a16;
ggml_set_op_params(v20, (long long)v26, 20LL);
*(_DWORD *)(v21 + 80) = 27;
if ( v25 )
v22 = ggml_dup_tensor(a1, (unsigned int *)v21);
else
v22 = 0LL;
*(_QWORD *)(v21 + 152) = v22;
*(_QWORD *)(v21 + 160) = a2;
*(_QWORD *)(v21 + 168) = a3;
return v21;
}
| ggml_set_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RSI + 0x18]
IMUL RAX,qword ptr [RSI + 0x10]
IMUL RAX,qword ptr [RSI + 0x20]
MOV R14,RDX
IMUL RAX,qword ptr [RSI + 0x28]
MOV RDX,qword ptr [RDX + 0x18]
IMUL RDX,qword ptr [R14 + 0x10]
IMUL RDX,qword ptr [R14 + 0x20]
IMUL RDX,qword ptr [R14 + 0x28]
CMP RAX,RDX
JL 0x0016b6f7
MOV RBX,RSI
CMP qword ptr [RSI + 0x98],0x0
JNZ 0x0016b64c
CMP qword ptr [R14 + 0x98],0x0
JZ 0x0016b6ea
LAB_0016b64c:
MOV AL,0x1
MOV dword ptr [RSP + 0x4],EAX
LAB_0016b652:
MOV R12,RCX
MOV R13,R8
MOV RBP,R9
CMP byte ptr [RSP + 0x68],0x0
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,RBX
JZ 0x0016b671
CALL 0x00169922
JMP 0x0016b676
LAB_0016b671:
CALL 0x00168a65
LAB_0016b676:
MOV R15,RAX
LEA RSI,[RSP + 0x10]
MOV dword ptr [RSI],R12D
MOV dword ptr [RSI + 0x4],R13D
MOV dword ptr [RSI + 0x8],EBP
MOV RAX,qword ptr [RSP + 0x60]
MOV dword ptr [RSI + 0xc],EAX
MOVZX EAX,byte ptr [RSP + 0x68]
MOV dword ptr [RSI + 0x10],EAX
PUSH 0x14
POP RDX
MOV RDI,R15
CALL 0x0016ab3d
MOV dword ptr [R15 + 0x50],0x1b
CMP byte ptr [RSP + 0x4],0x0
JZ 0x0016b6c1
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R15
CALL 0x00168a65
JMP 0x0016b6c3
LAB_0016b6c1:
XOR EAX,EAX
LAB_0016b6c3:
MOV qword ptr [R15 + 0x98],RAX
MOV qword ptr [R15 + 0xa0],RBX
MOV qword ptr [R15 + 0xa8],R14
MOV RAX,R15
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016b6ea:
MOV dword ptr [RSP + 0x4],0x0
JMP 0x0016b652
LAB_0016b6f7:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a355c]
MOV ECX,0x107b
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
long ggml_set_impl(int8 param_1,long param_2,long param_3,int4 param_4,
int4 param_5,int4 param_6,int4 param_7,byte param_8)
{
bool bVar1;
long lVar2;
int8 uVar3;
int4 local_48;
int4 local_44;
int4 local_40;
int4 local_3c;
uint local_38;
if (*(long *)(param_3 + 0x18) * *(long *)(param_3 + 0x10) * *(long *)(param_3 + 0x20) *
*(long *)(param_3 + 0x28) <=
*(long *)(param_2 + 0x18) * *(long *)(param_2 + 0x10) * *(long *)(param_2 + 0x20) *
*(long *)(param_2 + 0x28)) {
if ((*(long *)(param_2 + 0x98) == 0) && (*(long *)(param_3 + 0x98) == 0)) {
bVar1 = false;
}
else {
bVar1 = true;
}
if (param_8 == 0) {
lVar2 = ggml_dup_tensor(param_1,param_2);
}
else {
lVar2 = ggml_view_tensor();
}
local_3c = param_7;
local_38 = (uint)param_8;
local_48 = param_4;
local_44 = param_5;
local_40 = param_6;
ggml_set_op_params(lVar2,&local_48,0x14);
*(int4 *)(lVar2 + 0x50) = 0x1b;
if (bVar1) {
uVar3 = ggml_dup_tensor(param_1,lVar2);
}
else {
uVar3 = 0;
}
*(int8 *)(lVar2 + 0x98) = uVar3;
*(long *)(lVar2 + 0xa0) = param_2;
*(long *)(lVar2 + 0xa8) = param_3;
return lVar2;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
fprintf(*(FILE **)PTR_stderr_001d5fa8,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
0x107b,"ggml_nelements(a) >= ggml_nelements(b)");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
24,590 | ggml_set_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_set_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
size_t nb1,
size_t nb2,
size_t nb3,
size_t offset,
bool inplace) {
GGML_ASSERT(ggml_nelements(a) >= ggml_nelements(b));
bool is_node = false;
if (a->grad || b->grad) {
is_node = true;
}
// make a view of the destination
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
int32_t params[] = { nb1, nb2, nb3, offset, inplace ? 1 : 0 };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_SET;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
} | O3 | c | ggml_set_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x18(%rsi), %rax
imulq 0x10(%rsi), %rax
imulq 0x20(%rsi), %rax
movq %rdx, %r14
imulq 0x28(%rsi), %rax
movq 0x18(%rdx), %rdx
imulq 0x10(%r14), %rdx
imulq 0x20(%r14), %rdx
imulq 0x28(%r14), %rdx
cmpq %rdx, %rax
jl 0x917d2
movq %rsi, %rbx
cmpq $0x0, 0x98(%rsi)
jne 0x916ff
cmpq $0x0, 0x98(%r14)
je 0x917c5
movb $0x1, %al
movl %eax, 0x4(%rsp)
movq %rcx, %r13
movq %r8, %r15
movq %r9, %rbp
cmpb $0x0, 0x68(%rsp)
movq %rdi, 0x8(%rsp)
je 0x91724
movq %rbx, %rsi
callq 0x8f880
jmp 0x9173a
leaq 0x10(%rbx), %rcx
movl (%rbx), %esi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8d64f
movq %rax, %r12
leaq 0x10(%rsp), %rsi
movl %r13d, (%rsi)
movl %r15d, 0x4(%rsi)
movl %ebp, 0x8(%rsi)
movq 0x60(%rsp), %rax
movl %eax, 0xc(%rsi)
movzbl 0x68(%rsp), %eax
movl %eax, 0x10(%rsi)
movl $0x14, %edx
movq %r12, %rdi
callq 0x90cc8
movl $0x1b, 0x50(%r12)
cmpb $0x0, 0x4(%rsp)
je 0x91799
movl (%r12), %esi
leaq 0x10(%r12), %rcx
movq 0x8(%rsp), %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8d64f
jmp 0x9179b
xorl %eax, %eax
movq %rax, 0x98(%r12)
movq %rbx, 0xa0(%r12)
movq %r14, 0xa8(%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x4(%rsp)
jmp 0x91705
callq 0xd4f2
| ggml_set_impl:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+18h]
imul rax, [rsi+10h]
imul rax, [rsi+20h]
mov r14, rdx
imul rax, [rsi+28h]
mov rdx, [rdx+18h]
imul rdx, [r14+10h]
imul rdx, [r14+20h]
imul rdx, [r14+28h]
cmp rax, rdx
jl loc_917D2
mov rbx, rsi
cmp qword ptr [rsi+98h], 0
jnz short loc_916FF
cmp qword ptr [r14+98h], 0
jz loc_917C5
loc_916FF:
mov al, 1
mov [rsp+58h+var_54], eax
loc_91705:
mov r13, rcx
mov r15, r8
mov rbp, r9
cmp [rsp+58h+arg_8], 0
mov [rsp+58h+var_50], rdi
jz short loc_91724
mov rsi, rbx
call ggml_view_tensor
jmp short loc_9173A
loc_91724:
lea rcx, [rbx+10h]
mov esi, [rbx]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_9173A:
mov r12, rax
lea rsi, [rsp+58h+var_48]
mov [rsi], r13d
mov [rsi+4], r15d
mov [rsi+8], ebp
mov rax, [rsp+58h+arg_0]
mov [rsi+0Ch], eax
movzx eax, [rsp+58h+arg_8]
mov [rsi+10h], eax
mov edx, 14h
mov rdi, r12
call ggml_set_op_params
mov dword ptr [r12+50h], 1Bh
cmp byte ptr [rsp+58h+var_54], 0
jz short loc_91799
mov esi, [r12]
lea rcx, [r12+10h]
mov rdi, [rsp+58h+var_50]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
jmp short loc_9179B
loc_91799:
xor eax, eax
loc_9179B:
mov [r12+98h], rax
mov [r12+0A0h], rbx
mov [r12+0A8h], r14
mov rax, r12
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_917C5:
mov [rsp+58h+var_54], 0
jmp loc_91705
loc_917D2:
call ggml_set_impl_cold_1
| long long ggml_set_impl(
long long a1,
long long a2,
_QWORD *a3,
int a4,
int a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14,
long long a15,
unsigned __int8 a16)
{
long long v20; // rax
long long v21; // r12
long long v22; // rax
bool v24; // [rsp+4h] [rbp-54h]
_DWORD v25[18]; // [rsp+10h] [rbp-48h] BYREF
if ( *(_QWORD *)(a2 + 40) * *(_QWORD *)(a2 + 32) * *(_QWORD *)(a2 + 16) * *(_QWORD *)(a2 + 24) < a3[5]
* a3[4]
* a3[2]
* a3[3] )
ggml_set_impl_cold_1();
v24 = *(_QWORD *)(a2 + 152) || a3[19];
if ( a16 )
v20 = ggml_view_tensor(a1, a2, a7, a8, a9, a10, a11, a12, a13, a14);
else
v20 = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL, a7, a8);
v21 = v20;
v25[0] = a4;
v25[1] = a5;
v25[2] = a6;
v25[3] = a15;
v25[4] = a16;
ggml_set_op_params(v20, (long long)v25, 20LL);
*(_DWORD *)(v21 + 80) = 27;
if ( v24 )
v22 = ggml_new_tensor_impl(a1, *(_DWORD *)v21, 4, (_QWORD *)(v21 + 16), 0LL, 0LL, a7, a8);
else
v22 = 0LL;
*(_QWORD *)(v21 + 152) = v22;
*(_QWORD *)(v21 + 160) = a2;
*(_QWORD *)(v21 + 168) = a3;
return v21;
}
| |||
24,591 | ma_seq_search | eloqsql/storage/maria/ma_search.c | int _ma_seq_search(const MARIA_KEY *key, const MARIA_PAGE *ma_page,
uint32 comp_flag, uchar **ret_pos,
uchar *buff, my_bool *last_key)
{
int UNINIT_VAR(flag);
uint page_flag, nod_flag, UNINIT_VAR(length), not_used[2];
uchar t_buff[MARIA_MAX_KEY_BUFF], *end;
uchar *page;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_SHARE *share= keyinfo->share;
MARIA_KEY tmp_key;
DBUG_ENTER("_ma_seq_search");
page_flag= ma_page->flag;
nod_flag= ma_page->node;
page= ma_page->buff;
end= page + ma_page->size;
page+= share->keypage_header + nod_flag;
*ret_pos= page;
t_buff[0]=0; /* Avoid bugs */
tmp_key.data= t_buff;
tmp_key.keyinfo= keyinfo;
while (page < end)
{
length=(*keyinfo->get_key)(&tmp_key, page_flag, nod_flag, &page);
if (length == 0 || page > end)
{
_ma_set_fatal_error_with_share(share, HA_ERR_CRASHED);
DBUG_PRINT("error",
("Found wrong key: length: %u page: %p end: %p",
length, page, end));
DBUG_RETURN(MARIA_FOUND_WRONG_KEY);
}
if ((flag= ha_key_cmp(keyinfo->seg, t_buff, key->data,
key->data_length + key->ref_length,
comp_flag | tmp_key.flag,
not_used)) >= 0)
break;
DBUG_PRINT("loop_extra",("page:%p key: '%s' flag: %d",
page, t_buff, flag));
memcpy(buff,t_buff,length);
*ret_pos=page;
}
if (flag == 0)
memcpy(buff,t_buff,length); /* Result is first key */
*last_key= page == end;
DBUG_PRINT("exit",("flag: %d ret_pos: %p", flag, *ret_pos));
DBUG_RETURN(flag);
} | O0 | c | ma_seq_search:
pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp # imm = 0xA80
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x9f0(%rbp)
movq %rsi, -0x9f8(%rbp)
movl %edx, -0x9fc(%rbp)
movq %rcx, -0xa08(%rbp)
movq %r8, -0xa10(%rbp)
movq %r9, -0xa18(%rbp)
movl -0xa1c(%rbp), %eax
movl %eax, -0xa1c(%rbp)
movl -0xa28(%rbp), %eax
movl %eax, -0xa28(%rbp)
movq -0x9f0(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa48(%rbp)
movq -0xa48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa50(%rbp)
movq -0x9f8(%rbp), %rax
movl 0x2c(%rax), %eax
movl %eax, -0xa20(%rbp)
movq -0x9f8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0xa24(%rbp)
movq -0x9f8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xa40(%rbp)
movq -0xa40(%rbp), %rax
movq -0x9f8(%rbp), %rcx
movl 0x20(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xa38(%rbp)
movq -0xa50(%rbp), %rax
movl 0x744(%rax), %ecx
addl -0xa24(%rbp), %ecx
movq -0xa40(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0xa40(%rbp)
movq -0xa40(%rbp), %rcx
movq -0xa08(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x9e0(%rbp)
leaq -0x9e0(%rbp), %rax
movq %rax, -0xa70(%rbp)
movq -0xa48(%rbp), %rax
movq %rax, -0xa68(%rbp)
movq -0xa40(%rbp), %rax
cmpq -0xa38(%rbp), %rax
jae 0x69d53
movq -0xa48(%rbp), %rax
movq 0xe0(%rax), %rax
movl -0xa20(%rbp), %esi
movl -0xa24(%rbp), %edx
leaq -0xa70(%rbp), %rdi
leaq -0xa40(%rbp), %rcx
callq *%rax
movl %eax, -0xa28(%rbp)
cmpl $0x0, -0xa28(%rbp)
je 0x69ca0
movq -0xa40(%rbp), %rax
cmpq -0xa38(%rbp), %rax
jbe 0x69cc4
movq -0xa50(%rbp), %rdi
movl $0x7e, %esi
callq 0x33940
jmp 0x69cb3
jmp 0x69cb5
movl $0x7fffffff, -0x9e4(%rbp) # imm = 0x7FFFFFFF
jmp 0x69da8
movq -0xa48(%rbp), %rax
movq 0xc0(%rax), %rdi
leaq -0x9e0(%rbp), %rsi
movq -0x9f0(%rbp), %rax
movq (%rax), %rdx
movq -0x9f0(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x9f0(%rbp), %rax
addl 0x14(%rax), %ecx
movl -0x9fc(%rbp), %r8d
orl -0xa58(%rbp), %r8d
leaq -0xa30(%rbp), %r9
callq 0xf05d0
movl %eax, -0xa1c(%rbp)
cmpl $0x0, %eax
jl 0x69d1e
jmp 0x69d53
jmp 0x69d20
jmp 0x69d22
movq -0xa10(%rbp), %rdi
leaq -0x9e0(%rbp), %rsi
movl -0xa28(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0xa40(%rbp), %rcx
movq -0xa08(%rbp), %rax
movq %rcx, (%rax)
jmp 0x69c43
cmpl $0x0, -0xa1c(%rbp)
jne 0x69d77
movq -0xa10(%rbp), %rdi
leaq -0x9e0(%rbp), %rsi
movl -0xa28(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0xa40(%rbp), %rax
cmpq -0xa38(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0xa18(%rbp), %rax
movb %cl, (%rax)
jmp 0x69d9a
jmp 0x69d9c
movl -0xa1c(%rbp), %eax
movl %eax, -0x9e4(%rbp)
movl -0x9e4(%rbp), %eax
movl %eax, -0xa74(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x69dd5
movl -0xa74(%rbp), %eax
addq $0xa80, %rsp # imm = 0xA80
popq %rbp
retq
callq 0x2a270
nopw (%rax,%rax)
| _ma_seq_search:
push rbp
mov rbp, rsp
sub rsp, 0A80h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_9F0], rdi
mov [rbp+var_9F8], rsi
mov [rbp+var_9FC], edx
mov [rbp+var_A08], rcx
mov [rbp+var_A10], r8
mov [rbp+var_A18], r9
mov eax, [rbp+var_A1C]
mov [rbp+var_A1C], eax
mov eax, [rbp+var_A28]
mov [rbp+var_A28], eax
mov rax, [rbp+var_9F0]
mov rax, [rax+8]
mov [rbp+var_A48], rax
mov rax, [rbp+var_A48]
mov rax, [rax]
mov [rbp+var_A50], rax
mov rax, [rbp+var_9F8]
mov eax, [rax+2Ch]
mov [rbp+var_A20], eax
mov rax, [rbp+var_9F8]
mov eax, [rax+28h]
mov [rbp+var_A24], eax
mov rax, [rbp+var_9F8]
mov rax, [rax+10h]
mov [rbp+var_A40], rax
mov rax, [rbp+var_A40]
mov rcx, [rbp+var_9F8]
mov ecx, [rcx+20h]
add rax, rcx
mov [rbp+var_A38], rax
mov rax, [rbp+var_A50]
mov ecx, [rax+744h]
add ecx, [rbp+var_A24]
mov rax, [rbp+var_A40]
mov ecx, ecx
add rax, rcx
mov [rbp+var_A40], rax
mov rcx, [rbp+var_A40]
mov rax, [rbp+var_A08]
mov [rax], rcx
mov [rbp+var_9E0], 0
lea rax, [rbp+var_9E0]
mov [rbp+var_A70], rax
mov rax, [rbp+var_A48]
mov [rbp+var_A68], rax
loc_69C43:
mov rax, [rbp+var_A40]
cmp rax, [rbp+var_A38]
jnb loc_69D53
mov rax, [rbp+var_A48]
mov rax, [rax+0E0h]
mov esi, [rbp+var_A20]
mov edx, [rbp+var_A24]
lea rdi, [rbp+var_A70]
lea rcx, [rbp+var_A40]
call rax
mov [rbp+var_A28], eax
cmp [rbp+var_A28], 0
jz short loc_69CA0
mov rax, [rbp+var_A40]
cmp rax, [rbp+var_A38]
jbe short loc_69CC4
loc_69CA0:
mov rdi, [rbp+var_A50]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error_with_share
jmp short $+2
loc_69CB3:
jmp short $+2
loc_69CB5:
mov [rbp+var_9E4], 7FFFFFFFh
jmp loc_69DA8
loc_69CC4:
mov rax, [rbp+var_A48]
mov rdi, [rax+0C0h]
lea rsi, [rbp+var_9E0]
mov rax, [rbp+var_9F0]
mov rdx, [rax]
mov rax, [rbp+var_9F0]
mov ecx, [rax+10h]
mov rax, [rbp+var_9F0]
add ecx, [rax+14h]
mov r8d, [rbp+var_9FC]
or r8d, [rbp+var_A58]
lea r9, [rbp+var_A30]
call ha_key_cmp
mov [rbp+var_A1C], eax
cmp eax, 0
jl short loc_69D1E
jmp short loc_69D53
loc_69D1E:
jmp short $+2
loc_69D20:
jmp short $+2
loc_69D22:
mov rdi, [rbp+var_A10]
lea rsi, [rbp+var_9E0]
mov eax, [rbp+var_A28]
mov edx, eax
call _memcpy
mov rcx, [rbp+var_A40]
mov rax, [rbp+var_A08]
mov [rax], rcx
jmp loc_69C43
loc_69D53:
cmp [rbp+var_A1C], 0
jnz short loc_69D77
mov rdi, [rbp+var_A10]
lea rsi, [rbp+var_9E0]
mov eax, [rbp+var_A28]
mov edx, eax
call _memcpy
loc_69D77:
mov rax, [rbp+var_A40]
cmp rax, [rbp+var_A38]
setz al
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_A18]
mov [rax], cl
jmp short $+2
loc_69D9A:
jmp short $+2
loc_69D9C:
mov eax, [rbp+var_A1C]
mov [rbp+var_9E4], eax
loc_69DA8:
mov eax, [rbp+var_9E4]
mov [rbp+var_A74], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_69DD5
mov eax, [rbp+var_A74]
add rsp, 0A80h
pop rbp
retn
loc_69DD5:
call ___stack_chk_fail
| long long ma_seq_search(long long a1, long long a2, unsigned int a3, unsigned long long *a4, long long a5, bool *a6)
{
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
int v9; // r9d
_QWORD v11[3]; // [rsp+10h] [rbp-A70h] BYREF
int v12; // [rsp+28h] [rbp-A58h]
long long v13; // [rsp+30h] [rbp-A50h]
long long v14; // [rsp+38h] [rbp-A48h]
unsigned long long v15; // [rsp+40h] [rbp-A40h] BYREF
unsigned long long v16; // [rsp+48h] [rbp-A38h]
char v17[8]; // [rsp+50h] [rbp-A30h] BYREF
unsigned int v18; // [rsp+58h] [rbp-A28h]
unsigned int v19; // [rsp+5Ch] [rbp-A24h]
unsigned int v20; // [rsp+60h] [rbp-A20h]
int v21; // [rsp+64h] [rbp-A1Ch]
bool *v22; // [rsp+68h] [rbp-A18h]
long long v23; // [rsp+70h] [rbp-A10h]
unsigned long long *v24; // [rsp+78h] [rbp-A08h]
unsigned int v25; // [rsp+84h] [rbp-9FCh]
long long v26; // [rsp+88h] [rbp-9F8h]
long long v27; // [rsp+90h] [rbp-9F0h]
_BYTE v29[2520]; // [rsp+A0h] [rbp-9E0h] BYREF
unsigned long long v30; // [rsp+A78h] [rbp-8h]
v30 = __readfsqword(0x28u);
v27 = a1;
v26 = a2;
v25 = a3;
v24 = a4;
v23 = a5;
v22 = a6;
v14 = *(_QWORD *)(a1 + 8);
v13 = *(_QWORD *)v14;
v20 = *(_DWORD *)(a2 + 44);
v19 = *(_DWORD *)(a2 + 40);
v15 = *(_QWORD *)(a2 + 16);
v16 = *(unsigned int *)(a2 + 32) + v15;
v15 += v19 + *(_DWORD *)(v13 + 1860);
*a4 = v15;
v29[0] = 0;
v11[0] = v29;
v11[1] = v14;
while ( v15 < v16 )
{
v18 = (*(long long ( **)(_QWORD *, _QWORD, _QWORD, unsigned long long *))(v14 + 224))(v11, v20, v19, &v15);
if ( !v18 || v15 > v16 )
{
ma_set_fatal_error_with_share(v13, 126, v6, v7, v8, v9);
return 0x7FFFFFFF;
}
v21 = ha_key_cmp(
*(_QWORD *)(v14 + 192),
v29,
*(_QWORD *)v27,
(unsigned int)(*(_DWORD *)(v27 + 20) + *(_DWORD *)(v27 + 16)),
v12 | v25,
v17);
if ( v21 >= 0 )
break;
memcpy(v23, v29, v18);
*v24 = v15;
}
if ( !v21 )
memcpy(v23, v29, v18);
*v22 = v15 == v16;
return (unsigned int)v21;
}
| _ma_seq_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa80
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x9f0],RDI
MOV qword ptr [RBP + -0x9f8],RSI
MOV dword ptr [RBP + -0x9fc],EDX
MOV qword ptr [RBP + -0xa08],RCX
MOV qword ptr [RBP + -0xa10],R8
MOV qword ptr [RBP + -0xa18],R9
MOV EAX,dword ptr [RBP + -0xa1c]
MOV dword ptr [RBP + -0xa1c],EAX
MOV EAX,dword ptr [RBP + -0xa28]
MOV dword ptr [RBP + -0xa28],EAX
MOV RAX,qword ptr [RBP + -0x9f0]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xa48],RAX
MOV RAX,qword ptr [RBP + -0xa48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0xa50],RAX
MOV RAX,qword ptr [RBP + -0x9f8]
MOV EAX,dword ptr [RAX + 0x2c]
MOV dword ptr [RBP + -0xa20],EAX
MOV RAX,qword ptr [RBP + -0x9f8]
MOV EAX,dword ptr [RAX + 0x28]
MOV dword ptr [RBP + -0xa24],EAX
MOV RAX,qword ptr [RBP + -0x9f8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0xa40],RAX
MOV RAX,qword ptr [RBP + -0xa40]
MOV RCX,qword ptr [RBP + -0x9f8]
MOV ECX,dword ptr [RCX + 0x20]
ADD RAX,RCX
MOV qword ptr [RBP + -0xa38],RAX
MOV RAX,qword ptr [RBP + -0xa50]
MOV ECX,dword ptr [RAX + 0x744]
ADD ECX,dword ptr [RBP + -0xa24]
MOV RAX,qword ptr [RBP + -0xa40]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0xa40],RAX
MOV RCX,qword ptr [RBP + -0xa40]
MOV RAX,qword ptr [RBP + -0xa08]
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x9e0],0x0
LEA RAX,[RBP + -0x9e0]
MOV qword ptr [RBP + -0xa70],RAX
MOV RAX,qword ptr [RBP + -0xa48]
MOV qword ptr [RBP + -0xa68],RAX
LAB_00169c43:
MOV RAX,qword ptr [RBP + -0xa40]
CMP RAX,qword ptr [RBP + -0xa38]
JNC 0x00169d53
MOV RAX,qword ptr [RBP + -0xa48]
MOV RAX,qword ptr [RAX + 0xe0]
MOV ESI,dword ptr [RBP + -0xa20]
MOV EDX,dword ptr [RBP + -0xa24]
LEA RDI,[RBP + -0xa70]
LEA RCX,[RBP + -0xa40]
CALL RAX
MOV dword ptr [RBP + -0xa28],EAX
CMP dword ptr [RBP + -0xa28],0x0
JZ 0x00169ca0
MOV RAX,qword ptr [RBP + -0xa40]
CMP RAX,qword ptr [RBP + -0xa38]
JBE 0x00169cc4
LAB_00169ca0:
MOV RDI,qword ptr [RBP + -0xa50]
MOV ESI,0x7e
CALL 0x00133940
JMP 0x00169cb3
LAB_00169cb3:
JMP 0x00169cb5
LAB_00169cb5:
MOV dword ptr [RBP + -0x9e4],0x7fffffff
JMP 0x00169da8
LAB_00169cc4:
MOV RAX,qword ptr [RBP + -0xa48]
MOV RDI,qword ptr [RAX + 0xc0]
LEA RSI,[RBP + -0x9e0]
MOV RAX,qword ptr [RBP + -0x9f0]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x9f0]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x9f0]
ADD ECX,dword ptr [RAX + 0x14]
MOV R8D,dword ptr [RBP + -0x9fc]
OR R8D,dword ptr [RBP + -0xa58]
LEA R9,[RBP + -0xa30]
CALL 0x001f05d0
MOV dword ptr [RBP + -0xa1c],EAX
CMP EAX,0x0
JL 0x00169d1e
JMP 0x00169d53
LAB_00169d1e:
JMP 0x00169d20
LAB_00169d20:
JMP 0x00169d22
LAB_00169d22:
MOV RDI,qword ptr [RBP + -0xa10]
LEA RSI,[RBP + -0x9e0]
MOV EAX,dword ptr [RBP + -0xa28]
MOV EDX,EAX
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0xa40]
MOV RAX,qword ptr [RBP + -0xa08]
MOV qword ptr [RAX],RCX
JMP 0x00169c43
LAB_00169d53:
CMP dword ptr [RBP + -0xa1c],0x0
JNZ 0x00169d77
MOV RDI,qword ptr [RBP + -0xa10]
LEA RSI,[RBP + -0x9e0]
MOV EAX,dword ptr [RBP + -0xa28]
MOV EDX,EAX
CALL 0x0012a090
LAB_00169d77:
MOV RAX,qword ptr [RBP + -0xa40]
CMP RAX,qword ptr [RBP + -0xa38]
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0xa18]
MOV byte ptr [RAX],CL
JMP 0x00169d9a
LAB_00169d9a:
JMP 0x00169d9c
LAB_00169d9c:
MOV EAX,dword ptr [RBP + -0xa1c]
MOV dword ptr [RBP + -0x9e4],EAX
LAB_00169da8:
MOV EAX,dword ptr [RBP + -0x9e4]
MOV dword ptr [RBP + -0xa74],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00169dd5
MOV EAX,dword ptr [RBP + -0xa74]
ADD RSP,0xa80
POP RBP
RET
LAB_00169dd5:
CALL 0x0012a270
|
int _ma_seq_search(int8 *param_1,long param_2,uint param_3,ulong *param_4,void *param_5,
int8 param_6)
{
long in_FS_OFFSET;
int1 *local_a78;
long *local_a70;
uint local_a60;
long local_a58;
long *local_a50;
ulong local_a48;
ulong local_a40;
int1 local_a38 [8];
uint local_a30;
int local_a2c;
int4 local_a28;
int local_a24;
int8 local_a20;
void *local_a18;
ulong *local_a10;
uint local_a04;
long local_a00;
int8 *local_9f8;
int local_9ec;
int1 local_9e8 [2520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_a70 = (long *)param_1[1];
local_a58 = *local_a70;
local_a28 = *(int4 *)(param_2 + 0x2c);
local_a2c = *(int *)(param_2 + 0x28);
local_a40 = *(long *)(param_2 + 0x10) + (ulong)*(uint *)(param_2 + 0x20);
local_a48 = *(long *)(param_2 + 0x10) + (ulong)(uint)(*(int *)(local_a58 + 0x744) + local_a2c);
*param_4 = local_a48;
local_9e8[0] = 0;
local_a78 = local_9e8;
local_a50 = local_a70;
local_a20 = param_6;
local_a18 = param_5;
local_a10 = param_4;
local_a04 = param_3;
local_a00 = param_2;
local_9f8 = param_1;
while (local_a48 < local_a40) {
local_a30 = (*(code *)local_a50[0x1c])(&local_a78,local_a28,local_a2c,&local_a48);
if ((local_a30 == 0) || (local_a40 < local_a48)) {
_ma_set_fatal_error_with_share(local_a58,0x7e);
local_9ec = 0x7fffffff;
goto LAB_00169da8;
}
local_a24 = ha_key_cmp(local_a50[0x18],local_9e8,*local_9f8,
*(int *)(local_9f8 + 2) + *(int *)((long)local_9f8 + 0x14),
local_a04 | local_a60,local_a38);
if (-1 < local_a24) break;
memcpy(local_a18,local_9e8,(ulong)local_a30);
*local_a10 = local_a48;
}
if (local_a24 == 0) {
memcpy(local_a18,local_9e8,(ulong)local_a30);
}
*(bool *)local_a20 = local_a48 == local_a40;
local_9ec = local_a24;
LAB_00169da8:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_9ec;
}
| |
24,592 | stbi__bitcount(unsigned int) | SDL3Lite/dependencies/stb_image.h | static int stbi__bitcount(unsigned int a)
{
a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
a = (a + (a >> 8)); // max 16 per 8 bits
a = (a + (a >> 16)); // max 32 per 8 bits
return a & 0xff;
} | O0 | c | stbi__bitcount(unsigned int):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x55555555, %eax # imm = 0x55555555
movl -0x4(%rbp), %ecx
shrl %ecx
andl $0x55555555, %ecx # imm = 0x55555555
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x33333333, %eax # imm = 0x33333333
movl -0x4(%rbp), %ecx
shrl $0x2, %ecx
andl $0x33333333, %ecx # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x4, %ecx
addl %ecx, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL14stbi__bitcountj:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
and eax, 55555555h
mov ecx, [rbp+var_4]
shr ecx, 1
and ecx, 55555555h
add eax, ecx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
and eax, 33333333h
mov ecx, [rbp+var_4]
shr ecx, 2
and ecx, 33333333h
add eax, ecx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
mov ecx, [rbp+var_4]
shr ecx, 4
add eax, ecx
and eax, 0F0F0F0Fh
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
mov ecx, [rbp+var_4]
shr ecx, 8
add eax, ecx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
mov ecx, [rbp+var_4]
shr ecx, 10h
add eax, ecx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
and eax, 0FFh
pop rbp
retn
| long long stbi__bitcount(unsigned int a1)
{
return (unsigned __int8)(((((((((((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333)) >> 4)
+ (((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333)) & 0xF0F0F0F) >> 8)
+ (((((((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333)) >> 4)
+ (((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333)) & 0xF0F0F0F)) >> 16)
+ ((unsigned __int16)(((((((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333)) >> 4)
+ (((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x3333)
+ ((((a1 >> 1) & 0x5555) + (a1 & 0x5555)) & 0x3333)) & 0xF0F) >> 8)
+ (((((((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333)) >> 4)
+ (((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33)
+ ((((a1 >> 1) & 0x55) + (a1 & 0x55)) & 0x33)) & 0xF));
}
| stbi__bitcount:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x55555555
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x1
AND ECX,0x55555555
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x33333333
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x2
AND ECX,0x33333333
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x4
ADD EAX,ECX
AND EAX,0xf0f0f0f
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x8
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV ECX,dword ptr [RBP + -0x4]
SHR ECX,0x10
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xff
POP RBP
RET
|
/* stbi__bitcount(unsigned int) */
uint stbi__bitcount(uint param_1)
{
uint uVar1;
uVar1 = (param_1 & 0x55555555) + (param_1 >> 1 & 0x55555555);
uVar1 = (uVar1 & 0x33333333) + (uVar1 >> 2 & 0x33333333);
uVar1 = uVar1 + (uVar1 >> 4) & 0xf0f0f0f;
uVar1 = uVar1 + (uVar1 >> 8);
return uVar1 + (uVar1 >> 0x10) & 0xff;
}
| |
24,593 | stbi__bitcount(unsigned int) | SDL3Lite/dependencies/stb_image.h | static int stbi__bitcount(unsigned int a)
{
a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2
a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4
a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits
a = (a + (a >> 8)); // max 16 per 8 bits
a = (a + (a >> 16)); // max 32 per 8 bits
return a & 0xff;
} | O3 | c | stbi__bitcount(unsigned int):
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
andl $0x55555555, %eax # imm = 0x55555555
movl -0x4(%rsp), %ecx
shrl %ecx
andl $0x55555555, %ecx # imm = 0x55555555
addl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
andl $0x33333333, %eax # imm = 0x33333333
movl -0x4(%rsp), %ecx
shrl $0x2, %ecx
andl $0x33333333, %ecx # imm = 0x33333333
addl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl -0x4(%rsp), %ecx
shrl $0x4, %ecx
addl %ecx, %eax
andl $0xf0f0f0f, %eax # imm = 0xF0F0F0F
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl -0x4(%rsp), %ecx
shrl $0x8, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movl -0x4(%rsp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
andl $0xff, %eax
retq
nopl (%rax)
| _ZL14stbi__bitcountj:
mov [rsp+var_4], edi
mov eax, [rsp+var_4]
and eax, 55555555h
mov ecx, [rsp+var_4]
shr ecx, 1
and ecx, 55555555h
add eax, ecx
mov [rsp+var_4], eax
mov eax, [rsp+var_4]
and eax, 33333333h
mov ecx, [rsp+var_4]
shr ecx, 2
and ecx, 33333333h
add eax, ecx
mov [rsp+var_4], eax
mov eax, [rsp+var_4]
mov ecx, [rsp+var_4]
shr ecx, 4
add eax, ecx
and eax, 0F0F0F0Fh
mov [rsp+var_4], eax
mov eax, [rsp+var_4]
mov ecx, [rsp+var_4]
shr ecx, 8
add eax, ecx
mov [rsp+var_4], eax
mov eax, [rsp+var_4]
mov ecx, [rsp+var_4]
shr ecx, 10h
add eax, ecx
mov [rsp+var_4], eax
mov eax, [rsp+var_4]
and eax, 0FFh
retn
| long long stbi__bitcount(unsigned int a1)
{
unsigned int v2; // [rsp+0h] [rbp-4h]
unsigned int v3; // [rsp+0h] [rbp-4h]
v2 = (((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) >> 2) & 0x33333333)
+ ((((a1 >> 1) & 0x55555555) + (a1 & 0x55555555)) & 0x33333333);
v3 = ((((v2 >> 4) + v2) & 0xF0F0F0F) >> 8) + (((v2 >> 4) + v2) & 0xF0F0F0F);
return (unsigned __int8)(BYTE2(v3) + v3);
}
| stbi__bitcount:
MOV dword ptr [RSP + -0x4],EDI
MOV EAX,dword ptr [RSP + -0x4]
AND EAX,0x55555555
MOV ECX,dword ptr [RSP + -0x4]
SHR ECX,0x1
AND ECX,0x55555555
ADD EAX,ECX
MOV dword ptr [RSP + -0x4],EAX
MOV EAX,dword ptr [RSP + -0x4]
AND EAX,0x33333333
MOV ECX,dword ptr [RSP + -0x4]
SHR ECX,0x2
AND ECX,0x33333333
ADD EAX,ECX
MOV dword ptr [RSP + -0x4],EAX
MOV EAX,dword ptr [RSP + -0x4]
MOV ECX,dword ptr [RSP + -0x4]
SHR ECX,0x4
ADD EAX,ECX
AND EAX,0xf0f0f0f
MOV dword ptr [RSP + -0x4],EAX
MOV EAX,dword ptr [RSP + -0x4]
MOV ECX,dword ptr [RSP + -0x4]
SHR ECX,0x8
ADD EAX,ECX
MOV dword ptr [RSP + -0x4],EAX
MOV EAX,dword ptr [RSP + -0x4]
MOV ECX,dword ptr [RSP + -0x4]
SHR ECX,0x10
ADD EAX,ECX
MOV dword ptr [RSP + -0x4],EAX
MOV EAX,dword ptr [RSP + -0x4]
AND EAX,0xff
RET
|
/* stbi__bitcount(unsigned int) */
uint stbi__bitcount(uint param_1)
{
uint uVar1;
uVar1 = (param_1 & 0x55555555) + (param_1 >> 1 & 0x55555555);
uVar1 = (uVar1 & 0x33333333) + (uVar1 >> 2 & 0x33333333);
uVar1 = uVar1 + (uVar1 >> 4) & 0xf0f0f0f;
uVar1 = uVar1 + (uVar1 >> 8);
return uVar1 + (uVar1 >> 0x10) & 0xff;
}
| |
24,594 | my_symlink | eloqsql/mysys/my_symlink.c | int my_symlink(const char *content, const char *linkname, myf MyFlags)
{
#ifndef HAVE_READLINK
return 0;
#else
int result;
DBUG_ENTER("my_symlink");
DBUG_PRINT("enter",("content: %s linkname: %s", content, linkname));
result= 0;
if (symlink(content, linkname))
{
result= -1;
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_CANT_SYMLINK, MYF(0), linkname, content, errno);
}
else if ((MyFlags & MY_SYNC_DIR) && my_sync_dir_by_file(linkname, MyFlags))
result= -1;
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_symlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xfcbd6
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29060
cmpl $0x0, %eax
je 0xfcc4a
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
callq 0x29700
movl (%rax), %eax
movl %eax, -0x20(%rbp)
callq 0xfdd30
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0xfcc48
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x29700
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl (%rax), %r8d
movl $0x19, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0xf76a0
jmp 0xfcc75
movq -0x18(%rbp), %rax
andq $0x8000, %rax # imm = 0x8000
cmpq $0x0, %rax
je 0xfcc73
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfd9d0
cmpl $0x0, %eax
je 0xfcc73
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0xfcc75
jmp 0xfcc77
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_symlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
jmp short $+2
loc_FCBD6:
mov [rbp+var_1C], 0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _symlink
cmp eax, 0
jz short loc_FCC4A
mov [rbp+var_1C], 0FFFFFFFFh
call ___errno_location
mov eax, [rax]
mov [rbp+var_20], eax
call _my_thread_var
mov ecx, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_FCC48
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_28]
mov r8d, [rax]
mov edi, 19h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_FCC48:
jmp short loc_FCC75
loc_FCC4A:
mov rax, [rbp+var_18]
and rax, 8000h
cmp rax, 0
jz short loc_FCC73
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call my_sync_dir_by_file
cmp eax, 0
jz short loc_FCC73
mov [rbp+var_1C], 0FFFFFFFFh
loc_FCC73:
jmp short $+2
loc_FCC75:
jmp short $+2
loc_FCC77:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_symlink(long long a1, const char *a2, long long a3)
{
unsigned int *v3; // rax
int v5; // [rsp+20h] [rbp-20h]
unsigned int v6; // [rsp+24h] [rbp-1Ch]
v6 = 0;
if ( (unsigned int)symlink(a1, a2) )
{
v6 = -1;
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(a1, a2) = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x19u, 0LL, a2, a1, *v3);
}
}
else if ( (a3 & 0x8000) != 0 && (unsigned int)my_sync_dir_by_file(a2, a3) )
{
return (unsigned int)-1;
}
return v6;
}
| my_symlink:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
JMP 0x001fcbd6
LAB_001fcbd6:
MOV dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00129060
CMP EAX,0x0
JZ 0x001fcc4a
MOV dword ptr [RBP + -0x1c],0xffffffff
CALL 0x00129700
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x20],EAX
CALL 0x001fdd30
MOV ECX,dword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x001fcc48
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x00129700
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX]
MOV EDI,0x19
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x001f76a0
LAB_001fcc48:
JMP 0x001fcc75
LAB_001fcc4a:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x8000
CMP RAX,0x0
JZ 0x001fcc73
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001fd9d0
CMP EAX,0x0
JZ 0x001fcc73
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_001fcc73:
JMP 0x001fcc75
LAB_001fcc75:
JMP 0x001fcc77
LAB_001fcc77:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
|
int4 my_symlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
int *piVar2;
int4 local_24;
local_24 = 0;
iVar1 = symlink(param_1,param_2);
if (iVar1 == 0) {
if (((param_3 & 0x8000) != 0) && (iVar1 = my_sync_dir_by_file(param_2,param_3), iVar1 != 0)) {
local_24 = 0xffffffff;
}
}
else {
local_24 = 0xffffffff;
piVar2 = __errno_location();
iVar1 = *piVar2;
piVar2 = (int *)_my_thread_var();
*piVar2 = iVar1;
if ((param_3 & 0x10) != 0) {
piVar2 = __errno_location();
my_error(0x19,0,param_2,param_1,*piVar2);
}
}
return local_24;
}
| |
24,595 | ma_cmp_block_unique | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_cmp_block_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
const uchar *record, MARIA_RECORD_POS pos)
{
uchar *org_rec_buff, *old_record;
size_t org_rec_buff_size;
int error;
my_bool buff_alloced;
DBUG_ENTER("_ma_cmp_block_unique");
alloc_on_stack(*info->stack_end_ptr, old_record, buff_alloced,
info->s->base.reclength);
if (!old_record)
DBUG_RETURN(1);
/* Don't let the compare destroy blobs that may be in use */
org_rec_buff= info->rec_buff;
org_rec_buff_size= info->rec_buff_size;
if (info->s->base.blobs)
{
/* Force realloc of record buffer*/
info->rec_buff= 0;
info->rec_buff_size= 0;
}
error= _ma_read_block_record(info, old_record, pos);
if (!error)
error= _ma_unique_comp(def, record, old_record, def->null_are_equal);
if (info->s->base.blobs)
{
my_free(info->rec_buff);
info->rec_buff= org_rec_buff;
info->rec_buff_size= org_rec_buff_size;
}
DBUG_PRINT("exit", ("result: %d", error));
stack_alloc_free(old_record, buff_alloced);
DBUG_RETURN(error != 0);
} | O3 | c | ma_cmp_block_unique:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq 0x398(%rax), %rsi
leaq -0x50(%rbp), %rdx
movq %rsi, (%rdx)
movq 0x78(%rdi), %rcx
movq (%rcx), %rcx
subq %rdx, %rcx
subq %rsi, %rcx
jbe 0x4d9ff
cmpq $0x10000, %rcx # imm = 0x10000
ja 0x4d9df
cmpq $0x1000, %rsi # imm = 0x1000
jb 0x4d9ff
cmpq $0x8001, %rcx # imm = 0x8001
jb 0x4d9ff
movq %r15, -0x40(%rbp)
movq %r14, -0x48(%rbp)
movq %rsp, %r13
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r13
movq %r13, %rsp
movb $0x1, %cl
movl %ecx, -0x34(%rbp)
jmp 0x4da29
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0xaa1d9
testq %rax, %rax
je 0x4dab5
movq %rax, %r13
movq %r15, -0x40(%rbp)
movq %r14, -0x48(%rbp)
movq (%rbx), %rax
movl $0x0, -0x34(%rbp)
movq 0x3a0(%rbx), %r15
movq 0x460(%rbx), %r14
cmpl $0x0, 0x3f0(%rax)
je 0x4da50
xorl %eax, %eax
movq %rax, 0x3a0(%rbx)
movq %rax, 0x460(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4d859
movb $0x1, %r12b
testl %eax, %eax
jne 0x4da7f
movq -0x40(%rbp), %rdi
movsbl 0x3(%rdi), %ecx
movq -0x48(%rbp), %rsi
movq %r13, %rdx
callq 0x598e5
testb %al, %al
setne %r12b
movq (%rbx), %rax
cmpl $0x0, 0x3f0(%rax)
je 0x4daa5
movq 0x3a0(%rbx), %rdi
callq 0xaa406
movq %r15, 0x3a0(%rbx)
movq %r14, 0x460(%rbx)
cmpb $0x0, -0x34(%rbp)
jne 0x4dab8
movq %r13, %rdi
callq 0xaa406
jmp 0x4dab8
movb $0x1, %r12b
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x4dad9
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a250
| _ma_cmp_block_unique:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r12, rcx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov rsi, [rax+398h]
lea rdx, [rbp+var_50]
mov [rdx], rsi
mov rcx, [rdi+78h]
mov rcx, [rcx]
sub rcx, rdx
sub rcx, rsi
jbe short loc_4D9FF
cmp rcx, offset stru_10000
ja short loc_4D9DF
cmp rsi, 1000h
jb short loc_4D9FF
cmp rcx, 8001h
jb short loc_4D9FF
loc_4D9DF:
mov [rbp+var_40], r15
mov [rbp+var_48], r14
mov r13, rsp
add rsi, 0Fh
and rsi, 0FFFFFFFFFFFFFFF0h
sub r13, rsi
mov rsp, r13
mov cl, 1
mov [rbp+var_34], ecx
jmp short loc_4DA29
loc_4D9FF:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_4DAB5
mov r13, rax
mov [rbp+var_40], r15
mov [rbp+var_48], r14
mov rax, [rbx]
mov [rbp+var_34], 0
loc_4DA29:
mov r15, [rbx+3A0h]
mov r14, [rbx+460h]
cmp dword ptr [rax+3F0h], 0
jz short loc_4DA50
xor eax, eax
mov [rbx+3A0h], rax
mov [rbx+460h], rax
loc_4DA50:
mov rdi, rbx
mov rsi, r13
mov rdx, r12
call _ma_read_block_record
mov r12b, 1
test eax, eax
jnz short loc_4DA7F
mov rdi, [rbp+var_40]
movsx ecx, byte ptr [rdi+3]
mov rsi, [rbp+var_48]
mov rdx, r13
call _ma_unique_comp
test al, al
setnz r12b
loc_4DA7F:
mov rax, [rbx]
cmp dword ptr [rax+3F0h], 0
jz short loc_4DAA5
mov rdi, [rbx+3A0h]
call my_free
mov [rbx+3A0h], r15
mov [rbx+460h], r14
loc_4DAA5:
cmp byte ptr [rbp+var_34], 0
jnz short loc_4DAB8
mov rdi, r13
call my_free
jmp short loc_4DAB8
loc_4DAB5:
mov r12b, 1
loc_4DAB8:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_4DAD9
mov eax, r12d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4DAD9:
call ___stack_chk_fail
| long long ma_cmp_block_unique(long long **a1, long long a2, long long a3, unsigned long long a4)
{
long long *v7; // rax
unsigned long long v8; // rsi
unsigned long long v9; // rcx
bool v10; // cc
unsigned long long v11; // rcx
char *v12; // r13
long long v13; // rax
long long *v14; // r15
long long *v15; // r14
int block_record; // eax
unsigned long long v18; // [rsp+0h] [rbp-50h] BYREF
long long v19; // [rsp+8h] [rbp-48h]
long long v20; // [rsp+10h] [rbp-40h]
int v21; // [rsp+1Ch] [rbp-34h]
unsigned long long v22; // [rsp+20h] [rbp-30h]
v22 = __readfsqword(0x28u);
v7 = *a1;
v8 = (*a1)[115];
v18 = v8;
v9 = *a1[15] - (_QWORD)&v18;
v10 = v9 <= v8;
v11 = v9 - v8;
if ( v10 || v11 <= (unsigned long long)&stru_10000 && (v8 < 0x1000 || v11 < 0x8001) )
{
v13 = my_malloc(0LL, v8, 65552LL);
if ( !v13 )
{
LOBYTE(a4) = 1;
return (unsigned int)a4;
}
v12 = (char *)v13;
v20 = a2;
v19 = a3;
v7 = *a1;
v21 = 0;
}
else
{
v20 = a2;
v19 = a3;
v12 = (char *)&v18 - ((v8 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v11) = 1;
v21 = v11;
}
v14 = a1[116];
v15 = a1[140];
if ( *((_DWORD *)v7 + 252) )
{
a1[116] = 0LL;
a1[140] = 0LL;
}
block_record = ma_read_block_record(a1, (long long)v12, a4);
LOBYTE(a4) = 1;
if ( !block_record )
LOBYTE(a4) = (unsigned __int8)ma_unique_comp(v20, v19, v12, (unsigned int)*(char *)(v20 + 3)) != 0;
if ( *((_DWORD *)*a1 + 252) )
{
my_free(a1[116]);
a1[116] = v14;
a1[140] = v15;
}
if ( !(_BYTE)v21 )
my_free(v12);
return (unsigned int)a4;
}
| _ma_cmp_block_unique:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R12,RCX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RAX + 0x398]
LEA RDX,[RBP + -0x50]
MOV qword ptr [RDX],RSI
MOV RCX,qword ptr [RDI + 0x78]
MOV RCX,qword ptr [RCX]
SUB RCX,RDX
SUB RCX,RSI
JBE 0x0014d9ff
CMP RCX,0x10000
JA 0x0014d9df
CMP RSI,0x1000
JC 0x0014d9ff
CMP RCX,0x8001
JC 0x0014d9ff
LAB_0014d9df:
MOV qword ptr [RBP + -0x40],R15
MOV qword ptr [RBP + -0x48],R14
MOV R13,RSP
ADD RSI,0xf
AND RSI,-0x10
SUB R13,RSI
MOV RSP,R13
MOV CL,0x1
MOV dword ptr [RBP + -0x34],ECX
JMP 0x0014da29
LAB_0014d9ff:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x001aa1d9
TEST RAX,RAX
JZ 0x0014dab5
MOV R13,RAX
MOV qword ptr [RBP + -0x40],R15
MOV qword ptr [RBP + -0x48],R14
MOV RAX,qword ptr [RBX]
MOV dword ptr [RBP + -0x34],0x0
LAB_0014da29:
MOV R15,qword ptr [RBX + 0x3a0]
MOV R14,qword ptr [RBX + 0x460]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x0014da50
XOR EAX,EAX
MOV qword ptr [RBX + 0x3a0],RAX
MOV qword ptr [RBX + 0x460],RAX
LAB_0014da50:
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
CALL 0x0014d859
MOV R12B,0x1
TEST EAX,EAX
JNZ 0x0014da7f
MOV RDI,qword ptr [RBP + -0x40]
MOVSX ECX,byte ptr [RDI + 0x3]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,R13
CALL 0x001598e5
TEST AL,AL
SETNZ R12B
LAB_0014da7f:
MOV RAX,qword ptr [RBX]
CMP dword ptr [RAX + 0x3f0],0x0
JZ 0x0014daa5
MOV RDI,qword ptr [RBX + 0x3a0]
CALL 0x001aa406
MOV qword ptr [RBX + 0x3a0],R15
MOV qword ptr [RBX + 0x460],R14
LAB_0014daa5:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x0014dab8
MOV RDI,R13
CALL 0x001aa406
JMP 0x0014dab8
LAB_0014dab5:
MOV R12B,0x1
LAB_0014dab8:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0014dad9
MOV EAX,R12D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014dad9:
CALL 0x0012a250
|
ulong _ma_cmp_block_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
long lVar2;
int8 uVar3;
char cVar4;
int iVar5;
int1 *puVar6;
long lVar7;
ulong uVar8;
ulong *puVar9;
int7 uVar10;
long in_FS_OFFSET;
ulong local_58;
int8 local_50;
long local_48;
int4 local_3c;
long local_38;
puVar9 = &local_58;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar7 = *param_1;
local_58 = *(ulong *)(lVar7 + 0x398);
uVar8 = (*(long *)param_1[0xf] - (long)&local_58) - local_58;
uVar10 = (int7)((ulong)param_4 >> 8);
if (((ulong)(*(long *)param_1[0xf] - (long)&local_58) < local_58 || uVar8 == 0) ||
((uVar8 < 0x10001 && ((local_58 < 0x1000 || (uVar8 < 0x8001)))))) {
puVar6 = (int1 *)my_malloc(0,local_58,0x10010);
if (puVar6 == (int1 *)0x0) {
uVar8 = CONCAT71(uVar10,1);
goto LAB_0014dab8;
}
lVar7 = *param_1;
local_3c = 0;
puVar9 = &local_58;
}
else {
puVar6 = (int1 *)((long)&local_58 - (local_58 + 0xf & 0xfffffffffffffff0));
local_3c = (int4)CONCAT71((int7)(uVar8 >> 8),1);
puVar9 = (ulong *)puVar6;
}
lVar1 = param_1[0x74];
lVar2 = param_1[0x8c];
if (*(int *)(lVar7 + 0x3f0) != 0) {
param_1[0x74] = 0;
param_1[0x8c] = 0;
}
local_50 = param_3;
local_48 = param_2;
*(int8 *)((long)puVar9 + -8) = 0x14da5e;
iVar5 = _ma_read_block_record(param_1,puVar6,param_4);
lVar7 = local_48;
uVar3 = local_50;
uVar8 = CONCAT71(uVar10,1);
if (iVar5 == 0) {
cVar4 = *(char *)(local_48 + 3);
*(int8 *)((long)puVar9 + -8) = 0x14da79;
cVar4 = _ma_unique_comp(lVar7,uVar3,puVar6,(int)cVar4);
uVar8 = CONCAT71(uVar10,cVar4 != '\0');
}
if (*(int *)(*param_1 + 0x3f0) != 0) {
lVar7 = param_1[0x74];
*(int8 *)((long)puVar9 + -8) = 0x14da97;
my_free(lVar7);
param_1[0x74] = lVar1;
param_1[0x8c] = lVar2;
}
if ((char)local_3c == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x14dab3;
my_free(puVar6);
}
LAB_0014dab8:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar8 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_scan_init_block_record;
__stack_chk_fail();
}
| |
24,596 | my_multi_malloc | eloqsql/mysys/mulalloc.c | void* my_multi_malloc(PSI_memory_key key, myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
size_t tot_length,length;
DBUG_ENTER("my_multi_malloc");
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args,uint);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *) my_malloc(key, tot_length,myFlags)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,uint);
res+=ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
} | O3 | c | my_multi_malloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r10
movq %rsi, %rdx
leaq -0xe0(%rbp), %r14
movq %r10, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x5a80e
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movabsq $0x1fffffff8, %rbx # imm = 0x1FFFFFFF8
movq %r14, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movabsq $0x3000000010, %r15 # imm = 0x3000000010
movq %r15, -0x30(%rbp)
movl $0x10, %eax
xorl %esi, %esi
cmpl $0x28, %eax
ja 0x5a84e
movq %rcx, %r8
movl %eax, %ecx
addq %r14, %rcx
addl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0x5a856
leaq 0x8(%rcx), %r8
movq %r8, -0x28(%rbp)
cmpq $0x0, (%rcx)
je 0x5a889
cmpl $0x28, %eax
ja 0x5a872
movq %r8, %rcx
movl %eax, %r8d
addq %r14, %r8
addl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0x5a87a
leaq 0x8(%r8), %rcx
movq %rcx, -0x28(%rbp)
movl (%r8), %r8d
addq $0x7, %r8
andq %rbx, %r8
addq %r8, %rsi
jmp 0x5a839
callq 0x5d03d
testq %rax, %rax
je 0x5a907
movq %r14, -0x20(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %r15, -0x30(%rbp)
movl $0x10, %edx
movq %rax, %rcx
cmpl $0x28, %edx
ja 0x5a8be
movl %edx, %esi
addq -0x20(%rbp), %rsi
addl $0x8, %edx
movl %edx, -0x30(%rbp)
jmp 0x5a8ca
movq -0x28(%rbp), %rsi
leaq 0x8(%rsi), %rdx
movq %rdx, -0x28(%rbp)
movq (%rsi), %rdx
testq %rdx, %rdx
je 0x5a907
movq %rcx, (%rdx)
movl -0x30(%rbp), %edx
cmpq $0x28, %rdx
ja 0x5a8ed
movq %rdx, %rsi
addq -0x20(%rbp), %rsi
addl $0x8, %edx
movl %edx, -0x30(%rbp)
jmp 0x5a8f9
movq -0x28(%rbp), %rsi
leaq 0x8(%rsi), %rdi
movq %rdi, -0x28(%rbp)
movl (%rsi), %esi
addq $0x7, %rsi
andq %rbx, %rsi
addq %rsi, %rcx
jmp 0x5a8ab
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| my_multi_malloc:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0C8h
mov r10, rdx
mov rdx, rsi
lea r14, [rbp+var_E0]
mov [r14+10h], r10
mov [r14+18h], rcx
mov [r14+20h], r8
mov [r14+28h], r9
test al, al
jz short loc_5A80E
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_5A80E:
mov rbx, 1FFFFFFF8h
mov [rbp+var_20], r14
lea rcx, [rbp+arg_0]
mov [rbp+var_28], rcx
mov r15, 3000000010h
mov [rbp+var_30], r15
mov eax, 10h
xor esi, esi
loc_5A839:
cmp eax, 28h ; '('
ja short loc_5A84E
mov r8, rcx
mov ecx, eax
add rcx, r14
add eax, 8
mov dword ptr [rbp+var_30], eax
jmp short loc_5A856
loc_5A84E:
lea r8, [rcx+8]
mov [rbp+var_28], r8
loc_5A856:
cmp qword ptr [rcx], 0
jz short loc_5A889
cmp eax, 28h ; '('
ja short loc_5A872
mov rcx, r8
mov r8d, eax
add r8, r14
add eax, 8
mov dword ptr [rbp+var_30], eax
jmp short loc_5A87A
loc_5A872:
lea rcx, [r8+8]
mov [rbp+var_28], rcx
loc_5A87A:
mov r8d, [r8]
add r8, 7
and r8, rbx
add rsi, r8
jmp short loc_5A839
loc_5A889:
call my_malloc
test rax, rax
jz short loc_5A907
mov [rbp+var_20], r14
lea rcx, [rbp+arg_0]
mov [rbp+var_28], rcx
mov [rbp+var_30], r15
mov edx, 10h
mov rcx, rax
loc_5A8AB:
cmp edx, 28h ; '('
ja short loc_5A8BE
mov esi, edx
add rsi, [rbp+var_20]
add edx, 8
mov dword ptr [rbp+var_30], edx
jmp short loc_5A8CA
loc_5A8BE:
mov rsi, [rbp+var_28]
lea rdx, [rsi+8]
mov [rbp+var_28], rdx
loc_5A8CA:
mov rdx, [rsi]
test rdx, rdx
jz short loc_5A907
mov [rdx], rcx
mov edx, dword ptr [rbp+var_30]
cmp rdx, 28h ; '('
ja short loc_5A8ED
mov rsi, rdx
add rsi, [rbp+var_20]
add edx, 8
mov dword ptr [rbp+var_30], edx
jmp short loc_5A8F9
loc_5A8ED:
mov rsi, [rbp+var_28]
lea rdi, [rsi+8]
mov [rbp+var_28], rdi
loc_5A8F9:
mov esi, [rsi]
add rsi, 7
and rsi, rbx
add rcx, rsi
jmp short loc_5A8AB
loc_5A907:
add rsp, 0C8h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long my_multi_malloc(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
unsigned int *v17; // rcx
unsigned int v18; // eax
long long i; // rsi
unsigned int *v20; // r8
long long result; // rax
unsigned int v22; // edx
long long j; // rcx
char *v24; // rsi
char *v25; // rsi
_BYTE v26[16]; // [rsp+0h] [rbp-E0h] BYREF
long long v27; // [rsp+10h] [rbp-D0h]
long long v28; // [rsp+18h] [rbp-C8h]
long long v29; // [rsp+20h] [rbp-C0h]
long long v30; // [rsp+28h] [rbp-B8h]
__m128 v31; // [rsp+30h] [rbp-B0h]
__m128 v32; // [rsp+40h] [rbp-A0h]
__m128 v33; // [rsp+50h] [rbp-90h]
__m128 v34; // [rsp+60h] [rbp-80h]
__m128 v35; // [rsp+70h] [rbp-70h]
__m128 v36; // [rsp+80h] [rbp-60h]
__m128 v37; // [rsp+90h] [rbp-50h]
__m128 v38; // [rsp+A0h] [rbp-40h]
long long v39; // [rsp+B0h] [rbp-30h]
char *v40; // [rsp+B8h] [rbp-28h]
_BYTE *v41; // [rsp+C0h] [rbp-20h]
v31 = a7;
v32 = a8;
v33 = a9;
v34 = a10;
v35 = a11;
v36 = a12;
v37 = a13;
v38 = a14;
v27 = a3;
v28 = a4;
v29 = a5;
v30 = a6;
v41 = v26;
v17 = (unsigned int *)&a15;
v40 = &a15;
v39 = 0x3000000010LL;
v18 = 16;
for ( i = 0LL; ; i += (*v20 + 7LL) & 0x1FFFFFFF8LL )
{
if ( v18 > 0x28 )
{
v20 = v17 + 2;
v40 = (char *)(v17 + 2);
}
else
{
v20 = v17;
v17 = (unsigned int *)&v26[v18];
v18 += 8;
LODWORD(v39) = v18;
}
if ( !*(_QWORD *)v17 )
break;
if ( v18 > 0x28 )
{
v17 = v20 + 2;
v40 = (char *)(v20 + 2);
}
else
{
v17 = v20;
v20 = (unsigned int *)&v26[v18];
v18 += 8;
LODWORD(v39) = v18;
}
}
result = my_malloc(a1, i, a2);
if ( result )
{
v41 = v26;
v40 = &a15;
v39 = 0x3000000010LL;
v22 = 16;
for ( j = result; ; j += (*(unsigned int *)v25 + 7LL) & 0x1FFFFFFF8LL )
{
if ( v22 > 0x28 )
{
v24 = v40;
v40 += 8;
}
else
{
v24 = &v41[v22];
LODWORD(v39) = v22 + 8;
}
if ( !*(_QWORD *)v24 )
break;
**(_QWORD **)v24 = j;
v22 = v39;
if ( (unsigned int)v39 > 0x28uLL )
{
v25 = v40;
v40 += 8;
}
else
{
v25 = &v41[(unsigned int)v39];
v22 = v39 + 8;
LODWORD(v39) = v39 + 8;
}
}
}
return result;
}
| my_multi_malloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xc8
MOV R10,RDX
MOV RDX,RSI
LEA R14,[RBP + -0xe0]
MOV qword ptr [R14 + 0x10],R10
MOV qword ptr [R14 + 0x18],RCX
MOV qword ptr [R14 + 0x20],R8
MOV qword ptr [R14 + 0x28],R9
TEST AL,AL
JZ 0x0015a80e
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_0015a80e:
MOV RBX,0x1fffffff8
MOV qword ptr [RBP + -0x20],R14
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RCX
MOV R15,0x3000000010
MOV qword ptr [RBP + -0x30],R15
MOV EAX,0x10
XOR ESI,ESI
LAB_0015a839:
CMP EAX,0x28
JA 0x0015a84e
MOV R8,RCX
MOV ECX,EAX
ADD RCX,R14
ADD EAX,0x8
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0015a856
LAB_0015a84e:
LEA R8,[RCX + 0x8]
MOV qword ptr [RBP + -0x28],R8
LAB_0015a856:
CMP qword ptr [RCX],0x0
JZ 0x0015a889
CMP EAX,0x28
JA 0x0015a872
MOV RCX,R8
MOV R8D,EAX
ADD R8,R14
ADD EAX,0x8
MOV dword ptr [RBP + -0x30],EAX
JMP 0x0015a87a
LAB_0015a872:
LEA RCX,[R8 + 0x8]
MOV qword ptr [RBP + -0x28],RCX
LAB_0015a87a:
MOV R8D,dword ptr [R8]
ADD R8,0x7
AND R8,RBX
ADD RSI,R8
JMP 0x0015a839
LAB_0015a889:
CALL 0x0015d03d
TEST RAX,RAX
JZ 0x0015a907
MOV qword ptr [RBP + -0x20],R14
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R15
MOV EDX,0x10
MOV RCX,RAX
LAB_0015a8ab:
CMP EDX,0x28
JA 0x0015a8be
MOV ESI,EDX
ADD RSI,qword ptr [RBP + -0x20]
ADD EDX,0x8
MOV dword ptr [RBP + -0x30],EDX
JMP 0x0015a8ca
LAB_0015a8be:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDX,[RSI + 0x8]
MOV qword ptr [RBP + -0x28],RDX
LAB_0015a8ca:
MOV RDX,qword ptr [RSI]
TEST RDX,RDX
JZ 0x0015a907
MOV qword ptr [RDX],RCX
MOV EDX,dword ptr [RBP + -0x30]
CMP RDX,0x28
JA 0x0015a8ed
MOV RSI,RDX
ADD RSI,qword ptr [RBP + -0x20]
ADD EDX,0x8
MOV dword ptr [RBP + -0x30],EDX
JMP 0x0015a8f9
LAB_0015a8ed:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RSI + 0x8]
MOV qword ptr [RBP + -0x28],RDI
LAB_0015a8f9:
MOV ESI,dword ptr [RSI]
ADD RSI,0x7
AND RSI,RBX
ADD RCX,RSI
JMP 0x0015a8ab
LAB_0015a907:
ADD RSP,0xc8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void my_multi_malloc(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
uint uVar1;
uint *puVar2;
ulong uVar3;
long lVar4;
uint *puVar5;
uint *puVar6;
uint local_e8 [4];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
uint local_38;
int4 uStack_34;
uint *local_30;
uint *local_28;
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
puVar5 = (uint *)&stack0x00000008;
local_30 = puVar5;
local_38 = 0x10;
uStack_34 = 0x30;
uVar1 = 0x10;
lVar4 = 0;
while( true ) {
if (uVar1 < 0x29) {
uVar3 = (ulong)uVar1;
uVar1 = uVar1 + 8;
local_38 = uVar1;
puVar2 = (uint *)((long)local_e8 + uVar3);
puVar6 = puVar5;
}
else {
puVar6 = puVar5 + 2;
local_30 = puVar6;
puVar2 = puVar5;
}
if (*(long *)puVar2 == 0) break;
if (uVar1 < 0x29) {
uVar3 = (ulong)uVar1;
uVar1 = uVar1 + 8;
local_38 = uVar1;
puVar5 = puVar6;
puVar6 = (uint *)((long)local_e8 + uVar3);
}
else {
puVar5 = puVar6 + 2;
local_30 = puVar5;
}
lVar4 = lVar4 + ((ulong)*puVar6 + 7 & 0x1fffffff8);
}
lVar4 = my_malloc(param_9,lVar4,param_10);
if (lVar4 != 0) {
local_30 = (uint *)&stack0x00000008;
uVar1 = 0x10;
uVar3 = 0x10;
while( true ) {
if ((uint)uVar3 < 0x29) {
uVar1 = (uint)uVar3 + 8;
puVar5 = (uint *)((long)local_e8 + uVar3);
}
else {
puVar5 = local_30;
local_30 = local_30 + 2;
}
if (*(long **)puVar5 == (long *)0x0) break;
**(long **)puVar5 = lVar4;
uVar3 = (ulong)uVar1;
if (uVar3 < 0x29) {
puVar5 = (uint *)((long)local_e8 + uVar3);
uVar1 = uVar1 + 8;
uVar3 = (ulong)uVar1;
}
else {
puVar5 = local_30;
local_30 = local_30 + 2;
}
lVar4 = lVar4 + ((ulong)*puVar5 + 7 & 0x1fffffff8);
}
}
return;
}
| |
24,597 | diagnostic_context_add | tsotchke[P]eshkol/src/core/diagnostics/diagnostics.c | void diagnostic_context_add(
DiagnosticContext* context,
DiagnosticSeverity severity,
SourceLocation location,
const char* message,
const char* code) {
assert(context != NULL);
assert(message != NULL);
// Check if we need to resize the array
if (context->diagnostics.count >= context->diagnostics.capacity) {
size_t new_capacity = context->diagnostics.capacity == 0 ? 8 : context->diagnostics.capacity * 2;
size_t new_size = new_capacity * sizeof(Diagnostic);
// Allocate new array
Diagnostic* new_items = arena_alloc(context->arena, new_size);
if (!new_items) return; // Failed to allocate
// Copy old items
if (context->diagnostics.items) {
memcpy(new_items, context->diagnostics.items, context->diagnostics.count * sizeof(Diagnostic));
}
// Update array
context->diagnostics.items = new_items;
context->diagnostics.capacity = new_capacity;
}
// Add diagnostic
Diagnostic* diagnostic = &context->diagnostics.items[context->diagnostics.count++];
diagnostic->severity = severity;
diagnostic->location = location;
diagnostic->message = message;
diagnostic->code = code;
// Update error count
if (severity == DIAGNOSTIC_ERROR || severity == DIAGNOSTIC_FATAL) {
context->error_count++;
}
} | O0 | c | diagnostic_context_add:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4858
jmp 0x4877
leaq 0xbcf0(%rip), %rdi # 0x1054f
leaq 0xbc56(%rip), %rsi # 0x104bc
movl $0x44, %edx
leaq 0xbced(%rip), %rcx # 0x1055f
callq 0x10a0
cmpq $0x0, -0x18(%rbp)
je 0x4880
jmp 0x489f
leaq 0xbd49(%rip), %rdi # 0x105d0
leaq 0xbc2e(%rip), %rsi # 0x104bc
movl $0x45, %edx
leaq 0xbcc5(%rip), %rcx # 0x1055f
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x4948
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x48cb
movl $0x8, %eax
movq %rax, -0x50(%rbp)
jmp 0x48da
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x28(%rbp)
imulq $0x30, -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x3a90
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x490b
jmp 0x49ca
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4930
movq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
imulq $0x30, 0x10(%rax), %rdx
callq 0x10f0
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x10(%rsi), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edx
movq -0x40(%rbp), %rax
movl %edx, (%rax)
movq -0x40(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpl $0x2, -0xc(%rbp)
je 0x49ba
cmpl $0x3, -0xc(%rbp)
jne 0x49ca
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x50, %rsp
popq %rbp
retq
| diagnostic_context_add:
push rbp
mov rbp, rsp
sub rsp, 50h
lea rax, [rbp+arg_0]
mov [rbp+var_48], rax
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
cmp [rbp+var_8], 0
jz short loc_4858
jmp short loc_4877
loc_4858:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 44h ; 'D'
lea rcx, aVoidDiagnostic; "void diagnostic_context_add(DiagnosticC"...
call ___assert_fail
loc_4877:
cmp [rbp+var_18], 0
jz short loc_4880
jmp short loc_489F
loc_4880:
lea rdi, aMessageNull; "message != NULL"
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 45h ; 'E'
lea rcx, aVoidDiagnostic; "void diagnostic_context_add(DiagnosticC"...
call ___assert_fail
loc_489F:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov rcx, [rbp+var_8]
cmp rax, [rcx+18h]
jb loc_4948
mov rax, [rbp+var_8]
cmp qword ptr [rax+18h], 0
jnz short loc_48CB
mov eax, 8
mov [rbp+var_50], rax
jmp short loc_48DA
loc_48CB:
mov rax, [rbp+var_8]
mov rax, [rax+18h]
shl rax, 1
mov [rbp+var_50], rax
loc_48DA:
mov rax, [rbp+var_50]
mov [rbp+var_28], rax
imul rax, [rbp+var_28], 30h ; '0'
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rdi, [rax]
mov rsi, [rbp+var_30]
call arena_alloc
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz short loc_490B
jmp loc_49CA
loc_490B:
mov rax, [rbp+var_8]
cmp qword ptr [rax+8], 0
jz short loc_4930
mov rdi, [rbp+var_38]
mov rax, [rbp+var_8]
mov rsi, [rax+8]
mov rax, [rbp+var_8]
imul rdx, [rax+10h], 30h ; '0'
call _memcpy
loc_4930:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_8]
mov [rax+8], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+18h], rcx
loc_4948:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rsi, [rbp+var_8]
mov rdx, [rsi+10h]
mov rdi, rdx
add rdi, 1
mov [rsi+10h], rdi
imul rdx, 30h ; '0'
add rax, rdx
mov [rbp+var_40], rax
mov edx, [rbp+var_C]
mov rax, [rbp+var_40]
mov [rax], edx
mov rax, [rbp+var_40]
mov rdx, [rcx]
mov [rax+8], rdx
mov rdx, [rcx+8]
mov [rax+10h], rdx
mov rcx, [rcx+10h]
mov [rax+18h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_40]
mov [rax+20h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_40]
mov [rax+28h], rcx
cmp [rbp+var_C], 2
jz short loc_49BA
cmp [rbp+var_C], 3
jnz short loc_49CA
loc_49BA:
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
add rcx, 1
mov [rax+20h], rcx
loc_49CA:
add rsp, 50h
pop rbp
retn
| long long diagnostic_context_add(
long long *a1,
int a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
long long result; // rax
long long v10; // rax
long long v11; // rdx
long long v12; // [rsp+0h] [rbp-50h]
long long v13; // [rsp+10h] [rbp-40h]
long long v14; // [rsp+18h] [rbp-38h]
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/diagnostics/diagnostics.c",
68LL,
"void diagnostic_context_add(DiagnosticContext *, DiagnosticSeverity, SourceLocation, const char *, const char *)");
if ( !a3 )
__assert_fail(
"message != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/diagnostics/diagnostics.c",
69LL,
"void diagnostic_context_add(DiagnosticContext *, DiagnosticSeverity, SourceLocation, const char *, const char *)");
if ( a1[2] < (unsigned long long)a1[3] )
goto LABEL_13;
if ( a1[3] )
v12 = 2 * a1[3];
else
v12 = 8LL;
result = arena_alloc(*a1, 48 * v12);
v14 = result;
if ( result )
{
if ( a1[1] )
memcpy(result, a1[1], 48 * a1[2]);
a1[1] = v14;
a1[3] = v12;
LABEL_13:
v10 = a1[1];
v11 = a1[2];
a1[2] = v11 + 1;
v13 = 48 * v11 + v10;
*(_DWORD *)v13 = a2;
*(_QWORD *)(v13 + 8) = a7;
*(_QWORD *)(v13 + 16) = a8;
*(_QWORD *)(v13 + 24) = a9;
*(_QWORD *)(v13 + 32) = a3;
result = v13;
*(_QWORD *)(v13 + 40) = a4;
if ( a2 == 2 || a2 == 3 )
{
result = (long long)a1;
++a1[4];
}
}
return result;
}
| diagnostic_context_add:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00104858
JMP 0x00104877
LAB_00104858:
LEA RDI,[0x11054f]
LEA RSI,[0x1104bc]
MOV EDX,0x44
LEA RCX,[0x11055f]
CALL 0x001010a0
LAB_00104877:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00104880
JMP 0x0010489f
LAB_00104880:
LEA RDI,[0x1105d0]
LEA RSI,[0x1104bc]
MOV EDX,0x45
LEA RCX,[0x11055f]
CALL 0x001010a0
LAB_0010489f:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x18]
JC 0x00104948
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x001048cb
MOV EAX,0x8
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001048da
LAB_001048cb:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
SHL RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
LAB_001048da:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
IMUL RAX,qword ptr [RBP + -0x28],0x30
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x00103a90
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0010490b
JMP 0x001049ca
LAB_0010490b:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00104930
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
IMUL RDX,qword ptr [RAX + 0x10],0x30
CALL 0x001010f0
LAB_00104930:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
LAB_00104948:
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RSI + 0x10]
MOV RDI,RDX
ADD RDI,0x1
MOV qword ptr [RSI + 0x10],RDI
IMUL RDX,RDX,0x30
ADD RAX,RDX
MOV qword ptr [RBP + -0x40],RAX
MOV EDX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX + 0x28],RCX
CMP dword ptr [RBP + -0xc],0x2
JZ 0x001049ba
CMP dword ptr [RBP + -0xc],0x3
JNZ 0x001049ca
LAB_001049ba:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,0x1
MOV qword ptr [RAX + 0x20],RCX
LAB_001049ca:
ADD RSP,0x50
POP RBP
RET
|
void diagnostic_context_add
(int8 *param_1,int param_2,long param_3,int8 param_4,int8 param_5,
int8 param_6,int8 param_7,int8 param_8,int8 param_9)
{
long lVar1;
void *__dest;
int *piVar2;
long local_58;
if (param_1 == (int8 *)0x0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/diagnostics/diagnostics.c"
,0x44,
"void diagnostic_context_add(DiagnosticContext *, DiagnosticSeverity, SourceLocation, const char *, const char *)"
);
}
if (param_3 != 0) {
if ((ulong)param_1[3] <= (ulong)param_1[2]) {
if (param_1[3] == 0) {
local_58 = 8;
}
else {
local_58 = param_1[3] << 1;
}
__dest = (void *)arena_alloc(*param_1,local_58 * 0x30);
if (__dest == (void *)0x0) {
return;
}
if (param_1[1] != 0) {
memcpy(__dest,(void *)param_1[1],param_1[2] * 0x30);
}
param_1[1] = __dest;
param_1[3] = local_58;
}
lVar1 = param_1[2];
param_1[2] = lVar1 + 1;
piVar2 = (int *)(param_1[1] + lVar1 * 0x30);
*piVar2 = param_2;
*(int8 *)(piVar2 + 2) = param_7;
*(int8 *)(piVar2 + 4) = param_8;
*(int8 *)(piVar2 + 6) = param_9;
*(long *)(piVar2 + 8) = param_3;
*(int8 *)(piVar2 + 10) = param_4;
if ((param_2 == 2) || (param_2 == 3)) {
param_1[4] = param_1[4] + 1;
}
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("message != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/diagnostics/diagnostics.c"
,0x45,
"void diagnostic_context_add(DiagnosticContext *, DiagnosticSeverity, SourceLocation, const char *, const char *)"
);
}
| |
24,598 | ft_boolean_find_relevance | eloqsql/storage/myisam/ft_boolean_search.c | float ft_boolean_find_relevance(FT_INFO *ftb, uchar *record, uint length)
{
FTB_EXPR *ftbe;
FT_SEG_ITERATOR ftsi, ftsi2;
my_off_t docid=ftb->info->lastpos;
MY_FTB_FIND_PARAM ftb_param;
MYSQL_FTPARSER_PARAM *param;
struct st_mysql_ftparser *parser= ftb->keynr == NO_SUCH_KEY ?
&ft_default_parser :
ftb->info->s->keyinfo[ftb->keynr].parser;
if (docid == HA_OFFSET_ERROR)
return -2.0;
if (!ftb->queue.elements)
return 0;
if (! (param= ftparser_call_initializer(ftb->info, ftb->keynr, 0)))
return 0;
if (ftb->state != INDEX_SEARCH && docid <= ftb->lastpos)
{
FTB_EXPR *x;
uint i;
for (i=0; i < ftb->queue.elements; i++)
{
ftb->list[i]->docid[1]=HA_OFFSET_ERROR;
for (x=ftb->list[i]->up; x; x=x->up)
x->docid[1]=HA_OFFSET_ERROR;
}
}
ftb->lastpos=docid;
if (ftb->keynr==NO_SUCH_KEY)
_mi_ft_segiterator_dummy_init(record, length, &ftsi);
else
_mi_ft_segiterator_init(ftb->info, ftb->keynr, record, &ftsi);
memcpy(&ftsi2, &ftsi, sizeof(ftsi));
ftb_param.ftb= ftb;
ftb_param.ftsi= &ftsi2;
param->mysql_parse= ftb_find_relevance_parse;
param->mysql_add_word= ftb_find_relevance_add_word;
param->mysql_ftparam= (void *)&ftb_param;
param->flags= 0;
param->cs= ftb->charset;
param->mode= MYSQL_FTPARSER_SIMPLE_MODE;
while (_mi_ft_segiterator(&ftsi))
{
if (!ftsi.pos)
continue;
param->doc= (char *)ftsi.pos;
param->length= ftsi.len;
if (unlikely(parser->parse(param)))
return 0;
}
ftbe=ftb->root;
if (ftbe->docid[1]==docid && ftbe->cur_weight>0 &&
ftbe->yesses>=ftbe->ythresh && !ftbe->nos)
{ /* row matched ! */
return ftbe->cur_weight;
}
else
{ /* match failed ! */
return 0.0;
}
} | O0 | c | ft_boolean_find_relevance:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x170(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x340(%rax)
jne 0xa0926
leaq 0x21f863(%rip), %rax # 0x2c0180
movq %rax, -0xa8(%rbp)
jmp 0xa0954
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x340(%rcx), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $-0x1, -0x70(%rbp)
jne 0xa097b
movss 0xb169f(%rip), %xmm0 # 0x152010
movss %xmm0, -0x4(%rbp)
jmp 0xa0c25
movq -0x10(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0xa0995
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa0c25
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x340(%rax), %esi
xorl %edx, %edx
callq 0xa4130
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
jne 0xa09c8
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa0c25
movq -0x10(%rbp), %rax
cmpl $0x2, 0x348(%rax)
je 0xa0a84
movq -0x70(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x338(%rcx), %rax
ja 0xa0a84
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x80(%rcx), %eax
jae 0xa0a82
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x9c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq $-0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x9c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0xa0a6c
movq -0x98(%rbp), %rax
movq $-0x1, 0x18(%rax)
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x98(%rbp)
jmp 0xa0a40
jmp 0xa0a6e
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0xa09f8
jmp 0xa0a84
movq -0x70(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x338(%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x340(%rax)
jne 0xa0ab2
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
leaq -0x48(%rbp), %rdx
callq 0xa4400
jmp 0xa0ad1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x340(%rax), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0xa4380
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x68(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x88(%rbp), %rax
leaq 0x131(%rip), %rcx # 0xa0c40
movq %rcx, (%rax)
movq -0x88(%rbp), %rax
leaq 0x1a0(%rip), %rcx # 0xa0cc0
movq %rcx, 0x8(%rax)
movq -0x88(%rbp), %rax
leaq -0x80(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x88(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x88(%rbp), %rax
movl $0x0, 0x38(%rax)
leaq -0x48(%rbp), %rdi
callq 0xa4440
cmpl $0x0, %eax
je 0xa0bc8
cmpq $0x0, -0x30(%rbp)
jne 0xa0b79
jmp 0xa0b62
movq -0x30(%rbp), %rcx
movq -0x88(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x44(%rbp), %ecx
movq -0x88(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x90(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x88(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xa0bc6
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa0c25
jmp 0xa0b62
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x70(%rbp), %rax
jne 0xa0c1d
movq -0x28(%rbp), %rax
movss 0x2c(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xa0c1d
movq -0x28(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jb 0xa0c1d
movq -0x28(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xa0c1d
movq -0x28(%rbp), %rax
movss 0x2c(%rax), %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xa0c25
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ft_boolean_find_relevance:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax+170h]
mov [rbp+var_70], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+340h], 0FFFFFFFFh
jnz short loc_A0926
lea rax, ft_default_parser
mov [rbp+var_A8], rax
jmp short loc_A0954
loc_A0926:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax]
mov rax, [rax+218h]
mov rcx, [rbp+var_10]
mov ecx, [rcx+340h]
imul rcx, 70h ; 'p'
add rax, rcx
mov rax, [rax+38h]
mov [rbp+var_A8], rax
loc_A0954:
mov rax, [rbp+var_A8]
mov [rbp+var_90], rax
cmp [rbp+var_70], 0FFFFFFFFFFFFFFFFh
jnz short loc_A097B
movss xmm0, cs:dword_152010
movss [rbp+var_4], xmm0
jmp loc_A0C25
loc_A097B:
mov rax, [rbp+var_10]
cmp dword ptr [rax+80h], 0
jnz short loc_A0995
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
jmp loc_A0C25
loc_A0995:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rax, [rbp+var_10]
mov esi, [rax+340h]
xor edx, edx
call ftparser_call_initializer
mov [rbp+var_88], rax
cmp rax, 0
jnz short loc_A09C8
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
jmp loc_A0C25
loc_A09C8:
mov rax, [rbp+var_10]
cmp dword ptr [rax+348h], 2
jz loc_A0A84
mov rax, [rbp+var_70]
mov rcx, [rbp+var_10]
cmp rax, [rcx+338h]
ja loc_A0A84
mov [rbp+var_9C], 0
loc_A09F8:
mov eax, [rbp+var_9C]
mov rcx, [rbp+var_10]
cmp eax, [rcx+80h]
jnb short loc_A0A82
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov ecx, [rbp+var_9C]
mov rax, [rax+rcx*8]
mov qword ptr [rax+18h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov ecx, [rbp+var_9C]
mov rax, [rax+rcx*8]
mov rax, [rax]
mov [rbp+var_98], rax
loc_A0A40:
cmp [rbp+var_98], 0
jz short loc_A0A6C
mov rax, [rbp+var_98]
mov qword ptr [rax+18h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_98]
mov rax, [rax]
mov [rbp+var_98], rax
jmp short loc_A0A40
loc_A0A6C:
jmp short $+2
loc_A0A6E:
mov eax, [rbp+var_9C]
add eax, 1
mov [rbp+var_9C], eax
jmp loc_A09F8
loc_A0A82:
jmp short $+2
loc_A0A84:
mov rcx, [rbp+var_70]
mov rax, [rbp+var_10]
mov [rax+338h], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+340h], 0FFFFFFFFh
jnz short loc_A0AB2
mov rdi, [rbp+var_18]
mov esi, [rbp+var_1C]
lea rdx, [rbp+var_48]
call _mi_ft_segiterator_dummy_init
jmp short loc_A0AD1
loc_A0AB2:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
mov rax, [rbp+var_10]
mov esi, [rax+340h]
mov rdx, [rbp+var_18]
lea rcx, [rbp+var_48]
call _mi_ft_segiterator_init
loc_A0AD1:
mov rax, [rbp+var_48]
mov [rbp+var_68], rax
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov rax, [rbp+var_38]
mov [rbp+var_58], rax
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov [rbp+var_80], rax
lea rax, [rbp+var_68]
mov [rbp+var_78], rax
mov rax, [rbp+var_88]
lea rcx, ftb_find_relevance_parse
mov [rax], rcx
mov rax, [rbp+var_88]
lea rcx, ftb_find_relevance_add_word
mov [rax+8], rcx
mov rax, [rbp+var_88]
lea rcx, [rbp+var_80]
mov [rax+18h], rcx
mov rax, [rbp+var_88]
mov dword ptr [rax+34h], 0
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_88]
mov [rax+20h], rcx
mov rax, [rbp+var_88]
mov dword ptr [rax+38h], 0
loc_A0B62:
lea rdi, [rbp+var_48]
call _mi_ft_segiterator
cmp eax, 0
jz short loc_A0BC8
cmp [rbp+var_30], 0
jnz short loc_A0B79
jmp short loc_A0B62
loc_A0B79:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_88]
mov [rax+28h], rcx
mov ecx, dword ptr [rbp+var_48+4]
mov rax, [rbp+var_88]
mov [rax+30h], ecx
mov rax, [rbp+var_90]
mov rax, [rax+8]
mov rdi, [rbp+var_88]
call rax
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_A0BC6
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
jmp short loc_A0C25
loc_A0BC6:
jmp short loc_A0B62
loc_A0BC8:
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rax, [rax+18h]
cmp rax, [rbp+var_70]
jnz short loc_A0C1D
mov rax, [rbp+var_28]
movss xmm0, dword ptr [rax+2Ch]
xorps xmm1, xmm1
ucomiss xmm0, xmm1
jbe short loc_A0C1D
mov rax, [rbp+var_28]
mov eax, [rax+40h]
mov rcx, [rbp+var_28]
cmp eax, [rcx+48h]
jb short loc_A0C1D
mov rax, [rbp+var_28]
cmp dword ptr [rax+44h], 0
jnz short loc_A0C1D
mov rax, [rbp+var_28]
movss xmm0, dword ptr [rax+2Ch]
movss [rbp+var_4], xmm0
jmp short loc_A0C25
loc_A0C1D:
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
loc_A0C25:
movss xmm0, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
| float ft_boolean_find_relevance(long long a1, long long a2, unsigned int a3)
{
unsigned int ( **v4)(long long); // [rsp+8h] [rbp-A8h]
long long v5; // [rsp+14h] [rbp-9Ch]
_QWORD *i; // [rsp+18h] [rbp-98h]
long long v7; // [rsp+28h] [rbp-88h]
_QWORD v8[2]; // [rsp+30h] [rbp-80h] BYREF
unsigned long long v9; // [rsp+40h] [rbp-70h]
_QWORD v10[4]; // [rsp+48h] [rbp-68h] BYREF
_QWORD v11[3]; // [rsp+68h] [rbp-48h] BYREF
long long v12; // [rsp+80h] [rbp-30h]
long long v13; // [rsp+88h] [rbp-28h]
unsigned int v14; // [rsp+94h] [rbp-1Ch]
long long v15; // [rsp+98h] [rbp-18h]
long long v16; // [rsp+A0h] [rbp-10h]
v16 = a1;
v15 = a2;
v14 = a3;
v9 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 368LL);
if ( *(_DWORD *)(a1 + 832) == -1 )
v4 = (unsigned int ( **)(long long))&ft_default_parser;
else
v4 = *(unsigned int ( ***)(long long))(112LL * *(unsigned int *)(v16 + 832)
+ *(_QWORD *)(**(_QWORD **)(v16 + 8) + 536LL)
+ 56);
if ( v9 == -1LL )
return -2.0;
if ( !*(_DWORD *)(v16 + 128) )
return 0.0;
v7 = ftparser_call_initializer(*(_QWORD *)(v16 + 8), *(unsigned int *)(v16 + 832), 0LL);
if ( !v7 )
return 0.0;
if ( *(_DWORD *)(v16 + 840) != 2 && v9 <= *(_QWORD *)(v16 + 824) )
{
LODWORD(v5) = 0;
while ( (unsigned int)v5 < *(_DWORD *)(v16 + 128) )
{
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(v16 + 32) + 8LL * (unsigned int)v5) + 24LL) = -1LL;
for ( i = **(_QWORD ***)(*(_QWORD *)(v16 + 32) + 8LL * (unsigned int)v5); i; i = (_QWORD *)*i )
i[3] = -1LL;
v5 = (unsigned int)(v5 + 1);
}
}
*(_QWORD *)(v16 + 824) = v9;
if ( *(_DWORD *)(v16 + 832) == -1 )
mi_ft_segiterator_dummy_init(v15, v14, v11);
else
mi_ft_segiterator_init(*(_QWORD *)(v16 + 8), *(unsigned int *)(v16 + 832), v15, v11);
v10[0] = v11[0];
v10[1] = v11[1];
v10[2] = v11[2];
v10[3] = v12;
v8[0] = v16;
v8[1] = v10;
*(_QWORD *)v7 = ftb_find_relevance_parse;
*(_QWORD *)(v7 + 8) = ftb_find_relevance_add_word;
*(_QWORD *)(v7 + 24) = v8;
*(_DWORD *)(v7 + 52) = 0;
*(_QWORD *)(v7 + 32) = *(_QWORD *)(v16 + 16);
*(_DWORD *)(v7 + 56) = 0;
while ( (unsigned int)mi_ft_segiterator(v11) )
{
if ( v12 )
{
*(_QWORD *)(v7 + 40) = v12;
*(_DWORD *)(v7 + 48) = HIDWORD(v11[0]);
if ( v4[1](v7) )
return 0.0;
}
}
v13 = *(_QWORD *)(v16 + 24);
if ( *(_QWORD *)(v13 + 24) != v9
|| *(float *)(v13 + 44) <= 0.0
|| *(_DWORD *)(v13 + 64) < *(_DWORD *)(v13 + 72)
|| *(_DWORD *)(v13 + 68) )
{
return 0.0;
}
else
{
return *(float *)(v13 + 44);
}
}
| ft_boolean_find_relevance:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x170]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x340],-0x1
JNZ 0x001a0926
LEA RAX,[0x3c0180]
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x001a0954
LAB_001a0926:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x340]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0xa8],RAX
LAB_001a0954:
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0x90],RAX
CMP qword ptr [RBP + -0x70],-0x1
JNZ 0x001a097b
MOVSS XMM0,dword ptr [0x00252010]
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x001a0c25
LAB_001a097b:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x80],0x0
JNZ 0x001a0995
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x001a0c25
LAB_001a0995:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x340]
XOR EDX,EDX
CALL 0x001a4130
MOV qword ptr [RBP + -0x88],RAX
CMP RAX,0x0
JNZ 0x001a09c8
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x001a0c25
LAB_001a09c8:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x348],0x2
JZ 0x001a0a84
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x338]
JA 0x001a0a84
MOV dword ptr [RBP + -0x9c],0x0
LAB_001a09f8:
MOV EAX,dword ptr [RBP + -0x9c]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x80]
JNC 0x001a0a82
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV ECX,dword ptr [RBP + -0x9c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RAX + 0x18],-0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV ECX,dword ptr [RBP + -0x9c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x98],RAX
LAB_001a0a40:
CMP qword ptr [RBP + -0x98],0x0
JZ 0x001a0a6c
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RAX + 0x18],-0x1
MOV RAX,qword ptr [RBP + -0x98]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001a0a40
LAB_001a0a6c:
JMP 0x001a0a6e
LAB_001a0a6e:
MOV EAX,dword ptr [RBP + -0x9c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x9c],EAX
JMP 0x001a09f8
LAB_001a0a82:
JMP 0x001a0a84
LAB_001a0a84:
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x338],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x340],-0x1
JNZ 0x001a0ab2
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x1c]
LEA RDX,[RBP + -0x48]
CALL 0x001a4400
JMP 0x001a0ad1
LAB_001a0ab2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x340]
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x48]
CALL 0x001a4380
LAB_001a0ad1:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x80],RAX
LEA RAX,[RBP + -0x68]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0x1a0c40]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0x1a0cc0]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[RBP + -0x80]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX + 0x34],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX + 0x38],0x0
LAB_001a0b62:
LEA RDI,[RBP + -0x48]
CALL 0x001a4440
CMP EAX,0x0
JZ 0x001a0bc8
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001a0b79
JMP 0x001a0b62
LAB_001a0b79:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX + 0x28],RCX
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX + 0x30],ECX
MOV RAX,qword ptr [RBP + -0x90]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x88]
CALL RAX
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001a0bc6
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x001a0c25
LAB_001a0bc6:
JMP 0x001a0b62
LAB_001a0bc8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x18]
CMP RAX,qword ptr [RBP + -0x70]
JNZ 0x001a0c1d
MOV RAX,qword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RAX + 0x2c]
XORPS XMM1,XMM1
UCOMISS XMM0,XMM1
JBE 0x001a0c1d
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x28]
CMP EAX,dword ptr [RCX + 0x48]
JC 0x001a0c1d
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x44],0x0
JNZ 0x001a0c1d
MOV RAX,qword ptr [RBP + -0x28]
MOVSS XMM0,dword ptr [RAX + 0x2c]
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x001a0c25
LAB_001a0c1d:
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
LAB_001a0c25:
MOVSS XMM0,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 ft_boolean_find_relevance(long param_1,int8 param_2,int4 param_3)
{
long lVar1;
int iVar2;
int8 *puVar3;
int1 *local_b0;
uint local_a4;
int8 *local_a0;
long local_88;
int1 *local_80;
ulong local_78;
int1 local_70 [8];
int8 local_68;
int8 local_60;
long local_58;
int1 local_50 [4];
int4 uStack_4c;
int8 local_48;
int8 local_40;
long local_38;
int4 local_24;
int8 local_20;
long local_18;
int4 local_c;
local_78 = *(ulong *)(*(long *)(param_1 + 8) + 0x170);
if (*(int *)(param_1 + 0x340) == -1) {
local_b0 = ft_default_parser;
}
else {
local_b0 = *(int1 **)
(*(long *)(**(long **)(param_1 + 8) + 0x218) +
(ulong)*(uint *)(param_1 + 0x340) * 0x70 + 0x38);
}
if (local_78 == 0xffffffffffffffff) {
local_c = DAT_00252010;
}
else if (*(int *)(param_1 + 0x80) == 0) {
local_c = 0;
}
else {
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
puVar3 = (int8 *)
ftparser_call_initializer
(*(int8 *)(param_1 + 8),*(int4 *)(param_1 + 0x340),0);
if (puVar3 == (int8 *)0x0) {
local_c = 0;
}
else {
if ((*(int *)(local_18 + 0x348) != 2) && (local_78 <= *(ulong *)(local_18 + 0x338))) {
for (local_a4 = 0; local_a4 < *(uint *)(local_18 + 0x80); local_a4 = local_a4 + 1) {
*(int8 *)(*(long *)(*(long *)(local_18 + 0x20) + (ulong)local_a4 * 8) + 0x18) =
0xffffffffffffffff;
for (local_a0 = (int8 *)
**(int8 **)(*(long *)(local_18 + 0x20) + (ulong)local_a4 * 8);
local_a0 != (int8 *)0x0; local_a0 = (int8 *)*local_a0) {
local_a0[3] = 0xffffffffffffffff;
}
}
}
*(ulong *)(local_18 + 0x338) = local_78;
if (*(int *)(local_18 + 0x340) == -1) {
_mi_ft_segiterator_dummy_init(local_20,local_24,local_50);
}
else {
_mi_ft_segiterator_init
(*(int8 *)(local_18 + 8),*(int4 *)(local_18 + 0x340),local_20,local_50
);
}
local_68 = local_48;
local_60 = local_40;
local_58 = local_38;
local_88 = local_18;
local_80 = local_70;
*puVar3 = ftb_find_relevance_parse;
puVar3[1] = ftb_find_relevance_add_word;
puVar3[3] = &local_88;
*(int4 *)((long)puVar3 + 0x34) = 0;
puVar3[4] = *(int8 *)(local_18 + 0x10);
*(int4 *)(puVar3 + 7) = 0;
do {
do {
iVar2 = _mi_ft_segiterator(local_50);
if (iVar2 == 0) {
lVar1 = *(long *)(local_18 + 0x18);
if ((((*(ulong *)(lVar1 + 0x18) == local_78) && (0.0 < *(float *)(lVar1 + 0x2c))) &&
(*(uint *)(lVar1 + 0x48) <= *(uint *)(lVar1 + 0x40))) &&
(*(int *)(lVar1 + 0x44) == 0)) {
return *(int4 *)(lVar1 + 0x2c);
}
return 0;
}
} while (local_38 == 0);
puVar3[5] = local_38;
*(int4 *)(puVar3 + 6) = uStack_4c;
iVar2 = (**(code **)(local_b0 + 8))(puVar3);
} while (iVar2 == 0);
local_c = 0;
}
}
return local_c;
}
| |
24,599 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&) | monkey531[P]llama/common/./json.hpp | reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xa873f
movb $0x2, (%r14)
callq 0x3d420
movq %rax, %rdi
movq %rax, 0x8(%r14)
jmp 0xa8748
cmpl $0x2, %eax
jne 0xa8765
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xa8846
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x42dc8
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x116e6(%rip), %rsi # 0xb9e6d
leaq 0x10(%rsp), %rdi
callq 0xa87e8
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x42c7c
xorl %ebp, %ebp
leaq 0x52796(%rip), %rsi # 0xfaf48
leaq -0x68e61(%rip), %rdx # 0x3f958
movq %rbx, %rdi
callq 0x23ee0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241a8
testb %bpl, %bpl
jne 0xa87d8
jmp 0xa87e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x23680
movq %r14, %rdi
callq 0x23f70
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_A873F
mov byte ptr [r14], 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJEEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>()
mov rdi, rax
mov [r14+8], rax
jmp short loc_A8748
loc_A873F:
cmp eax, 2
jnz short loc_A8765
mov rdi, [r14+8]
loc_A8748:
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
mov rax, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_A8765:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_A87D8
jmp short loc_A87E0
mov r14, rax
loc_A87D8:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A87E0:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
long long a1,
long long a2)
{
long long v3; // rdi
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v6[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v6,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
311,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD *)(a1 + 8);
}
else
{
*(_BYTE *)a1 = 2;
v3 = 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>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>();
*(_QWORD *)(a1 + 8) = v3;
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
v3,
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
| emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001a873f
MOV byte ptr [R14],0x2
CALL 0x0013d420
MOV RDI,RAX
MOV qword ptr [R14 + 0x8],RAX
JMP 0x001a8748
LAB_001a873f:
CMP EAX,0x2
JNZ 0x001a8765
MOV RDI,qword ptr [R14 + 0x8]
LAB_001a8748:
MOV RSI,RBX
CALL 0x001a8846
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001a8765:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x00142dc8
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001a8780:
LEA RSI,[0x1b9e6d]
LEA RDI,[RSP + 0x10]
CALL 0x001a87e8
MOV BPL,0x1
LAB_001a8794:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x00142c7c
XOR EBP,EBP
LEA RSI,[0x1faf48]
LEA RDX,[0x13f958]
MOV RDI,RBX
CALL 0x00123ee0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, 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 * __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>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
this_00 = (vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
();
*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8) = this_00;
}
else {
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001a8780 to 001a8790 has its CatchHandler @ 001a87d5 */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001a8794 to 001a87c0 has its CatchHandler @ 001a87c1 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(this_00,param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.