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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
43,100 | js_date_toJSON | bluesky950520[P]quickjs/quickjs.c | static JSValue js_date_toJSON(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// toJSON(key)
JSValue obj, tv, method, rv;
double d;
rv = JS_EXCEPTION;
tv = JS_UNDEFINED;
obj = JS_ToObject(ctx, this_val);
tv = JS_ToPrimitive(ctx, obj, HINT_NUMBER);
if (JS_IsException(tv))
goto exception;
if (JS_IsNumber(tv)) {
if (JS_ToFloat64(ctx, &d, tv) < 0)
goto exception;
if (!isfinite(d)) {
rv = JS_NULL;
goto done;
}
}
method = JS_GetPropertyStr(ctx, obj, "toISOString");
if (JS_IsException(method))
goto exception;
if (!JS_IsFunction(ctx, method)) {
JS_ThrowTypeError(ctx, "object needs toISOString method");
JS_FreeValue(ctx, method);
goto exception;
}
rv = JS_CallFree(ctx, method, obj, 0, NULL);
exception:
done:
JS_FreeValue(ctx, obj);
JS_FreeValue(ctx, tv);
return rv;
} | O2 | c | js_date_toJSON:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x20b92
movq %rax, %r12
movq %rdx, %r15
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21846
movq %rax, %rbp
movq %rdx, %r13
pushq $0x6
popq %r14
cmpl $0x6, %r13d
movq %r15, 0x18(%rsp)
je 0x4a341
cmpl $0x7, %r13d
je 0x4a2e9
testl %r13d, %r13d
jne 0x4a327
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x2127f
testl %eax, %eax
js 0x4a341
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq 0x20(%rsp), %rax
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rcx, %rax
jle 0x4a327
movq %r12, %r15
pushq $0x2
popq %r14
jmp 0x4a344
leaq 0x3d054(%rip), %rcx # 0x87382
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1e3fb
cmpl $0x6, %edx
jne 0x4a37f
movq %r12, %r15
xorl %r12d, %r12d
xorl %ecx, %ecx
orq %rcx, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq 0x18(%rsp), %rdx
callq 0x1801e
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x1801e
movq %r12, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %rax, 0x8(%rsp)
movq %rax, %rsi
movq %rdx, 0x10(%rsp)
callq 0x1ce7d
testl %eax, %eax
je 0x4a3d5
andq $0x0, (%rsp)
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %r15
movq %r12, %rcx
movq 0x18(%rsp), %r8
xorl %r9d, %r9d
callq 0x1cd8e
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r12d
jmp 0x4a349
movq %r12, %r15
leaq 0x3d274(%rip), %rsi # 0x87653
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1c64d
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1801e
jmp 0x4a347
| js_date_toJSON:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
call JS_ToObject
mov r12, rax
mov r15, rdx
push 1
pop rcx
mov rdi, rbx
mov rsi, rax
call JS_ToPrimitive
mov rbp, rax
mov r13, rdx
push 6
pop r14
cmp r13d, 6
mov [rsp+58h+var_40], r15
jz short loc_4A341
cmp r13d, 7
jz short loc_4A2E9
test r13d, r13d
jnz short loc_4A327
loc_4A2E9:
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
mov rdx, rbp
mov rcx, r13
call JS_ToFloat64
test eax, eax
js short loc_4A341
mov rax, 7FFFFFFFFFFFFFFFh
and rax, [rsp+58h+var_38]
mov rcx, 7FEFFFFFFFFFFFFFh
cmp rax, rcx
jle short loc_4A327
mov r15, r12
push 2
pop r14
jmp short loc_4A344
loc_4A327:
lea rcx, aToisostring; "toISOString"
mov rdi, rbx
mov rsi, r12
mov rdx, r15
call JS_GetPropertyStr
cmp edx, 6
jnz short loc_4A37F
loc_4A341:
mov r15, r12
loc_4A344:
xor r12d, r12d
loc_4A347:
xor ecx, ecx
loc_4A349:
or r12, rcx
mov rdi, rbx
mov rsi, r15
mov rdx, [rsp+58h+var_40]
call JS_FreeValue
mov rdi, rbx
mov rsi, rbp
mov rdx, r13
call JS_FreeValue
mov rax, r12
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4A37F:
mov rdi, rbx
mov [rsp+58h+var_50], rax
mov rsi, rax
mov [rsp+58h+var_48], rdx
call JS_IsFunction
test eax, eax
jz short loc_4A3D5
and [rsp+58h+var_58], 0
mov rdi, rbx
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
mov r15, r12
mov rcx, r12
mov r8, [rsp+58h+var_40]
xor r9d, r9d
call JS_CallFree
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r12d, eax
jmp loc_4A349
loc_4A3D5:
mov r15, r12
lea rsi, aObjectNeedsToi; "object needs toISOString method"
xor r12d, r12d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov rdi, rbx
mov rsi, [rsp+58h+var_50]
mov rdx, [rsp+58h+var_48]
call JS_FreeValue
jmp loc_4A347
| unsigned long long js_date_toJSON(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
_DWORD *v14; // r12
long long v15; // rdx
long long v16; // r15
_DWORD *v17; // rax
long long v18; // rdx
long long v19; // rbp
long long v20; // r13
long long v21; // r15
long long PropertyStr; // rax
long long v23; // rdx
long long v24; // r12
unsigned long long v25; // rcx
unsigned long long v26; // r12
long long v28; // rdx
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
long long v34; // rax
char v35; // [rsp+0h] [rbp-58h]
long long v36; // [rsp+8h] [rbp-50h]
long long v37; // [rsp+10h] [rbp-48h]
long long v38; // [rsp+18h] [rbp-40h]
long long v39[7]; // [rsp+20h] [rbp-38h] BYREF
v14 = (_DWORD *)JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v16 = v15;
v17 = (_DWORD *)JS_ToPrimitive(a1, v14, v15);
v19 = (long long)v17;
v20 = v18;
v38 = v16;
if ( (_DWORD)v18 == 6 )
goto LABEL_8;
if ( (_DWORD)v18 == 7 || !(_DWORD)v18 )
{
if ( (int)JS_ToFloat64(a1, (long long)v39, v17, v18) < 0 )
{
LABEL_8:
v21 = (long long)v14;
goto LABEL_9;
}
if ( (v39[0] & 0x7FFFFFFFFFFFFFFFuLL) > 0x7FEFFFFFFFFFFFFFLL )
{
v21 = (long long)v14;
LABEL_9:
v24 = 0LL;
goto LABEL_10;
}
}
PropertyStr = JS_GetPropertyStr(a1, (int)v14, v16, "toISOString");
if ( (_DWORD)v23 == 6 )
goto LABEL_8;
v36 = PropertyStr;
v37 = v23;
if ( (unsigned int)JS_IsFunction(a1, PropertyStr, v23) )
{
v21 = (long long)v14;
v34 = JS_CallFree(a1, v36, v37, (int)v14, v38, 0, 0LL);
v25 = v34 & 0xFFFFFFFF00000000LL;
v24 = (unsigned int)v34;
goto LABEL_11;
}
v21 = (long long)v14;
v24 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"object needs toISOString method",
v28,
v29,
v30,
v31,
a7,
a8,
a9,
a10,
v32,
v33,
a13,
a14,
v35);
JS_FreeValue(a1, v36, v37);
LABEL_10:
v25 = 0LL;
LABEL_11:
v26 = v25 | v24;
JS_FreeValue(a1, v21, v38);
JS_FreeValue(a1, v19, v20);
return v26;
}
| js_date_toJSON:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
CALL 0x00120b92
MOV R12,RAX
MOV R15,RDX
PUSH 0x1
POP RCX
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00121846
MOV RBP,RAX
MOV R13,RDX
PUSH 0x6
POP R14
CMP R13D,0x6
MOV qword ptr [RSP + 0x18],R15
JZ 0x0014a341
CMP R13D,0x7
JZ 0x0014a2e9
TEST R13D,R13D
JNZ 0x0014a327
LAB_0014a2e9:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
MOV RDX,RBP
MOV RCX,R13
CALL 0x0012127f
TEST EAX,EAX
JS 0x0014a341
MOV RAX,0x7fffffffffffffff
AND RAX,qword ptr [RSP + 0x20]
MOV RCX,0x7fefffffffffffff
CMP RAX,RCX
JLE 0x0014a327
MOV R15,R12
PUSH 0x2
POP R14
JMP 0x0014a344
LAB_0014a327:
LEA RCX,[0x187382]
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
CALL 0x0011e3fb
CMP EDX,0x6
JNZ 0x0014a37f
LAB_0014a341:
MOV R15,R12
LAB_0014a344:
XOR R12D,R12D
LAB_0014a347:
XOR ECX,ECX
LAB_0014a349:
OR R12,RCX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0011801e
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R13
CALL 0x0011801e
MOV RAX,R12
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014a37f:
MOV RDI,RBX
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,RAX
MOV qword ptr [RSP + 0x10],RDX
CALL 0x0011ce7d
TEST EAX,EAX
JZ 0x0014a3d5
AND qword ptr [RSP],0x0
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV R15,R12
MOV RCX,R12
MOV R8,qword ptr [RSP + 0x18]
XOR R9D,R9D
CALL 0x0011cd8e
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV R12D,EAX
JMP 0x0014a349
LAB_0014a3d5:
MOV R15,R12
LEA RSI,[0x187653]
XOR R12D,R12D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0011c64d
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011801e
JMP 0x0014a347
|
int1 [16] js_date_toJSON(int8 param_1)
{
int iVar1;
int8 uVar2;
int8 uVar3;
ulong uVar4;
ulong uVar6;
int8 uVar7;
int1 auVar8 [16];
int1 auVar9 [16];
ulong local_38;
int8 uVar5;
auVar8 = JS_ToObject();
uVar5 = auVar8._8_8_;
uVar2 = auVar8._0_8_;
auVar8 = JS_ToPrimitive(param_1,uVar2,uVar5,1);
uVar7 = 6;
iVar1 = auVar8._8_4_;
if (iVar1 != 6) {
if ((iVar1 == 7) || (iVar1 == 0)) {
iVar1 = JS_ToFloat64(param_1,&local_38,auVar8._0_8_,auVar8._8_8_);
if (-1 < iVar1) {
if ((local_38 & 0x7fffffffffffffff) < 0x7ff0000000000000) goto LAB_0014a327;
uVar7 = 2;
}
}
else {
LAB_0014a327:
auVar9 = JS_GetPropertyStr(param_1,uVar2,uVar5,"toISOString");
uVar3 = auVar9._0_8_;
if (auVar9._8_4_ != 6) {
iVar1 = JS_IsFunction(param_1,uVar3);
if (iVar1 != 0) {
auVar9 = JS_CallFree(param_1,uVar3,auVar9._8_8_,uVar2,uVar5,0,0);
uVar7 = auVar9._8_8_;
uVar4 = auVar9._0_8_ & 0xffffffff00000000;
uVar6 = auVar9._0_8_ & 0xffffffff;
goto LAB_0014a349;
}
JS_ThrowTypeError(param_1,"object needs toISOString method");
JS_FreeValue(param_1,uVar3,auVar9._8_8_);
}
}
}
uVar6 = 0;
uVar4 = 0;
LAB_0014a349:
JS_FreeValue(param_1,uVar2,uVar5);
JS_FreeValue(param_1,auVar8._0_8_,auVar8._8_8_);
auVar8._8_8_ = uVar7;
auVar8._0_8_ = uVar6 | uVar4;
return auVar8;
}
| |
43,101 | minja::TextNode::~TextNode() | monkey531[P]llama/common/minja.hpp | TextNode(const Location & location, const std::string& t) : TemplateNode(location), text(t) {} | O3 | cpp | minja::TextNode::~TextNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8d9e5(%rip), %rax # 0x130218
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xa2852
movq (%rax), %rsi
incq %rsi
callq 0x1b910
leaq 0x8d76f(%rip), %rax # 0x12ffc8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa286f
popq %rbx
jmp 0x725dc
popq %rbx
retq
nop
| _ZN5minja8TextNodeD2Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja8TextNodeE; `vtable for'minja::TextNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_A2852
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A2852:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_A286F
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_A286F:
pop rbx
retn
| void minja::TextNode::~TextNode(minja::TextNode *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::TextNode + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
}
| ~TextNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x230218]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x001a2852
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011b910
LAB_001a2852:
LEA RAX,[0x22ffc8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x001a286f
POP RBX
JMP 0x001725dc
LAB_001a286f:
POP RBX
RET
|
/* minja::TextNode::~TextNode() */
void __thiscall minja::TextNode::~TextNode(TextNode *this)
{
*(int ***)this = &PTR_do_render_00230228;
if (*(TextNode **)(this + 0x20) != this + 0x30) {
operator_delete(*(TextNode **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_0022ffd8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_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 + 0x10));
return;
}
return;
}
| |
43,102 | mj_makeData | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_io.c | mjData* mj_makeData(const mjModel* m) {
mjData* d = NULL;
mj_makeRawData(&d, m);
if (d) {
_initPlugin(m, d);
mj_resetData(m, d);
}
return d;
} | O0 | c | mj_makeData:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x49fd0
cmpq $0x0, 0x8(%rsp)
je 0xde127
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xde140
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x49c50
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| mj_makeData:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], 0
mov rsi, [rsp+18h+var_8]
lea rdi, [rsp+18h+var_10]
call _mj_makeRawData
cmp [rsp+18h+var_10], 0
jz short loc_DE127
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call _initPlugin
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call _mj_resetData
loc_DE127:
mov rax, [rsp+18h+var_10]
add rsp, 18h
retn
| long long mj_makeData(long long a1)
{
long long v2; // [rsp+8h] [rbp-10h] BYREF
long long v3; // [rsp+10h] [rbp-8h]
v3 = a1;
v2 = 0LL;
mj_makeRawData(&v2, a1);
if ( v2 )
{
initPlugin(v3, v2);
mj_resetData(v3, v2);
}
return v2;
}
| mj_makeData:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],0x0
MOV RSI,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x8]
CALL 0x00149fd0
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001de127
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001de140
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00149c50
LAB_001de127:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0x18
RET
|
long mj_makeData(int8 param_1)
{
long local_10;
int8 local_8;
local_10 = 0;
local_8 = param_1;
mj_makeRawData(&local_10,param_1);
if (local_10 != 0) {
_initPlugin(local_8,local_10);
mj_resetData(local_8,local_10);
}
return local_10;
}
| |
43,103 | parse_device_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/arg.cpp | static std::vector<ggml_backend_dev_t> parse_device_list(const std::string & value) {
std::vector<ggml_backend_dev_t> devices;
auto dev_names = string_split<std::string>(value, ',');
if (dev_names.empty()) {
throw std::invalid_argument("no devices specified");
}
if (dev_names.size() == 1 && dev_names[0] == "none") {
devices.push_back(nullptr);
} else {
for (const auto & device : dev_names) {
auto * dev = ggml_backend_dev_by_name(device.c_str());
if (!dev || ggml_backend_dev_type(dev) != GGML_BACKEND_DEVICE_TYPE_GPU) {
throw std::invalid_argument(string_format("invalid device: %s", device.c_str()));
}
devices.push_back(dev);
}
devices.push_back(nullptr);
}
return devices;
} | O0 | cpp | parse_device_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0xd8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movb $0x0, 0xc7(%rsp)
callq 0x6c3f0
movq 0xc8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
movl $0x2c, %edx
callq 0xbd7d0
jmp 0xc1bfd
leaq 0xa8(%rsp), %rdi
callq 0xc7c80
testb $0x1, %al
jne 0xc1c13
jmp 0xc1ca8
movl $0x10, %edi
callq 0x5e6b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x15ba13(%rip), %rsi # 0x21d642
callq 0x5e320
jmp 0xc1c36
movq 0x20(%rsp), %rdi
movq 0x1f12e6(%rip), %rsi # 0x2b2f28
movq 0x1f12d7(%rip), %rdx # 0x2b2f20
callq 0x5eb30
jmp 0xc1f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xc1ef2
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
callq 0x5efd0
jmp 0xc1ecc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xc1ecc
leaq 0xa8(%rsp), %rdi
callq 0x6bc00
cmpq $0x1, %rax
jne 0xc1d10
xorl %eax, %eax
movl %eax, %esi
leaq 0xa8(%rsp), %rdi
callq 0xc7df0
movq %rax, %rdi
leaq 0x1568b9(%rip), %rsi # 0x21858f
callq 0x75140
movb %al, 0x1f(%rsp)
jmp 0xc1ce1
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xc1ceb
jmp 0xc1d10
movq 0x28(%rsp), %rdi
movq $0x0, 0x90(%rsp)
leaq 0x90(%rsp), %rsi
callq 0xf7040
jmp 0xc1d0b
jmp 0xc1eab
leaq 0xa8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x92190
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x92000
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xcbe30
testb $0x1, %al
jne 0xc1d62
jmp 0xc1e8f
leaq 0x80(%rsp), %rdi
callq 0xcbe70
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x5e1c0
movq %rax, %rdi
callq 0x5e3e0
movq %rax, 0x10(%rsp)
jmp 0xc1d8d
movq 0x10(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0xc1dbc
movq 0x68(%rsp), %rdi
callq 0x5ea50
movl %eax, 0xc(%rsp)
jmp 0xc1daf
movl 0xc(%rsp), %eax
cmpl $0x1, %eax
je 0xc1e6a
movb $0x1, 0x47(%rsp)
movl $0x10, %edi
callq 0x5e6b0
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x5e1c0
movq %rax, %rdx
leaq 0x15b874(%rip), %rsi # 0x21d657
xorl %eax, %eax
leaq 0x48(%rsp), %rdi
callq 0xfd020
jmp 0xc1df1
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5ea70
jmp 0xc1e01
movq (%rsp), %rdi
movb $0x0, 0x47(%rsp)
movq 0x1f1117(%rip), %rsi # 0x2b2f28
movq 0x1f1108(%rip), %rdx # 0x2b2f20
callq 0x5eb30
jmp 0xc1f09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0xc1e56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5f5d8
testb $0x1, 0x47(%rsp)
jne 0xc1e5f
jmp 0xc1e68
movq (%rsp), %rdi
callq 0x5efd0
jmp 0xc1ecc
movq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xf7070
jmp 0xc1e7b
jmp 0xc1e7d
leaq 0x80(%rsp), %rdi
callq 0xcbe80
jmp 0xc1d47
movq 0x28(%rsp), %rdi
movq $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0xf7040
jmp 0xc1ea9
jmp 0xc1eab
movb $0x1, 0xc7(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x699d0
testb $0x1, 0xc7(%rsp)
jne 0xc1ee5
jmp 0xc1edb
leaq 0xa8(%rsp), %rdi
callq 0x699d0
jmp 0xc1ef2
movq 0x28(%rsp), %rdi
callq 0x6d040
movq 0x30(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6d040
movq 0xa0(%rsp), %rdi
callq 0x5ebf0
nopl (%rax)
| _ZL17parse_device_listRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 0D8h
mov [rsp+0D8h+var_B0], rdi
mov rax, rdi
mov [rsp+0D8h+var_A8], rax
mov [rsp+0D8h+var_8], rdi
mov [rsp+0D8h+var_10], rsi
mov [rsp+0D8h+var_11], 0
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EEC2Ev; std::vector<ggml_backend_device *>::vector(void)
mov rsi, [rsp+0D8h+var_10]
lea rdi, [rsp+0D8h+var_30]
mov edx, 2Ch ; ','
call _ZL12string_splitINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIT_SaIS7_EERKS5_c; string_split<std::string>(std::string const&,char)
jmp short $+2
loc_C1BFD:
lea rdi, [rsp+0D8h+var_30]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5emptyEv; std::vector<std::string>::empty(void)
test al, 1
jnz short loc_C1C13
jmp loc_C1CA8
loc_C1C13:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0D8h+var_B8], rax
lea rsi, aNoDevicesSpeci; "no devices specified"
call __ZNSt16invalid_argumentC1EPKc; std::invalid_argument::invalid_argument(char const*)
jmp short $+2
loc_C1C36:
mov rdi, [rsp+0D8h+var_B8]; void *
mov rsi, cs:_ZTISt16invalid_argument_ptr; lptinfo
mov rdx, cs:_ZNSt16invalid_argumentD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_C1F09
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp loc_C1EF2
mov rdi, [rsp+arg_18]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
call ___cxa_free_exception
jmp loc_C1ECC
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp loc_C1ECC
loc_C1CA8:
lea rdi, [rsp+0D8h+var_30]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
cmp rax, 1
jnz short loc_C1D10
xor eax, eax
mov esi, eax
lea rdi, [rsp+0D8h+var_30]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax
lea rsi, aNone; "none"
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+0D8h+var_B9], al
jmp short $+2
loc_C1CE1:
mov al, [rsp+0D8h+var_B9]
test al, 1
jnz short loc_C1CEB
jmp short loc_C1D10
loc_C1CEB:
mov rdi, [rsp+0D8h+var_B0]
mov [rsp+0D8h+var_48], 0
lea rsi, [rsp+0D8h+var_48]
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EE9push_backEOS1_; std::vector<ggml_backend_device *>::push_back(ggml_backend_device *&&)
jmp short $+2
loc_C1D0B:
jmp loc_C1EAB
loc_C1D10:
lea rax, [rsp+0D8h+var_30]
mov [rsp+0D8h+var_50], rax
mov rdi, [rsp+0D8h+var_50]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rsp+0D8h+var_58], rax
mov rdi, [rsp+0D8h+var_50]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rsp+0D8h+var_60], rax
loc_C1D47:
lea rdi, [rsp+0D8h+var_58]
lea rsi, [rsp+0D8h+var_60]
call _ZN9__gnu_cxxneIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESG_; __gnu_cxx::operator!=<std::string *,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>> const&)
test al, 1
jnz short loc_C1D62
jmp loc_C1E8F
loc_C1D62:
lea rdi, [rsp+0D8h+var_58]
call _ZNK9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(void)
mov [rsp+0D8h+var_68], rax
mov rdi, [rsp+0D8h+var_68]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, rax
call _ggml_backend_dev_by_name
mov [rsp+0D8h+var_C8], rax
jmp short $+2
loc_C1D8D:
mov rax, [rsp+0D8h+var_C8]
mov [rsp+0D8h+var_70], rax
cmp [rsp+0D8h+var_70], 0
jz short loc_C1DBC
mov rdi, [rsp+0D8h+var_70]
call _ggml_backend_dev_type
mov [rsp+0D8h+var_CC], eax
jmp short $+2
loc_C1DAF:
mov eax, [rsp+0D8h+var_CC]
cmp eax, 1
jz loc_C1E6A
loc_C1DBC:
mov [rsp+0D8h+var_91], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov [rsp+0D8h+var_D8], rax
mov rdi, [rsp+0D8h+var_68]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdx, rax
lea rsi, aInvalidDeviceS; "invalid device: %s"
xor eax, eax
lea rdi, [rsp+0D8h+var_90]
call _Z13string_formatB5cxx11PKcz; string_format(char const*,...)
jmp short $+2
loc_C1DF1:
mov rdi, [rsp+0D8h+var_D8]
lea rsi, [rsp+0D8h+var_90]
call __ZNSt16invalid_argumentC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::invalid_argument::invalid_argument(std::string const&)
jmp short $+2
loc_C1E01:
mov rdi, [rsp+0D8h+var_D8]; void *
mov [rsp+0D8h+var_91], 0
mov rsi, cs:_ZTISt16invalid_argument_ptr; lptinfo
mov rdx, cs:_ZNSt16invalid_argumentD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_C1F09
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_C1E56
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C1E56:
test [rsp+arg_3F], 1
jnz short loc_C1E5F
jmp short loc_C1E68
loc_C1E5F:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_C1E68:
jmp short loc_C1ECC
loc_C1E6A:
mov rdi, [rsp+0D8h+var_B0]
lea rsi, [rsp+0D8h+var_70]
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EE9push_backERKS1_; std::vector<ggml_backend_device *>::push_back(ggml_backend_device * const&)
jmp short $+2
loc_C1E7B:
jmp short $+2
loc_C1E7D:
lea rdi, [rsp+0D8h+var_58]
call _ZN9__gnu_cxx17__normal_iteratorIPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(void)
jmp loc_C1D47
loc_C1E8F:
mov rdi, [rsp+0D8h+var_B0]
mov [rsp+0D8h+var_A0], 0
lea rsi, [rsp+0D8h+var_A0]
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EE9push_backEOS1_; std::vector<ggml_backend_device *>::push_back(ggml_backend_device *&&)
jmp short $+2
loc_C1EA9:
jmp short $+2
loc_C1EAB:
mov [rsp+0D8h+var_11], 1
lea rdi, [rsp+0D8h+var_30]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
test [rsp+0D8h+var_11], 1
jnz short loc_C1EE5
jmp short loc_C1EDB
loc_C1ECC:
lea rdi, [rsp+arg_A0]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_C1EF2
loc_C1EDB:
mov rdi, [rsp+0D8h+var_B0]
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EED2Ev; std::vector<ggml_backend_device *>::~vector()
loc_C1EE5:
mov rax, [rsp+0D8h+var_A8]
add rsp, 0D8h
retn
loc_C1EF2:
mov rdi, [rsp+arg_20]
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EED2Ev; std::vector<ggml_backend_device *>::~vector()
mov rdi, [rsp+arg_98]
call __Unwind_Resume
loc_C1F09:
nop dword ptr [rax+00000000h]
| long long * parse_device_list(long long *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
int v4; // eax
int v5; // ecx
int v6; // r8d
int v7; // r9d
void *v9; // [rsp+0h] [rbp-D8h]
std::invalid_argument *exception; // [rsp+20h] [rbp-B8h]
long long v11; // [rsp+38h] [rbp-A0h] BYREF
char v12; // [rsp+47h] [rbp-91h]
_BYTE v13[32]; // [rsp+48h] [rbp-90h] BYREF
long long v14; // [rsp+68h] [rbp-70h] BYREF
long long v15; // [rsp+70h] [rbp-68h]
long long v16; // [rsp+78h] [rbp-60h] BYREF
_QWORD v17[2]; // [rsp+80h] [rbp-58h] BYREF
_QWORD v18[3]; // [rsp+90h] [rbp-48h] BYREF
long long v19[3]; // [rsp+A8h] [rbp-30h] BYREF
char v20; // [rsp+C7h] [rbp-11h]
long long v21; // [rsp+C8h] [rbp-10h]
long long *v22; // [rsp+D0h] [rbp-8h]
v22 = a1;
v21 = a2;
v20 = 0;
std::vector<ggml_backend_device *>::vector((long long)a1);
string_split<std::string>((long long)v19, a2, 44);
if ( (std::vector<std::string>::empty(v19) & 1) != 0 )
{
exception = (std::invalid_argument *)__cxa_allocate_exception(0x10uLL);
std::invalid_argument::invalid_argument(exception, "no devices specified");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::invalid_argument,
(void (*)(void *))&std::invalid_argument::~invalid_argument);
}
if ( std::vector<std::string>::size(v19) == 1
&& (v2 = std::vector<std::string>::operator[](v19, 0LL), std::operator==<char>(v2, (long long)"none")) )
{
v18[0] = 0LL;
std::vector<ggml_backend_device *>::push_back(a1, v18);
}
else
{
v17[1] = v19;
v17[0] = std::vector<std::string>::begin((long long)v19);
v16 = std::vector<std::string>::end((long long)v19);
while ( (__gnu_cxx::operator!=<std::string *,std::vector<std::string>>(v17, &v16) & 1) != 0 )
{
v15 = __gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator*(v17);
v3 = std::string::c_str(v15);
v14 = ggml_backend_dev_by_name(v3);
if ( !v14 || (unsigned int)ggml_backend_dev_type(v14) != 1 )
{
v9 = __cxa_allocate_exception(0x10uLL);
v4 = std::string::c_str(v15);
string_format[abi:cxx11]((unsigned int)v13, (unsigned int)"invalid device: %s", v4, v5, v6, v7);
std::invalid_argument::invalid_argument(v9, v13);
v12 = 0;
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::invalid_argument,
(void (*)(void *))&std::invalid_argument::~invalid_argument);
}
std::vector<ggml_backend_device *>::push_back(a1, &v14);
__gnu_cxx::__normal_iterator<std::string *,std::vector<std::string>>::operator++(v17);
}
v11 = 0LL;
std::vector<ggml_backend_device *>::push_back(a1, &v11);
}
v20 = 1;
std::vector<std::string>::~vector(v19);
if ( (v20 & 1) == 0 )
std::vector<ggml_backend_device *>::~vector(a1);
return a1;
}
| parse_device_list:
SUB RSP,0xd8
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0xd0],RDI
MOV qword ptr [RSP + 0xc8],RSI
MOV byte ptr [RSP + 0xc7],0x0
CALL 0x0016c3f0
MOV RSI,qword ptr [RSP + 0xc8]
LAB_001c1be9:
LEA RDI,[RSP + 0xa8]
MOV EDX,0x2c
CALL 0x001bd7d0
LAB_001c1bfb:
JMP 0x001c1bfd
LAB_001c1bfd:
LEA RDI,[RSP + 0xa8]
CALL 0x001c7c80
TEST AL,0x1
JNZ 0x001c1c13
JMP 0x001c1ca8
LAB_001c1c13:
MOV EDI,0x10
CALL 0x0015e6b0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
LAB_001c1c28:
LEA RSI,[0x31d642]
CALL 0x0015e320
JMP 0x001c1c36
LAB_001c1c36:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [0x003b2f28]
MOV RDX,qword ptr [0x003b2f20]
CALL 0x0015eb30
LAB_001c1ca8:
LEA RDI,[RSP + 0xa8]
CALL 0x0016bc00
CMP RAX,0x1
JNZ 0x001c1d10
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0xa8]
CALL 0x001c7df0
MOV RDI,RAX
LAB_001c1ccf:
LEA RSI,[0x31858f]
CALL 0x00175140
MOV byte ptr [RSP + 0x1f],AL
JMP 0x001c1ce1
LAB_001c1ce1:
MOV AL,byte ptr [RSP + 0x1f]
TEST AL,0x1
JNZ 0x001c1ceb
JMP 0x001c1d10
LAB_001c1ceb:
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x90],0x0
LEA RSI,[RSP + 0x90]
CALL 0x001f7040
JMP 0x001c1d0b
LAB_001c1d0b:
JMP 0x001c1eab
LAB_001c1d10:
LEA RAX,[RSP + 0xa8]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x00192190
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x00192000
MOV qword ptr [RSP + 0x78],RAX
LAB_001c1d47:
LEA RDI,[RSP + 0x80]
LEA RSI,[RSP + 0x78]
CALL 0x001cbe30
TEST AL,0x1
JNZ 0x001c1d62
JMP 0x001c1e8f
LAB_001c1d62:
LEA RDI,[RSP + 0x80]
CALL 0x001cbe70
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x0015e1c0
MOV RDI,RAX
CALL 0x0015e3e0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001c1d8d
LAB_001c1d8d:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x68],RAX
CMP qword ptr [RSP + 0x68],0x0
JZ 0x001c1dbc
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0015ea50
LAB_001c1da9:
MOV dword ptr [RSP + 0xc],EAX
JMP 0x001c1daf
LAB_001c1daf:
MOV EAX,dword ptr [RSP + 0xc]
CMP EAX,0x1
JZ 0x001c1e6a
LAB_001c1dbc:
MOV byte ptr [RSP + 0x47],0x1
MOV EDI,0x10
CALL 0x0015e6b0
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x0015e1c0
MOV RDX,RAX
LAB_001c1ddc:
LEA RSI,[0x31d657]
XOR EAX,EAX
LEA RDI,[RSP + 0x48]
CALL 0x001fd020
JMP 0x001c1df1
LAB_001c1df1:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x48]
CALL 0x0015ea70
JMP 0x001c1e01
LAB_001c1e01:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x47],0x0
MOV RSI,qword ptr [0x003b2f28]
MOV RDX,qword ptr [0x003b2f20]
CALL 0x0015eb30
LAB_001c1e6a:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x68]
CALL 0x001f7070
JMP 0x001c1e7b
LAB_001c1e7b:
JMP 0x001c1e7d
LAB_001c1e7d:
LEA RDI,[RSP + 0x80]
CALL 0x001cbe80
JMP 0x001c1d47
LAB_001c1e8f:
MOV RDI,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x38],0x0
LEA RSI,[RSP + 0x38]
CALL 0x001f7040
LAB_001c1ea7:
JMP 0x001c1ea9
LAB_001c1ea9:
JMP 0x001c1eab
LAB_001c1eab:
MOV byte ptr [RSP + 0xc7],0x1
LEA RDI,[RSP + 0xa8]
CALL 0x001699d0
TEST byte ptr [RSP + 0xc7],0x1
JNZ 0x001c1ee5
JMP 0x001c1edb
LAB_001c1edb:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0016d040
LAB_001c1ee5:
MOV RAX,qword ptr [RSP + 0x30]
ADD RSP,0xd8
RET
|
/* parse_device_list(std::__cxx11::string const&) */
string * parse_device_list(string *param_1)
{
bool bVar1;
int iVar2;
ulong uVar3;
long lVar4;
string *psVar5;
int8 uVar6;
invalid_argument *piVar7;
char in_SIL;
ggml_backend_device *local_a0;
int1 local_91;
string local_90 [32];
ggml_backend_device *local_70;
int8 local_68;
int8 local_60;
int8 local_58;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *local_50;
ggml_backend_device *local_48 [3];
string local_30 [31];
byte local_11;
char local_10;
string *local_8;
local_11 = 0;
local_8 = param_1;
local_10 = in_SIL;
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::vector
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1);
/* try { // try from 001c1be9 to 001c1bfa has its CatchHandler @ 001c1c53 */
string_split<std::__cxx11::string>(local_30,local_10);
uVar3 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::empty
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_30);
if ((uVar3 & 1) != 0) {
piVar7 = (invalid_argument *)__cxa_allocate_exception(0x10);
/* try { // try from 001c1c28 to 001c1c33 has its CatchHandler @ 001c1c6c */
std::invalid_argument::invalid_argument(piVar7,"no devices specified");
/* try { // try from 001c1c36 to 001c1c4d has its CatchHandler @ 001c1c8f */
/* WARNING: Subroutine does not return */
__cxa_throw(piVar7,PTR_typeinfo_003b2f28,PTR__invalid_argument_003b2f20);
}
lVar4 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_30);
if (lVar4 == 1) {
psVar5 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
local_30,0);
/* try { // try from 001c1ccf to 001c1da8 has its CatchHandler @ 001c1c8f */
bVar1 = std::operator==(psVar5,"none");
if (bVar1) {
local_48[0] = (ggml_backend_device *)0x0;
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::push_back
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1,
local_48);
goto LAB_001c1eab;
}
}
local_50 = (vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_30;
local_58 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin(local_50)
;
local_60 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end(local_50);
while (bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_58,(__normal_iterator *)&local_60), bVar1) {
local_68 = __gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator*((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_58);
uVar6 = std::__cxx11::string::c_str();
local_70 = (ggml_backend_device *)ggml_backend_dev_by_name(uVar6);
if ((local_70 == (ggml_backend_device *)0x0) ||
(iVar2 = ggml_backend_dev_type(local_70), iVar2 != 1)) {
local_91 = 1;
piVar7 = (invalid_argument *)__cxa_allocate_exception(0x10);
uVar6 = std::__cxx11::string::c_str();
/* try { // try from 001c1ddc to 001c1dee has its CatchHandler @ 001c1e22 */
string_format_abi_cxx11_((char *)local_90,"invalid device: %s",uVar6);
/* try { // try from 001c1df1 to 001c1e1c has its CatchHandler @ 001c1e38 */
std::invalid_argument::invalid_argument(piVar7,local_90);
local_91 = 0;
/* WARNING: Subroutine does not return */
__cxa_throw(piVar7,PTR_typeinfo_003b2f28,PTR__invalid_argument_003b2f20);
}
/* try { // try from 001c1e6a to 001c1ea6 has its CatchHandler @ 001c1c8f */
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::push_back
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1,
&local_70);
__gnu_cxx::
__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator++((__normal_iterator<std::__cxx11::string*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
*)&local_58);
}
local_a0 = (ggml_backend_device *)0x0;
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::push_back
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1,&local_a0)
;
LAB_001c1eab:
local_11 = 1;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_30);
if ((local_11 & 1) == 0) {
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::~vector
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1);
}
return param_1;
}
| |
43,104 | spdlog::details::T_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 &, const std::tm &tm_time, memory_buf_t &dest) override {
const size_t field_size = 8;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, dest);
} | O0 | c | spdlog::details::T_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdx
movq $0x8, 0x10(%rsp)
addq $0x8, %rdx
movq 0x18(%rsp), %rcx
leaq 0xf(%rsp), %rdi
movl $0x8, %esi
callq 0x546d0
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x55010
movq 0x18(%rsp), %rdi
movb $0x3a, 0xe(%rsp)
leaq 0xe(%rsp), %rsi
callq 0x2a310
movq 0x20(%rsp), %rax
movl 0x4(%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x55010
movq 0x18(%rsp), %rdi
movb $0x3a, 0xd(%rsp)
leaq 0xd(%rsp), %rsi
callq 0x2a310
movq 0x20(%rsp), %rax
movl (%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x55010
addq $0x38, %rsp
retq
| _ZN6spdlog7details11T_formatterINS0_18null_scoped_padderEE6formatERKNS0_7log_msgERK2tmRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], rdx
mov [rsp+38h+var_20], rcx
mov rdx, [rsp+38h+var_8]
mov [rsp+38h+var_28], 8
add rdx, 8
mov rcx, [rsp+38h+var_20]
lea rdi, [rsp+38h+var_29]
mov esi, 8
call _ZN6spdlog7details18null_scoped_padderC2EmRKNS0_12padding_infoERN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::null_scoped_padder::null_scoped_padder(ulong,spdlog::details::padding_info const&,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
mov rax, [rsp+38h+var_18]
mov edi, [rax+8]
mov rsi, [rsp+38h+var_20]
call _ZN6spdlog7details10fmt_helper4pad2EiRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::fmt_helper::pad2(int,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
mov rdi, [rsp+38h+var_20]
mov [rsp+38h+var_2A], 3Ah ; ':'
lea rsi, [rsp+38h+var_2A]
call _ZN3fmt3v106detail6bufferIcE9push_backERKc; fmt::v10::detail::buffer<char>::push_back(char const&)
mov rax, [rsp+38h+var_18]
mov edi, [rax+4]
mov rsi, [rsp+38h+var_20]
call _ZN6spdlog7details10fmt_helper4pad2EiRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::fmt_helper::pad2(int,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
mov rdi, [rsp+38h+var_20]
mov [rsp+38h+var_2B], 3Ah ; ':'
lea rsi, [rsp+38h+var_2B]
call _ZN3fmt3v106detail6bufferIcE9push_backERKc; fmt::v10::detail::buffer<char>::push_back(char const&)
mov rax, [rsp+38h+var_18]
mov edi, [rax]
mov rsi, [rsp+38h+var_20]
call _ZN6spdlog7details10fmt_helper4pad2EiRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::fmt_helper::pad2(int,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
add rsp, 38h
retn
| long long spdlog::details::T_formatter<spdlog::details::null_scoped_padder>::format(
long long a1,
long long a2,
int *a3,
long long a4)
{
char v5; // [rsp+Dh] [rbp-2Bh] BYREF
char v6; // [rsp+Eh] [rbp-2Ah] BYREF
long long v7; // [rsp+10h] [rbp-28h]
long long v8; // [rsp+18h] [rbp-20h]
int *v9; // [rsp+20h] [rbp-18h]
long long v10; // [rsp+28h] [rbp-10h]
long long v11; // [rsp+30h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = 8LL;
spdlog::details::null_scoped_padder::null_scoped_padder();
spdlog::details::fmt_helper::pad2(v9[2], v8);
v6 = 58;
fmt::v10::detail::buffer<char>::push_back(v8, &v6);
spdlog::details::fmt_helper::pad2(v9[1], v8);
v5 = 58;
fmt::v10::detail::buffer<char>::push_back(v8, &v5);
return spdlog::details::fmt_helper::pad2(*v9, v8);
}
| format:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x18],RCX
MOV RDX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],0x8
ADD RDX,0x8
MOV RCX,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0xf]
MOV ESI,0x8
CALL 0x001546d0
MOV RAX,qword ptr [RSP + 0x20]
MOV EDI,dword ptr [RAX + 0x8]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00155010
MOV RDI,qword ptr [RSP + 0x18]
MOV byte ptr [RSP + 0xe],0x3a
LEA RSI,[RSP + 0xe]
CALL 0x0012a310
MOV RAX,qword ptr [RSP + 0x20]
MOV EDI,dword ptr [RAX + 0x4]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00155010
MOV RDI,qword ptr [RSP + 0x18]
MOV byte ptr [RSP + 0xd],0x3a
LEA RSI,[RSP + 0xd]
CALL 0x0012a310
MOV RAX,qword ptr [RSP + 0x20]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00155010
ADD RSP,0x38
RET
|
/* spdlog::details::T_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg
const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::T_formatter<spdlog::details::null_scoped_padder>::format
(T_formatter<spdlog::details::null_scoped_padder> *this,log_msg *param_1,tm *param_2,
basic_memory_buffer *param_3)
{
char local_2b [2];
null_scoped_padder local_29;
int8 local_28;
basic_memory_buffer *local_20;
tm *local_18;
log_msg *local_10;
T_formatter<spdlog::details::null_scoped_padder> *local_8;
local_28 = 8;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
null_scoped_padder::null_scoped_padder(&local_29,8,(padding_info *)(this + 8),param_3);
fmt_helper::pad2(local_18->tm_hour,local_20);
local_2b[1] = 0x3a;
fmt::v10::detail::buffer<char>::push_back((buffer<char> *)local_20,local_2b + 1);
fmt_helper::pad2(local_18->tm_min,local_20);
local_2b[0] = ':';
fmt::v10::detail::buffer<char>::push_back((buffer<char> *)local_20,local_2b);
fmt_helper::pad2(local_18->tm_sec,local_20);
return;
}
| |
43,105 | js_string_compare | bluesky950520[P]quickjs/quickjs.c | static int js_string_compare(const JSString *p1, const JSString *p2)
{
int res, len;
len = min_int(p1->len, p2->len);
res = js_string_memcmp(p1, p2, len);
if (res == 0)
res = compare_u32(p1->len, p2->len);
return res;
} | O3 | c | js_string_compare:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x7fffffff, %ebx # imm = 0x7FFFFFFF
movl 0x4(%rdi), %ebp
andl %ebx, %ebp
andl 0x4(%rsi), %ebx
cmpl %ebx, %ebp
movl %ebx, %edx
cmovbl %ebp, %edx
callq 0x3c614
testl %eax, %eax
jne 0x43eca
xorl %eax, %eax
cmpl %ebp, %ebx
setb %al
cmpl %ebx, %ebp
sbbl $0x0, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| js_string_compare:
push rbp
push rbx
push rax
mov ebx, 7FFFFFFFh
mov ebp, [rdi+4]
and ebp, ebx
and ebx, [rsi+4]
cmp ebp, ebx
mov edx, ebx
cmovb edx, ebp
call js_string_memcmp
test eax, eax
jnz short loc_43ECA
xor eax, eax
cmp ebx, ebp
setb al
cmp ebp, ebx
sbb eax, 0
loc_43ECA:
add rsp, 8
pop rbx
pop rbp
retn
| unsigned long long js_string_compare(long long a1, long long a2)
{
unsigned int v2; // ebp
unsigned int v3; // ebx
int v4; // edx
unsigned long long result; // rax
v2 = *(_DWORD *)(a1 + 4) & 0x7FFFFFFF;
v3 = *(_DWORD *)(a2 + 4) & 0x7FFFFFFF;
v4 = v3;
if ( v2 < v3 )
v4 = *(_DWORD *)(a1 + 4) & 0x7FFFFFFF;
result = js_string_memcmp(a1, a2, v4);
if ( !(_DWORD)result )
return (__PAIR64__(v3 < v2, v2) - v3) >> 32;
return result;
}
| js_string_compare:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBX,0x7fffffff
MOV EBP,dword ptr [RDI + 0x4]
AND EBP,EBX
AND EBX,dword ptr [RSI + 0x4]
CMP EBP,EBX
MOV EDX,EBX
CMOVC EDX,EBP
CALL 0x0013c614
TEST EAX,EAX
JNZ 0x00143eca
XOR EAX,EAX
CMP EBX,EBP
SETC AL
CMP EBP,EBX
SBB EAX,0x0
LAB_00143eca:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
ulong js_string_compare(long param_1,long param_2)
{
uint uVar1;
ulong uVar2;
uint uVar3;
uint uVar4;
uVar4 = *(uint *)(param_1 + 4) & 0x7fffffff;
uVar3 = *(uint *)(param_2 + 4) & 0x7fffffff;
uVar1 = uVar3;
if (uVar4 < uVar3) {
uVar1 = uVar4;
}
uVar2 = js_string_memcmp(param_1,param_2,uVar1);
if ((int)uVar2 == 0) {
uVar2 = (ulong)((uint)(uVar3 < uVar4) - (uint)(uVar4 < uVar3));
}
return uVar2;
}
| |
43,106 | atoi_octal | eloqsql/mysys/my_init.c | static ulong atoi_octal(const char *str)
{
long int tmp;
while (*str && my_isspace(&my_charset_latin1, *str))
str++;
str2int(str,
(*str == '0' ? 8 : 10), /* Octalt or decimalt */
0, INT_MAX, &tmp);
return (ulong) tmp;
} | O0 | c | atoi_octal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0xbd6d0
leaq 0x271b8c(%rip), %rax # 0x32f240
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xbd6d9
jmp 0xbd6e7
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xbd69c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movl $0xa, %esi
movl $0x8, %eax
cmpl $0x30, %ecx
cmovel %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
leaq -0x10(%rbp), %r8
callq 0x11af10
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| atoi_octal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
loc_BD69C:
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_11], al
jz short loc_BD6D0
lea rax, my_charset_latin1
mov rax, [rax+40h]
mov rcx, [rbp+var_8]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_11], al
loc_BD6D0:
mov al, [rbp+var_11]
test al, 1
jnz short loc_BD6D9
jmp short loc_BD6E7
loc_BD6D9:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_BD69C
loc_BD6E7:
mov rdi, [rbp+var_8]
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax]
mov esi, 0Ah
mov eax, 8
cmp ecx, 30h ; '0'
cmovz esi, eax
xor eax, eax
mov edx, eax
mov ecx, 7FFFFFFFh
lea r8, [rbp+var_10]
call str2int
mov rax, [rbp+var_10]
add rsp, 20h
pop rbp
retn
| long long atoi_octal(_BYTE *a1)
{
long long v1; // rsi
bool v3; // [rsp+Fh] [rbp-11h]
long long v4; // [rsp+10h] [rbp-10h] BYREF
_BYTE *i; // [rsp+18h] [rbp-8h]
for ( i = a1; ; ++i )
{
v3 = 0;
if ( *i )
v3 = (*(_BYTE *)(*((_QWORD *)&my_charset_latin1 + 8) + (unsigned __int8)*i + 1LL) & 8) != 0;
if ( !v3 )
break;
}
v1 = 10LL;
if ( *i == 48 )
v1 = 8LL;
str2int(i, v1, 0LL, 0x7FFFFFFFLL, &v4);
return v4;
}
| atoi_octal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
LAB_001bd69c:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x11],AL
JZ 0x001bd6d0
LEA RAX,[0x42f240]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x11],AL
LAB_001bd6d0:
MOV AL,byte ptr [RBP + -0x11]
TEST AL,0x1
JNZ 0x001bd6d9
JMP 0x001bd6e7
LAB_001bd6d9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bd69c
LAB_001bd6e7:
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX]
MOV ESI,0xa
MOV EAX,0x8
CMP ECX,0x30
CMOVZ ESI,EAX
XOR EAX,EAX
MOV EDX,EAX
MOV ECX,0x7fffffff
LEA R8,[RBP + -0x10]
CALL 0x0021af10
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x20
POP RBP
RET
|
int8 atoi_octal(byte *param_1)
{
int8 uVar1;
bool bVar2;
int8 local_18;
byte *local_10;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (*local_10 != 0) {
bVar2 = (PTR_ctype_latin1_0042f280[(ulong)*local_10 + 1] & 8) != 0;
}
if (!bVar2) break;
local_10 = local_10 + 1;
}
uVar1 = 10;
if (*local_10 == 0x30) {
uVar1 = 8;
}
str2int(local_10,uVar1,0,0x7fffffff,&local_18);
return local_18;
}
| |
43,107 | ma_fcvt | eloqsql/libmariadb/libmariadb/ma_dtoa.c | size_t ma_fcvt(double x, int precision, char *to, my_bool *error)
{
int decpt, sign, len, i;
char *res, *src, *end, *dst= to;
char buf[DTOA_BUFF_SIZE];
DBUG_ASSERT(precision >= 0 && precision < NOT_FIXED_DEC && to != NULL);
res= dtoa(x, 5, precision, &decpt, &sign, &end, buf, sizeof(buf));
if (decpt == DTOA_OVERFLOW)
{
dtoa_free(res, buf, sizeof(buf));
*to++= '0';
*to= '\0';
if (error != NULL)
*error= TRUE;
return 1;
}
src= res;
len= (int)(end - src);
if (sign)
*dst++= '-';
if (decpt <= 0)
{
*dst++= '0';
*dst++= '.';
for (i= decpt; i < 0; i++)
*dst++= '0';
}
for (i= 1; i <= len; i++)
{
*dst++= *src++;
if (i == decpt && i < len)
*dst++= '.';
}
while (i++ <= decpt)
*dst++= '0';
if (precision > 0)
{
if (len <= decpt)
*dst++= '.';
for (i= precision - MAX(0, (len - decpt)); i > 0; i--)
*dst++= '0';
}
*dst= '\0';
if (error != NULL)
*error= FALSE;
dtoa_free(res, buf, sizeof(buf));
return dst - to;
} | O0 | c | ma_fcvt:
pushq %rbp
movq %rsp, %rbp
subq $0xee0, %rsp # imm = 0xEE0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movsd %xmm0, -0xe80(%rbp)
movl %edi, -0xe84(%rbp)
movq %rsi, -0xe90(%rbp)
movq %rdx, -0xe98(%rbp)
movq -0xe90(%rbp), %rax
movq %rax, -0xec8(%rbp)
movsd -0xe80(%rbp), %xmm0
movl -0xe84(%rbp), %esi
leaq -0xe70(%rbp), %r9
movl $0x5, %edi
leaq -0xe9c(%rbp), %rdx
leaq -0xea0(%rbp), %rcx
leaq -0xec0(%rbp), %r8
movq $0xe60, (%rsp) # imm = 0xE60
callq 0x36e30
movq %rax, -0xeb0(%rbp)
cmpl $0x270f, -0xe9c(%rbp) # imm = 0x270F
jne 0x36b6f
movq -0xeb0(%rbp), %rdi
leaq -0xe70(%rbp), %rsi
movl $0xe60, %edx # imm = 0xE60
callq 0x38490
movq -0xe90(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xe90(%rbp)
movb $0x30, (%rax)
movq -0xe90(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xe98(%rbp)
je 0x36b5f
movq -0xe98(%rbp), %rax
movb $0x1, (%rax)
movq $0x1, -0xe78(%rbp)
jmp 0x36df6
movq -0xeb0(%rbp), %rax
movq %rax, -0xeb8(%rbp)
movq -0xec0(%rbp), %rax
movq -0xeb8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xea4(%rbp)
cmpl $0x0, -0xea0(%rbp)
je 0x36bb5
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2d, (%rax)
cmpl $0x0, -0xe9c(%rbp)
jg 0x36c2e
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
movl -0xe9c(%rbp), %eax
movl %eax, -0xea8(%rbp)
cmpl $0x0, -0xea8(%rbp)
jge 0x36c2c
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movl -0xea8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x36bfa
jmp 0x36c2e
movl $0x1, -0xea8(%rbp)
movl -0xea8(%rbp), %eax
cmpl -0xea4(%rbp), %eax
jg 0x36cbe
movq -0xeb8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xeb8(%rbp)
movb (%rax), %cl
movq -0xec8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0xec8(%rbp)
movb %cl, (%rax)
movl -0xea8(%rbp), %eax
cmpl -0xe9c(%rbp), %eax
jne 0x36ca8
movl -0xea8(%rbp), %eax
cmpl -0xea4(%rbp), %eax
jge 0x36ca8
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
jmp 0x36caa
movl -0xea8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x36c38
jmp 0x36cc0
movl -0xea8(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xea8(%rbp)
cmpl -0xe9c(%rbp), %eax
jg 0x36cf3
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
jmp 0x36cc0
cmpl $0x0, -0xe84(%rbp)
jle 0x36da8
movl -0xea4(%rbp), %eax
cmpl -0xe9c(%rbp), %eax
jg 0x36d26
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x2e, (%rax)
movl -0xe84(%rbp), %eax
movl %eax, -0xecc(%rbp)
movl -0xea4(%rbp), %ecx
subl -0xe9c(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x36d4e
xorl %eax, %eax
movl %eax, -0xed0(%rbp)
jmp 0x36d60
movl -0xea4(%rbp), %eax
subl -0xe9c(%rbp), %eax
movl %eax, -0xed0(%rbp)
movl -0xecc(%rbp), %eax
movl -0xed0(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0xea8(%rbp)
cmpl $0x0, -0xea8(%rbp)
jle 0x36da6
movq -0xec8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0xec8(%rbp)
movb $0x30, (%rax)
movl -0xea8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xea8(%rbp)
jmp 0x36d74
jmp 0x36da8
movq -0xec8(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xe98(%rbp)
je 0x36dc6
movq -0xe98(%rbp), %rax
movb $0x0, (%rax)
movq -0xeb0(%rbp), %rdi
leaq -0xe70(%rbp), %rsi
movl $0xe60, %edx # imm = 0xE60
callq 0x38490
movq -0xec8(%rbp), %rax
movq -0xe90(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xe78(%rbp)
movq -0xe78(%rbp), %rax
movq %rax, -0xed8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x36e26
movq -0xed8(%rbp), %rax
addq $0xee0, %rsp # imm = 0xEE0
popq %rbp
retq
callq 0x134b0
nopl (%rax,%rax)
| ma_fcvt:
push rbp
mov rbp, rsp
sub rsp, 0EE0h
mov rax, fs:28h
mov [rbp+var_8], rax
movsd [rbp+var_E80], xmm0
mov [rbp+var_E84], edi
mov [rbp+var_E90], rsi
mov [rbp+var_E98], rdx
mov rax, [rbp+var_E90]
mov [rbp+var_EC8], rax
movsd xmm0, [rbp+var_E80]
mov esi, [rbp+var_E84]
lea r9, [rbp+var_E70]
mov edi, 5
lea rdx, [rbp+var_E9C]
lea rcx, [rbp+var_EA0]
lea r8, [rbp+var_EC0]
mov [rsp+0EE0h+var_EE0], 0E60h
call dtoa
mov [rbp+var_EB0], rax
cmp [rbp+var_E9C], 270Fh
jnz short loc_36B6F
mov rdi, [rbp+var_EB0]
lea rsi, [rbp+var_E70]
mov edx, 0E60h
call dtoa_free
mov rax, [rbp+var_E90]
mov rcx, rax
add rcx, 1
mov [rbp+var_E90], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_E90]
mov byte ptr [rax], 0
cmp [rbp+var_E98], 0
jz short loc_36B5F
mov rax, [rbp+var_E98]
mov byte ptr [rax], 1
loc_36B5F:
mov [rbp+var_E78], 1
jmp loc_36DF6
loc_36B6F:
mov rax, [rbp+var_EB0]
mov [rbp+var_EB8], rax
mov rax, [rbp+var_EC0]
mov rcx, [rbp+var_EB8]
sub rax, rcx
mov [rbp+var_EA4], eax
cmp [rbp+var_EA0], 0
jz short loc_36BB5
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Dh ; '-'
loc_36BB5:
cmp [rbp+var_E9C], 0
jg short loc_36C2E
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
mov eax, [rbp+var_E9C]
mov [rbp+var_EA8], eax
loc_36BFA:
cmp [rbp+var_EA8], 0
jge short loc_36C2C
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov eax, [rbp+var_EA8]
add eax, 1
mov [rbp+var_EA8], eax
jmp short loc_36BFA
loc_36C2C:
jmp short $+2
loc_36C2E:
mov [rbp+var_EA8], 1
loc_36C38:
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_EA4]
jg short loc_36CBE
mov rax, [rbp+var_EB8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EB8], rcx
mov cl, [rax]
mov rax, [rbp+var_EC8]
mov rdx, rax
add rdx, 1
mov [rbp+var_EC8], rdx
mov [rax], cl
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_E9C]
jnz short loc_36CA8
mov eax, [rbp+var_EA8]
cmp eax, [rbp+var_EA4]
jge short loc_36CA8
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
loc_36CA8:
jmp short $+2
loc_36CAA:
mov eax, [rbp+var_EA8]
add eax, 1
mov [rbp+var_EA8], eax
jmp loc_36C38
loc_36CBE:
jmp short $+2
loc_36CC0:
mov eax, [rbp+var_EA8]
mov ecx, eax
add ecx, 1
mov [rbp+var_EA8], ecx
cmp eax, [rbp+var_E9C]
jg short loc_36CF3
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
jmp short loc_36CC0
loc_36CF3:
cmp [rbp+var_E84], 0
jle loc_36DA8
mov eax, [rbp+var_EA4]
cmp eax, [rbp+var_E9C]
jg short loc_36D26
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 2Eh ; '.'
loc_36D26:
mov eax, [rbp+var_E84]
mov [rbp+var_ECC], eax
mov ecx, [rbp+var_EA4]
sub ecx, [rbp+var_E9C]
xor eax, eax
cmp eax, ecx
jle short loc_36D4E
xor eax, eax
mov [rbp+var_ED0], eax
jmp short loc_36D60
loc_36D4E:
mov eax, [rbp+var_EA4]
sub eax, [rbp+var_E9C]
mov [rbp+var_ED0], eax
loc_36D60:
mov eax, [rbp+var_ECC]
mov ecx, [rbp+var_ED0]
sub eax, ecx
mov [rbp+var_EA8], eax
loc_36D74:
cmp [rbp+var_EA8], 0
jle short loc_36DA6
mov rax, [rbp+var_EC8]
mov rcx, rax
add rcx, 1
mov [rbp+var_EC8], rcx
mov byte ptr [rax], 30h ; '0'
mov eax, [rbp+var_EA8]
add eax, 0FFFFFFFFh
mov [rbp+var_EA8], eax
jmp short loc_36D74
loc_36DA6:
jmp short $+2
loc_36DA8:
mov rax, [rbp+var_EC8]
mov byte ptr [rax], 0
cmp [rbp+var_E98], 0
jz short loc_36DC6
mov rax, [rbp+var_E98]
mov byte ptr [rax], 0
loc_36DC6:
mov rdi, [rbp+var_EB0]
lea rsi, [rbp+var_E70]
mov edx, 0E60h
call dtoa_free
mov rax, [rbp+var_EC8]
mov rcx, [rbp+var_E90]
sub rax, rcx
mov [rbp+var_E78], rax
loc_36DF6:
mov rax, [rbp+var_E78]
mov [rbp+var_ED8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_36E26
mov rax, [rbp+var_ED8]
add rsp, 0EE0h
pop rbp
retn
loc_36E26:
call ___stack_chk_fail
| long long ma_fcvt(int a1, _BYTE *a2, _BYTE *a3, double a4)
{
_BYTE *v4; // rax
_BYTE *v5; // rax
_BYTE *v6; // rax
char *v7; // rax
char v8; // cl
_BYTE *v9; // rax
_BYTE *v10; // rax
int v11; // eax
_BYTE *v12; // rax
_BYTE *v13; // rax
_BYTE *v14; // rax
int v16; // [rsp+10h] [rbp-ED0h]
_BYTE *v17; // [rsp+18h] [rbp-EC8h]
long long v18; // [rsp+20h] [rbp-EC0h] BYREF
char *v19; // [rsp+28h] [rbp-EB8h]
long long v20; // [rsp+30h] [rbp-EB0h]
int i; // [rsp+38h] [rbp-EA8h]
int v22; // [rsp+3Ch] [rbp-EA4h]
int v23; // [rsp+40h] [rbp-EA0h] BYREF
int v24; // [rsp+44h] [rbp-E9Ch] BYREF
_BYTE *v25; // [rsp+48h] [rbp-E98h]
_BYTE *v26; // [rsp+50h] [rbp-E90h]
int v27; // [rsp+5Ch] [rbp-E84h]
double v28; // [rsp+60h] [rbp-E80h]
_BYTE v30[3688]; // [rsp+70h] [rbp-E70h] BYREF
unsigned long long v31; // [rsp+ED8h] [rbp-8h]
v31 = __readfsqword(0x28u);
v28 = a4;
v27 = a1;
v26 = a2;
v25 = a3;
v17 = a2;
v20 = dtoa(5, a1, (unsigned int)&v24, (unsigned int)&v23, (unsigned int)&v18, (unsigned int)v30, 3680LL);
if ( v24 == 9999 )
{
dtoa_free(v20, v30, 3680LL);
v4 = v26++;
*v4 = 48;
*v26 = 0;
if ( v25 )
*v25 = 1;
return 1LL;
}
else
{
v19 = (char *)v20;
v22 = v18 - v20;
if ( v23 )
{
v17 = a2 + 1;
*a2 = 45;
}
if ( v24 <= 0 )
{
*v17 = 48;
v5 = v17 + 1;
v17 += 2;
*v5 = 46;
for ( i = v24; i < 0; ++i )
{
v6 = v17++;
*v6 = 48;
}
}
for ( i = 1; i <= v22; ++i )
{
v7 = v19++;
v8 = *v7;
v9 = v17++;
*v9 = v8;
if ( i == v24 && i < v22 )
{
v10 = v17++;
*v10 = 46;
}
}
while ( 1 )
{
v11 = i++;
if ( v11 > v24 )
break;
v12 = v17++;
*v12 = 48;
}
if ( v27 > 0 )
{
if ( v22 <= v24 )
{
v13 = v17++;
*v13 = 46;
}
if ( v22 - v24 >= 0 )
v16 = v22 - v24;
else
v16 = 0;
for ( i = v27 - v16; i > 0; --i )
{
v14 = v17++;
*v14 = 48;
}
}
*v17 = 0;
if ( v25 )
*v25 = 0;
dtoa_free(v20, v30, 3680LL);
return v17 - v26;
}
}
| ma_fcvt:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xee0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOVSD qword ptr [RBP + -0xe80],XMM0
MOV dword ptr [RBP + -0xe84],EDI
MOV qword ptr [RBP + -0xe90],RSI
MOV qword ptr [RBP + -0xe98],RDX
MOV RAX,qword ptr [RBP + -0xe90]
MOV qword ptr [RBP + -0xec8],RAX
MOVSD XMM0,qword ptr [RBP + -0xe80]
MOV ESI,dword ptr [RBP + -0xe84]
LEA R9,[RBP + -0xe70]
MOV EDI,0x5
LEA RDX,[RBP + -0xe9c]
LEA RCX,[RBP + -0xea0]
LEA R8,[RBP + -0xec0]
MOV qword ptr [RSP],0xe60
CALL 0x00136e30
MOV qword ptr [RBP + -0xeb0],RAX
CMP dword ptr [RBP + -0xe9c],0x270f
JNZ 0x00136b6f
MOV RDI,qword ptr [RBP + -0xeb0]
LEA RSI,[RBP + -0xe70]
MOV EDX,0xe60
CALL 0x00138490
MOV RAX,qword ptr [RBP + -0xe90]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xe90],RCX
MOV byte ptr [RAX],0x30
MOV RAX,qword ptr [RBP + -0xe90]
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0xe98],0x0
JZ 0x00136b5f
MOV RAX,qword ptr [RBP + -0xe98]
MOV byte ptr [RAX],0x1
LAB_00136b5f:
MOV qword ptr [RBP + -0xe78],0x1
JMP 0x00136df6
LAB_00136b6f:
MOV RAX,qword ptr [RBP + -0xeb0]
MOV qword ptr [RBP + -0xeb8],RAX
MOV RAX,qword ptr [RBP + -0xec0]
MOV RCX,qword ptr [RBP + -0xeb8]
SUB RAX,RCX
MOV dword ptr [RBP + -0xea4],EAX
CMP dword ptr [RBP + -0xea0],0x0
JZ 0x00136bb5
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2d
LAB_00136bb5:
CMP dword ptr [RBP + -0xe9c],0x0
JG 0x00136c2e
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2e
MOV EAX,dword ptr [RBP + -0xe9c]
MOV dword ptr [RBP + -0xea8],EAX
LAB_00136bfa:
CMP dword ptr [RBP + -0xea8],0x0
JGE 0x00136c2c
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
MOV EAX,dword ptr [RBP + -0xea8]
ADD EAX,0x1
MOV dword ptr [RBP + -0xea8],EAX
JMP 0x00136bfa
LAB_00136c2c:
JMP 0x00136c2e
LAB_00136c2e:
MOV dword ptr [RBP + -0xea8],0x1
LAB_00136c38:
MOV EAX,dword ptr [RBP + -0xea8]
CMP EAX,dword ptr [RBP + -0xea4]
JG 0x00136cbe
MOV RAX,qword ptr [RBP + -0xeb8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xeb8],RCX
MOV CL,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0xec8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0xec8],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0xea8]
CMP EAX,dword ptr [RBP + -0xe9c]
JNZ 0x00136ca8
MOV EAX,dword ptr [RBP + -0xea8]
CMP EAX,dword ptr [RBP + -0xea4]
JGE 0x00136ca8
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2e
LAB_00136ca8:
JMP 0x00136caa
LAB_00136caa:
MOV EAX,dword ptr [RBP + -0xea8]
ADD EAX,0x1
MOV dword ptr [RBP + -0xea8],EAX
JMP 0x00136c38
LAB_00136cbe:
JMP 0x00136cc0
LAB_00136cc0:
MOV EAX,dword ptr [RBP + -0xea8]
MOV ECX,EAX
ADD ECX,0x1
MOV dword ptr [RBP + -0xea8],ECX
CMP EAX,dword ptr [RBP + -0xe9c]
JG 0x00136cf3
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
JMP 0x00136cc0
LAB_00136cf3:
CMP dword ptr [RBP + -0xe84],0x0
JLE 0x00136da8
MOV EAX,dword ptr [RBP + -0xea4]
CMP EAX,dword ptr [RBP + -0xe9c]
JG 0x00136d26
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x2e
LAB_00136d26:
MOV EAX,dword ptr [RBP + -0xe84]
MOV dword ptr [RBP + -0xecc],EAX
MOV ECX,dword ptr [RBP + -0xea4]
SUB ECX,dword ptr [RBP + -0xe9c]
XOR EAX,EAX
CMP EAX,ECX
JLE 0x00136d4e
XOR EAX,EAX
MOV dword ptr [RBP + -0xed0],EAX
JMP 0x00136d60
LAB_00136d4e:
MOV EAX,dword ptr [RBP + -0xea4]
SUB EAX,dword ptr [RBP + -0xe9c]
MOV dword ptr [RBP + -0xed0],EAX
LAB_00136d60:
MOV EAX,dword ptr [RBP + -0xecc]
MOV ECX,dword ptr [RBP + -0xed0]
SUB EAX,ECX
MOV dword ptr [RBP + -0xea8],EAX
LAB_00136d74:
CMP dword ptr [RBP + -0xea8],0x0
JLE 0x00136da6
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0xec8],RCX
MOV byte ptr [RAX],0x30
MOV EAX,dword ptr [RBP + -0xea8]
ADD EAX,-0x1
MOV dword ptr [RBP + -0xea8],EAX
JMP 0x00136d74
LAB_00136da6:
JMP 0x00136da8
LAB_00136da8:
MOV RAX,qword ptr [RBP + -0xec8]
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0xe98],0x0
JZ 0x00136dc6
MOV RAX,qword ptr [RBP + -0xe98]
MOV byte ptr [RAX],0x0
LAB_00136dc6:
MOV RDI,qword ptr [RBP + -0xeb0]
LEA RSI,[RBP + -0xe70]
MOV EDX,0xe60
CALL 0x00138490
MOV RAX,qword ptr [RBP + -0xec8]
MOV RCX,qword ptr [RBP + -0xe90]
SUB RAX,RCX
MOV qword ptr [RBP + -0xe78],RAX
LAB_00136df6:
MOV RAX,qword ptr [RBP + -0xe78]
MOV qword ptr [RBP + -0xed8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00136e26
MOV RAX,qword ptr [RBP + -0xed8]
ADD RSP,0xee0
POP RBP
RET
LAB_00136e26:
CALL 0x001134b0
|
long ma_fcvt(int8 param_1,int param_2,int1 *param_3,int1 *param_4)
{
int1 *puVar1;
long in_FS_OFFSET;
int local_ed8;
int1 *local_ed0;
int local_ec8 [2];
int1 *local_ec0;
int1 *local_eb8;
int local_eb0;
int local_eac;
int local_ea8;
int local_ea4;
int1 *local_ea0;
int1 *local_e98;
int local_e8c;
int8 local_e88;
long local_e80;
int1 local_e78 [3688];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_ea0 = param_4;
local_e98 = param_3;
local_e8c = param_2;
local_e88 = param_1;
local_eb8 = (int1 *)dtoa(param_1,5,param_2,&local_ea4,&local_ea8,local_ec8,local_e78,0xe60);
if (local_ea4 == 9999) {
dtoa_free(local_eb8,local_e78,0xe60);
*local_e98 = 0x30;
local_e98[1] = 0;
if (local_ea0 != (int1 *)0x0) {
*local_ea0 = 1;
}
local_e80 = 1;
local_e98 = local_e98 + 1;
}
else {
local_eac = local_ec8[0] - (int)local_eb8;
local_ed0 = param_3;
if (local_ea8 != 0) {
local_ed0 = param_3 + 1;
*param_3 = 0x2d;
}
if (local_ea4 < 1) {
*local_ed0 = 0x30;
local_ed0[1] = 0x2e;
local_ed0 = local_ed0 + 2;
for (local_eb0 = local_ea4; local_eb0 < 0; local_eb0 = local_eb0 + 1) {
*local_ed0 = 0x30;
local_ed0 = local_ed0 + 1;
}
}
local_ec0 = local_eb8;
for (local_eb0 = 1; local_eb0 <= local_eac; local_eb0 = local_eb0 + 1) {
puVar1 = local_ed0 + 1;
*local_ed0 = *local_ec0;
if ((local_eb0 == local_ea4) && (local_eb0 < local_eac)) {
*puVar1 = 0x2e;
puVar1 = local_ed0 + 2;
}
local_ed0 = puVar1;
local_ec0 = local_ec0 + 1;
}
while (local_eb0 <= local_ea4) {
*local_ed0 = 0x30;
local_ed0 = local_ed0 + 1;
local_eb0 = local_eb0 + 1;
}
local_eb0 = local_eb0 + 1;
if (0 < local_e8c) {
if (local_eac <= local_ea4) {
*local_ed0 = 0x2e;
local_ed0 = local_ed0 + 1;
}
if (local_eac - local_ea4 < 0) {
local_ed8 = 0;
}
else {
local_ed8 = local_eac - local_ea4;
}
for (local_eb0 = local_e8c - local_ed8; 0 < local_eb0; local_eb0 = local_eb0 + -1) {
*local_ed0 = 0x30;
local_ed0 = local_ed0 + 1;
}
}
*local_ed0 = 0;
if (local_ea0 != (int1 *)0x0) {
*local_ea0 = 0;
}
dtoa_free(local_eb8,local_e78,0xe60);
local_e80 = (long)local_ed0 - (long)local_e98;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_e80;
}
| |
43,108 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O3 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1ff, %edx # imm = 0x1FF
movq %rsi, %rdi
movq %r14, %rsi
callq 0x26370
testl %eax, %eax
js 0x458b6
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movb $0x0, (%r14,%rax)
xorl %r14d, %r14d
jmp 0x45903
callq 0x26060
movq %rax, %r12
movl (%rax), %r13d
callq 0x4629e
movl %r13d, (%rax)
cmpl $0x16, %r13d
jne 0x458e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x262f0
movl $0x1, %r14d
jmp 0x45903
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
testb $0x10, %r15b
je 0x45903
movl (%r12), %ecx
movl $0x18, %edi
xorl %esi, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x4b447
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_readlink:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov rbx, rsi
mov r14, rdi
mov edx, 1FFh
mov rdi, rsi
mov rsi, r14
call _readlink
test eax, eax
js short loc_458B6
and eax, 7FFFFFFFh
mov byte ptr [r14+rax], 0
xor r14d, r14d
jmp short loc_45903
loc_458B6:
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
cmp r13d, 16h
jnz short loc_458E2
mov rdi, r14
mov rsi, rbx
call _strcpy
mov r14d, 1
jmp short loc_45903
loc_458E2:
mov r14d, 0FFFFFFFFh
test r15b, 10h
jz short loc_45903
mov ecx, [r12]
mov edi, 18h
xor esi, esi
mov rdx, rbx
xor eax, eax
call my_error
loc_45903:
mov eax, r14d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_readlink(long long a1, long long a2, char a3)
{
int v4; // eax
unsigned int v5; // r14d
_DWORD *v6; // r12
int v7; // r13d
int v8; // r8d
int v9; // r9d
v4 = readlink(a2, a1, 511LL);
if ( v4 < 0 )
{
v6 = (_DWORD *)__errno_location(a2);
v7 = *v6;
*(_DWORD *)my_thread_var(a2) = v7;
if ( v7 == 22 )
{
strcpy(a1, a2);
return 1;
}
else
{
v5 = -1;
if ( (a3 & 0x10) != 0 )
my_error(24, 0, a2, *v6, v8, v9);
}
}
else
{
*(_BYTE *)(a1 + (v4 & 0x7FFFFFFF)) = 0;
return 0;
}
return v5;
}
| my_readlink:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
MOV EDX,0x1ff
MOV RDI,RSI
MOV RSI,R14
CALL 0x00126370
TEST EAX,EAX
JS 0x001458b6
AND EAX,0x7fffffff
MOV byte ptr [R14 + RAX*0x1],0x0
XOR R14D,R14D
JMP 0x00145903
LAB_001458b6:
CALL 0x00126060
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x0014629e
MOV dword ptr [RAX],R13D
CMP R13D,0x16
JNZ 0x001458e2
MOV RDI,R14
MOV RSI,RBX
CALL 0x001262f0
MOV R14D,0x1
JMP 0x00145903
LAB_001458e2:
MOV R14D,0xffffffff
TEST R15B,0x10
JZ 0x00145903
MOV ECX,dword ptr [R12]
MOV EDI,0x18
XOR ESI,ESI
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0014b447
LAB_00145903:
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int *piVar4;
int8 uVar5;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)(uint)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if (iVar1 == 0x16) {
strcpy(param_1,param_2);
uVar5 = 1;
}
else {
uVar5 = 0xffffffff;
if ((param_3 & 0x10) != 0) {
my_error(0x18,0,param_2,*piVar3);
}
}
}
else {
param_1[(uint)sVar2 & 0x7fffffff] = '\0';
uVar5 = 0;
}
return uVar5;
}
| |
43,109 | my_mb_wc_latin1 | eloqsql/strings/ctype-latin1.c | static
int my_mb_wc_latin1(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *wc,
const uchar *str,
const uchar *end __attribute__((unused)))
{
if (str >= end)
return MY_CS_TOOSMALL;
/*
There are no unassigned characters in latin1.
Every code point in latin1 is mapped to some Unicode code point.
We can always return 1, no needs to check the value of cs_to_uni[*str].
*/
*wc= cs_to_uni[*str];
DBUG_ASSERT(wc[0] || !str[0]);
return 1;
} | O3 | c | my_mb_wc_latin1:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x39e18
movzbl (%rdx), %eax
leaq 0x16c954(%rip), %rcx # 0x1a6760
movzwl (%rcx,%rax,2), %eax
movq %rax, (%rsi)
movl $0x1, %eax
popq %rbp
retq
| my_mb_wc_latin1:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_39E18
movzx eax, byte ptr [rdx]
lea rcx, cs_to_uni
movzx eax, word ptr [rcx+rax*2]
mov [rsi], rax
mov eax, 1
loc_39E18:
pop rbp
retn
| long long my_mb_wc_latin1(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
*a2 = cs_to_uni[*a3];
return 1LL;
}
return result;
}
| my_mb_wc_latin1:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00139e18
MOVZX EAX,byte ptr [RDX]
LEA RCX,[0x2a6760]
MOVZX EAX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RAX
MOV EAX,0x1
LAB_00139e18:
POP RBP
RET
|
int8 my_mb_wc_latin1(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9b;
if (param_3 < param_4) {
*param_2 = (ulong)*(ushort *)(cs_to_uni + (ulong)*param_3 * 2);
uVar1 = 1;
}
return uVar1;
}
| |
43,110 | get_one_option | eloqsql/extra/mysql_waitpid.c | static my_bool
get_one_option(const struct my_option *opt,
const char *argument __attribute__((unused)),
const char *filename __attribute__((unused)))
{
switch(opt->id) {
case 'V':
printf("%s version %s by Jani Tolonen\n", progname, VER);
exit(0);
case 'I':
case '?':
usage();
exit(0);
}
return 0;
} | O0 | c | get_one_option:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x3f, %eax
je 0x248cc
jmp 0x24895
movl -0x1c(%rbp), %eax
subl $0x49, %eax
je 0x248cc
jmp 0x2489f
movl -0x1c(%rbp), %eax
subl $0x56, %eax
jne 0x248d8
jmp 0x248a9
movq 0x368168(%rip), %rsi # 0x38ca18
movq 0x1b0989(%rip), %rdx # 0x1d5240
leaq 0x5a97f(%rip), %rdi # 0x7f23d
movb $0x0, %al
callq 0x24050
xorl %edi, %edi
callq 0x24390
callq 0x248e0
xorl %edi, %edi
callq 0x24390
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
| get_one_option:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_1C], eax
sub eax, 3Fh ; '?'
jz short loc_248CC
jmp short $+2
loc_24895:
mov eax, [rbp+var_1C]
sub eax, 49h ; 'I'
jz short loc_248CC
jmp short $+2
loc_2489F:
mov eax, [rbp+var_1C]
sub eax, 56h ; 'V'
jnz short loc_248D8
jmp short $+2
loc_248A9:
mov rsi, cs:progname
mov rdx, cs:VER
lea rdi, aSVersionSByJan; "%s version %s by Jani Tolonen\n"
mov al, 0
call _printf
xor edi, edi
call _exit
loc_248CC:
call usage
xor edi, edi
call _exit
loc_248D8:
xor eax, eax
add rsp, 20h
pop rbp
retn
| long long get_one_option(long long a1)
{
int v2; // [rsp+4h] [rbp-1Ch]
v2 = *(_DWORD *)(a1 + 8);
if ( v2 == 63 || v2 == 73 )
{
usage();
exit(0LL);
}
if ( v2 == 86 )
{
printf("%s version %s by Jani Tolonen\n", (const char *)progname, VER);
exit(0LL);
}
return 0LL;
}
| get_one_option:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x1c],EAX
SUB EAX,0x3f
JZ 0x001248cc
JMP 0x00124895
LAB_00124895:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x49
JZ 0x001248cc
JMP 0x0012489f
LAB_0012489f:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x56
JNZ 0x001248d8
JMP 0x001248a9
LAB_001248a9:
MOV RSI,qword ptr [0x0048ca18]
MOV RDX,qword ptr [0x002d5240]
LEA RDI,[0x17f23d]
MOV AL,0x0
CALL 0x00124050
XOR EDI,EDI
CALL 0x00124390
LAB_001248cc:
CALL 0x001248e0
XOR EDI,EDI
CALL 0x00124390
LAB_001248d8:
XOR EAX,EAX
ADD RSP,0x20
POP RBP
RET
|
int8 get_one_option(long param_1)
{
int iVar1;
iVar1 = *(int *)(param_1 + 8);
if ((iVar1 != 0x3f) && (iVar1 != 0x49)) {
if (iVar1 == 0x56) {
printf("%s version %s by Jani Tolonen\n",progname,VER);
/* WARNING: Subroutine does not return */
exit(0);
}
return 0;
}
usage();
/* WARNING: Subroutine does not return */
exit(0);
}
| |
43,111 | mysql_reset_connection_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_reset_connection_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_reset_connection,
(parms->mysql),
parms->mysql,
int,
r_int)
} | O3 | c | mysql_reset_connection_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1d60e
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_reset_connection_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_reset_connection
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| long long mysql_reset_connection_start_internal(
long long *a1,
long long a2,
long long a3,
long long a4,
unsigned long long a5,
int a6)
{
long long v6; // rdi
_DWORD *v7; // rbx
long long result; // rax
v6 = *a1;
v7 = *(_DWORD **)(*(_QWORD *)(v6 + 1152) + 40LL);
result = mysql_reset_connection(v6, a2, a3, a4, a5, a6);
v7[2] = result;
*v7 = 0;
return result;
}
| mysql_reset_connection_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011d60e
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_reset_connection_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_reset_connection();
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
43,112 | my_copy_with_hex_escaping(charset_info_st const*, char*, unsigned long, char const*, unsigned long) | eloqsql/sql/sql_string.cc | size_t
my_copy_with_hex_escaping(CHARSET_INFO *cs,
char *dst, size_t dstlen,
const char *src, size_t srclen)
{
const char *srcend= src + srclen;
char *dst0= dst;
for ( ; src < srcend ; )
{
size_t chlen;
if ((chlen= my_ismbchar(cs, src, srcend)))
{
if (dstlen < chlen)
break; /* purecov: inspected */
memcpy(dst, src, chlen);
src+= chlen;
dst+= chlen;
dstlen-= chlen;
}
else if (*src & 0x80)
{
if (dstlen < 4)
break; /* purecov: inspected */
*dst++= '\\';
*dst++= 'x';
APPEND_HEX(dst, (uchar) *src);
src++;
dstlen-= 4;
}
else
{
if (dstlen < 1)
break; /* purecov: inspected */
*dst++= *src++;
dstlen--;
}
}
return dst - dst0;
} | O3 | cpp | my_copy_with_hex_escaping(charset_info_st const*, char*, unsigned long, char const*, unsigned long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
testq %r8, %r8
jle 0x727cb
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
addq %rcx, %r14
movq -0x30(%rbp), %r15
movq -0x38(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r12, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
movl %eax, %ebx
cmpl $0x2, %eax
movl $0x0, %eax
cmovll %eax, %ebx
jge 0x7276e
movb (%r12), %al
testb %al, %al
js 0x72789
testq %r13, %r13
je 0x727cb
incq %r12
movb %al, (%r15)
incq %r15
decq %r13
jmp 0x727c2
subq %rbx, %r13
jb 0x727cb
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5f0e0
addq %rbx, %r12
addq %rbx, %r15
jmp 0x727c2
cmpq $0x4, %r13
jb 0x727cb
movw $0x785c, (%r15) # imm = 0x785C
movzbl (%r12), %eax
movl %eax, %ecx
shrl $0x4, %ecx
leaq 0x33cb2a(%rip), %rdx # 0x3af2d0
movb (%rdx,%rcx), %cl
movb %cl, 0x2(%r15)
andl $0xf, %eax
movb (%rdx,%rax), %al
movb %al, 0x3(%r15)
addq $0x4, %r15
incq %r12
addq $-0x4, %r13
cmpq %r14, %r12
jb 0x7272d
subq -0x30(%rbp), %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _Z25my_copy_with_hex_escapingPK15charset_info_stPcmPKcm:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rsi
mov [rbp+var_38], rdi
mov [rbp+var_30], rsi
test r8, r8
jle loc_727CB
mov r14, r8
mov r12, rcx
mov r13, rdx
add r14, rcx
mov r15, [rbp+var_30]
loc_7272D:
mov rdi, [rbp+var_38]
mov rax, [rdi+0B8h]
mov rsi, r12
mov rdx, r14
call qword ptr [rax+0C0h]
mov ebx, eax
cmp eax, 2
mov eax, 0
cmovl ebx, eax
jge short loc_7276E
mov al, [r12]
test al, al
js short loc_72789
test r13, r13
jz short loc_727CB
inc r12
mov [r15], al
inc r15
dec r13
jmp short loc_727C2
loc_7276E:
sub r13, rbx
jb short loc_727CB
mov rdi, r15
mov rsi, r12
mov rdx, rbx
call _memcpy
add r12, rbx
add r15, rbx
jmp short loc_727C2
loc_72789:
cmp r13, 4
jb short loc_727CB
mov word ptr [r15], 785Ch
movzx eax, byte ptr [r12]
mov ecx, eax
shr ecx, 4
lea rdx, _dig_vec_upper; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rdx+rcx]
mov [r15+2], cl
and eax, 0Fh
mov al, [rdx+rax]
mov [r15+3], al
add r15, 4
inc r12
add r13, 0FFFFFFFFFFFFFFFCh
loc_727C2:
cmp r12, r14
jb loc_7272D
loc_727CB:
sub r15, [rbp+var_30]
mov rax, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * my_copy_with_hex_escaping(long long a1, char *a2, unsigned long long a3, char *a4, long long a5)
{
char *v5; // r15
char *v6; // r12
unsigned long long v8; // r14
unsigned int v9; // eax
long long v10; // rbx
char v11; // al
bool v12; // cf
char v13; // al
v5 = a2;
if ( a5 > 0 )
{
v6 = a4;
v8 = (unsigned long long)&a4[a5];
v5 = a2;
do
{
v9 = (*(long long ( **)(long long, char *, unsigned long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, v6, v8);
v10 = v9;
if ( (int)v9 >= 2 )
{
v12 = a3 < v9;
a3 -= v9;
if ( v12 )
return (_BYTE *)(v5 - a2);
memcpy(v5, v6, v9);
v6 += v10;
v5 += v10;
}
else
{
v11 = *v6;
if ( *v6 < 0 )
{
if ( a3 < 4 )
return (_BYTE *)(v5 - a2);
*(_WORD *)v5 = 30812;
v13 = *v6;
v5[2] = dig_vec_upper[(unsigned __int8)*v6 >> 4];
v5[3] = dig_vec_upper[v13 & 0xF];
v5 += 4;
++v6;
a3 -= 4LL;
}
else
{
if ( !a3 )
return (_BYTE *)(v5 - a2);
++v6;
*v5++ = v11;
--a3;
}
}
}
while ( (unsigned long long)v6 < v8 );
}
return (_BYTE *)(v5 - a2);
}
| my_copy_with_hex_escaping:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RSI
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x30],RSI
TEST R8,R8
JLE 0x001727cb
MOV R14,R8
MOV R12,RCX
MOV R13,RDX
ADD R14,RCX
MOV R15,qword ptr [RBP + -0x30]
LAB_0017272d:
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R12
MOV RDX,R14
CALL qword ptr [RAX + 0xc0]
MOV EBX,EAX
CMP EAX,0x2
MOV EAX,0x0
CMOVL EBX,EAX
JGE 0x0017276e
MOV AL,byte ptr [R12]
TEST AL,AL
JS 0x00172789
TEST R13,R13
JZ 0x001727cb
INC R12
MOV byte ptr [R15],AL
INC R15
DEC R13
JMP 0x001727c2
LAB_0017276e:
SUB R13,RBX
JC 0x001727cb
MOV RDI,R15
MOV RSI,R12
MOV RDX,RBX
CALL 0x0015f0e0
ADD R12,RBX
ADD R15,RBX
JMP 0x001727c2
LAB_00172789:
CMP R13,0x4
JC 0x001727cb
MOV word ptr [R15],0x785c
MOVZX EAX,byte ptr [R12]
MOV ECX,EAX
SHR ECX,0x4
LEA RDX,[0x4af2d0]
MOV CL,byte ptr [RDX + RCX*0x1]
MOV byte ptr [R15 + 0x2],CL
AND EAX,0xf
MOV AL,byte ptr [RDX + RAX*0x1]
MOV byte ptr [R15 + 0x3],AL
ADD R15,0x4
INC R12
ADD R13,-0x4
LAB_001727c2:
CMP R12,R14
JC 0x0017272d
LAB_001727cb:
SUB R15,qword ptr [RBP + -0x30]
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* my_copy_with_hex_escaping(charset_info_st const*, char*, unsigned long, char const*, unsigned
long) */
long my_copy_with_hex_escaping
(charset_info_st *param_1,char *param_2,ulong param_3,char *param_4,ulong param_5)
{
byte bVar1;
uint uVar2;
ulong __n;
byte *pbVar3;
byte *__dest;
bool bVar4;
__dest = (byte *)param_2;
if (0 < (long)param_5) {
pbVar3 = (byte *)(param_4 + param_5);
do {
uVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,param_4,pbVar3);
__n = (ulong)uVar2;
if ((int)uVar2 < 2) {
bVar1 = *param_4;
if ((char)bVar1 < '\0') {
if (param_3 < 4) break;
__dest[0] = 0x5c;
__dest[1] = 0x78;
bVar1 = *param_4;
__dest[2] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[bVar1 >> 4];
__dest[3] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[bVar1 & 0xf];
__dest = __dest + 4;
param_4 = (char *)((byte *)param_4 + 1);
param_3 = param_3 - 4;
}
else {
if (param_3 == 0) break;
param_4 = (char *)((byte *)param_4 + 1);
*__dest = bVar1;
__dest = __dest + 1;
param_3 = param_3 - 1;
}
}
else {
bVar4 = param_3 < __n;
param_3 = param_3 - __n;
if (bVar4) break;
memcpy(__dest,param_4,__n);
param_4 = (char *)((byte *)param_4 + __n);
__dest = __dest + __n;
}
} while (param_4 < pbVar3);
}
return (long)__dest - (long)param_2;
}
| |
43,113 | translog_sync_files | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_sync_files(uint32 min, uint32 max,
my_bool sync_dir)
{
uint fn;
my_bool rc= 0;
ulonglong flush_interval;
DBUG_ENTER("translog_sync_files");
DBUG_PRINT("info", ("min: %lu max: %lu sync dir: %d",
(ulong) min, (ulong) max, (int) sync_dir));
DBUG_ASSERT(min <= max);
flush_interval= group_commit_wait;
if (flush_interval)
flush_start= microsecond_interval_timer();
for (fn= min; fn <= max; fn++)
{
TRANSLOG_FILE *file= get_logfile_by_number(fn);
DBUG_ASSERT(file != NULL);
if (!file->is_sync)
{
if (mysql_file_sync(file->handler.file, MYF(MY_WME)))
{
rc= 1;
translog_stop_writing();
DBUG_RETURN(rc);
}
translog_syncs++;
file->is_sync= 1;
}
}
if (sync_dir)
{
if (!(rc= sync_dir(log_descriptor.directory_fd,
MYF(MY_WME | MY_IGNORE_BADFD))))
translog_syncs++;
}
DBUG_RETURN(rc);
} | O0 | c | translog_sync_files:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movb $0x0, -0x15(%rbp)
jmp 0x5bef9
jmp 0x5befb
jmp 0x5befd
movl 0xbe6fc1(%rip), %eax # 0xc42ec4
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5bf24
callq 0xbae40
movl $0x3e8, %ecx # imm = 0x3E8
xorl %edx, %edx
divq %rcx
movq %rax, 0xbe6f8c(%rip) # 0xc42eb0
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0x5bfa4
movl -0x14(%rbp), %edi
callq 0x5db50
movq %rax, -0x28(%rbp)
jmp 0x5bf40
movq -0x28(%rbp), %rax
cmpb $0x0, 0x51(%rax)
jne 0x5bf97
movq -0x28(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0xc32d7(%rip), %rdi # 0x11f22f
movl $0x1ed2, %esi # imm = 0x1ED2
movl $0x10, %ecx
callq 0x5e320
cmpl $0x0, %eax
je 0x5bf7d
movb $0x1, -0x15(%rbp)
callq 0x54970
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x5bfe9
movq 0x3e4e14(%rip), %rax # 0x440d98
addq $0x1, %rax
movq %rax, 0x3e4e09(%rip) # 0x440d98
movq -0x28(%rbp), %rax
movb $0x1, 0x51(%rax)
jmp 0x5bf99
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5bf2a
cmpb $0x0, -0xd(%rbp)
je 0x5bfe1
movl 0x3e62e0(%rip), %edx # 0x442290
leaq 0xc3278(%rip), %rdi # 0x11f22f
movl $0x1ee0, %esi # imm = 0x1EE0
movl $0x30, %ecx
callq 0x5e320
movb %al, -0x15(%rbp)
cmpb $0x0, %al
jne 0x5bfdf
movq 0x3e4dc4(%rip), %rax # 0x440d98
addq $0x1, %rax
movq %rax, 0x3e4db9(%rip) # 0x440d98
jmp 0x5bfe1
jmp 0x5bfe3
movb -0x15(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_sync_files:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_8], edi
mov [rbp+var_C], esi
mov [rbp+var_D], al
mov [rbp+var_15], 0
jmp short $+2
loc_5BEF9:
jmp short $+2
loc_5BEFB:
jmp short $+2
loc_5BEFD:
mov eax, cs:group_commit_wait
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_5BF24
call my_interval_timer
mov ecx, 3E8h
xor edx, edx
div rcx
mov cs:flush_start, rax
loc_5BF24:
mov eax, [rbp+var_8]
mov [rbp+var_14], eax
loc_5BF2A:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_C]
ja short loc_5BFA4
mov edi, [rbp+var_14]
call get_logfile_by_number
mov [rbp+var_28], rax
jmp short $+2
loc_5BF40:
mov rax, [rbp+var_28]
cmp byte ptr [rax+51h], 0
jnz short loc_5BF97
mov rax, [rbp+var_28]
mov edx, [rax+18h]
lea rdi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1ED2h
mov ecx, 10h
call inline_mysql_file_sync_3
cmp eax, 0
jz short loc_5BF7D
mov [rbp+var_15], 1
call translog_stop_writing
mov al, [rbp+var_15]
mov [rbp+var_1], al
jmp short loc_5BFE9
loc_5BF7D:
mov rax, cs:translog_syncs
add rax, 1
mov cs:translog_syncs, rax
mov rax, [rbp+var_28]
mov byte ptr [rax+51h], 1
loc_5BF97:
jmp short $+2
loc_5BF99:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_5BF2A
loc_5BFA4:
cmp [rbp+var_D], 0
jz short loc_5BFE1
mov edx, cs:dword_442290
lea rdi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1EE0h
mov ecx, 30h ; '0'
call inline_mysql_file_sync_3
mov [rbp+var_15], al
cmp al, 0
jnz short loc_5BFDF
mov rax, cs:translog_syncs
add rax, 1
mov cs:translog_syncs, rax
loc_5BFDF:
jmp short $+2
loc_5BFE1:
jmp short $+2
loc_5BFE3:
mov al, [rbp+var_15]
mov [rbp+var_1], al
loc_5BFE9:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char translog_sync_files(unsigned int a1, unsigned int a2, char a3)
{
long long logfile_by_number; // [rsp+8h] [rbp-28h]
char v5; // [rsp+1Bh] [rbp-15h]
v5 = 0;
if ( group_commit_wait )
flush_start = my_interval_timer() / 0x3E8uLL;
while ( a1 <= a2 )
{
logfile_by_number = get_logfile_by_number(a1);
if ( !*(_BYTE *)(logfile_by_number + 81) )
{
if ( (unsigned int)inline_mysql_file_sync_3(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
7890LL,
*(unsigned int *)(logfile_by_number + 24),
16LL) )
{
translog_stop_writing();
return 1;
}
++translog_syncs;
*(_BYTE *)(logfile_by_number + 81) = 1;
}
++a1;
}
if ( a3 )
{
v5 = inline_mysql_file_sync_3(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
7904LL,
(unsigned int)dword_442290,
48LL);
if ( !v5 )
++translog_syncs;
}
return v5;
}
| translog_sync_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],ESI
MOV byte ptr [RBP + -0xd],AL
MOV byte ptr [RBP + -0x15],0x0
JMP 0x0015bef9
LAB_0015bef9:
JMP 0x0015befb
LAB_0015befb:
JMP 0x0015befd
LAB_0015befd:
MOV EAX,dword ptr [0x00d42ec4]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0015bf24
CALL 0x001bae40
MOV ECX,0x3e8
XOR EDX,EDX
DIV RCX
MOV qword ptr [0x00d42eb0],RAX
LAB_0015bf24:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x14],EAX
LAB_0015bf2a:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0xc]
JA 0x0015bfa4
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x0015db50
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015bf40
LAB_0015bf40:
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x51],0x0
JNZ 0x0015bf97
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RAX + 0x18]
LEA RDI,[0x21f22f]
MOV ESI,0x1ed2
MOV ECX,0x10
CALL 0x0015e320
CMP EAX,0x0
JZ 0x0015bf7d
MOV byte ptr [RBP + -0x15],0x1
CALL 0x00154970
MOV AL,byte ptr [RBP + -0x15]
MOV byte ptr [RBP + -0x1],AL
JMP 0x0015bfe9
LAB_0015bf7d:
MOV RAX,qword ptr [0x00540d98]
ADD RAX,0x1
MOV qword ptr [0x00540d98],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x51],0x1
LAB_0015bf97:
JMP 0x0015bf99
LAB_0015bf99:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0015bf2a
LAB_0015bfa4:
CMP byte ptr [RBP + -0xd],0x0
JZ 0x0015bfe1
MOV EDX,dword ptr [0x00542290]
LEA RDI,[0x21f22f]
MOV ESI,0x1ee0
MOV ECX,0x30
CALL 0x0015e320
MOV byte ptr [RBP + -0x15],AL
CMP AL,0x0
JNZ 0x0015bfdf
MOV RAX,qword ptr [0x00540d98]
ADD RAX,0x1
MOV qword ptr [0x00540d98],RAX
LAB_0015bfdf:
JMP 0x0015bfe1
LAB_0015bfe1:
JMP 0x0015bfe3
LAB_0015bfe3:
MOV AL,byte ptr [RBP + -0x15]
MOV byte ptr [RBP + -0x1],AL
LAB_0015bfe9:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int8 translog_sync_files(uint param_1,uint param_2,char param_3)
{
int iVar1;
ulong uVar2;
long lVar3;
int8 uVar4;
int7 uVar5;
char local_1d;
uint local_1c;
char local_9;
local_1d = '\0';
local_1c = param_1;
if (group_commit_wait != 0) {
uVar2 = my_interval_timer();
flush_start = uVar2 / 1000;
}
do {
uVar2 = (ulong)local_1c;
if (param_2 < local_1c) {
if (param_3 != '\0') {
uVar2 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1ee0,DAT_00542290,0x30);
local_1d = (char)uVar2;
if (local_1d == '\0') {
uVar2 = translog_syncs + 1;
translog_syncs = uVar2;
}
}
uVar5 = (int7)(uVar2 >> 8);
local_9 = local_1d;
LAB_0015bfe9:
return CONCAT71(uVar5,local_9);
}
lVar3 = get_logfile_by_number(local_1c);
if (*(char *)(lVar3 + 0x51) == '\0') {
iVar1 = inline_mysql_file_sync
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x1ed2,*(int4 *)(lVar3 + 0x18),0x10);
if (iVar1 != 0) {
uVar4 = translog_stop_writing();
uVar5 = (int7)((ulong)uVar4 >> 8);
local_9 = '\x01';
goto LAB_0015bfe9;
}
translog_syncs = translog_syncs + 1;
*(int1 *)(lVar3 + 0x51) = 1;
}
local_1c = local_1c + 1;
} while( true );
}
| |
43,114 | get_charset_name | eloqsql/mysys/charset.c | const char *get_charset_name(uint charset_number)
{
my_pthread_once(&charsets_initialized, init_available_charsets);
if (charset_number < array_elements(all_charsets))
{
CHARSET_INFO *cs= all_charsets[charset_number];
if (cs && (cs->number == charset_number) && cs->coll_name.str)
return cs->coll_name.str;
}
return "?"; /* this mimics find_type() */
} | O3 | c | get_charset_name:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x36540a(%rip), %rdi # 0x3b5c30
leaq -0x302(%rip), %rsi # 0x5052b
callq 0x28350
leaq 0x45bf0(%rip), %rcx # 0x96429
cmpl $0x7ff, %ebx # imm = 0x7FF
ja 0x50860
movl %ebx, %eax
leaq 0x35d376(%rip), %rdx # 0x3adbc0
movq (%rdx,%rax,8), %rax
testq %rax, %rax
je 0x50860
cmpl %ebx, (%rax)
jne 0x50860
movq 0x20(%rax), %rax
testq %rax, %rax
jne 0x50863
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| get_charset_name:
push rbp
mov rbp, rsp
push rbx
push rax
mov ebx, edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
lea rcx, asc_96429; "?"
cmp ebx, 7FFh
ja short loc_50860
mov eax, ebx
lea rdx, all_charsets
mov rax, [rdx+rax*8]
test rax, rax
jz short loc_50860
cmp [rax], ebx
jnz short loc_50860
mov rax, [rax+20h]
test rax, rax
jnz short loc_50863
loc_50860:
mov rax, rcx
loc_50863:
add rsp, 8
pop rbx
pop rbp
retn
| const char * get_charset_name(unsigned int a1)
{
long long v1; // rax
const char *result; // rax
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 > 0x7FF )
return "?";
v1 = all_charsets[a1];
if ( !v1 )
return "?";
if ( *(_DWORD *)v1 != a1 )
return "?";
result = *(const char **)(v1 + 32);
if ( !result )
return "?";
return result;
}
| get_charset_name:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EBX,EDI
LEA RDI,[0x4b5c30]
LEA RSI,[0x15052b]
CALL 0x00128350
LEA RCX,[0x196429]
CMP EBX,0x7ff
JA 0x00150860
MOV EAX,EBX
LEA RDX,[0x4adbc0]
MOV RAX,qword ptr [RDX + RAX*0x8]
TEST RAX,RAX
JZ 0x00150860
CMP dword ptr [RAX],EBX
JNZ 0x00150860
MOV RAX,qword ptr [RAX + 0x20]
TEST RAX,RAX
JNZ 0x00150863
LAB_00150860:
MOV RAX,RCX
LAB_00150863:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int * get_charset_name(uint param_1)
{
uint *puVar1;
int *puVar2;
pthread_once(&charsets_initialized,init_available_charsets);
if ((((0x7ff < param_1) || (puVar1 = (uint *)(&all_charsets)[param_1], puVar1 == (uint *)0x0)) ||
(*puVar1 != param_1)) || (puVar2 = *(int **)(puVar1 + 8), puVar2 == (int *)0x0)) {
puVar2 = &DAT_00196429;
}
return puVar2;
}
| |
43,115 | nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parser(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool) | hkr04[P]cpp-mcp/common/json.hpp | explicit parser(InputAdapterType&& adapter,
const parser_callback_t<BasicJsonType> cb = nullptr,
const bool allow_exceptions_ = true,
const bool skip_comments = false)
: callback(cb)
, m_lexer(std::move(adapter), skip_comments)
, allow_exceptions(allow_exceptions_)
{
// read first token
get_token();
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parser(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&&, std::function<bool (int, nlohmann::json_abi_v3_11_3::detail::parse_event_t, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&)>, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x484fc
movl $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x48b50
movb %r14b, 0xc0(%rbx)
movq %r15, %rdi
callq 0x48bf0
movl %eax, 0x20(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x48bbc
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x48b40
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xaa60
movq %rax, %rdi
callq 0xe901
| _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_St8functionIFbiNS1_13parse_event_tERSF_EEbb:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, r8d
mov r14d, ecx
mov r12, rsi
mov rbx, rdi
mov rsi, rdx
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
mov dword ptr [rbx+20h], 0
lea r15, [rbx+28h]
mov rdi, r15
mov rsi, r12
mov edx, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEEC2EOSM_b; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::lexer(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>&&,bool)
mov [rbx+0C0h], r14b
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE4scanEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan(void)
mov [rbx+20h], eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~lexer()
mov rax, [rbx+10h]
test rax, rax
jz short loc_48B40
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_48B40:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parser(
long long a1,
long long a2,
long long a3,
char a4,
unsigned int a5)
{
long long result; // rax
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
(_OWORD *)a1,
a3);
*(_DWORD *)(a1 + 32) = 0;
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::lexer(
a1 + 40,
a2,
a5);
*(_BYTE *)(a1 + 192) = a4;
result = nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan(a1 + 40);
*(_DWORD *)(a1 + 32) = result;
return result;
}
| parser:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,R8D
MOV R14D,ECX
MOV R12,RSI
MOV RBX,RDI
MOV RSI,RDX
CALL 0x001484fc
MOV dword ptr [RBX + 0x20],0x0
LEA R15,[RBX + 0x28]
MOV RDI,R15
MOV RSI,R12
MOV EDX,EBP
CALL 0x00148b50
MOV byte ptr [RBX + 0xc0],R14B
LAB_00148b0b:
MOV RDI,R15
CALL 0x00148bf0
MOV dword ptr [RBX + 0x20],EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >
>::parser(nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > >&&, std::function<bool (int,
nlohmann::json_abi_v3_11_3::detail::parse_event_t,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&)>, bool, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::parser(parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,iterator_input_adapter *param_1,function *param_3,
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
param_4,bool param_5)
{
int4 uVar1;
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)this,param_3);
*(int4 *)(this + 0x20) = 0;
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::lexer((lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*)(this + 0x28),param_1,param_5);
this[0xc0] = param_4;
/* try { // try from 00148b0b to 00148b12 has its CatchHandler @ 00148b1f */
uVar1 = lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan((lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*)(this + 0x28));
*(int4 *)(this + 0x20) = uVar1;
return;
}
| |
43,116 | js_object_hasOwnProperty | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_hasOwnProperty(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj;
JSAtom atom;
JSObject *p;
BOOL ret;
atom = JS_ValueToAtom(ctx, argv[0]); /* must be done first */
if (unlikely(atom == JS_ATOM_NULL))
return JS_EXCEPTION;
obj = JS_ToObject(ctx, this_val);
if (JS_IsException(obj)) {
JS_FreeAtom(ctx, atom);
return obj;
}
p = JS_VALUE_GET_OBJ(obj);
ret = JS_GetOwnPropertyInternal(ctx, NULL, p, atom);
JS_FreeAtom(ctx, atom);
JS_FreeValue(ctx, obj);
if (ret < 0)
return JS_EXCEPTION;
else
return js_bool(ret);
} | O3 | c | js_object_hasOwnProperty:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x23ad1
pushq $0x6
popq %rbx
testl %eax, %eax
je 0x12a81
movl %eax, %ebp
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x268d8
movq %rax, %r14
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x12a31
movq %r15, %rdi
movl %ebp, %esi
callq 0x202f5
movq %r12, %rbx
jmp 0x12a84
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x237bd
movl %eax, %r13d
movq %r15, %rdi
movl %ebp, %esi
callq 0x202f5
cmpl $-0x9, %r12d
jb 0x12a70
movq 0x18(%r15), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x12a70
movq %r14, %rsi
movq %r12, %rdx
callq 0x20d90
testl %r13d, %r13d
js 0x12a81
setne %al
movzbl %al, %r14d
pushq $0x1
popq %rbx
jmp 0x12a84
xorl %r14d, %r14d
movq %r14, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_object_hasOwnProperty:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ValueToAtom
push 6
pop rbx
test eax, eax
jz short loc_12A81
mov ebp, eax
mov rdi, r15
mov rsi, r12
mov rdx, r14
call JS_ToObject
mov r14, rax
mov r12, rdx
cmp r12d, 6
jnz short loc_12A31
mov rdi, r15
mov esi, ebp
call JS_FreeAtom
mov rbx, r12
jmp short loc_12A84
loc_12A31:
mov rdi, r15
xor esi, esi
mov rdx, r14
mov ecx, ebp
call JS_GetOwnPropertyInternal
mov r13d, eax
mov rdi, r15
mov esi, ebp
call JS_FreeAtom
cmp r12d, 0FFFFFFF7h
jb short loc_12A70
mov rdi, [r15+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_12A70
mov rsi, r14
mov rdx, r12
call js_free_value_rt
loc_12A70:
test r13d, r13d
js short loc_12A81
setnz al
movzx r14d, al
push 1
pop rbx
jmp short loc_12A84
loc_12A81:
xor r14d, r14d
loc_12A84:
mov rax, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BOOL8 js_object_hasOwnProperty(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
unsigned int v6; // eax
unsigned int v7; // ebp
long long v8; // rax
_DWORD *v9; // r14
unsigned int v10; // edx
unsigned int v11; // r12d
int OwnPropertyInternal; // r13d
long long v13; // rdi
int v14; // eax
v6 = JS_ValueToAtom(a1, *a5, a5[1]);
if ( !v6 )
return 0LL;
v7 = v6;
v8 = JS_ToObject(a1, a2, a3);
v9 = (_DWORD *)v8;
v11 = v10;
if ( v10 != 6 )
{
OwnPropertyInternal = JS_GetOwnPropertyInternal(a1, 0LL, v8, v7);
JS_FreeAtom(a1, v7);
if ( v11 >= 0xFFFFFFF7 )
{
v13 = *(_QWORD *)(a1 + 24);
v14 = (*v9)--;
if ( v14 <= 1 )
js_free_value_rt(v13, v9);
}
if ( OwnPropertyInternal >= 0 )
return OwnPropertyInternal != 0;
return 0LL;
}
JS_FreeAtom(a1, v7);
return (_BOOL8)v9;
}
| js_object_hasOwnProperty:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00123ad1
PUSH 0x6
POP RBX
TEST EAX,EAX
JZ 0x00112a81
MOV EBP,EAX
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x001268d8
MOV R14,RAX
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00112a31
MOV RDI,R15
MOV ESI,EBP
CALL 0x001202f5
MOV RBX,R12
JMP 0x00112a84
LAB_00112a31:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R14
MOV ECX,EBP
CALL 0x001237bd
MOV R13D,EAX
MOV RDI,R15
MOV ESI,EBP
CALL 0x001202f5
CMP R12D,-0x9
JC 0x00112a70
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00112a70
MOV RSI,R14
MOV RDX,R12
CALL 0x00120d90
LAB_00112a70:
TEST R13D,R13D
JS 0x00112a81
SETNZ AL
MOVZX R14D,AL
PUSH 0x1
POP RBX
JMP 0x00112a84
LAB_00112a81:
XOR R14D,R14D
LAB_00112a84:
MOV RAX,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_object_hasOwnProperty
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 *param_5
)
{
int8 uVar1;
int iVar2;
int iVar3;
int1 auVar4 [16];
iVar2 = JS_ValueToAtom(param_1,*param_5,param_5[1]);
if (iVar2 != 0) {
auVar4 = JS_ToObject(param_1,param_2,param_3);
auVar4._0_8_ = auVar4._0_8_;
if (auVar4._8_4_ == 6) {
JS_FreeAtom(param_1,iVar2);
return auVar4;
}
iVar3 = JS_GetOwnPropertyInternal(param_1,0,auVar4._0_8_,iVar2);
JS_FreeAtom(param_1,iVar2);
if (0xfffffff6 < auVar4._8_4_) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar2 = *auVar4._0_8_;
*auVar4._0_8_ = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar1,auVar4._0_8_,auVar4._8_8_);
}
}
if (-1 < iVar3) {
auVar4._1_7_ = 0;
auVar4[0] = iVar3 != 0;
auVar4._8_8_ = 1;
return auVar4;
}
}
return ZEXT816(6) << 0x40;
}
| |
43,117 | Bfree | eloqsql/strings/dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O0 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0xdcb03
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xdcb0e
movq -0x18(%rbp), %rdi
callq 0x294a0
jmp 0xdcb47
movq -0x8(%rbp), %rax
cmpl $0xf, 0x8(%rax)
jg 0xdcb45
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq 0x18(%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0xdcb47
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| Bfree:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jb short loc_DCB03
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
jb short loc_DCB0E
loc_DCB03:
mov rdi, [rbp+var_18]
call _free
jmp short loc_DCB47
loc_DCB0E:
mov rax, [rbp+var_8]
cmp dword ptr [rax+8], 0Fh
jg short loc_DCB45
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov rcx, [rax+rcx*8+18h]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rdx, [rbp+var_8]
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+8]
mov [rax+rcx*8+18h], rdx
loc_DCB45:
jmp short $+2
loc_DCB47:
add rsp, 20h
pop rbp
retn
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( a1 < *a2 || a1 >= a2[2] )
return free(a1);
result = a1;
if ( *(int *)(a1 + 8) <= 15 )
{
*(_QWORD *)a1 = a2[*(int *)(a1 + 8) + 3];
result = (long long)a2;
a2[*(int *)(a1 + 8) + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JC 0x001dcb03
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JC 0x001dcb0e
LAB_001dcb03:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001294a0
JMP 0x001dcb47
LAB_001dcb0e:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x8],0xf
JG 0x001dcb45
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV RCX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x8]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
LAB_001dcb45:
JMP 0x001dcb47
LAB_001dcb47:
ADD RSP,0x20
POP RBP
RET
|
void Bfree(ulong *param_1,ulong *param_2)
{
if ((param_1 < (ulong *)*param_2) || ((ulong *)param_2[2] <= param_1)) {
free(param_1);
}
else if ((int)param_1[1] < 0x10) {
*param_1 = param_2[(long)(int)param_1[1] + 3];
param_2[(long)(int)param_1[1] + 3] = (ulong)param_1;
}
return;
}
| |
43,118 | Bfree | eloqsql/strings/dtoa.c | static void Bfree(Bigint *v, Stack_alloc *alloc)
{
char *gptr= (char*) v; /* generic pointer */
if (gptr < alloc->begin || gptr >= alloc->end)
free(gptr);
else if (v->k <= Kmax)
{
/*
Maintain free lists only for stack objects: this way we don't
have to bother with freeing lists in the end of dtoa;
heap should not be used normally anyway.
*/
v->p.next= alloc->freelist[v->k];
alloc->freelist[v->k]= v;
}
} | O3 | c | Bfree:
pushq %rbp
movq %rsp, %rbp
cmpq %rdi, (%rsi)
ja 0x943ad
cmpq %rdi, 0x10(%rsi)
jbe 0x943ad
movslq 0x8(%rdi), %rax
cmpq $0xf, %rax
jg 0x943ab
movq 0x18(%rsi,%rax,8), %rcx
movq %rcx, (%rdi)
movq %rdi, 0x18(%rsi,%rax,8)
popq %rbp
retq
popq %rbp
jmp 0x284f0
| Bfree:
push rbp
mov rbp, rsp
cmp [rsi], rdi
ja short loc_943AD
cmp [rsi+10h], rdi
jbe short loc_943AD
movsxd rax, dword ptr [rdi+8]
cmp rax, 0Fh
jg short loc_943AB
mov rcx, [rsi+rax*8+18h]
mov [rdi], rcx
mov [rsi+rax*8+18h], rdi
loc_943AB:
pop rbp
retn
loc_943AD:
pop rbp
jmp _free
| long long Bfree(unsigned long long a1, unsigned long long *a2)
{
long long result; // rax
if ( *a2 > a1 || a2[2] <= a1 )
return free(a1, a2);
result = *(int *)(a1 + 8);
if ( result <= 15 )
{
*(_QWORD *)a1 = a2[result + 3];
a2[result + 3] = a1;
}
return result;
}
| Bfree:
PUSH RBP
MOV RBP,RSP
CMP qword ptr [RSI],RDI
JA 0x001943ad
CMP qword ptr [RSI + 0x10],RDI
JBE 0x001943ad
MOVSXD RAX,dword ptr [RDI + 0x8]
CMP RAX,0xf
JG 0x001943ab
MOV RCX,qword ptr [RSI + RAX*0x8 + 0x18]
MOV qword ptr [RDI],RCX
MOV qword ptr [RSI + RAX*0x8 + 0x18],RDI
LAB_001943ab:
POP RBP
RET
LAB_001943ad:
POP RBP
JMP 0x001284f0
|
void Bfree(ulong *param_1,ulong *param_2)
{
long lVar1;
if (((ulong *)*param_2 <= param_1) && (param_1 < (ulong *)param_2[2])) {
lVar1 = (long)(int)param_1[1];
if (lVar1 < 0x10) {
*param_1 = param_2[lVar1 + 3];
param_2[lVar1 + 3] = (ulong)param_1;
}
return;
}
free(param_1);
return;
}
| |
43,119 | LefDefParser::lefwEndBeginext() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwEndBeginext()
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (lefwState != LEFW_BEGINEXT_START &&
lefwState != LEFW_BEGINEXT)
return LEFW_BAD_ORDER;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) ";\nENDEXT\n\n");
else
fprintf(lefwFile, ";\nENDEXT\n\n");
lefwState = LEFW_BEGINEXT_END;
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwEndBeginext():
pushq %rax
leaq 0x91078(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x341eb
movl $0x1, 0x4(%rsp)
jmp 0x3428b
leaq 0x912b2(%rip), %rax # 0xc54a4
cmpl $0x0, (%rax)
jne 0x34204
movl $0x2, 0x4(%rsp)
jmp 0x3428b
leaq 0x91295(%rip), %rax # 0xc54a0
cmpl $0x3, (%rax)
je 0x34226
leaq 0x91289(%rip), %rax # 0xc54a0
cmpl $0x14, (%rax)
je 0x34226
movl $0x2, 0x4(%rsp)
jmp 0x3428b
cmpl $0x0, 0x9130f(%rip) # 0xc553c
je 0x34249
leaq 0x9101a(%rip), %rax # 0xc5250
movq (%rax), %rdi
leaq 0x60780(%rip), %rsi # 0x949c0
movb $0x0, %al
callq 0x8bf50
jmp 0x34261
leaq 0x91000(%rip), %rax # 0xc5250
movq (%rax), %rdi
leaq 0x60766(%rip), %rsi # 0x949c0
movb $0x0, %al
callq 0x2370
leaq 0x91238(%rip), %rax # 0xc54a0
movl $0x51, (%rax)
leaq 0x91227(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9121b(%rip), %rax # 0xc549c
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
| _ZN12LefDefParser15lefwEndBeginextEv:
push rax
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_341EB
mov [rsp+8+var_4], 1
jmp loc_3428B
loc_341EB:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_34204
mov [rsp+8+var_4], 2
jmp loc_3428B
loc_34204:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 3
jz short loc_34226
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 14h
jz short loc_34226
mov [rsp+8+var_4], 2
jmp short loc_3428B
loc_34226:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_34249
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aEndext; ";\nENDEXT\n\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_34261
loc_34249:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aEndext; ";\nENDEXT\n\n"
mov al, 0
call _fprintf
loc_34261:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 51h ; 'Q'
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+8+var_4], 0
loc_3428B:
mov eax, [rsp+8+var_4]
pop rcx
retn
| long long LefDefParser::lefwEndBeginext(LefDefParser *this, long long a2, int a3, int a4, int a5, int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwState == 3 || LefDefParser::lefwState == 20 )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)";\nENDEXT\n\n", a3, a4, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, ";\nENDEXT\n\n");
LefDefParser::lefwState = 81;
++LefDefParser::lefwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwEndBeginext:
PUSH RAX
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x001341eb
MOV dword ptr [RSP + 0x4],0x1
JMP 0x0013428b
LAB_001341eb:
LEA RAX,[0x1c54a4]
CMP dword ptr [RAX],0x0
JNZ 0x00134204
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0013428b
LAB_00134204:
LEA RAX,[0x1c54a0]
CMP dword ptr [RAX],0x3
JZ 0x00134226
LEA RAX,[0x1c54a0]
CMP dword ptr [RAX],0x14
JZ 0x00134226
MOV dword ptr [RSP + 0x4],0x2
JMP 0x0013428b
LAB_00134226:
CMP dword ptr [0x001c553c],0x0
JZ 0x00134249
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1949c0]
MOV AL,0x0
CALL 0x0018bf50
JMP 0x00134261
LAB_00134249:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1949c0]
MOV AL,0x0
CALL 0x00102370
LAB_00134261:
LEA RAX,[0x1c54a0]
MOV dword ptr [RAX],0x51
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x4],0x0
LAB_0013428b:
MOV EAX,dword ptr [RSP + 0x4]
POP RCX
RET
|
/* LefDefParser::lefwEndBeginext() */
int4 LefDefParser::lefwEndBeginext(void)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if ((lefwState == 3) || (lefwState == 0x14)) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile,";\nENDEXT\n\n");
}
else {
encPrint(lefwFile,";\nENDEXT\n\n");
}
lefwState = 0x51;
lefwLines = lefwLines + 1;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
| |
43,120 | delete_dynamic_element | eloqsql/mysys/array.c | void delete_dynamic_element(DYNAMIC_ARRAY *array, uint idx)
{
char *ptr= (char*) array->buffer+array->size_of_element*idx;
array->elements--;
memmove(ptr,ptr+array->size_of_element,
(array->elements-idx)*array->size_of_element);
} | O3 | c | delete_dynamic_element:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %edx
movl 0x14(%rdi), %ecx
movl %ecx, %eax
imull %esi, %eax
addq (%rdi), %rax
decl %edx
movl %edx, 0x8(%rdi)
subl %esi, %edx
imull %ecx, %edx
movq %rcx, %rsi
addq %rax, %rsi
movq %rax, %rdi
popq %rbp
jmp 0x24550
| delete_dynamic_element:
push rbp
mov rbp, rsp
mov edx, [rdi+8]
mov ecx, [rdi+14h]
mov eax, ecx
imul eax, esi
add rax, [rdi]
dec edx
mov [rdi+8], edx
sub edx, esi
imul edx, ecx
mov rsi, rcx
add rsi, rax
mov rdi, rax
pop rbp
jmp _memmove
| long long delete_dynamic_element(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
int v4; // edx
v2 = *(unsigned int *)(a1 + 20);
v3 = *(_QWORD *)a1 + (unsigned int)(a2 * *(_DWORD *)(a1 + 20));
v4 = *(_DWORD *)(a1 + 8) - 1;
*(_DWORD *)(a1 + 8) = v4;
return memmove(v3, v3 + v2, (unsigned int)(v2 * (v4 - a2)));
}
| delete_dynamic_element:
PUSH RBP
MOV RBP,RSP
MOV EDX,dword ptr [RDI + 0x8]
MOV ECX,dword ptr [RDI + 0x14]
MOV EAX,ECX
IMUL EAX,ESI
ADD RAX,qword ptr [RDI]
DEC EDX
MOV dword ptr [RDI + 0x8],EDX
SUB EDX,ESI
IMUL EDX,ECX
MOV RSI,RCX
ADD RSI,RAX
MOV RDI,RAX
POP RBP
JMP 0x00124550
|
void delete_dynamic_element(long *param_1,int param_2)
{
uint uVar1;
void *__dest;
int iVar2;
uVar1 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar1 * param_2) + *param_1);
iVar2 = (int)param_1[1] + -1;
*(int *)(param_1 + 1) = iVar2;
memmove(__dest,(void *)((ulong)uVar1 + (long)__dest),(ulong)((iVar2 - param_2) * uVar1));
return;
}
| |
43,121 | gguf_get_meta_size | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | size_t gguf_get_meta_size(const struct gguf_context * ctx) {
// only return size
std::vector<int8_t> buf;
gguf_write_to_buf(ctx, buf, /*only_meta =*/ true);
return buf.size();
} | O3 | cpp | gguf_get_meta_size:
pushq %r14
pushq %rbx
subq $0x18, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movl $0x1, %edx
callq 0x16df0
movq (%rsp), %rbx
movq 0x8(%rsp), %r14
testq %rbx, %rbx
je 0x40520
movq 0x10(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x170d0
subq %rbx, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x40547
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x170d0
movq %rbx, %rdi
callq 0x17e90
| gguf_get_meta_size:
push r14
push rbx
sub rsp, 18h
xorps xmm0, xmm0
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov qword ptr [rsi+10h], 0
mov edx, 1
call __Z17gguf_write_to_bufPK12gguf_contextRSt6vectorIaSaIaEEb; gguf_write_to_buf(gguf_context const*,std::vector<signed char> &,bool)
mov rbx, [rsp+28h+var_28]
mov r14, [rsp+28h+var_20]
test rbx, rbx
jz short loc_40520
mov rsi, [rsp+28h+var_18]
sub rsi, rbx; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_40520:
sub r14, rbx
mov rax, r14
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_40547
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_40547:
mov rdi, rbx
call __Unwind_Resume
| long long gguf_get_meta_size(_QWORD *a1)
{
__int128 v1; // kr00_16
__int128 v3; // [rsp+0h] [rbp-28h] BYREF
long long v4; // [rsp+10h] [rbp-18h]
v3 = 0LL;
v4 = 0LL;
gguf_write_to_buf(a1, (long long)&v3, 1);
v1 = v3;
if ( (_QWORD)v3 )
operator delete((void *)v3, v4 - v3);
return *((_QWORD *)&v1 + 1) - v1;
}
| gguf_get_meta_size:
PUSH R14
PUSH RBX
SUB RSP,0x18
XORPS XMM0,XMM0
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV qword ptr [RSI + 0x10],0x0
LAB_001404f8:
MOV EDX,0x1
CALL 0x00116df0
LAB_00140502:
MOV RBX,qword ptr [RSP]
MOV R14,qword ptr [RSP + 0x8]
TEST RBX,RBX
JZ 0x00140520
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RBX
MOV RDI,RBX
CALL 0x001170d0
LAB_00140520:
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R14
RET
|
long gguf_get_meta_size(gguf_context *param_1)
{
void *pvVar1;
long lVar2;
void *local_28;
long lStack_20;
long local_18;
local_28 = (void *)0x0;
lStack_20 = 0;
local_18 = 0;
/* try { // try from 001404f8 to 00140501 has its CatchHandler @ 0014052e */
gguf_write_to_buf(param_1,(vector *)&local_28,true);
lVar2 = lStack_20;
pvVar1 = local_28;
if (local_28 != (void *)0x0) {
operator_delete(local_28,local_18 - (long)local_28);
}
return lVar2 - (long)pvVar1;
}
| |
43,122 | ImPlot::SetupAxisZoomConstraints(int, double, double) | zkingston[P]unknot/build_O1/_deps/implot-src/implot.cpp | void SetupAxisZoomConstraints(ImAxis idx, double z_min, double z_max) {
ImPlotContext& gp = *GImPlot;
IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
"Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
ImPlotPlot& plot = *gp.CurrentPlot;
ImPlotAxis& axis = plot.Axes[idx];
IM_ASSERT_USER_ERROR(axis.Enabled, "Axis is not enabled! Did you forget to call SetupAxis()?");
axis.ConstraintZoom.Min = z_min;
axis.ConstraintZoom.Max = z_max;
} | O1 | cpp | ImPlot::SetupAxisZoomConstraints(int, double, double):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl %edi, %ebx
movq 0x27e114(%rip), %r14 # 0x336ca0
movq 0x50(%r14), %rax
testq %rax, %rax
je 0xb8b9e
cmpb $0x1, 0x9de(%rax)
jne 0xb8baa
leaq 0x1dc39f(%rip), %rdi # 0x294f44
callq 0x2161f4
movq 0x50(%r14), %rax
movslq %ebx, %rcx
imulq $0x178, %rcx, %rcx # imm = 0x178
leaq (%rax,%rcx), %rbx
addq $0x18, %rbx
cmpb $0x0, 0x16c(%rbx)
jne 0xb8bd5
leaq 0x1e1a23(%rip), %rdi # 0x29a5f3
callq 0x2161f4
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| _ZN6ImPlot24SetupAxisZoomConstraintsEidd:
push r14
push rbx
sub rsp, 18h
movsd [rsp+28h+var_18], xmm1
movsd [rsp+28h+var_20], xmm0
mov ebx, edi
mov r14, cs:GImPlot
mov rax, [r14+50h]
test rax, rax
jz short loc_B8B9E
cmp byte ptr [rax+9DEh], 1
jnz short loc_B8BAA
loc_B8B9E:
lea rdi, aSetupNeedsToBe; "Setup needs to be called after BeginPlo"...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_B8BAA:
mov rax, [r14+50h]
movsxd rcx, ebx
imul rcx, 178h
lea rbx, [rax+rcx]
add rbx, 18h
cmp byte ptr [rbx+16Ch], 0
jnz short loc_B8BD5
lea rdi, aAxisIsNotEnabl; "Axis is not enabled! Did you forget to "...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_B8BD5:
movsd xmm0, [rsp+28h+var_20]
movsd qword ptr [rbx+50h], xmm0
movsd xmm0, [rsp+28h+var_18]
movsd qword ptr [rbx+58h], xmm0
add rsp, 18h
pop rbx
pop r14
retn
| long long ImPlot::SetupAxisZoomConstraints(ImPlot *this, const char *a2, double a3, double a4)
{
ImGui *v4; // r14
long long v5; // rax
long long result; // rax
long long v7; // rcx
long long v8; // rbx
v4 = GImPlot;
v5 = *((_QWORD *)GImPlot + 10);
if ( !v5 || *(_BYTE *)(v5 + 2526) == 1 )
ImGui::ErrorLog(
(ImGui *)"Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!",
a2);
result = *((_QWORD *)v4 + 10);
v7 = 376LL * (int)this;
v8 = result + v7 + 24;
if ( !*(_BYTE *)(result + v7 + 388) )
result = ImGui::ErrorLog((ImGui *)"Axis is not enabled! Did you forget to call SetupAxis()?", a2);
*(double *)(v8 + 80) = a3;
*(double *)(v8 + 88) = a4;
return result;
}
| SetupAxisZoomConstraints:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x10],XMM1
MOVSD qword ptr [RSP + 0x8],XMM0
MOV EBX,EDI
MOV R14,qword ptr [0x00436ca0]
MOV RAX,qword ptr [R14 + 0x50]
TEST RAX,RAX
JZ 0x001b8b9e
CMP byte ptr [RAX + 0x9de],0x1
JNZ 0x001b8baa
LAB_001b8b9e:
LEA RDI,[0x394f44]
CALL 0x003161f4
LAB_001b8baa:
MOV RAX,qword ptr [R14 + 0x50]
MOVSXD RCX,EBX
IMUL RCX,RCX,0x178
LEA RBX,[RAX + RCX*0x1]
ADD RBX,0x18
CMP byte ptr [RBX + 0x16c],0x0
JNZ 0x001b8bd5
LEA RDI,[0x39a5f3]
CALL 0x003161f4
LAB_001b8bd5:
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RBX + 0x50],XMM0
MOVSD XMM0,qword ptr [RSP + 0x10]
MOVSD qword ptr [RBX + 0x58],XMM0
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* ImPlot::SetupAxisZoomConstraints(int, double, double) */
void ImPlot::SetupAxisZoomConstraints(int param_1,double param_2,double param_3)
{
long lVar1;
lVar1 = GImPlot;
if ((*(long *)(GImPlot + 0x50) == 0) || (*(char *)(*(long *)(GImPlot + 0x50) + 0x9de) == '\x01'))
{
ImGui::ErrorLog(
"Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!"
);
}
lVar1 = *(long *)(lVar1 + 0x50) + (long)param_1 * 0x178;
if (*(char *)(lVar1 + 0x184) == '\0') {
ImGui::ErrorLog("Axis is not enabled! Did you forget to call SetupAxis()?");
}
*(double *)(lVar1 + 0x68) = param_2;
*(double *)(lVar1 + 0x70) = param_3;
return;
}
| |
43,123 | simd_init | tsotchke[P]eshkol/src/core/utils/simd.c | void simd_init(void) {
if (g_simd_initialized) {
return;
}
// Initialize SIMD detection
#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
detect_simd_x86();
#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) || defined(_M_ARM64)
detect_simd_arm();
#else
g_simd_info.name = strdup("Unknown");
#endif
g_simd_initialized = true;
} | O0 | c | simd_init:
pushq %rbp
movq %rsp, %rbp
testb $0x1, 0x67a6(%rip) # 0xf0b1
je 0x890f
jmp 0x891b
callq 0x8920
movb $0x1, 0x6796(%rip) # 0xf0b1
popq %rbp
retq
nopl (%rax)
| simd_init:
push rbp
mov rbp, rsp
test cs:g_simd_initialized, 1
jz short loc_890F
jmp short loc_891B
loc_890F:
call detect_simd_x86
mov cs:g_simd_initialized, 1
loc_891B:
pop rbp
retn
| long long simd_init()
{
long long result; // rax
if ( (g_simd_initialized & 1) == 0 )
{
result = detect_simd_x86();
g_simd_initialized = 1;
}
return result;
}
| simd_init:
PUSH RBP
MOV RBP,RSP
TEST byte ptr [0x0010f0b1],0x1
JZ 0x0010890f
JMP 0x0010891b
LAB_0010890f:
CALL 0x00108920
MOV byte ptr [0x0010f0b1],0x1
LAB_0010891b:
POP RBP
RET
|
void simd_init(void)
{
if ((g_simd_initialized & 1) == 0) {
detect_simd_x86();
g_simd_initialized = 1;
}
return;
}
| |
43,124 | reciprocal_fp2 | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/recip.c | static void reciprocal_fp2(vec384x out, const vec384x inp)
{
vec384 t0, t1;
/*
* |out| = 1/(a + b*i) = a/(a^2+b^2) - b/(a^2+b^2)*i
*/
sqr_fp(t0, inp[0]);
sqr_fp(t1, inp[1]);
add_fp(t0, t0, t1);
reciprocal_fp(t1, t0);
mul_fp(out[0], inp[0], t1);
mul_fp(out[1], inp[1], t1);
neg_fp(out[1], out[1]);
} | O3 | c | reciprocal_fp2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x2a5eb(%rip), %rdx # 0x8cca0
leaq -0x90(%rbp), %r14
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
movq %r14, %rdi
callq 0x74720
leaq 0x30(%r12), %r13
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
leaq 0x2a5bc(%rip), %rdx # 0x8cca0
movabsq $-0x760c000300030003, %rcx # imm = 0x89F3FFFCFFFCFFFD
callq 0x74720
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
leaq 0x2a59d(%rip), %rcx # 0x8cca0
callq 0x6f640
movq %r15, %rdi
movq %r14, %rsi
callq 0x62590
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
leaq 0x2a57d(%rip), %rcx # 0x8cca0
movabsq $-0x760c000300030003, %r12 # imm = 0x89F3FFFCFFFCFFFD
movq %r12, %r8
callq 0x74ea0
addq $0x30, %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
leaq 0x2a557(%rip), %rcx # 0x8cca0
movq %rcx, %r14
movq %r12, %r8
callq 0x74ea0
movl $0x1, %edx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x6fcc0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| reciprocal_fp2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12, rsi
mov rbx, rdi
lea rdx, BLS12_381_P
lea r14, [rbp+var_90]
mov rcx, 89F3FFFCFFFCFFFDh
mov rdi, r14
call sqr_mont_384
lea r13, [r12+30h]
lea r15, [rbp+var_60]
mov rdi, r15
mov rsi, r13
lea rdx, BLS12_381_P
mov rcx, 89F3FFFCFFFCFFFDh
call sqr_mont_384
mov rdi, r14
mov rsi, r14
mov rdx, r15
lea rcx, BLS12_381_P
call add_mod_384
mov rdi, r15
mov rsi, r14
call reciprocal_fp
mov rdi, rbx
mov rsi, r12
mov rdx, r15
lea rcx, BLS12_381_P
mov r12, 89F3FFFCFFFCFFFDh
mov r8, r12
call mul_mont_384
add rbx, 30h ; '0'
mov rdi, rbx
mov rsi, r13
mov rdx, r15
lea rcx, BLS12_381_P
mov r14, rcx
mov r8, r12
call mul_mont_384
mov edx, 1
mov rdi, rbx
mov rsi, rbx
mov rcx, r14
call cneg_mod_384
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long reciprocal_fp2(long long a1, long long a2)
{
_BYTE v3[48]; // [rsp+0h] [rbp-90h] BYREF
_OWORD v4[6]; // [rsp+30h] [rbp-60h] BYREF
sqr_mont_384(v3, a2, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sqr_mont_384(v4, a2 + 48, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
add_mod_384(v3, v3, v4, &BLS12_381_P);
reciprocal_fp(v4, (long long)v3);
mul_mont_384(a1, a2, v4, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(a1 + 48, a2 + 48, v4, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
return cneg_mod_384(a1 + 48, a1 + 48, 1LL, &BLS12_381_P);
}
| reciprocal_fp2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12,RSI
MOV RBX,RDI
LEA RDX,[0x18cca0]
LEA R14,[RBP + -0x90]
MOV RCX,-0x760c000300030003
MOV RDI,R14
CALL 0x00174720
LEA R13,[R12 + 0x30]
LEA R15,[RBP + -0x60]
MOV RDI,R15
MOV RSI,R13
LEA RDX,[0x18cca0]
MOV RCX,-0x760c000300030003
CALL 0x00174720
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
LEA RCX,[0x18cca0]
CALL 0x0016f640
MOV RDI,R15
MOV RSI,R14
CALL 0x00162590
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
LEA RCX,[0x18cca0]
MOV R12,-0x760c000300030003
MOV R8,R12
CALL 0x00174ea0
ADD RBX,0x30
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
LEA RCX,[0x18cca0]
MOV R14,RCX
MOV R8,R12
CALL 0x00174ea0
MOV EDX,0x1
MOV RDI,RBX
MOV RSI,RBX
MOV RCX,R14
CALL 0x0016fcc0
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void reciprocal_fp2(long param_1,long param_2)
{
int1 local_98 [48];
int1 local_68 [56];
sqr_mont_384(local_98,param_2,BLS12_381_P,0x89f3fffcfffcfffd);
sqr_mont_384(local_68,param_2 + 0x30,BLS12_381_P,0x89f3fffcfffcfffd);
add_mod_384(local_98,local_98,local_68,BLS12_381_P);
reciprocal_fp(local_68,local_98);
mul_mont_384(param_1,param_2,local_68,BLS12_381_P,0x89f3fffcfffcfffd);
param_1 = param_1 + 0x30;
mul_mont_384(param_1,param_2 + 0x30,local_68,BLS12_381_P,0x89f3fffcfffcfffd);
cneg_mod_384(param_1,param_1,1,BLS12_381_P);
return;
}
| |
43,125 | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | static std::string strip(const std::string & s) {
auto start = s.find_first_not_of(" \t\n\r");
if (start == std::string::npos) return "";
auto end = s.find_last_not_of(" \t\n\r");
return s.substr(start, end - start + 1);
} | O0 | cpp | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x11be3a(%rip), %rsi # 0x211131
xorl %eax, %eax
movl %eax, %edx
callq 0x5af80
movq %rax, 0x40(%rsp)
cmpq $-0x1, 0x40(%rsp)
jne 0xf535a
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5b0d0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x116f4c(%rip), %rsi # 0x20c279
callq 0x61fc0
jmp 0xf5334
leaq 0x3f(%rsp), %rdi
callq 0x5b530
jmp 0xf5399
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x5b530
jmp 0xf53a3
movq 0x48(%rsp), %rdi
leaq 0x11bdcb(%rip), %rsi # 0x211131
movq $-0x1, %rdx
callq 0x5af10
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq 0x40(%rsp), %rcx
addq $0x1, %rcx
callq 0x5b130
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x5abc0
nopl (%rax)
| _ZN5minjaL5stripERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 58h
mov [rsp+58h+var_48], rdi
mov rax, rdi
mov [rsp+58h+var_40], rax
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rdi, [rsp+58h+var_10]
lea rsi, asc_211131; " \t\n\r"
xor eax, eax
mov edx, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcm; std::string::find_first_not_of(char const*,ulong)
mov [rsp+58h+var_18], rax
cmp [rsp+58h+var_18], 0FFFFFFFFFFFFFFFFh
jnz short loc_F535A
lea rdi, [rsp+58h+var_19]
mov [rsp+58h+var_50], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+58h+var_48]
mov rdx, [rsp+58h+var_50]
lea rsi, aExampleSpecifi+27h; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_F5334:
lea rdi, [rsp+58h+var_19]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_F5399
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_37]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_F53A3
loc_F535A:
mov rdi, [rsp+58h+var_10]
lea rsi, asc_211131; " \t\n\r"
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcm; std::string::find_last_not_of(char const*,ulong)
mov rdi, [rsp+58h+var_48]
mov [rsp+58h+var_38], rax
mov rsi, [rsp+58h+var_10]
mov rdx, [rsp+58h+var_18]
mov rcx, [rsp+58h+var_38]
sub rcx, [rsp+58h+var_18]
add rcx, 1
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
loc_F5399:
mov rax, [rsp+58h+var_40]
add rsp, 58h
retn
loc_F53A3:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long minja::strip(long long a1, long long a2)
{
long long last_not_of; // [rsp+20h] [rbp-38h]
char v4; // [rsp+3Fh] [rbp-19h] BYREF
long long first_not_of; // [rsp+40h] [rbp-18h]
long long v6; // [rsp+48h] [rbp-10h]
long long v7; // [rsp+50h] [rbp-8h]
v7 = a1;
v6 = a2;
first_not_of = std::string::find_first_not_of(a2, " \t\n\r", 0LL);
if ( first_not_of == -1 )
{
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(a1, (long long)"", (long long)&v4);
std::allocator<char>::~allocator(&v4);
}
else
{
last_not_of = std::string::find_last_not_of(v6, " \t\n\r", -1LL);
std::string::substr(a1, v6, first_not_of, last_not_of - first_not_of + 1);
}
return a1;
}
| strip:
SUB RSP,0x58
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x311131]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0015af80
MOV qword ptr [RSP + 0x40],RAX
CMP qword ptr [RSP + 0x40],-0x1
JNZ 0x001f535a
LEA RDI,[RSP + 0x3f]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0015b0d0
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001f5326:
LEA RSI,[0x30c279]
CALL 0x00161fc0
LAB_001f5332:
JMP 0x001f5334
LAB_001f5334:
LEA RDI,[RSP + 0x3f]
CALL 0x0015b530
JMP 0x001f5399
LAB_001f535a:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x311131]
MOV RDX,-0x1
CALL 0x0015af10
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x20]
SUB RCX,qword ptr [RSP + 0x40]
ADD RCX,0x1
CALL 0x0015b130
LAB_001f5399:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x58
RET
|
/* minja::strip(std::__cxx11::string const&) */
minja * __thiscall minja::strip(minja *this,string *param_1)
{
allocator local_19;
long local_18;
string *local_10;
minja *local_8;
local_10 = param_1;
local_8 = this;
local_18 = std::__cxx11::string::find_first_not_of((char *)param_1,0x311131);
if (local_18 == -1) {
std::allocator<char>::allocator();
/* try { // try from 001f5326 to 001f5331 has its CatchHandler @ 001f5340 */
std::__cxx11::string::string<std::allocator<char>>((string *)this,"",&local_19);
std::allocator<char>::~allocator((allocator<char> *)&local_19);
}
else {
std::__cxx11::string::find_last_not_of((char *)local_10,0x311131);
std::__cxx11::string::substr((ulong)this,(ulong)local_10);
}
return this;
}
| |
43,126 | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | static std::string strip(const std::string & s) {
auto start = s.find_first_not_of(" \t\n\r");
if (start == std::string::npos) return "";
auto end = s.find_last_not_of(" \t\n\r");
return s.substr(start, end - start + 1);
} | O3 | cpp | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78249(%rip), %rsi # 0xef74a
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x1aef0
cmpq $-0x1, %rax
je 0x7754e
movq %rax, %r15
leaq 0x7822a(%rip), %rsi # 0xef74a
movl $0x4, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x1ae40
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1a930
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x7358a(%rip), %rdx # 0xeaae6
movq %rbx, %rdi
movq %rdx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x214e2
| _ZN5minjaL5stripERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
lea rsi, asc_EF74A; " \t\n\r"
mov ecx, 4
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcmm; std::string::find_first_not_of(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_7754E
mov r15, rax
lea rsi, asc_EF74A; " \t\n\r"
mov ecx, 4
mov rdi, r14
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcmm; std::string::find_last_not_of(char const*,ulong,ulong)
sub rax, r15
lea rcx, [rax+1]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
pop rbx
pop r14
pop r15
jmp __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
loc_7754E:
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aErrorWhileHand_0+34h; ""
mov rdi, rbx
mov rsi, rdx
pop rbx
pop r14
pop r15
jmp _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
| long long minja::strip(_QWORD *a1, long long a2)
{
long long first_not_of; // rax
long long v3; // r15
long long last_not_of; // rax
first_not_of = std::string::find_first_not_of(a2, " \t\n\r", 0LL, 4LL);
if ( first_not_of == -1 )
{
*a1 = a1 + 2;
return std::string::_M_construct<char const*>((long long)a1, "", (long long)"");
}
else
{
v3 = first_not_of;
last_not_of = std::string::find_last_not_of(a2, " \t\n\r", -1LL, 4LL);
return std::string::substr(a1, a2, v3, last_not_of - v3 + 1);
}
}
| strip:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x1ef74a]
MOV ECX,0x4
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011aef0
CMP RAX,-0x1
JZ 0x0017754e
MOV R15,RAX
LEA RSI,[0x1ef74a]
MOV ECX,0x4
MOV RDI,R14
MOV RDX,-0x1
CALL 0x0011ae40
SUB RAX,R15
LEA RCX,[RAX + 0x1]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
POP RBX
POP R14
POP R15
JMP 0x0011a930
LAB_0017754e:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x1eaae6]
MOV RDI,RBX
MOV RSI,RDX
POP RBX
POP R14
POP R15
JMP 0x001214e2
|
/* minja::strip(std::__cxx11::string const&) */
void __thiscall minja::strip(minja *this,string *param_1)
{
long lVar1;
lVar1 = std::__cxx11::string::find_first_not_of((char *)param_1,0x1ef74a,0);
if (lVar1 != -1) {
std::__cxx11::string::find_last_not_of((char *)param_1,0x1ef74a,0xffffffffffffffff);
std::__cxx11::string::substr((ulong)this,(ulong)param_1);
return;
}
*(minja **)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,"");
return;
}
| |
43,127 | aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend() | aimrt_mujoco_sim/_deps/aimrt-src/src/runtime/core/../core/logger/rotate_file_logger_backend.h | RotateFileLoggerBackend() = default; | O3 | c | aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d8b17(%rip), %rax # 0x297b10
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0xbf184
leaq 0x118(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0xf8(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movq %rbp, 0x108(%rbx)
movq $0x0, 0x110(%rbx)
movb $0x0, 0x118(%rbx)
leaq 0x128(%rbx), %r12
movq %r12, %rdi
callq 0x83920
movb $0x0, 0x328(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x330(%rbx)
movups %xmm0, 0x340(%rbx)
movups %xmm0, 0x350(%rbx)
movq $0x0, 0x360(%rbx)
leaq 0x368(%rbx), %r13
leaq 0x398(%rbx), %rax
movq %rax, 0x368(%rbx)
movq $0x1, 0x370(%rbx)
movups %xmm0, 0x378(%rbx)
movl $0x3f800000, 0x388(%rbx) # imm = 0x3F800000
leaq 0x3c0(%rbx), %rdi
leaq 0x3d0(%rbx), %rax
movups %xmm0, 0x390(%rbx)
movups %xmm0, 0x3a0(%rbx)
movups %xmm0, 0x3b0(%rbx)
movq %rax, 0x3c0(%rbx)
leaq 0x134162(%rip), %rsi # 0x1f3241
leaq 0x13417b(%rip), %rdx # 0x1f3261
callq 0x80c40
xorps %xmm0, %xmm0
movups %xmm0, 0x3e0(%rbx)
movq $0x0, 0x3f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x3a0(%rbx), %rdi
callq 0xbeed8
movq %r13, %rdi
callq 0xbef46
movq %r12, %rdi
callq 0x83150
jmp 0xbf133
movq %rax, %r15
movq 0x108(%rbx), %rdi
cmpq %rbp, %rdi
je 0xbf14b
movq (%rbp), %rsi
incq %rsi
callq 0x82190
movq 0xe8(%rbx), %rax
testq %rax, %rax
je 0xbf16b
addq $0xd8, %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xbf330
movq %r15, %rdi
callq 0x83b70
movq %rax, %rdi
callq 0x8b40b
nop
| _ZN5aimrt7runtime4core6logger23RotateFileLoggerBackendC2Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5aimrt7runtime4core6logger23RotateFileLoggerBackendE; `vtable for'aimrt::runtime::core::logger::RotateFileLoggerBackend
add rax, 10h
mov [rdi], rax
lea r14, [rdi+8]
mov rdi, r14; this
call _ZN5aimrt7runtime4core6logger23RotateFileLoggerBackend7OptionsC2Ev; aimrt::runtime::core::logger::RotateFileLoggerBackend::Options::Options(void)
lea rbp, [rbx+118h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+0F8h], xmm0
movups xmmword ptr [rbx+0E8h], xmm0
movups xmmword ptr [rbx+0D8h], xmm0
mov [rbx+108h], rbp
mov qword ptr [rbx+110h], 0
mov byte ptr [rbx+118h], 0
lea r12, [rbx+128h]
mov rdi, r12
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEEC1Ev; std::ofstream::basic_ofstream(void)
mov byte ptr [rbx+328h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+330h], xmm0
movups xmmword ptr [rbx+340h], xmm0
movups xmmword ptr [rbx+350h], xmm0
mov qword ptr [rbx+360h], 0
lea r13, [rbx+368h]
lea rax, [rbx+398h]
mov [rbx+368h], rax
mov qword ptr [rbx+370h], 1
movups xmmword ptr [rbx+378h], xmm0
mov dword ptr [rbx+388h], 3F800000h
lea rdi, [rbx+3C0h]
lea rax, [rbx+3D0h]
movups xmmword ptr [rbx+390h], xmm0
movups xmmword ptr [rbx+3A0h], xmm0
movups xmmword ptr [rbx+3B0h], xmm0
mov [rbx+3C0h], rax
lea rsi, aCFLTNGRFV; "[%c.%f][%l][%t][%n][%g:%R @%F]%v"
lea rdx, aCFLTNGRFV+20h; ""
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)
xorps xmm0, xmm0
movups xmmword ptr [rbx+3E0h], xmm0
mov qword ptr [rbx+3F0h], 0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r15, rax
lea rdi, [rbx+3A0h]
call _ZNSt6vectorISt8functionIFvRKN5aimrt7runtime4core6logger14LogDataWrapperERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaISG_EED2Ev; std::vector<std::function<void ()(aimrt::runtime::core::logger::LogDataWrapper const&,std::string &)>>::~vector()
mov rdi, r13
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_bESaIS8_ENSt8__detail10_Select1stESt8equal_toIvEN5aimrt6common4util10StringHashENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,bool>,std::allocator<std::pair<std::string const,bool>>,std::__detail::_Select1st,std::equal_to<void>,aimrt::common::util::StringHash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
mov rdi, r12
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEED1Ev; std::ofstream::~ofstream()
jmp short loc_BF133
mov r15, rax
loc_BF133:
mov rdi, [rbx+108h]; void *
cmp rdi, rbp
jz short loc_BF14B
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_BF14B:
mov rax, [rbx+0E8h]
test rax, rax
jz short loc_BF16B
add rbx, 0D8h
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_BF16B:
mov rdi, r14; this
call _ZN5aimrt7runtime4core6logger23RotateFileLoggerBackend7OptionsD2Ev; aimrt::runtime::core::logger::RotateFileLoggerBackend::Options::~Options()
mov rdi, r15
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend(
aimrt::runtime::core::logger::RotateFileLoggerBackend *this)
{
long long result; // rax
*(_QWORD *)this = &`vtable for'aimrt::runtime::core::logger::RotateFileLoggerBackend + 2;
aimrt::runtime::core::logger::RotateFileLoggerBackend::Options::Options((aimrt::runtime::core::logger::RotateFileLoggerBackend *)((char *)this + 8));
*(_OWORD *)((char *)this + 248) = 0LL;
*(_OWORD *)((char *)this + 232) = 0LL;
*(_OWORD *)((char *)this + 216) = 0LL;
*((_QWORD *)this + 33) = (char *)this + 280;
*((_QWORD *)this + 34) = 0LL;
*((_BYTE *)this + 280) = 0;
std::ofstream::basic_ofstream((char *)this + 296);
*((_BYTE *)this + 808) = 0;
*((_OWORD *)this + 51) = 0LL;
*((_OWORD *)this + 52) = 0LL;
*((_OWORD *)this + 53) = 0LL;
*((_QWORD *)this + 108) = 0LL;
*((_QWORD *)this + 109) = (char *)this + 920;
*((_QWORD *)this + 110) = 1LL;
*(_OWORD *)((char *)this + 888) = 0LL;
*((_DWORD *)this + 226) = 1065353216;
*((_OWORD *)this + 57) = 0LL;
*((_OWORD *)this + 58) = 0LL;
*((_OWORD *)this + 59) = 0LL;
*((_QWORD *)this + 120) = (char *)this + 976;
result = std::string::_M_construct<char const*>((char *)this + 960, "[%c.%f][%l][%t][%n][%g:%R @%F]%v", "");
*((_OWORD *)this + 62) = 0LL;
*((_QWORD *)this + 126) = 0LL;
return result;
}
| RotateFileLoggerBackend:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x397b10]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x8]
MOV RDI,R14
CALL 0x001bf184
LEA RBP,[RBX + 0x118]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xf8],XMM0
MOVUPS xmmword ptr [RBX + 0xe8],XMM0
MOVUPS xmmword ptr [RBX + 0xd8],XMM0
MOV qword ptr [RBX + 0x108],RBP
MOV qword ptr [RBX + 0x110],0x0
MOV byte ptr [RBX + 0x118],0x0
LEA R12,[RBX + 0x128]
LAB_001bf04b:
MOV RDI,R12
CALL 0x00183920
MOV byte ptr [RBX + 0x328],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x330],XMM0
MOVUPS xmmword ptr [RBX + 0x340],XMM0
MOVUPS xmmword ptr [RBX + 0x350],XMM0
MOV qword ptr [RBX + 0x360],0x0
LEA R13,[RBX + 0x368]
LEA RAX,[RBX + 0x398]
MOV qword ptr [RBX + 0x368],RAX
MOV qword ptr [RBX + 0x370],0x1
MOVUPS xmmword ptr [RBX + 0x378],XMM0
MOV dword ptr [RBX + 0x388],0x3f800000
LEA RDI,[RBX + 0x3c0]
LEA RAX,[RBX + 0x3d0]
MOVUPS xmmword ptr [RBX + 0x390],XMM0
MOVUPS xmmword ptr [RBX + 0x3a0],XMM0
MOVUPS xmmword ptr [RBX + 0x3b0],XMM0
MOV qword ptr [RBX + 0x3c0],RAX
LAB_001bf0d8:
LEA RSI,[0x2f3241]
LEA RDX,[0x2f3261]
CALL 0x00180c40
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x3e0],XMM0
MOV qword ptr [RBX + 0x3f0],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend() */
void __thiscall
aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend
(RotateFileLoggerBackend *this)
{
*(int ***)this = &PTR__RotateFileLoggerBackend_00397b20;
Options::Options((Options *)(this + 8));
*(int8 *)(this + 0xf8) = 0;
*(int8 *)(this + 0x100) = 0;
*(int8 *)(this + 0xe8) = 0;
*(int8 *)(this + 0xf0) = 0;
*(int8 *)(this + 0xd8) = 0;
*(int8 *)(this + 0xe0) = 0;
*(RotateFileLoggerBackend **)(this + 0x108) = this + 0x118;
*(int8 *)(this + 0x110) = 0;
this[0x118] = (RotateFileLoggerBackend)0x0;
/* try { // try from 001bf04b to 001bf052 has its CatchHandler @ 001bf130 */
std::ofstream::ofstream((ofstream *)(this + 0x128));
this[0x328] = (RotateFileLoggerBackend)0x0;
*(int8 *)(this + 0x330) = 0;
*(int8 *)(this + 0x338) = 0;
*(int8 *)(this + 0x340) = 0;
*(int8 *)(this + 0x348) = 0;
*(int8 *)(this + 0x350) = 0;
*(int8 *)(this + 0x358) = 0;
*(int8 *)(this + 0x360) = 0;
*(RotateFileLoggerBackend **)(this + 0x368) = this + 0x398;
*(int8 *)(this + 0x370) = 1;
*(int8 *)(this + 0x378) = 0;
*(int8 *)(this + 0x380) = 0;
*(int4 *)(this + 0x388) = 0x3f800000;
*(int8 *)(this + 0x390) = 0;
*(int8 *)(this + 0x398) = 0;
*(int8 *)(this + 0x3a0) = 0;
*(int8 *)(this + 0x3a8) = 0;
*(int8 *)(this + 0x3b0) = 0;
*(int8 *)(this + 0x3b8) = 0;
*(RotateFileLoggerBackend **)(this + 0x3c0) = this + 0x3d0;
/* try { // try from 001bf0d8 to 001bf0ea has its CatchHandler @ 001bf10f */
std::__cxx11::string::_M_construct<char_const*>(this + 0x3c0,&DAT_002f3241,&DAT_002f3261);
*(int8 *)(this + 0x3e0) = 0;
*(int8 *)(this + 1000) = 0;
*(int8 *)(this + 0x3f0) = 0;
return;
}
| |
43,128 | my_readlink | eloqsql/mysys/my_symlink.c | int my_readlink(char *to, const char *filename, myf MyFlags)
{
#ifndef HAVE_READLINK
strmov(to,filename);
return 1;
#else
int result=0;
int length;
DBUG_ENTER("my_readlink");
if ((length=readlink(filename, to, FN_REFLEN-1)) < 0)
{
/* Don't give an error if this wasn't a symlink */
if ((my_errno=errno) == EINVAL)
{
result= 1;
strmov(to,filename);
}
else
{
if (MyFlags & MY_WME)
my_error(EE_CANT_READLINK, MYF(0), filename, errno);
result= -1;
}
}
else
to[length]=0;
DBUG_PRINT("exit" ,("result: %d", result));
DBUG_RETURN(result);
#endif /* HAVE_READLINK */
} | O0 | c | my_readlink:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x253b0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jge 0x30d11
callq 0x25050
movl (%rax), %eax
movl %eax, -0x24(%rbp)
callq 0x27e10
movq %rax, %rcx
movl -0x24(%rbp), %eax
movl %eax, (%rcx)
cmpl $0x16, %eax
jne 0x30cd7
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x25390
jmp 0x30d0f
movq -0x18(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x30d08
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x25050
movq -0x30(%rbp), %rdx
movl (%rax), %ecx
movl $0x18, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x2f180
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x30d1d
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x30d1f
jmp 0x30d21
jmp 0x30d23
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_readlink:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
mov edx, 1FFh
call _readlink
mov [rbp+var_20], eax
cmp eax, 0
jge short loc_30D11
call ___errno_location
mov eax, [rax]
mov [rbp+var_24], eax
call _my_thread_var
mov rcx, rax
mov eax, [rbp+var_24]
mov [rcx], eax
cmp eax, 16h
jnz short loc_30CD7
mov [rbp+var_1C], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call _stpcpy
jmp short loc_30D0F
loc_30CD7:
mov rax, [rbp+var_18]
and rax, 10h
cmp rax, 0
jz short loc_30D08
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
call ___errno_location
mov rdx, [rbp+var_30]
mov ecx, [rax]
mov edi, 18h
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_30D08:
mov [rbp+var_1C], 0FFFFFFFFh
loc_30D0F:
jmp short loc_30D1D
loc_30D11:
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_20]
mov byte ptr [rax+rcx], 0
loc_30D1D:
jmp short $+2
loc_30D1F:
jmp short $+2
loc_30D21:
jmp short $+2
loc_30D23:
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
| long long my_readlink(long long a1, long long a2, char a3)
{
unsigned int *v3; // rax
int v5; // [rsp+1Ch] [rbp-24h]
int v6; // [rsp+20h] [rbp-20h]
unsigned int v7; // [rsp+24h] [rbp-1Ch]
v7 = 0;
v6 = readlink(a2, a1, 511LL);
if ( v6 >= 0 )
{
*(_BYTE *)(a1 + v6) = 0;
}
else
{
v5 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( v5 == 22 )
{
v7 = 1;
stpcpy(a1, a2);
}
else
{
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)__errno_location();
my_error(0x18u, 0LL, a2, *v3);
}
return (unsigned int)-1;
}
}
return v7;
}
| my_readlink:
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 dword ptr [RBP + -0x1c],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
MOV EDX,0x1ff
CALL 0x001253b0
MOV dword ptr [RBP + -0x20],EAX
CMP EAX,0x0
JGE 0x00130d11
CALL 0x00125050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
CALL 0x00127e10
MOV RCX,RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RCX],EAX
CMP EAX,0x16
JNZ 0x00130cd7
MOV dword ptr [RBP + -0x1c],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00125390
JMP 0x00130d0f
LAB_00130cd7:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x10
CMP RAX,0x0
JZ 0x00130d08
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00125050
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
MOV EDI,0x18
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x0012f180
LAB_00130d08:
MOV dword ptr [RBP + -0x1c],0xffffffff
LAB_00130d0f:
JMP 0x00130d1d
LAB_00130d11:
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_00130d1d:
JMP 0x00130d1f
LAB_00130d1f:
JMP 0x00130d21
LAB_00130d21:
JMP 0x00130d23
LAB_00130d23:
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_readlink(char *param_1,char *param_2,ulong param_3)
{
int iVar1;
ssize_t sVar2;
int *piVar3;
int4 local_24;
local_24 = 0;
sVar2 = readlink(param_2,param_1,0x1ff);
if ((int)sVar2 < 0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if (iVar1 == 0x16) {
local_24 = 1;
stpcpy(param_1,param_2);
}
else {
if ((param_3 & 0x10) != 0) {
piVar3 = __errno_location();
my_error(0x18,0,param_2,*piVar3);
}
local_24 = 0xffffffff;
}
}
else {
param_1[(int)sVar2] = '\0';
}
return local_24;
}
| |
43,129 | stbi__pnm_info | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image.h | static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp)
{
int maxv, dummy;
char c, p, t;
if (!x) x = &dummy;
if (!y) y = &dummy;
if (!comp) comp = &dummy;
stbi__rewind(s);
// Get identifier
p = (char) stbi__get8(s);
t = (char) stbi__get8(s);
if (p != 'P' || (t != '5' && t != '6')) {
stbi__rewind(s);
return 0;
}
*comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm
c = (char) stbi__get8(s);
stbi__pnm_skip_whitespace(s, &c);
*x = stbi__pnm_getinteger(s, &c); // read width
if(*x == 0)
return stbi__err("invalid width", "PPM image header had zero or overflowing width");
stbi__pnm_skip_whitespace(s, &c);
*y = stbi__pnm_getinteger(s, &c); // read height
if (*y == 0)
return stbi__err("invalid width", "PPM image header had zero or overflowing width");
stbi__pnm_skip_whitespace(s, &c);
maxv = stbi__pnm_getinteger(s, &c); // read max value
if (maxv > 65535)
return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images");
else if (maxv > 255)
return 16;
else
return 8;
} | O0 | c | stbi__pnm_info:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7bd87
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x7bd96
leaq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7bda5
leaq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a170
movq -0x10(%rbp), %rdi
callq 0x6a1b0
movb %al, -0x32(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a1b0
movb %al, -0x33(%rbp)
movsbl -0x32(%rbp), %eax
cmpl $0x50, %eax
jne 0x7bde1
movsbl -0x33(%rbp), %eax
cmpl $0x35, %eax
je 0x7bdf6
movsbl -0x33(%rbp), %eax
cmpl $0x36, %eax
je 0x7bdf6
movq -0x10(%rbp), %rdi
callq 0x6a170
movl $0x0, -0x4(%rbp)
jmp 0x7bee7
movsbl -0x33(%rbp), %edx
movl $0x1, %ecx
movl $0x3, %eax
cmpl $0x36, %edx
cmovel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6a1b0
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x7c000
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x7c0e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x7be5b
leaq 0x14f40(%rip), %rdi # 0x90d8e
callq 0x66030
movl %eax, -0x4(%rbp)
jmp 0x7bee7
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x7c000
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x7c0e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x7be97
leaq 0x14f01(%rip), %rdi # 0x90d8e
callq 0x66030
movl %eax, -0x4(%rbp)
jmp 0x7bee7
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x7c000
movq -0x10(%rbp), %rdi
leaq -0x31(%rbp), %rsi
callq 0x7c0e0
movl %eax, -0x2c(%rbp)
cmpl $0xffff, -0x2c(%rbp) # imm = 0xFFFF
jle 0x7bece
leaq 0x14ed8(%rip), %rdi # 0x90d9c
callq 0x66030
movl %eax, -0x4(%rbp)
jmp 0x7bee7
cmpl $0xff, -0x2c(%rbp)
jle 0x7bee0
movl $0x10, -0x4(%rbp)
jmp 0x7bee7
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
| stbi__pnm_info:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
cmp [rbp+var_18], 0
jnz short loc_7BD87
lea rax, [rbp+var_30]
mov [rbp+var_18], rax
loc_7BD87:
cmp [rbp+var_20], 0
jnz short loc_7BD96
lea rax, [rbp+var_30]
mov [rbp+var_20], rax
loc_7BD96:
cmp [rbp+var_28], 0
jnz short loc_7BDA5
lea rax, [rbp+var_30]
mov [rbp+var_28], rax
loc_7BDA5:
mov rdi, [rbp+var_10]
call stbi__rewind
mov rdi, [rbp+var_10]
call stbi__get8
mov [rbp+var_32], al
mov rdi, [rbp+var_10]
call stbi__get8
mov [rbp+var_33], al
movsx eax, [rbp+var_32]
cmp eax, 50h ; 'P'
jnz short loc_7BDE1
movsx eax, [rbp+var_33]
cmp eax, 35h ; '5'
jz short loc_7BDF6
movsx eax, [rbp+var_33]
cmp eax, 36h ; '6'
jz short loc_7BDF6
loc_7BDE1:
mov rdi, [rbp+var_10]
call stbi__rewind
mov [rbp+var_4], 0
jmp loc_7BEE7
loc_7BDF6:
movsx edx, [rbp+var_33]
mov ecx, 1
mov eax, 3
cmp edx, 36h ; '6'
cmovz ecx, eax
mov rax, [rbp+var_28]
mov [rax], ecx
mov rdi, [rbp+var_10]
call stbi__get8
mov [rbp+var_31], al
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_31]
call stbi__pnm_skip_whitespace
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_31]
call stbi__pnm_getinteger
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], ecx
mov rax, [rbp+var_18]
cmp dword ptr [rax], 0
jnz short loc_7BE5B
lea rdi, aInvalidWidth; "invalid width"
call stbi__err
mov [rbp+var_4], eax
jmp loc_7BEE7
loc_7BE5B:
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_31]
call stbi__pnm_skip_whitespace
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_31]
call stbi__pnm_getinteger
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax], ecx
mov rax, [rbp+var_20]
cmp dword ptr [rax], 0
jnz short loc_7BE97
lea rdi, aInvalidWidth; "invalid width"
call stbi__err
mov [rbp+var_4], eax
jmp short loc_7BEE7
loc_7BE97:
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_31]
call stbi__pnm_skip_whitespace
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_31]
call stbi__pnm_getinteger
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0FFFFh
jle short loc_7BECE
lea rdi, aMaxValue65535; "max value > 65535"
call stbi__err
mov [rbp+var_4], eax
jmp short loc_7BEE7
loc_7BECE:
cmp [rbp+var_2C], 0FFh
jle short loc_7BEE0
mov [rbp+var_4], 10h
jmp short loc_7BEE7
loc_7BEE0:
mov [rbp+var_4], 8
loc_7BEE7:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long stbi__pnm_info(_QWORD *a1, _DWORD *a2, _DWORD *a3, int *a4)
{
int v4; // ecx
int v5; // eax
int v6; // eax
char v8; // [rsp+Dh] [rbp-33h]
char v9; // [rsp+Eh] [rbp-32h]
char v10; // [rsp+Fh] [rbp-31h] BYREF
_BYTE v11[4]; // [rsp+10h] [rbp-30h] BYREF
int v12; // [rsp+14h] [rbp-2Ch]
int *v13; // [rsp+18h] [rbp-28h]
_DWORD *v14; // [rsp+20h] [rbp-20h]
_DWORD *v15; // [rsp+28h] [rbp-18h]
_QWORD *v16; // [rsp+30h] [rbp-10h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
if ( !a2 )
v15 = v11;
if ( !v14 )
v14 = v11;
if ( !v13 )
v13 = (int *)v11;
stbi__rewind(v16);
v9 = stbi__get8((long long)v16);
v8 = stbi__get8((long long)v16);
if ( v9 == 80 && (v8 == 53 || v8 == 54) )
{
v4 = 1;
if ( v8 == 54 )
v4 = 3;
*v13 = v4;
v10 = stbi__get8((long long)v16);
stbi__pnm_skip_whitespace(v16, &v10);
v5 = stbi__pnm_getinteger(v16, &v10);
*v15 = v5;
if ( *v15 && (stbi__pnm_skip_whitespace(v16, &v10), v6 = stbi__pnm_getinteger(v16, &v10), (*v14 = v6) != 0) )
{
stbi__pnm_skip_whitespace(v16, &v10);
v12 = stbi__pnm_getinteger(v16, &v10);
if ( v12 <= 0xFFFF )
{
if ( v12 <= 255 )
return 8;
else
return 16;
}
else
{
return (unsigned int)stbi__err((long long)"max value > 65535");
}
}
else
{
return (unsigned int)stbi__err((long long)"invalid width");
}
}
else
{
stbi__rewind(v16);
return 0;
}
}
| stbi__pnm_info:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0017bd87
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x18],RAX
LAB_0017bd87:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0017bd96
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x20],RAX
LAB_0017bd96:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0017bda5
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
LAB_0017bda5:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0016a170
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0016a1b0
MOV byte ptr [RBP + -0x32],AL
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0016a1b0
MOV byte ptr [RBP + -0x33],AL
MOVSX EAX,byte ptr [RBP + -0x32]
CMP EAX,0x50
JNZ 0x0017bde1
MOVSX EAX,byte ptr [RBP + -0x33]
CMP EAX,0x35
JZ 0x0017bdf6
MOVSX EAX,byte ptr [RBP + -0x33]
CMP EAX,0x36
JZ 0x0017bdf6
LAB_0017bde1:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0016a170
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0017bee7
LAB_0017bdf6:
MOVSX EDX,byte ptr [RBP + -0x33]
MOV ECX,0x1
MOV EAX,0x3
CMP EDX,0x36
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0016a1b0
MOV byte ptr [RBP + -0x31],AL
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x31]
CALL 0x0017c000
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x31]
CALL 0x0017c0e0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x0
JNZ 0x0017be5b
LEA RDI,[0x190d8e]
CALL 0x00166030
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017bee7
LAB_0017be5b:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x31]
CALL 0x0017c000
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x31]
CALL 0x0017c0e0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x0
JNZ 0x0017be97
LEA RDI,[0x190d8e]
CALL 0x00166030
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017bee7
LAB_0017be97:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x31]
CALL 0x0017c000
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x31]
CALL 0x0017c0e0
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0xffff
JLE 0x0017bece
LEA RDI,[0x190d9c]
CALL 0x00166030
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017bee7
LAB_0017bece:
CMP dword ptr [RBP + -0x2c],0xff
JLE 0x0017bee0
MOV dword ptr [RBP + -0x4],0x10
JMP 0x0017bee7
LAB_0017bee0:
MOV dword ptr [RBP + -0x4],0x8
LAB_0017bee7:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 stbi__pnm_info(int8 param_1,int *param_2,int *param_3,int *param_4)
{
char cVar1;
char cVar2;
int iVar3;
int1 local_39;
int local_38;
int local_34;
int *local_30;
int *local_28;
int *local_20;
int8 local_18;
int4 local_c;
local_20 = param_2;
if (param_2 == (int *)0x0) {
local_20 = &local_38;
}
local_28 = param_3;
if (param_3 == (int *)0x0) {
local_28 = &local_38;
}
local_30 = param_4;
if (param_4 == (int *)0x0) {
local_30 = &local_38;
}
local_18 = param_1;
stbi__rewind(param_1);
cVar1 = stbi__get8(local_18);
cVar2 = stbi__get8(local_18);
if ((cVar1 == 'P') && ((cVar2 == '5' || (cVar2 == '6')))) {
iVar3 = 1;
if (cVar2 == '6') {
iVar3 = 3;
}
*local_30 = iVar3;
local_39 = stbi__get8(local_18);
stbi__pnm_skip_whitespace(local_18,&local_39);
iVar3 = stbi__pnm_getinteger(local_18,&local_39);
*local_20 = iVar3;
if (*local_20 == 0) {
local_c = stbi__err("invalid width");
}
else {
stbi__pnm_skip_whitespace(local_18,&local_39);
iVar3 = stbi__pnm_getinteger(local_18,&local_39);
*local_28 = iVar3;
if (*local_28 == 0) {
local_c = stbi__err("invalid width");
}
else {
stbi__pnm_skip_whitespace(local_18,&local_39);
local_34 = stbi__pnm_getinteger(local_18,&local_39);
if (local_34 < 0x10000) {
if (local_34 < 0x100) {
local_c = 8;
}
else {
local_c = 0x10;
}
}
else {
local_c = stbi__err("max value > 65535");
}
}
}
}
else {
stbi__rewind(local_18);
local_c = 0;
}
return local_c;
}
| |
43,130 | 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>>::operator++() | llama.cpp/common/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O3 | cpp | 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>>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x6d6db
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x6d6cc
cmpl $0x1, %eax
jne 0x6d6d3
addq $0x30, 0x8(%rdi)
jmp 0x6d6d7
addq $0x10, 0x10(%rdi)
jmp 0x6d6d7
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x5e558(%rip), %rdi # 0xcbc3b
leaq 0x5a9a6(%rip), %rdx # 0xc8090
leaq 0x5ed3c(%rip), %rcx # 0xcc42d
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x1ca40
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_6D6DB
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_6D6CC
cmp eax, 1
jnz short loc_6D6D3
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_6D6D7
loc_6D6CC:
add qword ptr [rdi+10h], 10h
jmp short loc_6D6D7
loc_6D6D3:
inc qword ptr [rdi+18h]
loc_6D6D7:
mov rax, rdi
retn
loc_6D6DB:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
nop
| long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
13248LL);
}
}
| operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0016d6db
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x0016d6cc
CMP EAX,0x1
JNZ 0x0016d6d3
ADD qword ptr [RDI + 0x8],0x30
JMP 0x0016d6d7
LAB_0016d6cc:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x0016d6d7
LAB_0016d6d3:
INC qword ptr [RDI + 0x18]
LAB_0016d6d7:
MOV RAX,RDI
RET
LAB_0016d6db:
PUSH RAX
LEA RDI,[0x1cbc3b]
LEA RDX,[0x1c8090]
LEA RCX,[0x1cc42d]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x0011ca40
|
/* 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> >::TEMPNAMEPLACEHOLDERVALUE() */
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>>
* __thiscall
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>>
::operator++(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>>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
| |
43,131 | ImPlot::SetupLegend(int, int) | zkingston[P]unknot/build_O1/_deps/implot-src/implot.cpp | void SetupLegend(ImPlotLocation location, ImPlotLegendFlags flags) {
ImPlotContext& gp = *GImPlot;
IM_ASSERT_USER_ERROR(gp.CurrentPlot != nullptr && !gp.CurrentPlot->SetupLocked,
"Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!");
IM_ASSERT_USER_ERROR(gp.CurrentItems != nullptr,
"SetupLegend() needs to be called within an itemized context!");
ImPlotLegend& legend = gp.CurrentItems->Legend;
// check and set location
if (location != legend.PreviousLocation)
legend.Location = location;
legend.PreviousLocation = location;
// check and set flags
if (flags != legend.PreviousFlags)
legend.Flags = flags;
legend.PreviousFlags = flags;
} | O1 | cpp | ImPlot::SetupLegend(int, int):
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
movq 0x27e03e(%rip), %r14 # 0x336ca0
movq 0x50(%r14), %rax
testq %rax, %rax
je 0xb8c74
cmpb $0x1, 0x9de(%rax)
jne 0xb8c80
leaq 0x1dc2c9(%rip), %rdi # 0x294f44
callq 0x2161f4
cmpq $0x0, 0x60(%r14)
jne 0xb8c93
leaq 0x1dc507(%rip), %rdi # 0x295195
callq 0x2161f4
movq 0x60(%r14), %rax
cmpl %ebp, 0x14(%rax)
je 0xb8c9f
movl %ebp, 0x10(%rax)
movl %ebp, 0x14(%rax)
cmpl %ebx, 0xc(%rax)
je 0xb8caa
movl %ebx, 0x8(%rax)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| _ZN6ImPlot11SetupLegendEii:
push rbp
push r14
push rbx
mov ebx, esi
mov ebp, edi
mov r14, cs:GImPlot
mov rax, [r14+50h]
test rax, rax
jz short loc_B8C74
cmp byte ptr [rax+9DEh], 1
jnz short loc_B8C80
loc_B8C74:
lea rdi, aSetupNeedsToBe; "Setup needs to be called after BeginPlo"...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_B8C80:
cmp qword ptr [r14+60h], 0
jnz short loc_B8C93
lea rdi, aSetuplegendNee_0; "SetupLegend() needs to be called within"...
call _ZN5ImGui8ErrorLogEPKc; ImGui::ErrorLog(char const*)
loc_B8C93:
mov rax, [r14+60h]
cmp [rax+14h], ebp
jz short loc_B8C9F
mov [rax+10h], ebp
loc_B8C9F:
mov [rax+14h], ebp
cmp [rax+0Ch], ebx
jz short loc_B8CAA
mov [rax+8], ebx
loc_B8CAA:
mov [rax+0Ch], ebx
pop rbx
pop r14
pop rbp
retn
| _DWORD * ImPlot::SetupLegend(ImPlot *this, const char *a2)
{
ImGui *v2; // r14
long long v3; // rax
_DWORD *result; // rax
v2 = GImPlot;
v3 = *((_QWORD *)GImPlot + 10);
if ( !v3 || *(_BYTE *)(v3 + 2526) == 1 )
ImGui::ErrorLog(
(ImGui *)"Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!",
a2);
if ( !*((_QWORD *)v2 + 12) )
ImGui::ErrorLog((ImGui *)"SetupLegend() needs to be called within an itemized context!", a2);
result = (_DWORD *)*((_QWORD *)v2 + 12);
if ( result[5] != (_DWORD)this )
result[4] = (_DWORD)this;
result[5] = (_DWORD)this;
if ( result[3] != (_DWORD)a2 )
result[2] = (_DWORD)a2;
result[3] = (_DWORD)a2;
return result;
}
| SetupLegend:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,ESI
MOV EBP,EDI
MOV R14,qword ptr [0x00436ca0]
MOV RAX,qword ptr [R14 + 0x50]
TEST RAX,RAX
JZ 0x001b8c74
CMP byte ptr [RAX + 0x9de],0x1
JNZ 0x001b8c80
LAB_001b8c74:
LEA RDI,[0x394f44]
CALL 0x003161f4
LAB_001b8c80:
CMP qword ptr [R14 + 0x60],0x0
JNZ 0x001b8c93
LEA RDI,[0x395195]
CALL 0x003161f4
LAB_001b8c93:
MOV RAX,qword ptr [R14 + 0x60]
CMP dword ptr [RAX + 0x14],EBP
JZ 0x001b8c9f
MOV dword ptr [RAX + 0x10],EBP
LAB_001b8c9f:
MOV dword ptr [RAX + 0x14],EBP
CMP dword ptr [RAX + 0xc],EBX
JZ 0x001b8caa
MOV dword ptr [RAX + 0x8],EBX
LAB_001b8caa:
MOV dword ptr [RAX + 0xc],EBX
POP RBX
POP R14
POP RBP
RET
|
/* ImPlot::SetupLegend(int, int) */
void ImPlot::SetupLegend(int param_1,int param_2)
{
long lVar1;
lVar1 = GImPlot;
if ((*(long *)(GImPlot + 0x50) == 0) || (*(char *)(*(long *)(GImPlot + 0x50) + 0x9de) == '\x01'))
{
ImGui::ErrorLog(
"Setup needs to be called after BeginPlot and before any setup locking functions (e.g. PlotX)!"
);
}
if (*(long *)(lVar1 + 0x60) == 0) {
ImGui::ErrorLog("SetupLegend() needs to be called within an itemized context!");
}
lVar1 = *(long *)(lVar1 + 0x60);
if (*(int *)(lVar1 + 0x14) != param_1) {
*(int *)(lVar1 + 0x10) = param_1;
}
*(int *)(lVar1 + 0x14) = param_1;
if (*(int *)(lVar1 + 0xc) != param_2) {
*(int *)(lVar1 + 8) = param_2;
}
*(int *)(lVar1 + 0xc) = param_2;
return;
}
| |
43,132 | blst_scalar_from_fr | corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/exports.c | void blst_scalar_from_fr(pow256 ret, const vec256 a)
{
const union {
long one;
char little;
} is_endian = { 1 };
if ((uptr_t)ret == (uptr_t)a && is_endian.little) {
from_mont_256((limb_t *)ret, a, BLS12_381_r, r0);
} else {
vec256 out;
from_mont_256(out, a, BLS12_381_r, r0);
le_bytes_from_limbs(ret, out, 32);
vec_zero(out, sizeof(out));
}
} | O0 | c | blst_scalar_from_fr:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x24b09(%rip), %rax # 0x54fc0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq %rcx, %rax
jne 0x304f1
movsbl -0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x304f1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x245b0(%rip), %rdx # 0x54a90
movabsq $-0x100000001, %rcx # imm = 0xFFFFFFFEFFFFFFFF
callq 0x47620
jmp 0x3052f
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x24590(%rip), %rdx # 0x54a90
movabsq $-0x100000001, %rcx # imm = 0xFFFFFFFEFFFFFFFF
callq 0x47620
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x20, %edx
callq 0x30540
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x23310
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| blst_scalar_from_fr:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, cs:qword_54FC0
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
cmp rax, rcx
jnz short loc_304F1
movsx eax, byte ptr [rbp+var_18]
cmp eax, 0
jz short loc_304F1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, BLS12_381_r
mov rcx, 0FFFFFFFEFFFFFFFFh
call from_mont_256
jmp short loc_3052F
loc_304F1:
lea rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
lea rdx, BLS12_381_r
mov rcx, 0FFFFFFFEFFFFFFFFh
call from_mont_256
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_40]
mov edx, 20h ; ' '
call le_bytes_from_limbs
lea rdi, [rbp+var_40]
mov esi, 20h ; ' '
call vec_zero
loc_3052F:
add rsp, 40h
pop rbp
retn
| long long blst_scalar_from_fr(long long a1, long long a2)
{
_BYTE v3[40]; // [rsp+0h] [rbp-40h] BYREF
long long v4; // [rsp+28h] [rbp-18h]
long long v5; // [rsp+30h] [rbp-10h]
long long v6; // [rsp+38h] [rbp-8h]
v6 = a1;
v5 = a2;
v4 = 1LL;
if ( a1 == a2 )
return from_mont_256(v6, v5, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
from_mont_256(v3, v5, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
le_bytes_from_limbs(v6, v3, 32LL);
return vec_zero((long long)v3, 0x20uLL);
}
| blst_scalar_from_fr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [0x00154fc0]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,RCX
JNZ 0x001304f1
MOVSX EAX,byte ptr [RBP + -0x18]
CMP EAX,0x0
JZ 0x001304f1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0x154a90]
MOV RCX,-0x100000001
CALL 0x00147620
JMP 0x0013052f
LAB_001304f1:
LEA RDI,[RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0x154a90]
MOV RCX,-0x100000001
CALL 0x00147620
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x40]
MOV EDX,0x20
CALL 0x00130540
LEA RDI,[RBP + -0x40]
MOV ESI,0x20
CALL 0x00123310
LAB_0013052f:
ADD RSP,0x40
POP RBP
RET
|
void blst_scalar_from_fr(long param_1,long param_2)
{
int1 local_48 [40];
int8 local_20;
long local_18;
long local_10;
local_20 = DAT_00154fc0;
local_18 = param_2;
local_10 = param_1;
if ((param_1 == param_2) && (local_20._0_1_ = (char)DAT_00154fc0, (char)local_20 != '\0')) {
from_mont_256(param_1,param_2,BLS12_381_r,0xfffffffeffffffff);
}
else {
from_mont_256(local_48,param_2,BLS12_381_r,0xfffffffeffffffff);
le_bytes_from_limbs(local_10,local_48,0x20);
vec_zero(local_48,0x20);
}
return;
}
| |
43,133 | init_view | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | static void init_view(ggml_gallocr_t galloc, struct ggml_tensor * view, bool update_backend) {
ggml_tallocr_t alloc = node_tallocr(galloc, view);
GGML_ASSERT(view->view_src != NULL && view->view_src->data != NULL);
if (update_backend) {
view->backend = view->view_src->backend;
}
// views are initialized in the alloc buffer rather than the view_src buffer
view->buffer = alloc->buffer;
view->data = (char *)view->view_src->data + view->view_offs;
assert(ggml_tallocr_is_measure(alloc) || !view->buffer || view->buffer->buft == alloc->buffer->buft);
if (!alloc->measure) {
ggml_backend_buffer_init_tensor(alloc->buffer, view);
}
} | O0 | c | init_view:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x166110
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x108(%rax)
je 0x165ddf
movq 0x18(%rsp), %rax
movq 0x108(%rax), %rax
cmpq $0x0, 0x118(%rax)
jne 0x165e23
movq 0x72142(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0x721b3(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x19e1b(%rip), %rsi # 0x17fc1a
leaq 0x2665a(%rip), %rdx # 0x18c460
movl $0x1c0, %ecx # imm = 0x1C0
leaq 0x267ae(%rip), %r8 # 0x18c5c0
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x165e25
testb $0x1, 0x17(%rsp)
je 0x165e43
movq 0x18(%rsp), %rax
movq 0x108(%rax), %rax
movl 0x4(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x108(%rax), %rax
movq 0x118(%rax), %rcx
movq 0x18(%rsp), %rax
addq 0x110(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x118(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x1030(%rax)
jne 0x165e9f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x166a30
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| init_view:
sub rsp, 28h
mov al, dl
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
and al, 1
mov [rsp+28h+var_11], al
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_10]
call node_tallocr
mov [rsp+28h+var_20], rax
mov rax, [rsp+28h+var_10]
cmp qword ptr [rax+108h], 0
jz short loc_165DDF
mov rax, [rsp+28h+var_10]
mov rax, [rax+108h]
cmp qword ptr [rax+118h], 0
jnz short loc_165E23
loc_165DDF:
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_8; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 1C0h
lea r8, aViewViewSrcNul; "view->view_src != NULL && view->view_sr"...
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_165E23:
jmp short $+2
loc_165E25:
test [rsp+28h+var_11], 1
jz short loc_165E43
mov rax, [rsp+28h+var_10]
mov rax, [rax+108h]
mov ecx, [rax+4]
mov rax, [rsp+28h+var_10]
mov [rax+4], ecx
loc_165E43:
mov rax, [rsp+28h+var_20]
mov rcx, [rax]
mov rax, [rsp+28h+var_10]
mov [rax+8], rcx
mov rax, [rsp+28h+var_10]
mov rax, [rax+108h]
mov rcx, [rax+118h]
mov rax, [rsp+28h+var_10]
add rcx, [rax+110h]
mov rax, [rsp+28h+var_10]
mov [rax+118h], rcx
mov rax, [rsp+28h+var_20]
test byte ptr [rax+1030h], 1
jnz short loc_165E9F
mov rax, [rsp+28h+var_20]
mov rdi, [rax]
mov rsi, [rsp+28h+var_10]
call ggml_backend_buffer_init_tensor
loc_165E9F:
add rsp, 28h
retn
| long long init_view(long long a1, long long a2, char a3)
{
long long v3; // rdi
long long result; // rax
long long v5; // [rsp+8h] [rbp-20h]
char v6; // [rsp+17h] [rbp-11h]
v6 = a3 & 1;
v5 = node_tallocr(a1, a2);
if ( !*(_QWORD *)(a2 + 264) || !*(_QWORD *)(*(_QWORD *)(a2 + 264) + 280LL) )
{
fflush(stdout);
v3 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c",
448,
"view->view_src != NULL && view->view_src->data != NULL");
ggml_print_backtrace();
abort(v3);
}
if ( (v6 & 1) != 0 )
*(_DWORD *)(a2 + 4) = *(_DWORD *)(*(_QWORD *)(a2 + 264) + 4LL);
*(_QWORD *)(a2 + 8) = *(_QWORD *)v5;
*(_QWORD *)(a2 + 280) = *(_QWORD *)(a2 + 272) + *(_QWORD *)(*(_QWORD *)(a2 + 264) + 280LL);
result = v5;
if ( (*(_BYTE *)(v5 + 4144) & 1) == 0 )
return ggml_backend_buffer_init_tensor(*(_QWORD *)v5, a2);
return result;
}
| _S_maximum:
MOV qword ptr [RSP + -0x8],RDI
LAB_00165d95:
MOV RAX,qword ptr [RSP + -0x8]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x00165db1
MOV RAX,qword ptr [RSP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x00165d95
LAB_00165db1:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* std::_Rb_tree_node_base::_S_maximum(std::_Rb_tree_node_base*) */
_Rb_tree_node_base * std::_Rb_tree_node_base::_S_maximum(_Rb_tree_node_base *param_1)
{
_Rb_tree_node_base *local_8;
for (local_8 = param_1; *(long *)(local_8 + 0x18) != 0;
local_8 = *(_Rb_tree_node_base **)(local_8 + 0x18)) {
}
return local_8;
}
| |
43,134 | init_view | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | static void init_view(ggml_gallocr_t galloc, struct ggml_tensor * view, bool update_backend) {
ggml_tallocr_t alloc = node_tallocr(galloc, view);
GGML_ASSERT(view->view_src != NULL && view->view_src->data != NULL);
if (update_backend) {
view->backend = view->view_src->backend;
}
// views are initialized in the alloc buffer rather than the view_src buffer
view->buffer = alloc->buffer;
view->data = (char *)view->view_src->data + view->view_offs;
assert(ggml_tallocr_is_measure(alloc) || !view->buffer || view->buffer->buft == alloc->buffer->buft);
if (!alloc->measure) {
ggml_backend_buffer_init_tensor(alloc->buffer, view);
}
} | O2 | c | init_view:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
callq 0x8fb36
movq 0x108(%rbx), %rdx
testq %rdx, %rdx
je 0x8f797
movq 0x118(%rdx), %rcx
testq %rcx, %rcx
je 0x8f797
testb %bpl, %bpl
je 0x8f764
movl 0x4(%rdx), %edx
movl %edx, 0x4(%rbx)
movq (%rax), %rdi
movq %rdi, 0x8(%rbx)
addq 0x110(%rbx), %rcx
movq %rcx, 0x118(%rbx)
cmpb $0x0, 0x1030(%rax)
je 0x8f789
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8fcad
movq 0x467aa(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x467fb(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0xaa67(%rip), %rsi # 0x9a21e
leaq 0x14d9c(%rip), %rdx # 0xa455a
leaq 0x14ef5(%rip), %r8 # 0xa46ba
movl $0x1c0, %ecx # imm = 0x1C0
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| init_view:
push rbp
push rbx
push rax
mov ebp, edx
mov rbx, rsi
call node_tallocr
mov rdx, [rbx+108h]
test rdx, rdx
jz short loc_8F797
mov rcx, [rdx+118h]
test rcx, rcx
jz short loc_8F797
test bpl, bpl
jz short loc_8F764
mov edx, [rdx+4]
mov [rbx+4], edx
loc_8F764:
mov rdi, [rax]
mov [rbx+8], rdi
add rcx, [rbx+110h]
mov [rbx+118h], rcx
cmp byte ptr [rax+1030h], 0
jz short loc_8F789
add rsp, 8
pop rbx
pop rbp
retn
loc_8F789:
mov rsi, rbx
add rsp, 8
pop rbx
pop rbp
jmp ggml_backend_buffer_init_tensor
loc_8F797:
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_8; "/workspace/llm4binary/github/2025_star3"...
lea r8, aViewViewSrcNul; "view->view_src != NULL && view->view_sr"...
mov ecx, 1C0h
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long init_view(long long a1, long long a2, char a3, long long a4, long long a5, long long a6, long long a7)
{
long long result; // rax
long long v9; // r8
long long v10; // r9
long long v11; // rdx
long long v12; // rcx
long long v13; // rdi
long long v14; // rcx
long long v15; // rdi
result = node_tallocr(a1);
v11 = *(_QWORD *)(a2 + 264);
if ( !v11 || (v12 = *(_QWORD *)(v11 + 280)) == 0 )
{
fflush(stdout);
v15 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c",
448,
"view->view_src != NULL && view->view_src->data != NULL");
ggml_print_backtrace();
abort(v15);
}
if ( a3 )
{
v11 = *(unsigned int *)(v11 + 4);
*(_DWORD *)(a2 + 4) = v11;
}
v13 = *(_QWORD *)result;
*(_QWORD *)(a2 + 8) = *(_QWORD *)result;
v14 = *(_QWORD *)(a2 + 272) + v12;
*(_QWORD *)(a2 + 280) = v14;
if ( !*(_BYTE *)(result + 4144) )
return ggml_backend_buffer_init_tensor(v13, a2, v11, v14, v9, v10, a7);
return result;
}
| init_view:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV RBX,RSI
CALL 0x0018fb36
MOV RDX,qword ptr [RBX + 0x108]
TEST RDX,RDX
JZ 0x0018f797
MOV RCX,qword ptr [RDX + 0x118]
TEST RCX,RCX
JZ 0x0018f797
TEST BPL,BPL
JZ 0x0018f764
MOV EDX,dword ptr [RDX + 0x4]
MOV dword ptr [RBX + 0x4],EDX
LAB_0018f764:
MOV RDI,qword ptr [RAX]
MOV qword ptr [RBX + 0x8],RDI
ADD RCX,qword ptr [RBX + 0x110]
MOV qword ptr [RBX + 0x118],RCX
CMP byte ptr [RAX + 0x1030],0x0
JZ 0x0018f789
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0018f789:
MOV RSI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0018fcad
LAB_0018f797:
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,[0x1a455a]
LEA R8,[0x1a46ba]
MOV ECX,0x1c0
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void init_view(int8 param_1,long param_2,char param_3)
{
long lVar1;
long lVar2;
int8 uVar3;
int8 *puVar4;
puVar4 = (int8 *)node_tallocr();
lVar1 = *(long *)(param_2 + 0x108);
if ((lVar1 == 0) || (lVar2 = *(long *)(lVar1 + 0x118), lVar2 == 0)) {
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-alloc.c"
,0x1c0,"view->view_src != NULL && view->view_src->data != NULL");
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
if (param_3 != '\0') {
*(int4 *)(param_2 + 4) = *(int4 *)(lVar1 + 4);
}
uVar3 = *puVar4;
*(int8 *)(param_2 + 8) = uVar3;
*(long *)(param_2 + 0x118) = lVar2 + *(long *)(param_2 + 0x110);
if (*(char *)(puVar4 + 0x206) != '\0') {
return;
}
ggml_backend_buffer_init_tensor(uVar3,param_2);
return;
}
| |
43,135 | init_view | 7CodeWizard[P]stablediffusion/ggml/src/ggml-alloc.c | static void init_view(ggml_gallocr_t galloc, struct ggml_tensor * view, bool update_backend) {
ggml_tallocr_t alloc = node_tallocr(galloc, view);
GGML_ASSERT(view->view_src != NULL && view->view_src->data != NULL);
if (update_backend) {
view->backend = view->view_src->backend;
}
// views are initialized in the alloc buffer rather than the view_src buffer
view->buffer = alloc->buffer;
view->data = (char *)view->view_src->data + view->view_offs;
assert(ggml_tallocr_is_measure(alloc) || !view->buffer || view->buffer->buft == alloc->buffer->buft);
if (!alloc->measure) {
ggml_backend_buffer_init_tensor(alloc->buffer, view);
}
} | O3 | c | init_view:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq (%rdi), %rax
testq %rax, %rax
jne 0xb2593
movq 0x28(%rdi), %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x94f49
movq (%r14,%rax,8), %rax
movq 0x108(%rbx), %rdx
testq %rdx, %rdx
je 0xb25e5
movq 0x118(%rdx), %rcx
testq %rcx, %rcx
je 0xb25e5
testb %bpl, %bpl
je 0xb25b6
movl 0x4(%rdx), %edx
movl %edx, 0x4(%rbx)
movq (%rax), %rdi
movq %rdi, 0x8(%rbx)
addq 0x110(%rbx), %rcx
movq %rcx, 0x118(%rbx)
cmpb $0x0, 0x1030(%rax)
je 0xb25d9
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xb2a59
callq 0x17c10
| init_view:
push rbp
push r14
push rbx
mov ebp, edx
mov rbx, rsi
mov rax, [rdi]
test rax, rax
jnz short loc_B2593
mov r14, [rdi+28h]
mov rax, [rdi+8]
mov rsi, [rdi+10h]
mov rdi, rax
mov rdx, rbx
call ggml_hash_find_or_insert
mov rax, [r14+rax*8]
loc_B2593:
mov rdx, [rbx+108h]
test rdx, rdx
jz short loc_B25E5
mov rcx, [rdx+118h]
test rcx, rcx
jz short loc_B25E5
test bpl, bpl
jz short loc_B25B6
mov edx, [rdx+4]
mov [rbx+4], edx
loc_B25B6:
mov rdi, [rax]
mov [rbx+8], rdi
add rcx, [rbx+110h]
mov [rbx+118h], rcx
cmp byte ptr [rax+1030h], 0
jz short loc_B25D9
pop rbx
pop r14
pop rbp
retn
loc_B25D9:
mov rsi, rbx
pop rbx
pop r14
pop rbp
jmp ggml_backend_buffer_init_tensor
loc_B25E5:
call init_view_cold_1
| long long init_view(long long *a1, unsigned long long a2, char a3, long long a4, long long a5, long long a6, long long a7)
{
long long result; // rax
long long v9; // r14
long long v10; // rdx
long long v11; // rcx
long long v12; // rdi
long long v13; // rcx
result = *a1;
if ( !*a1 )
{
v9 = a1[5];
result = *(_QWORD *)(v9 + 8 * ggml_hash_find_or_insert(a1[1], a1[2], a2));
}
v10 = *(_QWORD *)(a2 + 264);
if ( !v10 || (v11 = *(_QWORD *)(v10 + 280)) == 0 )
init_view_cold_1();
if ( a3 )
{
v10 = *(unsigned int *)(v10 + 4);
*(_DWORD *)(a2 + 4) = v10;
}
v12 = *(_QWORD *)result;
*(_QWORD *)(a2 + 8) = *(_QWORD *)result;
v13 = *(_QWORD *)(a2 + 272) + v11;
*(_QWORD *)(a2 + 280) = v13;
if ( !*(_BYTE *)(result + 4144) )
return ggml_backend_buffer_init_tensor(v12, a2, v10, v13, a5, a6, a7);
return result;
}
| |||
43,136 | my_strxfrm_pad_desc_and_reverse | eloqsql/strings/ctype-simple.c | size_t
my_strxfrm_pad_desc_and_reverse(CHARSET_INFO *cs,
uchar *str, uchar *frmend, uchar *strend,
uint nweights, uint flags, uint level)
{
if (nweights && frmend < strend && (flags & MY_STRXFRM_PAD_WITH_SPACE))
{
uint fill_length= MY_MIN((uint) (strend - frmend), nweights * cs->mbminlen);
my_ci_fill(cs, (char*) frmend, fill_length, cs->pad_char);
frmend+= fill_length;
}
my_strxfrm_desc_and_reverse(str, frmend, flags, level);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && frmend < strend)
{
size_t fill_length= strend - frmend;
my_ci_fill(cs, (char*) frmend, fill_length, cs->pad_char);
frmend= strend;
}
return frmend - str;
} | O0 | c | my_strxfrm_pad_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x52763
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x52763
movl -0x28(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x52763
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x98(%rdx), %ecx
cmpl %ecx, %eax
jae 0x5271f
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x3c(%rbp)
jmp 0x52730
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x98(%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movzbl 0xb0(%rax), %ecx
callq 0x55c50
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x28(%rbp), %edx
movl 0x10(%rbp), %ecx
callq 0x55b10
movl -0x28(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x527c0
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x527c0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl 0xb0(%rax), %ecx
callq 0x55c50
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strxfrm_pad_desc_and_reverse:
push rbp
mov rbp, rsp
sub rsp, 40h
mov eax, [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_24], r8d
mov [rbp+var_28], r9d
cmp [rbp+var_24], 0
jz loc_52763
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_52763
mov eax, [rbp+var_28]
and eax, 40h
cmp eax, 0
jz short loc_52763
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov ecx, [rbp+var_24]
mov rdx, [rbp+var_8]
imul ecx, [rdx+98h]
cmp eax, ecx
jnb short loc_5271F
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_3C], eax
jmp short loc_52730
loc_5271F:
mov eax, [rbp+var_24]
mov rcx, [rbp+var_8]
imul eax, [rcx+98h]
mov [rbp+var_3C], eax
loc_52730:
mov eax, [rbp+var_3C]
mov [rbp+var_2C], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_2C]
mov edx, eax
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax+0B0h]
call my_ci_fill_0
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
loc_52763:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_28]
mov ecx, [rbp+arg_0]
call my_strxfrm_desc_and_reverse
mov eax, [rbp+var_28]
and eax, 80h
cmp eax, 0
jz short loc_527C0
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_527C0
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax+0B0h]
call my_ci_fill_0
mov rax, [rbp+var_20]
mov [rbp+var_18], rax
loc_527C0:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
add rsp, 40h
pop rbp
retn
| long long my_strxfrm_pad_desc_and_reverse(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
int a5,
unsigned int a6,
unsigned int a7)
{
unsigned int v8; // [rsp+4h] [rbp-3Ch]
unsigned long long v11; // [rsp+28h] [rbp-18h]
v11 = a3;
if ( a5 && a3 < a4 && (a6 & 0x40) != 0 )
{
if ( (int)a4 - (int)a3 >= (unsigned int)(*(_DWORD *)(a1 + 152) * a5) )
v8 = *(_DWORD *)(a1 + 152) * a5;
else
v8 = a4 - a3;
my_ci_fill_0(a1, a3, v8, *(unsigned __int8 *)(a1 + 176));
v11 += v8;
}
my_strxfrm_desc_and_reverse(a2, v11, a6, a7);
if ( (a6 & 0x80) != 0 && v11 < a4 )
{
my_ci_fill_0(a1, v11, a4 - v11, *(unsigned __int8 *)(a1 + 176));
v11 = a4;
}
return v11 - a2;
}
| my_strxfrm_pad_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV EAX,dword 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 dword ptr [RBP + -0x24],R8D
MOV dword ptr [RBP + -0x28],R9D
CMP dword ptr [RBP + -0x24],0x0
JZ 0x00152763
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x00152763
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x40
CMP EAX,0x0
JZ 0x00152763
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV ECX,dword ptr [RBP + -0x24]
MOV RDX,qword ptr [RBP + -0x8]
IMUL ECX,dword ptr [RDX + 0x98]
CMP EAX,ECX
JNC 0x0015271f
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00152730
LAB_0015271f:
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x98]
MOV dword ptr [RBP + -0x3c],EAX
LAB_00152730:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x2c],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX + 0xb0]
CALL 0x00155c50
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
LAB_00152763:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + 0x10]
CALL 0x00155b10
MOV EAX,dword ptr [RBP + -0x28]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001527c0
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001527c0
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX + 0xb0]
CALL 0x00155c50
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x18],RAX
LAB_001527c0:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
ADD RSP,0x40
POP RBP
RET
|
long my_strxfrm_pad_desc_and_reverse
(long param_1,long param_2,ulong param_3,ulong param_4,int param_5,uint param_6,
int4 param_7)
{
int4 local_44;
int8 local_20;
local_20 = param_3;
if (((param_5 != 0) && (param_3 < param_4)) && ((param_6 & 0x40) != 0)) {
if ((uint)((int)param_4 - (int)param_3) < (uint)(param_5 * *(int *)(param_1 + 0x98))) {
local_44 = (int)param_4 - (int)param_3;
}
else {
local_44 = param_5 * *(int *)(param_1 + 0x98);
}
my_ci_fill(param_1,param_3,local_44,*(int1 *)(param_1 + 0xb0));
local_20 = param_3 + local_44;
}
my_strxfrm_desc_and_reverse(param_2,local_20,param_6,param_7);
if (((param_6 & 0x80) != 0) && (local_20 < param_4)) {
my_ci_fill(param_1,local_20,param_4 - local_20,*(int1 *)(param_1 + 0xb0));
local_20 = param_4;
}
return local_20 - param_2;
}
| |
43,137 | minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<minja::TemplateNode>&&) | monkey531[P]llama/common/minja.hpp | SetTemplateNode(const Location & location, const std::string & name, std::shared_ptr<TemplateNode> && tv)
: TemplateNode(location), name(name), template_value(std::move(tv)) {} | O2 | cpp | minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<minja::TemplateNode>&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x759f8
leaq 0x877e0(%rip), %rax # 0x1003d8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x24e00
andq $0x0, 0x48(%rbx)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x40(%rbx)
andq $0x0, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x7a672
movq %r14, %rdi
callq 0x251e0
| _ZN5minja15SetTemplateNodeC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt10shared_ptrINS_12TemplateNodeEE:
push r15
push r14
push rbx
mov r14, rcx
mov r15, rdx
mov rbx, rdi
call _ZN5minja12TemplateNodeC2ERKNS_8LocationE; minja::TemplateNode::TemplateNode(minja::Location const&)
lea rax, _ZTVN5minja15SetTemplateNodeE; `vtable for'minja::SetTemplateNode
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+20h]
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
and qword ptr [rbx+48h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [rbx+40h], xmm0
and qword ptr [r14], 0
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; this
call _ZN5minja12TemplateNodeD2Ev; minja::TemplateNode::~TemplateNode()
mov rdi, r14
call __Unwind_Resume
| long long minja::SetTemplateNode::SetTemplateNode(long long a1, _QWORD *a2, long long a3, __int128 *a4)
{
long long result; // rax
__int128 v7; // xmm0
minja::TemplateNode::TemplateNode((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::SetTemplateNode + 2;
result = std::string::basic_string(a1 + 32, a3);
*(_QWORD *)(a1 + 72) = 0LL;
v7 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 64) = v7;
*(_QWORD *)a4 = 0LL;
return result;
}
| SetTemplateNode:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RCX
MOV R15,RDX
MOV RBX,RDI
CALL 0x001759f8
LEA RAX,[0x2003d8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x20]
LAB_00178c03:
MOV RSI,R15
CALL 0x00124e00
LAB_00178c0b:
AND qword ptr [RBX + 0x48],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
AND qword ptr [R14],0x0
POP RBX
POP R14
POP R15
RET
|
/* minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::string const&,
std::shared_ptr<minja::TemplateNode>&&) */
void __thiscall
minja::SetTemplateNode::SetTemplateNode
(SetTemplateNode *this,Location *param_1,string *param_2,shared_ptr *param_3)
{
int8 uVar1;
TemplateNode::TemplateNode((TemplateNode *)this,param_1);
*(int ***)this = &PTR_do_render_002003e8;
/* try { // try from 00178c03 to 00178c0a has its CatchHandler @ 00178c27 */
std::__cxx11::string::string((string *)(this + 0x20),param_2);
*(int8 *)(this + 0x48) = 0;
uVar1 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x40) = *(int8 *)param_3;
*(int8 *)(this + 0x48) = uVar1;
*(int8 *)param_3 = 0;
return;
}
| |
43,138 | minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<minja::TemplateNode>&&) | monkey531[P]llama/common/minja.hpp | SetTemplateNode(const Location & location, const std::string & name, std::shared_ptr<TemplateNode> && tv)
: TemplateNode(location), name(name), template_value(std::move(tv)) {} | O3 | cpp | minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<minja::TemplateNode>&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x8b952(%rip), %r15 # 0x12cfc8
addq $0x10, %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0xa16a6
movq 0x8c8e8(%rip), %rcx # 0x12df80
cmpb $0x0, (%rcx)
je 0xa16a2
incl 0x8(%rax)
jmp 0xa16a6
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x8bd13(%rip), %rax # 0x12d3c8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x229dc
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movups (%r14), %xmm0
movq %rax, 0x8(%r14)
movups %xmm0, 0x40(%rbx)
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa1706
callq 0x70324
movq %r14, %rdi
callq 0x1c1e0
| _ZN5minja15SetTemplateNodeC2ERKNS_8LocationERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt10shared_ptrINS_12TemplateNodeEE:
push r15
push r14
push rbx
mov r14, rcx
mov rbx, rdi
lea r15, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add r15, 10h
mov [rdi], r15
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_A16A6
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_A16A2
inc dword ptr [rax+8]
jmp short loc_A16A6
loc_A16A2:
lock inc dword ptr [rax+8]
loc_A16A6:
mov rax, [rsi+10h]
mov [rbx+18h], rax
lea rax, _ZTVN5minja15SetTemplateNodeE; `vtable for'minja::SetTemplateNode
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+20h]
lea rax, [rbx+30h]
mov [rbx+20h], rax
mov rsi, [rdx]
mov rdx, [rdx+8]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
xor eax, eax
mov [rbx+48h], rax
movups xmm0, xmmword ptr [r14]
mov [r14+8], rax
movups xmmword ptr [rbx+40h], xmm0
mov [r14], rax
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r15
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_A1706
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_A1706:
mov rdi, r14
call __Unwind_Resume
| long long minja::SetTemplateNode::SetTemplateNode(long long a1, _QWORD *a2, long long a3, __int128 *a4)
{
long long v5; // rax
long long result; // rax
__int128 v7; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateNode + 2;
*(_QWORD *)(a1 + 8) = *a2;
v5 = a2[1];
*(_QWORD *)(a1 + 16) = v5;
if ( v5 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v5 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v5 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::SetTemplateNode + 2;
*(_QWORD *)(a1 + 32) = a1 + 48;
std::string::_M_construct<char *>(a1 + 32, *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
result = 0LL;
*(_QWORD *)(a1 + 72) = 0LL;
v7 = *a4;
*((_QWORD *)a4 + 1) = 0LL;
*(_OWORD *)(a1 + 64) = v7;
*(_QWORD *)a4 = 0LL;
return result;
}
| SetTemplateNode:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RCX
MOV RBX,RDI
LEA R15,[0x22cfc8]
ADD R15,0x10
MOV qword ptr [RDI],R15
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x001a16a6
MOV RCX,qword ptr [0x0022df80]
CMP byte ptr [RCX],0x0
JZ 0x001a16a2
INC dword ptr [RAX + 0x8]
JMP 0x001a16a6
LAB_001a16a2:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001a16a6:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x22d3c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x20]
LEA RAX,[RBX + 0x30]
MOV qword ptr [RBX + 0x20],RAX
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
ADD RDX,RSI
LAB_001a16d2:
CALL 0x001229dc
LAB_001a16d7:
XOR EAX,EAX
MOV qword ptr [RBX + 0x48],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOV qword ptr [R14 + 0x8],RAX
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV qword ptr [R14],RAX
POP RBX
POP R14
POP R15
RET
|
/* minja::SetTemplateNode::SetTemplateNode(minja::Location const&, std::__cxx11::string const&,
std::shared_ptr<minja::TemplateNode>&&) */
void __thiscall
minja::SetTemplateNode::SetTemplateNode
(SetTemplateNode *this,Location *param_1,string *param_2,shared_ptr *param_3)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_0022cfd8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_0022df80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_0022d3d8;
*(SetTemplateNode **)(this + 0x20) = this + 0x30;
/* try { // try from 001a16d2 to 001a16d6 has its CatchHandler @ 001a16f2 */
std::__cxx11::string::_M_construct<char*>
(this + 0x20,*(long *)param_2,*(long *)(param_2 + 8) + *(long *)param_2);
*(int8 *)(this + 0x48) = 0;
uVar2 = *(int8 *)(param_3 + 8);
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x40) = *(int8 *)param_3;
*(int8 *)(this + 0x48) = uVar2;
*(int8 *)param_3 = 0;
return;
}
| |
43,139 | my_strtoll10_utf32 | eloqsql/strings/ctype-ucs2.c | static longlong
my_strtoll10_utf32(CHARSET_INFO *cs __attribute__((unused)),
const char *nptr, char **endptr, int *error)
{
const char *s, *end, *start, *n_end, *true_end;
uchar c;
unsigned long i, j, k;
ulonglong li;
int negative;
ulong cutoff, cutoff2, cutoff3;
s= nptr;
/* If fixed length string */
if (endptr)
{
/* Make sure string length is even */
end= s + ((*endptr - s) / 4) * 4;
while (s < end && !s[0] && !s[1] && !s[2] &&
(s[3] == ' ' || s[3] == '\t'))
s+= 4;
if (s == end)
goto no_conv;
}
else
{
/* We don't support null terminated strings in UCS2 */
goto no_conv;
}
/* Check for a sign. */
negative= 0;
if (!s[0] && !s[1] && !s[2] && s[3] == '-')
{
*error= -1; /* Mark as negative number */
negative= 1;
s+= 4;
if (s == end)
goto no_conv;
cutoff= MAX_NEGATIVE_NUMBER / LFACTOR2;
cutoff2= (MAX_NEGATIVE_NUMBER % LFACTOR2) / 100;
cutoff3= MAX_NEGATIVE_NUMBER % 100;
}
else
{
*error= 0;
if (!s[0] && !s[1] && !s[2] && s[3] == '+')
{
s+= 4;
if (s == end)
goto no_conv;
}
cutoff= ULONGLONG_MAX / LFACTOR2;
cutoff2= ULONGLONG_MAX % LFACTOR2 / 100;
cutoff3= ULONGLONG_MAX % 100;
}
/* Handle case where we have a lot of pre-zero */
if (!s[0] && !s[1] && !s[2] && s[3] == '0')
{
i= 0;
do
{
s+= 4;
if (s == end)
goto end_i; /* Return 0 */
}
while (!s[0] && !s[1] && !s[2] && s[3] == '0');
n_end= s + 4 * INIT_CNT;
}
else
{
/* Read first digit to check that it's a valid number */
if (s[0] || s[1] || s[2] || (c= (s[3]-'0')) > 9)
goto no_conv;
i= c;
s+= 4;
n_end= s + 4 * (INIT_CNT-1);
}
/* Handle first 9 digits and store them in i */
if (n_end > end)
n_end= end;
for (; s != n_end ; s+= 4)
{
if (s[0] || s[1] || s[2] || (c= (s[3] - '0')) > 9)
goto end_i;
i= i * 10 + c;
}
if (s == end)
goto end_i;
/* Handle next 9 digits and store them in j */
j= 0;
start= s; /* Used to know how much to shift i */
n_end= true_end= s + 4 * INIT_CNT;
if (n_end > end)
n_end= end;
do
{
if (s[0] || s[1] || s[2] || (c= (s[3] - '0')) > 9)
goto end_i_and_j;
j= j * 10 + c;
s+= 4;
} while (s != n_end);
if (s == end)
{
if (s != true_end)
goto end_i_and_j;
goto end3;
}
if (s[0] || s[1] || s[2] || (c= (s[3] - '0')) > 9)
goto end3;
/* Handle the next 1 or 2 digits and store them in k */
k=c;
s+= 4;
if (s == end || s[0] || s[1] || s[2] || (c= (s[3]-'0')) > 9)
goto end4;
k= k * 10 + c;
s+= 4;
*endptr= (char*) s;
/* number string should have ended here */
if (s != end && !s[0] && !s[1] && !s[2] && (c= (s[3] - '0')) <= 9)
goto overflow;
/* Check that we didn't get an overflow with the last digit */
if (i > cutoff || (i == cutoff && ((j > cutoff2 || j == cutoff2) &&
k > cutoff3)))
goto overflow;
li= i * LFACTOR2+ (ulonglong) j * 100 + k;
return (longlong) li;
overflow: /* *endptr is set here */
*error= MY_ERRNO_ERANGE;
return negative ? LONGLONG_MIN : (longlong) ULONGLONG_MAX;
end_i:
*endptr= (char*) s;
return (negative ? ((longlong) -(long) i) : (longlong) i);
end_i_and_j:
li= (ulonglong) i * lfactor[(size_t) (s-start) / 4] + j;
*endptr= (char*) s;
return (negative ? -((longlong) li) : (longlong) li);
end3:
li= (ulonglong) i*LFACTOR+ (ulonglong) j;
*endptr= (char*) s;
return (negative ? -((longlong) li) : (longlong) li);
end4:
li= (ulonglong) i*LFACTOR1+ (ulonglong) j * 10 + k;
*endptr= (char*) s;
if (negative)
{
if (li > MAX_NEGATIVE_NUMBER)
goto overflow;
return -((longlong) li);
}
return (longlong) li;
no_conv:
/* There was no number to convert. */
*error= MY_ERRNO_EDOM;
*endptr= (char *) nptr;
return 0;
} | O3 | c | my_strtoll10_utf32:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xc5026
movq (%rdx), %rdi
subq %rsi, %rdi
leaq 0x3(%rdi), %rax
testq %rdi, %rdi
cmovnsq %rdi, %rax
andq $-0x4, %rax
addq %rsi, %rax
movq %rsi, %r11
cmpq $0x4, %rdi
jl 0xc4f30
movq %rsi, %r11
cmpb $0x0, (%r11)
jne 0xc4f30
cmpb $0x0, 0x1(%r11)
jne 0xc4f30
cmpb $0x0, 0x2(%r11)
jne 0xc4f30
movzbl 0x3(%r11), %edi
cmpl $0x20, %edi
je 0xc4f27
cmpl $0x9, %edi
jne 0xc4f30
addq $0x4, %r11
cmpq %rax, %r11
jb 0xc4f04
cmpq %rax, %r11
je 0xc5026
cmpb $0x0, (%r11)
jne 0xc4f7d
cmpb $0x0, 0x1(%r11)
jne 0xc4f7d
cmpb $0x0, 0x2(%r11)
jne 0xc4f7d
cmpb $0x2d, 0x3(%r11)
jne 0xc4f7d
movl $0xffffffff, (%rcx) # imm = 0xFFFFFFFF
addq $0x4, %r11
cmpq %rax, %r11
je 0xc5026
movl $0x8, %r8d
movl $0x15f797ae, %r9d # imm = 0x15F797AE
movl $0x57f5ff8, %r10d # imm = 0x57F5FF8
xorl %edi, %edi
jmp 0xc4fc0
movl $0x0, (%rcx)
cmpb $0x0, (%r11)
jne 0xc5026
movl $0xf, %r8d
movl $0x2bef2f5c, %r9d # imm = 0x2BEF2F5C
movl $0xafebff0, %r10d # imm = 0xAFEBFF0
movb $0x1, %dil
cmpb $0x0, 0x1(%r11)
jne 0xc4fc0
cmpb $0x0, 0x2(%r11)
jne 0xc4fc0
cmpb $0x2b, 0x3(%r11)
jne 0xc4fc0
addq $0x4, %r11
cmpq %rax, %r11
je 0xc5026
cmpb $0x0, (%r11)
jne 0xc5026
cmpb $0x0, 0x1(%r11)
jne 0xc5026
cmpb $0x0, 0x2(%r11)
jne 0xc5013
cmpb $0x30, 0x3(%r11)
jne 0xc5013
addq $0x28, %r11
xorl %esi, %esi
leaq -0x24(%r11), %rbx
cmpq %rax, %rbx
je 0xc51c9
movq %r11, %r14
cmpb $0x0, (%rbx)
jne 0xc500f
cmpb $0x0, -0x23(%r14)
jne 0xc500f
cmpb $0x0, -0x22(%r14)
jne 0xc500f
leaq 0x4(%r14), %r11
cmpb $0x30, -0x21(%r14)
je 0xc4fe1
xorl %esi, %esi
jmp 0xc504a
cmpb $0x0, 0x2(%r11)
jne 0xc5026
movb 0x3(%r11), %bl
addb $-0x30, %bl
cmpb $0x9, %bl
jbe 0xc503c
movl $0x21, (%rcx)
movq %rsi, (%rdx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %bl, %esi
leaq 0x4(%r11), %rbx
addq $0x24, %r11
movq %r11, %r14
cmpq %rax, %r14
cmovaq %rax, %r14
cmpq %r14, %rbx
je 0xc5097
cmpb $0x0, (%rbx)
jne 0xc51c6
cmpb $0x0, 0x1(%rbx)
jne 0xc51c6
cmpb $0x0, 0x2(%rbx)
jne 0xc51c6
movb 0x3(%rbx), %r11b
addb $-0x30, %r11b
cmpb $0x9, %r11b
ja 0xc51c6
leaq (%rsi,%rsi,4), %rsi
movzbl %r11b, %r11d
leaq (%r11,%rsi,2), %rsi
addq $0x4, %rbx
jmp 0xc5051
cmpq %rax, %rbx
je 0xc51c6
leaq 0x24(%rbx), %r12
cmpq %rax, %r12
cmovaq %rax, %r12
leaq 0x8(%rbx), %r14
movl $0x24, %r13d
xorl %r11d, %r11d
cmpb $0x0, -0x8(%r14)
jne 0xc51ce
cmpb $0x0, -0x7(%r14)
jne 0xc51ce
cmpb $0x0, -0x6(%r14)
jne 0xc51ce
movb -0x5(%r14), %r15b
addb $-0x30, %r15b
cmpb $0x9, %r15b
ja 0xc51ce
leaq (%r11,%r11,4), %r11
movzbl %r15b, %r15d
leaq (%r15,%r11,2), %r11
leaq 0x4(%r14), %r15
addq $-0x4, %r14
addq $-0x4, %r13
cmpq %r12, %r14
movq %r15, %r14
jne 0xc50b8
leaq -0x8(%r15), %r14
cmpq %rax, %r12
je 0xc5200
cmpb $0x0, (%r14)
jne 0xc5205
cmpb $0x0, -0x7(%r15)
jne 0xc5205
cmpb $0x0, -0x6(%r15)
jne 0xc5205
movb -0x5(%r15), %bl
addb $-0x30, %bl
cmpb $0x9, %bl
ja 0xc5205
movzbl %bl, %ebx
leaq -0x4(%r15), %r12
cmpq %rax, %r12
je 0xc517b
cmpb $0x0, -0x4(%r15)
jne 0xc517b
cmpb $0x0, -0x3(%r15)
jne 0xc517b
cmpb $0x0, -0x2(%r15)
jne 0xc517b
movb -0x1(%r15), %r14b
addb $-0x30, %r14b
cmpb $0x9, %r14b
jbe 0xc522c
movabsq $0x2540be400, %rax # imm = 0x2540BE400
imulq %rax, %rsi
leaq (%r11,%r11,4), %rax
leaq (%rsi,%rax,2), %rax
addq %rbx, %rax
movq %r12, (%rdx)
testb %dil, %dil
jne 0xc5031
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
cmpq %rdx, %rax
jbe 0xc5224
movl $0x22, (%rcx)
movzbl %dil, %eax
negq %rax
btsq $0x3f, %rax
jmp 0xc5031
movq %rbx, %rax
movq %rax, (%rdx)
jmp 0xc51ee
addq $-0x8, %r14
movq %r14, %rax
subq %rbx, %rax
andq $-0x4, %rax
leaq 0x21124d(%rip), %rcx # 0x2d6430
imulq (%rcx,%rax,2), %rsi
addq %r11, %rsi
movq %r14, (%rdx)
movq %rsi, %rax
negq %rax
testb %dil, %dil
cmovneq %rsi, %rax
jmp 0xc5031
testq %r13, %r13
jne 0xc51d2
imulq $0x3b9aca00, %rsi, %rax # imm = 0x3B9ACA00
addq %rax, %r11
movq %r14, (%rdx)
movq %r11, %rax
negq %rax
testb %dil, %dil
cmovneq %r11, %rax
jmp 0xc5031
negq %rax
jmp 0xc5031
movq %r15, (%rdx)
cmpq %rax, %r15
je 0xc5256
cmpb $0x0, (%r15)
jne 0xc5256
cmpb $0x0, 0x1(%r15)
jne 0xc5256
cmpb $0x0, 0x2(%r15)
jne 0xc5256
movb 0x3(%r15), %al
addb $-0x30, %al
cmpb $0xa, %al
jb 0xc51af
cmpq %r10, %rsi
ja 0xc51af
leaq (%rbx,%rbx,4), %rax
movzbl %r14b, %edx
leaq (%rdx,%rax,2), %rax
cmpq %r10, %rsi
jne 0xc527e
cmpq %r9, %r11
jb 0xc527e
cmpl %r8d, %eax
ja 0xc51af
movabsq $0x174876e800, %rcx # imm = 0x174876E800
imulq %rcx, %rsi
imulq $0x64, %r11, %rcx
addq %rax, %rsi
addq %rcx, %rsi
movq %rsi, %rax
jmp 0xc5031
| my_strtoll10_utf32:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
test rdx, rdx
jz loc_C5026
mov rdi, [rdx]
sub rdi, rsi
lea rax, [rdi+3]
test rdi, rdi
cmovns rax, rdi
and rax, 0FFFFFFFFFFFFFFFCh
add rax, rsi
mov r11, rsi
cmp rdi, 4
jl short loc_C4F30
mov r11, rsi
loc_C4F04:
cmp byte ptr [r11], 0
jnz short loc_C4F30
cmp byte ptr [r11+1], 0
jnz short loc_C4F30
cmp byte ptr [r11+2], 0
jnz short loc_C4F30
movzx edi, byte ptr [r11+3]
cmp edi, 20h ; ' '
jz short loc_C4F27
cmp edi, 9
jnz short loc_C4F30
loc_C4F27:
add r11, 4
cmp r11, rax
jb short loc_C4F04
loc_C4F30:
cmp r11, rax
jz loc_C5026
cmp byte ptr [r11], 0
jnz short loc_C4F7D
cmp byte ptr [r11+1], 0
jnz short loc_C4F7D
cmp byte ptr [r11+2], 0
jnz short loc_C4F7D
cmp byte ptr [r11+3], 2Dh ; '-'
jnz short loc_C4F7D
mov dword ptr [rcx], 0FFFFFFFFh
add r11, 4
cmp r11, rax
jz loc_C5026
mov r8d, 8
mov r9d, 15F797AEh
mov r10d, 57F5FF8h
xor edi, edi
jmp short loc_C4FC0
loc_C4F7D:
mov dword ptr [rcx], 0
cmp byte ptr [r11], 0
jnz loc_C5026
mov r8d, 0Fh
mov r9d, 2BEF2F5Ch
mov r10d, 0AFEBFF0h
mov dil, 1
cmp byte ptr [r11+1], 0
jnz short loc_C4FC0
cmp byte ptr [r11+2], 0
jnz short loc_C4FC0
cmp byte ptr [r11+3], 2Bh ; '+'
jnz short loc_C4FC0
add r11, 4
cmp r11, rax
jz short loc_C5026
loc_C4FC0:
cmp byte ptr [r11], 0
jnz short loc_C5026
cmp byte ptr [r11+1], 0
jnz short loc_C5026
cmp byte ptr [r11+2], 0
jnz short loc_C5013
cmp byte ptr [r11+3], 30h ; '0'
jnz short loc_C5013
add r11, 28h ; '('
xor esi, esi
loc_C4FE1:
lea rbx, [r11-24h]
cmp rbx, rax
jz loc_C51C9
mov r14, r11
cmp byte ptr [rbx], 0
jnz short loc_C500F
cmp byte ptr [r14-23h], 0
jnz short loc_C500F
cmp byte ptr [r14-22h], 0
jnz short loc_C500F
lea r11, [r14+4]
cmp byte ptr [r14-21h], 30h ; '0'
jz short loc_C4FE1
loc_C500F:
xor esi, esi
jmp short loc_C504A
loc_C5013:
cmp byte ptr [r11+2], 0
jnz short loc_C5026
mov bl, [r11+3]
add bl, 0D0h
cmp bl, 9
jbe short loc_C503C
loc_C5026:
mov dword ptr [rcx], 21h ; '!'
mov [rdx], rsi
xor eax, eax
loc_C5031:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C503C:
movzx esi, bl
lea rbx, [r11+4]
add r11, 24h ; '$'
mov r14, r11
loc_C504A:
cmp r14, rax
cmova r14, rax
loc_C5051:
cmp rbx, r14
jz short loc_C5097
cmp byte ptr [rbx], 0
jnz loc_C51C6
cmp byte ptr [rbx+1], 0
jnz loc_C51C6
cmp byte ptr [rbx+2], 0
jnz loc_C51C6
mov r11b, [rbx+3]
add r11b, 0D0h
cmp r11b, 9
ja loc_C51C6
lea rsi, [rsi+rsi*4]
movzx r11d, r11b
lea rsi, [r11+rsi*2]
add rbx, 4
jmp short loc_C5051
loc_C5097:
cmp rbx, rax
jz loc_C51C6
lea r12, [rbx+24h]
cmp r12, rax
cmova r12, rax
lea r14, [rbx+8]
mov r13d, 24h ; '$'
xor r11d, r11d
loc_C50B8:
cmp byte ptr [r14-8], 0
jnz loc_C51CE
cmp byte ptr [r14-7], 0
jnz loc_C51CE
cmp byte ptr [r14-6], 0
jnz loc_C51CE
mov r15b, [r14-5]
add r15b, 0D0h
cmp r15b, 9
ja loc_C51CE
lea r11, [r11+r11*4]
movzx r15d, r15b
lea r11, [r15+r11*2]
lea r15, [r14+4]
add r14, 0FFFFFFFFFFFFFFFCh
add r13, 0FFFFFFFFFFFFFFFCh
cmp r14, r12
mov r14, r15
jnz short loc_C50B8
lea r14, [r15-8]
cmp r12, rax
jz loc_C5200
cmp byte ptr [r14], 0
jnz loc_C5205
cmp byte ptr [r15-7], 0
jnz loc_C5205
cmp byte ptr [r15-6], 0
jnz loc_C5205
mov bl, [r15-5]
add bl, 0D0h
cmp bl, 9
ja loc_C5205
movzx ebx, bl
lea r12, [r15-4]
cmp r12, rax
jz short loc_C517B
cmp byte ptr [r15-4], 0
jnz short loc_C517B
cmp byte ptr [r15-3], 0
jnz short loc_C517B
cmp byte ptr [r15-2], 0
jnz short loc_C517B
mov r14b, [r15-1]
add r14b, 0D0h
cmp r14b, 9
jbe loc_C522C
loc_C517B:
mov rax, 2540BE400h
imul rsi, rax
lea rax, [r11+r11*4]
lea rax, [rsi+rax*2]
add rax, rbx
mov [rdx], r12
test dil, dil
jnz loc_C5031
mov rdx, 8000000000000000h
cmp rax, rdx
jbe short loc_C5224
loc_C51AF:
mov dword ptr [rcx], 22h ; '"'
movzx eax, dil
neg rax
bts rax, 3Fh ; '?'
jmp loc_C5031
loc_C51C6:
mov rax, rbx
loc_C51C9:
mov [rdx], rax
jmp short loc_C51EE
loc_C51CE:
add r14, 0FFFFFFFFFFFFFFF8h
loc_C51D2:
mov rax, r14
sub rax, rbx
and rax, 0FFFFFFFFFFFFFFFCh
lea rcx, lfactor
imul rsi, [rcx+rax*2]
add rsi, r11
mov [rdx], r14
loc_C51EE:
mov rax, rsi
neg rax
test dil, dil
cmovnz rax, rsi
jmp loc_C5031
loc_C5200:
test r13, r13
jnz short loc_C51D2
loc_C5205:
imul rax, rsi, 3B9ACA00h
add r11, rax
mov [rdx], r14
mov rax, r11
neg rax
test dil, dil
cmovnz rax, r11
jmp loc_C5031
loc_C5224:
neg rax
jmp loc_C5031
loc_C522C:
mov [rdx], r15
cmp r15, rax
jz short loc_C5256
cmp byte ptr [r15], 0
jnz short loc_C5256
cmp byte ptr [r15+1], 0
jnz short loc_C5256
cmp byte ptr [r15+2], 0
jnz short loc_C5256
mov al, [r15+3]
add al, 0D0h
cmp al, 0Ah
jb loc_C51AF
loc_C5256:
cmp rsi, r10
ja loc_C51AF
lea rax, [rbx+rbx*4]
movzx edx, r14b
lea rax, [rdx+rax*2]
cmp rsi, r10
jnz short loc_C527E
cmp r11, r9
jb short loc_C527E
cmp eax, r8d
ja loc_C51AF
loc_C527E:
mov rcx, 174876E800h
imul rsi, rcx
imul rcx, r11, 64h ; 'd'
add rsi, rax
add rsi, rcx
mov rax, rsi
jmp loc_C5031
| unsigned long long my_strtoll10_utf32(long long a1, _BYTE *a2, unsigned long long *a3, _DWORD *a4)
{
long long v4; // rdi
long long v5; // rax
unsigned long long v6; // rax
_BYTE *v7; // r11
int v8; // edi
unsigned int v9; // r8d
unsigned long long v10; // r9
unsigned long long v11; // r10
unsigned __int8 v12; // di
_BYTE *v13; // r11
unsigned long long v14; // rsi
_BYTE *v15; // rbx
_BYTE *v16; // r14
unsigned __int8 v17; // bl
unsigned long long result; // rax
unsigned __int8 v19; // r11
_BYTE *v20; // r12
_BYTE *v21; // r14
long long v22; // r13
unsigned long long v23; // r11
unsigned __int8 v24; // r15
_BYTE *v25; // r15
bool v26; // zf
_BYTE *v27; // r14
unsigned __int8 v28; // bl
unsigned __int8 v29; // r14
unsigned long long v30; // r11
long long v31; // rax
if ( !a3 )
goto LABEL_37;
v4 = *a3 - (_QWORD)a2;
v5 = v4 + 3;
if ( v4 >= 0 )
v5 = *a3 - (_QWORD)a2;
v6 = (unsigned long long)&a2[v5 & 0xFFFFFFFFFFFFFFFCLL];
v7 = a2;
if ( v4 >= 4 )
{
v7 = a2;
do
{
if ( *v7 )
break;
if ( v7[1] )
break;
if ( v7[2] )
break;
v8 = (unsigned __int8)v7[3];
if ( v8 != 32 && v8 != 9 )
break;
v7 += 4;
}
while ( (unsigned long long)v7 < v6 );
}
if ( v7 == (_BYTE *)v6 )
goto LABEL_37;
if ( *v7 || v7[1] || v7[2] || v7[3] != 45 )
{
*a4 = 0;
if ( *v7 )
goto LABEL_37;
v9 = 15;
v10 = 737095516LL;
v11 = 184467440LL;
v12 = 1;
if ( !v7[1] && !v7[2] && v7[3] == 43 )
{
v7 += 4;
if ( v7 == (_BYTE *)v6 )
goto LABEL_37;
}
}
else
{
*a4 = -1;
v7 += 4;
if ( v7 == (_BYTE *)v6 )
goto LABEL_37;
v9 = 8;
v10 = 368547758LL;
v11 = 92233720LL;
v12 = 0;
}
if ( *v7 || v7[1] )
goto LABEL_37;
if ( !v7[2] && v7[3] == 48 )
{
v13 = v7 + 40;
v14 = 0LL;
while ( 1 )
{
v15 = v13 - 36;
if ( v13 - 36 == (_BYTE *)v6 )
goto LABEL_71;
v16 = v13;
if ( !*v15 && !*(v13 - 35) && !*(v13 - 34) )
{
v13 += 4;
if ( *(v16 - 33) == 48 )
continue;
}
v14 = 0LL;
goto LABEL_40;
}
}
if ( v7[2] || (v17 = v7[3] - 48, v17 > 9u) )
{
LABEL_37:
*a4 = 33;
*a3 = (unsigned long long)a2;
return 0LL;
}
v14 = v17;
v15 = v7 + 4;
v16 = v7 + 36;
LABEL_40:
if ( (unsigned long long)v16 > v6 )
v16 = (_BYTE *)v6;
while ( v15 != v16 )
{
if ( *v15 )
goto LABEL_70;
if ( v15[1] )
goto LABEL_70;
if ( v15[2] )
goto LABEL_70;
v19 = v15[3] - 48;
if ( v19 > 9u )
goto LABEL_70;
v14 = v19 + 10 * v14;
v15 += 4;
}
if ( v15 != (_BYTE *)v6 )
{
v20 = v15 + 36;
if ( (unsigned long long)(v15 + 36) > v6 )
v20 = (_BYTE *)v6;
v21 = v15 + 8;
v22 = 36LL;
v23 = 0LL;
while ( !*(v21 - 8) )
{
if ( *(v21 - 7) )
break;
if ( *(v21 - 6) )
break;
v24 = *(v21 - 5) - 48;
if ( v24 > 9u )
break;
v23 = v24 + 10 * v23;
v25 = v21 + 4;
v22 -= 4LL;
v26 = v21 - 4 == v20;
v21 += 4;
if ( v26 )
{
v27 = v25 - 8;
if ( v20 != (_BYTE *)v6 )
{
if ( !*v27 && !*(v25 - 7) && !*(v25 - 6) )
{
v28 = *(v25 - 5) - 48;
if ( v28 <= 9u )
{
if ( v25 - 4 == (_BYTE *)v6 || *(v25 - 4) || *(v25 - 3) || *(v25 - 2) || (v29 = *(v25 - 1) - 48, v29 > 9u) )
{
result = v28 + 10000000000LL * v14 + 10 * v23;
*a3 = (unsigned long long)(v25 - 4);
if ( v12 )
return result;
if ( result > 0x8000000000000000LL )
goto LABEL_69;
return -(long long)result;
}
else
{
*a3 = (unsigned long long)v25;
if ( v25 != (_BYTE *)v6 && !*v25 && !v25[1] && !v25[2] && (unsigned __int8)(v25[3] - 48) < 0xAu
|| v14 > v11
|| (v31 = v29 + 10LL * v28, v14 == v11) && v23 >= v10 && (unsigned int)v31 > v9 )
{
LABEL_69:
*a4 = 34;
return -(long long)v12 | 0x8000000000000000LL;
}
return 100 * v23 + v31 + 100000000000LL * v14;
}
}
}
LABEL_78:
v30 = 1000000000 * v14 + v23;
*a3 = (unsigned long long)v27;
result = -(long long)v30;
if ( v12 )
return v30;
return result;
}
if ( !v22 )
goto LABEL_78;
LABEL_73:
v14 = v23 + *(_QWORD *)((char *)&lfactor + 2 * ((v27 - v15) & 0xFFFFFFFFFFFFFFFCLL)) * v14;
*a3 = (unsigned long long)v27;
goto LABEL_74;
}
}
v27 = v21 - 8;
goto LABEL_73;
}
LABEL_70:
v6 = (unsigned long long)v15;
LABEL_71:
*a3 = v6;
LABEL_74:
result = -(long long)v14;
if ( v12 )
return v14;
return result;
}
| my_strtoll10_utf32:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDX,RDX
JZ 0x001c5026
MOV RDI,qword ptr [RDX]
SUB RDI,RSI
LEA RAX,[RDI + 0x3]
TEST RDI,RDI
CMOVNS RAX,RDI
AND RAX,-0x4
ADD RAX,RSI
MOV R11,RSI
CMP RDI,0x4
JL 0x001c4f30
MOV R11,RSI
LAB_001c4f04:
CMP byte ptr [R11],0x0
JNZ 0x001c4f30
CMP byte ptr [R11 + 0x1],0x0
JNZ 0x001c4f30
CMP byte ptr [R11 + 0x2],0x0
JNZ 0x001c4f30
MOVZX EDI,byte ptr [R11 + 0x3]
CMP EDI,0x20
JZ 0x001c4f27
CMP EDI,0x9
JNZ 0x001c4f30
LAB_001c4f27:
ADD R11,0x4
CMP R11,RAX
JC 0x001c4f04
LAB_001c4f30:
CMP R11,RAX
JZ 0x001c5026
CMP byte ptr [R11],0x0
JNZ 0x001c4f7d
CMP byte ptr [R11 + 0x1],0x0
JNZ 0x001c4f7d
CMP byte ptr [R11 + 0x2],0x0
JNZ 0x001c4f7d
CMP byte ptr [R11 + 0x3],0x2d
JNZ 0x001c4f7d
MOV dword ptr [RCX],0xffffffff
ADD R11,0x4
CMP R11,RAX
JZ 0x001c5026
MOV R8D,0x8
MOV R9D,0x15f797ae
MOV R10D,0x57f5ff8
XOR EDI,EDI
JMP 0x001c4fc0
LAB_001c4f7d:
MOV dword ptr [RCX],0x0
CMP byte ptr [R11],0x0
JNZ 0x001c5026
MOV R8D,0xf
MOV R9D,0x2bef2f5c
MOV R10D,0xafebff0
MOV DIL,0x1
CMP byte ptr [R11 + 0x1],0x0
JNZ 0x001c4fc0
CMP byte ptr [R11 + 0x2],0x0
JNZ 0x001c4fc0
CMP byte ptr [R11 + 0x3],0x2b
JNZ 0x001c4fc0
ADD R11,0x4
CMP R11,RAX
JZ 0x001c5026
LAB_001c4fc0:
CMP byte ptr [R11],0x0
JNZ 0x001c5026
CMP byte ptr [R11 + 0x1],0x0
JNZ 0x001c5026
CMP byte ptr [R11 + 0x2],0x0
JNZ 0x001c5013
CMP byte ptr [R11 + 0x3],0x30
JNZ 0x001c5013
ADD R11,0x28
XOR ESI,ESI
LAB_001c4fe1:
LEA RBX,[R11 + -0x24]
CMP RBX,RAX
JZ 0x001c51c9
MOV R14,R11
CMP byte ptr [RBX],0x0
JNZ 0x001c500f
CMP byte ptr [R14 + -0x23],0x0
JNZ 0x001c500f
CMP byte ptr [R14 + -0x22],0x0
JNZ 0x001c500f
LEA R11,[R14 + 0x4]
CMP byte ptr [R14 + -0x21],0x30
JZ 0x001c4fe1
LAB_001c500f:
XOR ESI,ESI
JMP 0x001c504a
LAB_001c5013:
CMP byte ptr [R11 + 0x2],0x0
JNZ 0x001c5026
MOV BL,byte ptr [R11 + 0x3]
ADD BL,0xd0
CMP BL,0x9
JBE 0x001c503c
LAB_001c5026:
MOV dword ptr [RCX],0x21
MOV qword ptr [RDX],RSI
XOR EAX,EAX
LAB_001c5031:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c503c:
MOVZX ESI,BL
LEA RBX,[R11 + 0x4]
ADD R11,0x24
MOV R14,R11
LAB_001c504a:
CMP R14,RAX
CMOVA R14,RAX
LAB_001c5051:
CMP RBX,R14
JZ 0x001c5097
CMP byte ptr [RBX],0x0
JNZ 0x001c51c6
CMP byte ptr [RBX + 0x1],0x0
JNZ 0x001c51c6
CMP byte ptr [RBX + 0x2],0x0
JNZ 0x001c51c6
MOV R11B,byte ptr [RBX + 0x3]
ADD R11B,0xd0
CMP R11B,0x9
JA 0x001c51c6
LEA RSI,[RSI + RSI*0x4]
MOVZX R11D,R11B
LEA RSI,[R11 + RSI*0x2]
ADD RBX,0x4
JMP 0x001c5051
LAB_001c5097:
CMP RBX,RAX
JZ 0x001c51c6
LEA R12,[RBX + 0x24]
CMP R12,RAX
CMOVA R12,RAX
LEA R14,[RBX + 0x8]
MOV R13D,0x24
XOR R11D,R11D
LAB_001c50b8:
CMP byte ptr [R14 + -0x8],0x0
JNZ 0x001c51ce
CMP byte ptr [R14 + -0x7],0x0
JNZ 0x001c51ce
CMP byte ptr [R14 + -0x6],0x0
JNZ 0x001c51ce
MOV R15B,byte ptr [R14 + -0x5]
ADD R15B,0xd0
CMP R15B,0x9
JA 0x001c51ce
LEA R11,[R11 + R11*0x4]
MOVZX R15D,R15B
LEA R11,[R15 + R11*0x2]
LEA R15,[R14 + 0x4]
ADD R14,-0x4
ADD R13,-0x4
CMP R14,R12
MOV R14,R15
JNZ 0x001c50b8
LEA R14,[R15 + -0x8]
CMP R12,RAX
JZ 0x001c5200
CMP byte ptr [R14],0x0
JNZ 0x001c5205
CMP byte ptr [R15 + -0x7],0x0
JNZ 0x001c5205
CMP byte ptr [R15 + -0x6],0x0
JNZ 0x001c5205
MOV BL,byte ptr [R15 + -0x5]
ADD BL,0xd0
CMP BL,0x9
JA 0x001c5205
MOVZX EBX,BL
LEA R12,[R15 + -0x4]
CMP R12,RAX
JZ 0x001c517b
CMP byte ptr [R15 + -0x4],0x0
JNZ 0x001c517b
CMP byte ptr [R15 + -0x3],0x0
JNZ 0x001c517b
CMP byte ptr [R15 + -0x2],0x0
JNZ 0x001c517b
MOV R14B,byte ptr [R15 + -0x1]
ADD R14B,0xd0
CMP R14B,0x9
JBE 0x001c522c
LAB_001c517b:
MOV RAX,0x2540be400
IMUL RSI,RAX
LEA RAX,[R11 + R11*0x4]
LEA RAX,[RSI + RAX*0x2]
ADD RAX,RBX
MOV qword ptr [RDX],R12
TEST DIL,DIL
JNZ 0x001c5031
MOV RDX,-0x8000000000000000
CMP RAX,RDX
JBE 0x001c5224
LAB_001c51af:
MOV dword ptr [RCX],0x22
MOVZX EAX,DIL
NEG RAX
BTS RAX,0x3f
JMP 0x001c5031
LAB_001c51c6:
MOV RAX,RBX
LAB_001c51c9:
MOV qword ptr [RDX],RAX
JMP 0x001c51ee
LAB_001c51ce:
ADD R14,-0x8
LAB_001c51d2:
MOV RAX,R14
SUB RAX,RBX
AND RAX,-0x4
LEA RCX,[0x3d6430]
IMUL RSI,qword ptr [RCX + RAX*0x2]
ADD RSI,R11
MOV qword ptr [RDX],R14
LAB_001c51ee:
MOV RAX,RSI
NEG RAX
TEST DIL,DIL
CMOVNZ RAX,RSI
JMP 0x001c5031
LAB_001c5200:
TEST R13,R13
JNZ 0x001c51d2
LAB_001c5205:
IMUL RAX,RSI,0x3b9aca00
ADD R11,RAX
MOV qword ptr [RDX],R14
MOV RAX,R11
NEG RAX
TEST DIL,DIL
CMOVNZ RAX,R11
JMP 0x001c5031
LAB_001c5224:
NEG RAX
JMP 0x001c5031
LAB_001c522c:
MOV qword ptr [RDX],R15
CMP R15,RAX
JZ 0x001c5256
CMP byte ptr [R15],0x0
JNZ 0x001c5256
CMP byte ptr [R15 + 0x1],0x0
JNZ 0x001c5256
CMP byte ptr [R15 + 0x2],0x0
JNZ 0x001c5256
MOV AL,byte ptr [R15 + 0x3]
ADD AL,0xd0
CMP AL,0xa
JC 0x001c51af
LAB_001c5256:
CMP RSI,R10
JA 0x001c51af
LEA RAX,[RBX + RBX*0x4]
MOVZX EDX,R14B
LEA RAX,[RDX + RAX*0x2]
CMP RSI,R10
JNZ 0x001c527e
CMP R11,R9
JC 0x001c527e
CMP EAX,R8D
JA 0x001c51af
LAB_001c527e:
MOV RCX,0x174876e800
IMUL RSI,RCX
IMUL RCX,R11,0x64
ADD RSI,RAX
ADD RSI,RCX
MOV RAX,RSI
JMP 0x001c5031
|
ulong my_strtoll10_utf32(int8 param_1,char *param_2,long *param_3,int4 *param_4)
{
char *pcVar1;
char cVar2;
char *pcVar3;
byte bVar4;
char *pcVar5;
ulong uVar6;
byte bVar7;
ulong uVar8;
uint uVar9;
ulong uVar10;
char *pcVar11;
ulong uVar12;
long lVar13;
char *pcVar14;
char *pcVar15;
if (param_3 != (long *)0x0) {
uVar8 = *param_3 - (long)param_2;
uVar10 = uVar8 + 3;
if (-1 < (long)uVar8) {
uVar10 = uVar8;
}
pcVar3 = param_2 + (uVar10 & 0xfffffffffffffffc);
pcVar11 = param_2;
if (3 < (long)uVar8) {
do {
if ((((*pcVar11 != '\0') || (pcVar11[1] != '\0')) || (pcVar11[2] != '\0')) ||
((pcVar11[3] != ' ' && (pcVar11[3] != '\t')))) break;
pcVar11 = pcVar11 + 4;
} while (pcVar11 < pcVar3);
}
if (pcVar11 != pcVar3) {
if (((*pcVar11 == '\0') && (pcVar11[1] == '\0')) &&
((pcVar11[2] == '\0' && (pcVar11[3] == '-')))) {
*param_4 = 0xffffffff;
pcVar11 = pcVar11 + 4;
if (pcVar11 == pcVar3) goto LAB_001c5026;
uVar9 = 8;
uVar10 = 0x15f797ae;
uVar8 = 0x57f5ff8;
bVar7 = 0;
}
else {
*param_4 = 0;
if (*pcVar11 != '\0') goto LAB_001c5026;
uVar9 = 0xf;
uVar10 = 0x2bef2f5c;
uVar8 = 0xafebff0;
bVar7 = 1;
if ((((pcVar11[1] == '\0') && (pcVar11[2] == '\0')) && (pcVar11[3] == '+')) &&
(pcVar11 = pcVar11 + 4, pcVar11 == pcVar3)) goto LAB_001c5026;
}
if ((*pcVar11 == '\0') && (pcVar11[1] == '\0')) {
if ((pcVar11[2] == '\0') && (pcVar11[3] == '0')) {
uVar6 = 0;
pcVar5 = pcVar11 + 0x28;
do {
pcVar11 = pcVar5;
pcVar1 = pcVar11 + -0x24;
pcVar5 = pcVar3;
if (pcVar1 == pcVar3) goto LAB_001c51c9;
} while ((((*pcVar1 == '\0') && (pcVar11[-0x23] == '\0')) && (pcVar11[-0x22] == '\0')) &&
(pcVar5 = pcVar11 + 4, pcVar11[-0x21] == '0'));
uVar6 = 0;
pcVar5 = pcVar1;
}
else {
if ((pcVar11[2] != '\0') || (9 < (byte)(pcVar11[3] - 0x30U))) goto LAB_001c5026;
uVar6 = (ulong)(byte)(pcVar11[3] - 0x30U);
pcVar5 = pcVar11 + 4;
pcVar11 = pcVar11 + 0x24;
}
if (pcVar3 < pcVar11) {
pcVar11 = pcVar3;
}
for (; pcVar5 != pcVar11; pcVar5 = pcVar5 + 4) {
if (((*pcVar5 != '\0') || (pcVar5[1] != '\0')) ||
((pcVar5[2] != '\0' || (9 < (byte)(pcVar5[3] - 0x30U))))) goto LAB_001c51c9;
uVar6 = (ulong)(byte)(pcVar5[3] - 0x30U) + uVar6 * 10;
}
if (pcVar5 != pcVar3) {
pcVar11 = pcVar5 + 0x24;
if (pcVar3 < pcVar5 + 0x24) {
pcVar11 = pcVar3;
}
lVar13 = 0x24;
uVar12 = 0;
pcVar1 = pcVar5 + 8;
do {
pcVar14 = pcVar1;
if (((pcVar14[-8] != '\0') || (pcVar14[-7] != '\0')) ||
((pcVar14[-6] != '\0' || (9 < (byte)(pcVar14[-5] - 0x30U))))) {
pcVar15 = pcVar14 + -8;
goto LAB_001c51d2;
}
uVar12 = (ulong)(byte)(pcVar14[-5] - 0x30U) + uVar12 * 10;
pcVar1 = pcVar14 + 4;
lVar13 = lVar13 + -4;
} while (pcVar14 + -4 != pcVar11);
pcVar15 = pcVar14 + -4;
if (pcVar11 == pcVar3) {
if (lVar13 != 0) {
LAB_001c51d2:
uVar6 = uVar6 * *(long *)((long)&lfactor +
((long)pcVar15 - (long)pcVar5 & 0xfffffffffffffffcU) * 2) +
uVar12;
*param_3 = (long)pcVar15;
goto LAB_001c51ee;
}
}
else if ((((*pcVar15 == '\0') && (pcVar14[-3] == '\0')) && (pcVar14[-2] == '\0')) &&
(bVar4 = pcVar14[-1] - 0x30, bVar4 < 10)) {
if (((pcVar14 == pcVar3) || (*pcVar14 != '\0')) ||
((pcVar14[1] != '\0' ||
((pcVar14[2] != '\0' || (cVar2 = pcVar14[3], 9 < (byte)(cVar2 - 0x30U))))))) {
uVar10 = uVar6 * 10000000000 + uVar12 * 10 + (ulong)bVar4;
*param_3 = (long)pcVar14;
if (bVar7 != 0) {
return uVar10;
}
if (uVar10 < 0x8000000000000001) {
return -uVar10;
}
}
else {
*param_3 = (long)pcVar1;
if ((((((pcVar1 == pcVar3) || (*pcVar1 != '\0')) || (pcVar14[5] != '\0')) ||
((pcVar14[6] != '\0' || (9 < (byte)(pcVar14[7] - 0x30U))))) && (uVar6 <= uVar8))
&& (((lVar13 = (ulong)(byte)(cVar2 - 0x30U) + (ulong)bVar4 * 10, uVar6 != uVar8 ||
(uVar12 < uVar10)) || ((uint)lVar13 <= uVar9)))) {
return uVar6 * 100000000000 + lVar13 + uVar12 * 100;
}
}
*param_4 = 0x22;
return -(ulong)bVar7 | 0x8000000000000000;
}
uVar12 = uVar12 + uVar6 * 1000000000;
*param_3 = (long)pcVar15;
if (bVar7 == 0) {
return -uVar12;
}
return uVar12;
}
LAB_001c51c9:
*param_3 = (long)pcVar5;
LAB_001c51ee:
if (bVar7 == 0) {
return -uVar6;
}
return uVar6;
}
}
}
LAB_001c5026:
*param_4 = 0x21;
*param_3 = (long)param_2;
return 0;
}
| |
43,140 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | monkey531[P]llama/common/json.hpp | const_reference operator[](const typename object_t::key_type& key) const
{
// const operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto it = m_data.m_value.object->find(key);
JSON_ASSERT(it != m_data.m_value.object->end());
return it->second;
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x7e7d4
movq 0x8(%r14), %rdi
callq 0x7e878
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x7e830
addq $0x20, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23470
movq %rax, %rbx
movq %r14, %rdi
callq 0x4334a
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3675e(%rip), %rsi # 0xb4f54
leaq 0x10(%rsp), %rdi
callq 0x7e567
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x632a8
xorl %ebp, %ebp
leaq 0x7d727(%rip), %rsi # 0xfbf48
leaq -0x3e8d4(%rip), %rdx # 0x3ff54
movq %rbx, %rdi
callq 0x23f40
leaq 0x31599(%rip), %rdi # 0xafdd0
leaq 0x315dc(%rip), %rdx # 0xafe1a
leaq 0x36742(%rip), %rcx # 0xb4f87
movl $0x53ca, %esi # imm = 0x53CA
xorl %eax, %eax
callq 0x23ef0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241f8
testb %bpl, %bpl
jne 0x7e868
jmp 0x7e870
movq %rax, %r14
movq %rbx, %rdi
callq 0x236a0
movq %r14, %rdi
callq 0x23fc0
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixERKS9_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_7E7D4
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::find(std::string const&)
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_7E830
add rax, 20h ; ' '
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_7E7D4:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7E830:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aItMDataMValueO; "it != m_data.m_value.object->end()"
mov esi, 53CAh
xor eax, eax
call _ggml_abort
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7E868
jmp short loc_7E870
mov r14, rax
loc_7E868:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7E870:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[](
long long a1)
{
void *v1; // rbx
char v2; // bp
long long v3; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
long long v6; // r14
const char *v7; // [rsp+8h] [rbp-40h] BYREF
_BYTE v8[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v7 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(
(long long)v8,
(long long)"cannot use operator[] with a string argument with ",
&v7);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
305,
(long long)v8);
__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 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::find(*(_QWORD *)(a1 + 8));
if ( v3 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v6 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
21450LL,
"GGML_ASSERT(%s) failed",
"it != m_data.m_value.object->end()");
std::string::~string(v8);
if ( v2 )
__cxa_free_exception(v1);
_Unwind_Resume(v6);
}
return v3 + 32;
}
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x0017e7d4
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0017e878
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0017e830
ADD RAX,0x20
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0017e7d4:
PUSH 0x20
POP RDI
CALL 0x00123470
MOV RBX,RAX
MOV RDI,R14
CALL 0x0014334a
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0017e7ef:
LEA RSI,[0x1b4f54]
LEA RDI,[RSP + 0x10]
CALL 0x0017e567
MOV BPL,0x1
LAB_0017e803:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x001632a8
XOR EBP,EBP
LEA RSI,[0x1fbf48]
LEA RDX,[0x13ff54]
MOV RDI,RBX
CALL 0x00123f40
LAB_0017e830:
LEA RDI,[0x1afdd0]
LEA RDX,[0x1afe1a]
LEA RCX,[0x1b4f87]
MOV ESI,0x53ca
XOR EAX,EAX
CALL 0x00123ef0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](std::__cxx11::string const&) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,string *param_1)
{
long lVar1;
int8 uVar2;
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>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0017e7ef to 0017e7ff has its CatchHandler @ 0017e865 */
detail::concat<std::__cxx11::string,char_const(&)[51],char_const*>
(local_38,"cannot use operator[] with a string argument with ",&local_40);
/* try { // try from 0017e803 to 0017e82f has its CatchHandler @ 0017e851 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&detail::type_error::typeinfo,detail::exception::~exception);
}
lVar1 = ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::find(*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8),param_1);
if (lVar1 != *(long *)(*(long *)(this + 8) + 8)) {
return lVar1 + 0x20;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x53ca,
"GGML_ASSERT(%s) failed","it != m_data.m_value.object->end()");
}
| |
43,141 | ma_scramble_323 | eloqsql/libmariadb/libmariadb/ma_password.c | char *ma_scramble_323(char *to, const char *message, const char *password)
{
struct rand_struct rand_st;
ulong hash_pass[2], hash_message[2];
if (password && password[0])
{
char extra, *to_start=to;
const char *end_scramble323= message + SCRAMBLE_LENGTH_323;
ma_hash_password(hash_pass,password, (uint) strlen(password));
/* Don't use strlen, could be > SCRAMBLE_LENGTH_323 ! */
ma_hash_password(hash_message, message, SCRAMBLE_LENGTH_323);
ma_randominit(&rand_st, hash_pass[0] ^ hash_message[0],
hash_pass[1] ^ hash_message[1]);
for (; message < end_scramble323; message++)
*to++= (char) (floor(rnd(&rand_st) * 31) + 64);
extra=(char) (floor(rnd(&rand_st) * 31));
while (to_start != to)
*(to_start++)^= extra;
}
*to= 0;
return to;
} | O0 | c | ma_scramble_323:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x79f5f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x79f5f
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x38410
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl %eax, %eax
movl %eax, %edx
callq 0x79b10
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x79b10
movq -0x50(%rbp), %rsi
xorq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdx
xorq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x799f0
movq -0x10(%rbp), %rax
cmpq -0x78(%rbp), %rax
jae 0x79f16
leaq -0x38(%rbp), %rdi
callq 0x79a70
movsd 0x6c764(%rip), %xmm1 # 0xe6640
mulsd %xmm1, %xmm0
callq 0x38110
movsd 0x6c75b(%rip), %xmm1 # 0xe6648
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x79ec1
leaq -0x38(%rbp), %rdi
callq 0x79a70
movsd 0x6c719(%rip), %xmm1 # 0xe6640
mulsd %xmm1, %xmm0
callq 0x38110
cvttsd2si %xmm0, %eax
movb %al, -0x61(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x79f5d
movsbl -0x61(%rbp), %edx
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movsbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
jmp 0x79f37
jmp 0x79f5f
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| ma_scramble_323:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
cmp [rbp+var_18], 0
jz loc_79F5F
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0
jz loc_79F5F
mov rax, [rbp+var_8]
mov [rbp+var_70], rax
mov rax, [rbp+var_10]
add rax, 8
mov [rbp+var_78], rax
lea rax, [rbp+var_50]
mov [rbp+var_88], rax
mov rax, [rbp+var_18]
mov [rbp+var_80], rax
mov rdi, [rbp+var_18]
call _strlen
mov rdi, [rbp+var_88]
mov rsi, [rbp+var_80]
mov eax, eax
mov edx, eax
call ma_hash_password
lea rdi, [rbp+var_60]
mov rsi, [rbp+var_10]
mov edx, 8
call ma_hash_password
mov rsi, [rbp+var_50]
xor rsi, [rbp+var_60]
mov rdx, [rbp+var_48]
xor rdx, [rbp+var_58]
lea rdi, [rbp+var_38]
call ma_randominit
loc_79EC1:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_78]
jnb short loc_79F16
lea rdi, [rbp+var_38]
call rnd
movsd xmm1, cs:qword_E6640
mulsd xmm0, xmm1
call _floor
movsd xmm1, cs:qword_E6648
addsd xmm0, xmm1
cvttsd2si eax, xmm0
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_79EC1
loc_79F16:
lea rdi, [rbp+var_38]
call rnd
movsd xmm1, cs:qword_E6640
mulsd xmm0, xmm1
call _floor
cvttsd2si eax, xmm0
mov [rbp+var_61], al
loc_79F37:
mov rax, [rbp+var_70]
cmp rax, [rbp+var_8]
jz short loc_79F5D
movsx edx, [rbp+var_61]
mov rax, [rbp+var_70]
mov rcx, rax
add rcx, 1
mov [rbp+var_70], rcx
movsx ecx, byte ptr [rax]
xor ecx, edx
mov [rax], cl
jmp short loc_79F37
loc_79F5D:
jmp short $+2
loc_79F5F:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
| _BYTE * ma_scramble_323(_BYTE *a1, _BYTE *a2, _BYTE *a3)
{
unsigned int v3; // eax
double v4; // xmm0_8
double v5; // xmm0_8
_BYTE *v6; // rax
double v7; // xmm0_8
_BYTE *v8; // rax
_BYTE *v10; // [rsp+10h] [rbp-80h]
_BYTE *v11; // [rsp+18h] [rbp-78h]
_BYTE *v12; // [rsp+20h] [rbp-70h]
char v13; // [rsp+2Fh] [rbp-61h]
_QWORD v14[2]; // [rsp+30h] [rbp-60h] BYREF
_QWORD v15[3]; // [rsp+40h] [rbp-50h] BYREF
_BYTE v16[32]; // [rsp+58h] [rbp-38h] BYREF
_BYTE *v17; // [rsp+78h] [rbp-18h]
_BYTE *v18; // [rsp+80h] [rbp-10h]
_BYTE *v19; // [rsp+88h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
if ( a3 && *v17 )
{
v12 = v19;
v11 = v18 + 8;
v10 = v17;
v3 = strlen(v17);
ma_hash_password(v15, v10, v3);
ma_hash_password(v14, v18, 8LL);
ma_randominit((long long)v16, v14[0] ^ v15[0], v14[1] ^ v15[1]);
while ( v18 < v11 )
{
v4 = rnd((long long)v16);
v5 = floor(v4 * 31.0);
v6 = v19++;
*v6 = (int)(v5 + 64.0);
++v18;
}
v7 = rnd((long long)v16);
v13 = (int)floor(v7 * 31.0);
while ( v12 != v19 )
{
v8 = v12++;
*v8 ^= v13;
}
}
*v19 = 0;
return v19;
}
| ma_scramble_323:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00179f5f
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00179f5f
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
MOV qword ptr [RBP + -0x78],RAX
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00138410
MOV RDI,qword ptr [RBP + -0x88]
MOV RSI,qword ptr [RBP + -0x80]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x00179b10
LEA RDI,[RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x8
CALL 0x00179b10
MOV RSI,qword ptr [RBP + -0x50]
XOR RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x48]
XOR RDX,qword ptr [RBP + -0x58]
LEA RDI,[RBP + -0x38]
CALL 0x001799f0
LAB_00179ec1:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x78]
JNC 0x00179f16
LEA RDI,[RBP + -0x38]
CALL 0x00179a70
MOVSD XMM1,qword ptr [0x001e6640]
MULSD XMM0,XMM1
CALL 0x00138110
MOVSD XMM1,qword ptr [0x001e6648]
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00179ec1
LAB_00179f16:
LEA RDI,[RBP + -0x38]
CALL 0x00179a70
MOVSD XMM1,qword ptr [0x001e6640]
MULSD XMM0,XMM1
CALL 0x00138110
CVTTSD2SI EAX,XMM0
MOV byte ptr [RBP + -0x61],AL
LAB_00179f37:
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x8]
JZ 0x00179f5d
MOVSX EDX,byte ptr [RBP + -0x61]
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x70],RCX
MOVSX ECX,byte ptr [RAX]
XOR ECX,EDX
MOV byte ptr [RAX],CL
JMP 0x00179f37
LAB_00179f5d:
JMP 0x00179f5f
LAB_00179f5f:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
byte * ma_scramble_323(byte *param_1,ulong param_2,char *param_3)
{
size_t sVar1;
double dVar2;
byte *local_78;
ulong local_68;
ulong local_60;
ulong local_58;
ulong local_50;
int1 local_40 [32];
char *local_20;
ulong local_18;
byte *local_10;
local_10 = param_1;
if ((param_3 != (char *)0x0) && (*param_3 != '\0')) {
local_20 = param_3;
local_18 = param_2;
sVar1 = strlen(param_3);
ma_hash_password(&local_58,param_3,sVar1 & 0xffffffff);
ma_hash_password(&local_68,local_18,8);
ma_randominit(local_40,local_58 ^ local_68,local_50 ^ local_60);
for (; local_18 < param_2 + 8; local_18 = local_18 + 1) {
dVar2 = (double)rnd(local_40);
dVar2 = floor(dVar2 * DAT_001e6640);
*local_10 = (byte)(int)(dVar2 + DAT_001e6648);
local_10 = local_10 + 1;
}
dVar2 = (double)rnd(local_40);
dVar2 = floor(dVar2 * DAT_001e6640);
local_78 = param_1;
while (local_78 != local_10) {
*local_78 = *local_78 ^ (byte)(int)dVar2;
local_78 = local_78 + 1;
}
}
*local_10 = 0;
return local_10;
}
| |
43,142 | my_b_write | eloqsql/mysys/mf_iocache.c | int _my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
size_t rest_length;
int res;
/* Always use my_b_flush_io_cache() to flush write_buffer! */
DBUG_ASSERT(Buffer != info->write_buffer);
if (info->pos_in_file + info->buffer_length > info->end_of_file)
{
my_errno=errno=EFBIG;
return info->error = -1;
}
rest_length= (size_t) (info->write_end - info->write_pos);
DBUG_ASSERT(Count >= rest_length);
memcpy(info->write_pos, Buffer, (size_t) rest_length);
Buffer+=rest_length;
Count-=rest_length;
info->write_pos+=rest_length;
if (my_b_flush_io_cache(info, 1))
return 1;
if (Count)
{
my_off_t old_pos_in_file= info->pos_in_file;
res= info->write_function(info, Buffer, Count);
Count-= (size_t) (info->pos_in_file - old_pos_in_file);
Buffer+= info->pos_in_file - old_pos_in_file;
}
else
res= 0;
if (!res && Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return res;
} | O0 | c | my_b_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x6f516
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0xe8(%rcx), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x6f562
callq 0x28040
movl $0x1b, (%rax)
callq 0x82e30
movl $0x1b, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6f672
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x40(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x6f57b
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x28290
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x6f1e0
cmpl $0x0, %eax
je 0x6f5da
movl $0x1, -0x4(%rbp)
jmp 0x6f672
cmpq $0x0, -0x20(%rbp)
je 0x6f633
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
subq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
subq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6f63a
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6f66c
cmpq $0x0, -0x20(%rbp)
je 0x6f66c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x28290
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _my_b_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_6F516:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
add rax, [rcx+0E8h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jbe short loc_6F562
call ___errno_location
mov dword ptr [rax], 1Bh
call _my_thread_var
mov dword ptr [rax], 1Bh
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_6F672
loc_6F562:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+40h]
sub rax, rcx
mov [rbp+var_28], rax
jmp short $+2
loc_6F57B:
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call _memcpy
mov rax, [rbp+var_28]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
mov rdi, [rbp+var_10]
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_6F5DA
mov [rbp+var_4], 1
jmp loc_6F672
loc_6F5DA:
cmp [rbp+var_20], 0
jz short loc_6F633
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+0A8h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call rax
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
sub rcx, [rbp+var_38]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax]
sub rax, [rbp+var_38]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
jmp short loc_6F63A
loc_6F633:
mov [rbp+var_2C], 0
loc_6F63A:
cmp [rbp+var_2C], 0
jnz short loc_6F66C
cmp [rbp+var_20], 0
jz short loc_6F66C
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
loc_6F66C:
mov eax, [rbp+var_2C]
mov [rbp+var_4], eax
loc_6F672:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long my_b_write(long long a1, const char *a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-38h]
unsigned int v5; // [rsp+14h] [rbp-2Ch]
long long v6; // [rsp+18h] [rbp-28h]
long long v8; // [rsp+20h] [rbp-20h]
const char *v9; // [rsp+28h] [rbp-18h]
if ( *(_QWORD *)(a1 + 232) + *(_QWORD *)a1 <= *(_QWORD *)(a1 + 8) )
{
v6 = *(_QWORD *)(a1 + 72) - *(_QWORD *)(a1 + 64);
memcpy(*(_QWORD *)(a1 + 64), a2, v6);
v9 = &a2[v6];
v8 = a3 - v6;
*(_QWORD *)(a1 + 64) += v6;
if ( (unsigned int)my_b_flush_io_cache(a1, 1) )
{
return 1;
}
else
{
if ( v8 )
{
v4 = *(_QWORD *)a1;
v5 = (*(long long ( **)(long long, const char *, long long))(a1 + 168))(a1, v9, v8);
v8 -= *(_QWORD *)a1 - v4;
v9 += *(_QWORD *)a1 - v4;
}
else
{
v5 = 0;
}
if ( !v5 && v8 )
{
memcpy(*(_QWORD *)(a1 + 64), v9, v8);
*(_QWORD *)(a1 + 64) += v8;
}
return v5;
}
}
else
{
*(_DWORD *)__errno_location() = 27;
*(_DWORD *)my_thread_var(a1, a2) = 27;
*(_DWORD *)(a1 + 228) = -1;
return (unsigned int)-1;
}
}
| _my_b_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x0016f516
LAB_0016f516:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RCX + 0xe8]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JBE 0x0016f562
CALL 0x00128040
MOV dword ptr [RAX],0x1b
CALL 0x00182e30
MOV dword ptr [RAX],0x1b
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x0016f672
LAB_0016f562:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x40]
SUB RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0016f57b
LAB_0016f57b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00128290
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x0016f1e0
CMP EAX,0x0
JZ 0x0016f5da
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0016f672
LAB_0016f5da:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0016f633
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xa8]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL RAX
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
SUB RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
SUB RAX,qword ptr [RBP + -0x38]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0016f63a
LAB_0016f633:
MOV dword ptr [RBP + -0x2c],0x0
LAB_0016f63a:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x0016f66c
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0016f66c
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00128290
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
LAB_0016f66c:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0016f672:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int _my_b_write(long *param_1,void *param_2,long param_3)
{
long lVar1;
int iVar2;
int *piVar3;
int4 *puVar4;
size_t __n;
int local_34;
size_t local_28;
void *local_20;
int local_c;
if ((ulong)param_1[1] < (ulong)(*param_1 + param_1[0x1d])) {
piVar3 = __errno_location();
*piVar3 = 0x1b;
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x1b;
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
local_c = -1;
}
else {
__n = param_1[9] - param_1[8];
memcpy((void *)param_1[8],param_2,__n);
local_20 = (void *)(__n + (long)param_2);
param_3 = param_3 - __n;
param_1[8] = __n + param_1[8];
iVar2 = my_b_flush_io_cache(param_1,1);
if (iVar2 == 0) {
if (param_3 == 0) {
local_34 = 0;
local_28 = 0;
}
else {
lVar1 = *param_1;
local_34 = (*(code *)param_1[0x15])(param_1,local_20,param_3);
local_28 = param_3 - (*param_1 - lVar1);
local_20 = (void *)((*param_1 - lVar1) + (long)local_20);
}
if ((local_34 == 0) && (local_28 != 0)) {
memcpy((void *)param_1[8],local_20,local_28);
param_1[8] = local_28 + param_1[8];
}
local_c = local_34;
}
else {
local_c = 1;
}
}
return local_c;
}
| |
43,143 | write_hook_for_undo_key_insert | eloqsql/storage/maria/ma_key_recover.c | my_bool write_hook_for_undo_key_insert(enum translog_record_type type,
TRN *trn, MARIA_HA *tbl_info,
LSN *lsn, void *hook_arg)
{
struct st_msg_to_write_hook_for_undo_key *msg=
(struct st_msg_to_write_hook_for_undo_key *) hook_arg;
MARIA_SHARE *share= tbl_info->s;
if (msg->auto_increment > 0)
{
/*
Only reason to set it here is to have a mutex protect from checkpoint
reading at the same time (would see a corrupted value).
The purpose of the following code is to set auto_increment if the row
has a with auto_increment value higher than the current one. We also
want to be able to restore the old value, in case of rollback,
if no one else has tried to set the value.
The logic used is that we only restore the auto_increment value if
tbl_info->last_auto_increment == share->last_auto_increment
when it's time to do the rollback.
*/
DBUG_PRINT("info",("auto_inc: %lu new auto_inc: %lu",
(ulong)share->state.auto_increment,
(ulong)msg->auto_increment));
if (share->state.auto_increment < msg->auto_increment)
{
/* Remember the original value, in case of rollback */
tbl_info->last_auto_increment= share->last_auto_increment=
share->state.auto_increment;
share->state.auto_increment= msg->auto_increment;
}
else
{
/*
If the current value would have affected the original auto_increment
value, set it to an impossible value so that it's not restored on
rollback
*/
if (msg->auto_increment > share->last_auto_increment)
share->last_auto_increment= ~(ulonglong) 0;
}
}
return write_hook_for_undo_key(type, trn, tbl_info, lsn, hook_arg);
} | O0 | c | write_hook_for_undo_key_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x42a50
jmp 0x429db
jmp 0x429dd
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x42a28
movq -0x38(%rbp), %rax
movq 0xd8(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x610(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x3e8(%rax)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0xd8(%rax)
jmp 0x42a4e
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x610(%rcx), %rax
jbe 0x42a4c
movq -0x38(%rbp), %rax
movq $-0x1, 0x610(%rax)
jmp 0x42a4e
jmp 0x42a50
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x42910
addq $0x40, %rsp
popq %rbp
retq
nop
| write_hook_for_undo_key_insert:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
cmp qword ptr [rax+18h], 0
jbe short loc_42A50
jmp short $+2
loc_429DB:
jmp short $+2
loc_429DD:
mov rax, [rbp+var_38]
mov rax, [rax+0D8h]
mov rcx, [rbp+var_30]
cmp rax, [rcx+18h]
jnb short loc_42A28
mov rax, [rbp+var_38]
mov rcx, [rax+0D8h]
mov rax, [rbp+var_38]
mov [rax+610h], rcx
mov rax, [rbp+var_18]
mov [rax+3E8h], rcx
mov rax, [rbp+var_30]
mov rcx, [rax+18h]
mov rax, [rbp+var_38]
mov [rax+0D8h], rcx
jmp short loc_42A4E
loc_42A28:
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_38]
cmp rax, [rcx+610h]
jbe short loc_42A4C
mov rax, [rbp+var_38]
mov qword ptr [rax+610h], 0FFFFFFFFFFFFFFFFh
loc_42A4C:
jmp short $+2
loc_42A4E:
jmp short $+2
loc_42A50:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call write_hook_for_undo_key
add rsp, 40h
pop rbp
retn
| long long write_hook_for_undo_key_insert(unsigned int a1, long long a2, long long *a3, long long a4, long long a5)
{
long long v5; // rcx
long long v7; // [rsp+8h] [rbp-38h]
v7 = *a3;
if ( *(_QWORD *)(a5 + 24) )
{
if ( *(_QWORD *)(v7 + 216) >= *(_QWORD *)(a5 + 24) )
{
if ( *(_QWORD *)(a5 + 24) > *(_QWORD *)(v7 + 1552) )
*(_QWORD *)(v7 + 1552) = -1LL;
}
else
{
v5 = *(_QWORD *)(v7 + 216);
*(_QWORD *)(v7 + 1552) = v5;
a3[125] = v5;
*(_QWORD *)(v7 + 216) = *(_QWORD *)(a5 + 24);
}
}
return write_hook_for_undo_key(a1, a2, (long long)a3, a4, a5);
}
| write_hook_for_undo_key_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP qword ptr [RAX + 0x18],0x0
JBE 0x00142a50
JMP 0x001429db
LAB_001429db:
JMP 0x001429dd
LAB_001429dd:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0xd8]
MOV RCX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RCX + 0x18]
JNC 0x00142a28
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0xd8]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x3e8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0xd8],RCX
JMP 0x00142a4e
LAB_00142a28:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RCX + 0x610]
JBE 0x00142a4c
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x610],-0x1
LAB_00142a4c:
JMP 0x00142a4e
LAB_00142a4e:
JMP 0x00142a50
LAB_00142a50:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL 0x00142910
ADD RSP,0x40
POP RBP
RET
|
void write_hook_for_undo_key_insert
(int4 param_1,int8 param_2,long *param_3,int8 param_4,long param_5)
{
long lVar1;
lVar1 = *param_3;
if (*(long *)(param_5 + 0x18) != 0) {
if (*(ulong *)(lVar1 + 0xd8) < *(ulong *)(param_5 + 0x18)) {
*(long *)(lVar1 + 0x610) = *(long *)(lVar1 + 0xd8);
param_3[0x7d] = *(long *)(lVar1 + 0xd8);
*(int8 *)(lVar1 + 0xd8) = *(int8 *)(param_5 + 0x18);
}
else if (*(ulong *)(lVar1 + 0x610) < *(ulong *)(param_5 + 0x18)) {
*(int8 *)(lVar1 + 0x610) = 0xffffffffffffffff;
}
}
write_hook_for_undo_key(param_1,param_2,param_3,param_4,param_5);
return;
}
| |
43,144 | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool) | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O0 | cpp | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool):
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb 0x17(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
callq 0xd3350
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rdi)
movb $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0xb390
movq (%rsp), %rdi
callq 0x941f0
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0xba90
movq 0x8(%rsp), %rax
leaq 0xb3cd1(%rip), %rcx # 0x186f7e
movq %rcx, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
callq 0xd3360
movb %al, %cl
movq 0x8(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x90(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEEC2EOSJ_b:
sub rsp, 28h
mov al, dl
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
and al, 1
mov [rsp+28h+var_11], al
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
mov rcx, [rsp+28h+var_10]
mov rdx, [rcx]
mov [rax], rdx
mov rcx, [rcx+8]
mov [rax+8], rcx
mov cl, [rsp+28h+var_11]
and cl, 1
mov [rax+10h], cl
call _ZNSt11char_traitsIcE3eofEv; std::char_traits<char>::eof(void)
mov rdi, [rsp+28h+var_20]
mov [rdi+14h], eax
mov byte ptr [rdi+18h], 0
mov qword ptr [rdi+20h], 0
mov qword ptr [rdi+28h], 0
mov qword ptr [rdi+30h], 0
add rdi, 38h ; '8'
mov [rsp+28h+var_28], rdi
xor esi, esi
mov edx, 18h
call _memset
mov rdi, [rsp+28h+var_28]
call _ZNSt6vectorIcSaIcEEC2Ev; std::vector<char>::vector(void)
mov rdi, [rsp+28h+var_20]
add rdi, 50h ; 'P'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+28h+var_20]
lea rcx, dword_186F7E
mov [rax+70h], rcx
mov qword ptr [rax+78h], 0
mov qword ptr [rax+80h], 0
xorps xmm0, xmm0
movsd qword ptr [rax+88h], xmm0
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE17get_decimal_pointEv; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get_decimal_point(void)
mov cl, al
mov rax, [rsp+28h+var_20]
movsx ecx, cl
mov [rax+90h], ecx
add rsp, 28h
retn
| long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(
long long a1,
_QWORD *a2,
char a3)
{
char decimal_point; // cl
long long result; // rax
*(_QWORD *)a1 = *a2;
*(_QWORD *)(a1 + 8) = a2[1];
*(_BYTE *)(a1 + 16) = a3 & 1;
*(_DWORD *)(a1 + 20) = std::char_traits<char>::eof();
*(_BYTE *)(a1 + 24) = 0;
*(_QWORD *)(a1 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = 0LL;
memset(a1 + 56, 0LL, 24LL);
std::vector<char>::vector(a1 + 56);
std::string::basic_string(a1 + 80);
*(_QWORD *)(a1 + 112) = &dword_186F7E;
*(_QWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
decimal_point = nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get_decimal_point();
result = a1;
*(_DWORD *)(a1 + 144) = decimal_point;
return result;
}
| lexer:
SUB RSP,0x28
MOV AL,DL
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
AND AL,0x1
MOV byte ptr [RSP + 0x17],AL
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV CL,byte ptr [RSP + 0x17]
AND CL,0x1
MOV byte ptr [RAX + 0x10],CL
CALL 0x001d3350
MOV RDI,qword ptr [RSP + 0x8]
MOV dword ptr [RDI + 0x14],EAX
MOV byte ptr [RDI + 0x18],0x0
MOV qword ptr [RDI + 0x20],0x0
MOV qword ptr [RDI + 0x28],0x0
MOV qword ptr [RDI + 0x30],0x0
ADD RDI,0x38
MOV qword ptr [RSP],RDI
XOR ESI,ESI
MOV EDX,0x18
CALL 0x0010b390
MOV RDI,qword ptr [RSP]
CALL 0x001941f0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x50
CALL 0x0010ba90
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x286f7e]
MOV qword ptr [RAX + 0x70],RCX
MOV qword ptr [RAX + 0x78],0x0
MOV qword ptr [RAX + 0x80],0x0
XORPS XMM0,XMM0
MOVSD qword ptr [RAX + 0x88],XMM0
CALL 0x001d3360
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x8]
MOVSX ECX,CL
MOV dword ptr [RAX + 0x90],ECX
ADD RSP,0x28
RET
|
/* nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > >, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>
>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool) */
void __thiscall
nlohmann::json_abi_v3_11_2::detail::
lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
::lexer(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
*this,iterator_input_adapter *param_1,bool param_2)
{
char cVar1;
int4 uVar2;
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = *(int8 *)(param_1 + 8);
this[0x10] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)param_2;
uVar2 = std::char_traits<char>::eof();
*(int4 *)(this + 0x14) = uVar2;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
memset((vector<char,std::allocator<char>> *)(this + 0x38),0,0x18);
std::vector<char,std::allocator<char>>::vector((vector<char,std::allocator<char>> *)(this + 0x38))
;
std::__cxx11::string::string((string *)(this + 0x50));
*(int **)(this + 0x70) = &DAT_00286f7e;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
cVar1 = get_decimal_point();
*(int *)(this + 0x90) = (int)cVar1;
return;
}
| |
43,145 | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool) | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O1 | cpp | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x537b0(%rip), %rcx # 0xc4e2e
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0xac00
movq (%rax), %rax
testq %rax, %rax
je 0x7169f
movsbl (%rax), %eax
jmp 0x716a4
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEEC2EOSJ_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, unk_C4E2E
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_7169F
movsx eax, byte ptr [rax]
jmp short loc_716A4
loc_7169F:
mov eax, 2Eh ; '.'
loc_716A4:
mov [rbx+90h], eax
pop rbx
retn
| long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = &unk_C4E2E;
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv();
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
| |||
43,146 | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool) | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O2 | cpp | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
orl $-0x1, 0x14(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x52a46(%rip), %rax # 0xa0d3e
movq %rax, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
andq $0x0, 0x88(%rdi)
callq 0x4e344
movsbl %al, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEEC2EOSJ_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
or dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
and qword ptr [rdi+58h], 0
mov [rdi+60h], al
lea rax, unk_A0D3E
mov [rdi+70h], rax
movups xmmword ptr [rdi+78h], xmm0
and qword ptr [rdi+88h], 0
call _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEE17get_decimal_pointEv; nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<uchar>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get_decimal_point(void)
movsx eax, al
mov [rbx+90h], eax
pop rbx
retn
| long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = &unk_A0D3E;
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
result = (unsigned int)(char)nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get_decimal_point();
*(_DWORD *)(a1 + 144) = result;
return result;
}
| lexer:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV byte ptr [RDI + 0x10],DL
OR dword ptr [RDI + 0x14],0xffffffff
XOR EAX,EAX
MOV byte ptr [RDI + 0x18],AL
LEA RCX,[RDI + 0x60]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOV qword ptr [RDI + 0x50],RCX
AND qword ptr [RDI + 0x58],0x0
MOV byte ptr [RDI + 0x60],AL
LEA RAX,[0x1a0d3e]
MOV qword ptr [RDI + 0x70],RAX
MOVUPS xmmword ptr [RDI + 0x78],XMM0
AND qword ptr [RDI + 0x88],0x0
CALL 0x0014e344
MOVSX EAX,AL
MOV dword ptr [RBX + 0x90],EAX
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> > >, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>
>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool) */
void __thiscall
nlohmann::json_abi_v3_11_2::detail::
lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
::lexer(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
*this,iterator_input_adapter *param_1,bool param_2)
{
int8 uVar1;
char cVar2;
uVar1 = *(int8 *)(param_1 + 8);
*(int8 *)this = *(int8 *)param_1;
*(int8 *)(this + 8) = uVar1;
this[0x10] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)param_2;
*(int4 *)(this + 0x14) = 0xffffffff;
this[0x18] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)0x0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char_const*>>
)0x0;
*(int **)(this + 0x70) = &DAT_001a0d3e;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
cVar2 = get_decimal_point();
*(int *)(this + 0x90) = (int)cVar2;
return;
}
| |
43,147 | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool) | 7CodeWizard[P]stablediffusion/thirdparty/json.hpp | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | O3 | cpp | nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>&&, bool):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
movb %dl, 0x10(%rdi)
movl $0xffffffff, 0x14(%rdi) # imm = 0xFFFFFFFF
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movb %al, 0x60(%rdi)
leaq 0x53474(%rip), %rcx # 0xc3e3e
movq %rcx, 0x70(%rdi)
movups %xmm0, 0x78(%rdi)
movq %rax, 0x88(%rdi)
callq 0xabf0
movq (%rax), %rax
testq %rax, %rax
je 0x709eb
movsbl (%rax), %eax
jmp 0x709f0
movl $0x2e, %eax
movl %eax, 0x90(%rbx)
popq %rbx
retq
| _ZN8nlohmann16json_abi_v3_11_26detail5lexerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEEENS1_22iterator_input_adapterIPKcEEEC2EOSJ_b:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [rdi], xmm0
mov [rdi+10h], dl
mov dword ptr [rdi+14h], 0FFFFFFFFh
xor eax, eax
mov [rdi+18h], al
lea rcx, [rdi+60h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+40h], xmm0
mov [rdi+50h], rcx
mov [rdi+58h], rax
mov [rdi+60h], al
lea rcx, unk_C3E3E
mov [rdi+70h], rcx
movups xmmword ptr [rdi+78h], xmm0
mov [rdi+88h], rax
call _localeconv
mov rax, [rax]
test rax, rax
jz short loc_709EB
movsx eax, byte ptr [rax]
jmp short loc_709F0
loc_709EB:
mov eax, 2Eh ; '.'
loc_709F0:
mov [rbx+90h], eax
pop rbx
retn
| long long nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_2::adl_serializer,std::vector<unsigned char>>,nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::lexer(
long long a1,
_OWORD *a2,
char a3)
{
char *v3; // rax
long long result; // rax
*(_OWORD *)a1 = *a2;
*(_BYTE *)(a1 + 16) = a3;
*(_DWORD *)(a1 + 20) = -1;
*(_BYTE *)(a1 + 24) = 0;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
*(_QWORD *)(a1 + 112) = &unk_C3E3E;
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
v3 = *(char **)localeconv();
if ( v3 )
result = (unsigned int)*v3;
else
result = 46LL;
*(_DWORD *)(a1 + 144) = result;
return result;
}
| |||
43,148 | my_snprintf | eloqsql/strings/my_vsnprintf.c | size_t my_snprintf(char* to, size_t n, const char* fmt, ...)
{
size_t result;
va_list args;
va_start(args,fmt);
result= my_vsnprintf(to, n, fmt, args);
va_end(args);
return result;
} | O3 | c | my_snprintf:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdx, %r10
movq %rsi, %rdx
movq %rdi, %rsi
leaq -0xd0(%rbp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2714b
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %r8
movq %rdi, 0x10(%r8)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r8)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, (%r8)
leaq 0x2c8ea9(%rip), %rdi # 0x2f0018
movq %r10, %rcx
callq 0x25f18
addq $0xd0, %rsp
popq %rbp
retq
| my_snprintf:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov r10, rdx
mov rdx, rsi
mov rsi, rdi
lea rdi, [rbp+var_D0]
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test al, al
jz short loc_2714B
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_2714B:
lea r8, [rbp+var_20]
mov [r8+10h], rdi
lea rax, [rbp+arg_0]
mov [r8+8], rax
mov rax, 3000000018h
mov [r8], rax
lea rdi, my_charset_latin1
mov rcx, r10
call my_vsnprintf_ex
add rsp, 0D0h
pop rbp
retn
| unsigned long long my_snprintf(
unsigned long long a1,
long long a2,
unsigned __int8 *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+18h] [rbp-B8h]
long long v18; // [rsp+20h] [rbp-B0h]
long long v19; // [rsp+28h] [rbp-A8h]
__m128 v20; // [rsp+30h] [rbp-A0h]
__m128 v21; // [rsp+40h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-80h]
__m128 v23; // [rsp+60h] [rbp-70h]
__m128 v24; // [rsp+70h] [rbp-60h]
__m128 v25; // [rsp+80h] [rbp-50h]
__m128 v26; // [rsp+90h] [rbp-40h]
__m128 v27; // [rsp+A0h] [rbp-30h]
_QWORD v28[4]; // [rsp+B0h] [rbp-20h] BYREF
v20 = a7;
v21 = a8;
v22 = a9;
v23 = a10;
v24 = a11;
v25 = a12;
v26 = a13;
v27 = a14;
v17 = a4;
v18 = a5;
v19 = a6;
v28[2] = &v16;
v28[1] = &a15;
v28[0] = 0x3000000018LL;
return my_vsnprintf_ex((long long)&my_charset_latin1, a1, a2, a3, (unsigned int *)v28);
}
| my_snprintf:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV R10,RDX
MOV RDX,RSI
MOV RSI,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST AL,AL
JZ 0x0012714b
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0012714b:
LEA R8,[RBP + -0x20]
MOV qword ptr [R8 + 0x10],RDI
LEA RAX,[RBP + 0x10]
MOV qword ptr [R8 + 0x8],RAX
MOV RAX,0x3000000018
MOV qword ptr [R8],RAX
LEA RDI,[0x3f0018]
MOV RCX,R10
CALL 0x00125f18
ADD RSP,0xd0
POP RBP
RET
|
void my_snprintf(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;
int1 local_d8 [24];
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;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000018;
local_c0 = param_12;
local_b8 = param_13;
local_b0 = param_14;
my_vsnprintf_ex(&my_charset_latin1,param_9,param_10,param_11);
return;
}
| |
43,149 | mi_writeinfo | eloqsql/storage/myisam/mi_locking.c | int _mi_writeinfo(register MI_INFO *info, uint operation)
{
int error,olderror;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("_mi_writeinfo");
DBUG_PRINT("info",("operation: %u tot_locks: %u", operation,
share->tot_locks));
error=0;
if (share->tot_locks == 0)
{
olderror=my_errno; /* Remember last error */
if (operation)
{ /* Two threads can't be here */
share->state.process= share->last_process= share->this_process;
share->state.unique= info->last_unique= info->this_unique;
share->state.update_count= info->last_loop= ++info->this_loop;
if ((error=mi_state_info_write(share->kfile, &share->state, 1)))
olderror=my_errno;
#ifdef _WIN32
if (myisam_flush)
{
if (share->file_map)
my_msync(info->dfile, share->file_map, share->mmaped_length, MS_SYNC);
mysql_file_sync(share->kfile, 0);
mysql_file_sync(info->dfile, 0);
}
#endif
}
if (!(operation & WRITEINFO_NO_UNLOCK) &&
my_lock(share->kfile,F_UNLCK,0L,F_TO_EOF,
MYF(MY_WME | MY_SEEK_NOT_DONE)) && !error)
DBUG_RETURN(1);
my_errno=olderror;
}
else if (operation)
share->changed= 1; /* Mark keyfile changed */
DBUG_RETURN(error);
} | O0 | c | mi_writeinfo:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdb6bc
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x368(%rax)
jne 0xdb7cd
callq 0x1295d0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xdb779
movq -0x28(%rbp), %rax
movq 0x300(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x308(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x160(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x28(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x28(%rbp), %rax
movl 0x350(%rax), %edi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0xe1550
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0xdb777
callq 0x1295d0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0xdb779
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xdb7bb
movq -0x28(%rbp), %rax
movl 0x350(%rax), %edi
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
movl $0x30, %r8d
movq %rcx, %rdx
callq 0x126410
cmpl $0x0, %eax
je 0xdb7bb
cmpl $0x0, -0x18(%rbp)
jne 0xdb7bb
jmp 0xdb7b2
movl $0x1, -0x4(%rbp)
jmp 0xdb7e8
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x1295d0
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0xdb7e0
cmpl $0x0, -0x14(%rbp)
je 0xdb7de
movq -0x28(%rbp), %rax
movb $0x1, 0x37f(%rax)
jmp 0xdb7e0
jmp 0xdb7e2
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _mi_writeinfo:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_DB6BC:
mov [rbp+var_18], 0
mov rax, [rbp+var_28]
cmp dword ptr [rax+368h], 0
jnz loc_DB7CD
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
cmp [rbp+var_14], 0
jz loc_DB779
mov rax, [rbp+var_28]
mov rcx, [rax+300h]
mov rax, [rbp+var_28]
mov [rax+308h], rcx
mov rax, [rbp+var_28]
mov [rax+68h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+150h]
mov rax, [rbp+var_10]
mov [rax+158h], rcx
mov rax, [rbp+var_28]
mov [rax+70h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+160h]
add rcx, 1
mov [rax+160h], rcx
mov rax, [rbp+var_10]
mov [rax+168h], rcx
mov rax, [rbp+var_28]
mov [rax+78h], rcx
mov rax, [rbp+var_28]
mov edi, [rax+350h]
mov rsi, [rbp+var_28]
mov edx, 1
call mi_state_info_write
mov [rbp+var_18], eax
cmp eax, 0
jz short loc_DB777
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
loc_DB777:
jmp short $+2
loc_DB779:
mov eax, [rbp+var_14]
and eax, 2
cmp eax, 0
jnz short loc_DB7BB
mov rax, [rbp+var_28]
mov edi, [rax+350h]
mov esi, 2
xor eax, eax
mov ecx, eax
mov r8d, 30h ; '0'
mov rdx, rcx
call my_lock
cmp eax, 0
jz short loc_DB7BB
cmp [rbp+var_18], 0
jnz short loc_DB7BB
jmp short $+2
loc_DB7B2:
mov [rbp+var_4], 1
jmp short loc_DB7E8
loc_DB7BB:
mov eax, [rbp+var_1C]
mov [rbp+var_2C], eax
call _my_thread_var
mov ecx, [rbp+var_2C]
mov [rax], ecx
jmp short loc_DB7E0
loc_DB7CD:
cmp [rbp+var_14], 0
jz short loc_DB7DE
mov rax, [rbp+var_28]
mov byte ptr [rax+37Fh], 1
loc_DB7DE:
jmp short $+2
loc_DB7E0:
jmp short $+2
loc_DB7E2:
mov eax, [rbp+var_18]
mov [rbp+var_4], eax
loc_DB7E8:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mi_writeinfo(_QWORD *a1, const char *a2)
{
long long v2; // rcx
long long v3; // rcx
long long v4; // rcx
long long v6; // [rsp+8h] [rbp-28h]
int v7; // [rsp+14h] [rbp-1Ch]
unsigned int v8; // [rsp+18h] [rbp-18h]
char v9; // [rsp+1Ch] [rbp-14h]
v9 = (char)a2;
v6 = *a1;
v8 = 0;
if ( *(_DWORD *)(*a1 + 872LL) )
{
if ( (_DWORD)a2 )
*(_BYTE *)(v6 + 895) = 1;
return v8;
}
v7 = *(_DWORD *)my_thread_var(a1, a2);
if ( (_DWORD)a2 )
{
v2 = *(_QWORD *)(v6 + 768);
*(_QWORD *)(v6 + 776) = v2;
*(_QWORD *)(v6 + 104) = v2;
v3 = a1[42];
a1[43] = v3;
*(_QWORD *)(v6 + 112) = v3;
v4 = a1[44] + 1LL;
a1[44] = v4;
a1[45] = v4;
*(_QWORD *)(v6 + 120) = v4;
a1 = (_QWORD *)*(unsigned int *)(v6 + 848);
a2 = (const char *)v6;
v8 = mi_state_info_write(a1, v6, 1LL);
if ( v8 )
v7 = *(_DWORD *)my_thread_var(a1, (const char *)v6);
}
if ( (v9 & 2) != 0
|| (a1 = (_QWORD *)*(unsigned int *)(v6 + 848),
a2 = (_BYTE *)(&dword_0 + 2),
!(unsigned int)my_lock(a1, 2LL, 0LL, 0LL, 48LL))
|| v8 )
{
*(_DWORD *)my_thread_var(a1, a2) = v7;
return v8;
}
return 1;
}
| _mi_writeinfo:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001db6bc
LAB_001db6bc:
MOV dword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x001db7cd
CALL 0x002295d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x001db779
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x300]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x308],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x68],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x150]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x158],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x70],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x160]
ADD RCX,0x1
MOV qword ptr [RAX + 0x160],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x168],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x78],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDI,dword ptr [RAX + 0x350]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,0x1
CALL 0x001e1550
MOV dword ptr [RBP + -0x18],EAX
CMP EAX,0x0
JZ 0x001db777
CALL 0x002295d0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
LAB_001db777:
JMP 0x001db779
LAB_001db779:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x2
CMP EAX,0x0
JNZ 0x001db7bb
MOV RAX,qword ptr [RBP + -0x28]
MOV EDI,dword ptr [RAX + 0x350]
MOV ESI,0x2
XOR EAX,EAX
MOV ECX,EAX
MOV R8D,0x30
MOV RDX,RCX
CALL 0x00226410
CMP EAX,0x0
JZ 0x001db7bb
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001db7bb
JMP 0x001db7b2
LAB_001db7b2:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001db7e8
LAB_001db7bb:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x2c],EAX
CALL 0x002295d0
MOV ECX,dword ptr [RBP + -0x2c]
MOV dword ptr [RAX],ECX
JMP 0x001db7e0
LAB_001db7cd:
CMP dword ptr [RBP + -0x14],0x0
JZ 0x001db7de
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x37f],0x1
LAB_001db7de:
JMP 0x001db7e0
LAB_001db7e0:
JMP 0x001db7e2
LAB_001db7e2:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
LAB_001db7e8:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int _mi_writeinfo(long *param_1,uint param_2)
{
long lVar1;
int iVar2;
int4 *puVar3;
long lVar4;
int4 local_24;
int local_20;
lVar1 = *param_1;
local_20 = 0;
if (*(int *)(lVar1 + 0x368) == 0) {
puVar3 = (int4 *)_my_thread_var();
local_24 = *puVar3;
if (param_2 != 0) {
*(int8 *)(lVar1 + 0x308) = *(int8 *)(lVar1 + 0x300);
*(int8 *)(lVar1 + 0x68) = *(int8 *)(lVar1 + 0x300);
param_1[0x2b] = param_1[0x2a];
*(long *)(lVar1 + 0x70) = param_1[0x2a];
lVar4 = param_1[0x2c] + 1;
param_1[0x2c] = lVar4;
param_1[0x2d] = lVar4;
*(long *)(lVar1 + 0x78) = lVar4;
local_20 = mi_state_info_write(*(int4 *)(lVar1 + 0x350),lVar1,1);
if (local_20 != 0) {
puVar3 = (int4 *)_my_thread_var();
local_24 = *puVar3;
}
}
if ((((param_2 & 2) == 0) &&
(iVar2 = my_lock(*(int4 *)(lVar1 + 0x350),2,0,0,0x30), iVar2 != 0)) && (local_20 == 0)
) {
return 1;
}
puVar3 = (int4 *)_my_thread_var();
*puVar3 = local_24;
}
else if (param_2 != 0) {
*(int1 *)(lVar1 + 0x37f) = 1;
}
return local_20;
}
| |
43,150 | my_strnxfrm_unicode_full_bin | eloqsql/strings/ctype-utf8.c | size_t
my_strnxfrm_unicode_full_bin(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
uchar *dst0= dst;
uchar *de= dst + dstlen;
dst+= my_strnxfrm_unicode_full_bin_internal(cs, dst, de, &nweights,
src, src + srclen);
DBUG_ASSERT(dst <= de); /* Safety */
if (flags & MY_STRXFRM_PAD_WITH_SPACE)
{
for ( ; dst < de && nweights; nweights--)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
my_strxfrm_desc_and_reverse(dst0, dst, flags, 0);
if (flags & MY_STRXFRM_PAD_TO_MAXLEN)
{
while (dst < de)
{
*dst++= 0x00;
if (dst < de)
{
*dst++= 0x00;
if (dst < de)
*dst++= 0x20;
}
}
}
return dst - dst0;
} | O3 | c | my_strnxfrm_unicode_full_bin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movl 0x10(%rbp), %r15d
leaq -0x24(%rbp), %rax
movl %ecx, (%rax)
leaq (%rsi,%rdx), %r14
addq %r8, %r9
movq %r14, %rdx
movq %rax, %rcx
callq 0xce487
leaq (%rbx,%rax), %rcx
testb $0x40, %r15b
jne 0xce5d0
movq %rcx, %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0xb942e
testb %r15b, %r15b
setns %al
cmpq %r14, %r12
setae %cl
orb %al, %cl
jne 0xce61c
leaq 0x1(%r12), %rax
movb $0x0, (%r12)
cmpq %r14, %rax
jae 0xce5c6
leaq 0x2(%r12), %rax
movb $0x0, 0x1(%r12)
cmpq %r14, %rax
jae 0xce5c6
movb $0x20, 0x2(%r12)
addq $0x3, %r12
movq %r12, %rax
movq %rax, %r12
cmpq %r14, %rax
jb 0xce59a
jmp 0xce61f
cmpq %r12, %rax
jge 0xce573
cmpl $0x0, -0x24(%rbp)
je 0xce573
leaq 0x1(%rcx), %r12
movb $0x0, (%rcx)
cmpq %r14, %r12
jae 0xce5ff
leaq 0x2(%rcx), %r12
movb $0x0, 0x1(%rcx)
cmpq %r14, %r12
jae 0xce5ff
movb $0x20, 0x2(%rcx)
addq $0x3, %rcx
movq %rcx, %r12
movl -0x24(%rbp), %eax
decl %eax
movl %eax, -0x24(%rbp)
cmpq %r14, %r12
jae 0xce576
movq %r12, %rcx
testl %eax, %eax
jne 0xce5db
jmp 0xce576
movq %r12, %rax
subq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_strnxfrm_unicode_full_bin:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov rbx, rsi
mov r15d, [rbp+arg_0]
lea rax, [rbp+var_24]
mov [rax], ecx
lea r14, [rsi+rdx]
add r9, r8
mov rdx, r14
mov rcx, rax
call my_strnxfrm_unicode_full_bin_internal
lea rcx, [rbx+rax]
test r15b, 40h
jnz short loc_CE5D0
loc_CE573:
mov r12, rcx
loc_CE576:
mov rdi, rbx
mov rsi, r12
mov edx, r15d
xor ecx, ecx
call my_strxfrm_desc_and_reverse
test r15b, r15b
setns al
cmp r12, r14
setnb cl
or cl, al
jnz loc_CE61C
loc_CE59A:
lea rax, [r12+1]
mov byte ptr [r12], 0
cmp rax, r14
jnb short loc_CE5C6
lea rax, [r12+2]
mov byte ptr [r12+1], 0
cmp rax, r14
jnb short loc_CE5C6
mov byte ptr [r12+2], 20h ; ' '
add r12, 3
mov rax, r12
loc_CE5C6:
mov r12, rax
cmp rax, r14
jb short loc_CE59A
jmp short loc_CE61F
loc_CE5D0:
cmp rax, r12
jge short loc_CE573
cmp [rbp+var_24], 0
jz short loc_CE573
loc_CE5DB:
lea r12, [rcx+1]
mov byte ptr [rcx], 0
cmp r12, r14
jnb short loc_CE5FF
lea r12, [rcx+2]
mov byte ptr [rcx+1], 0
cmp r12, r14
jnb short loc_CE5FF
mov byte ptr [rcx+2], 20h ; ' '
add rcx, 3
mov r12, rcx
loc_CE5FF:
mov eax, [rbp+var_24]
dec eax
mov [rbp+var_24], eax
cmp r12, r14
jnb loc_CE576
mov rcx, r12
test eax, eax
jnz short loc_CE5DB
jmp loc_CE576
loc_CE61C:
mov rax, r12
loc_CE61F:
sub rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_strnxfrm_unicode_full_bin(
long long a1,
_BYTE *a2,
long long a3,
int a4,
long long a5,
long long a6,
unsigned int a7)
{
unsigned long long v8; // r14
long long v9; // rax
_BYTE *v10; // rcx
_BYTE *v11; // r12
_BYTE *v12; // rax
int v13; // eax
int v15[9]; // [rsp+Ch] [rbp-24h] BYREF
v15[0] = a4;
v8 = (unsigned long long)&a2[a3];
v9 = my_strnxfrm_unicode_full_bin_internal(a1, a2, (unsigned long long)&a2[a3], v15, a5, a5 + a6);
v10 = &a2[v9];
if ( (a7 & 0x40) != 0 && v9 < a3 && v15[0] )
{
do
{
v11 = v10 + 1;
*v10 = 0;
if ( (unsigned long long)(v10 + 1) < v8 )
{
v11 = v10 + 2;
v10[1] = 0;
if ( (unsigned long long)(v10 + 2) < v8 )
{
v10[2] = 32;
v11 = v10 + 3;
}
}
v13 = --v15[0];
if ( (unsigned long long)v11 >= v8 )
break;
v10 = v11;
}
while ( v13 );
}
else
{
v11 = &a2[v9];
}
my_strxfrm_desc_and_reverse(a2, v11, a7, 0);
if ( (a7 & 0x80u) == 0 || (unsigned long long)v11 >= v8 )
{
v12 = v11;
}
else
{
do
{
v12 = v11 + 1;
*v11 = 0;
if ( (unsigned long long)(v11 + 1) < v8 )
{
v12 = v11 + 2;
v11[1] = 0;
if ( (unsigned long long)(v11 + 2) < v8 )
{
v11[2] = 32;
v12 = v11 + 3;
}
}
v11 = v12;
}
while ( (unsigned long long)v12 < v8 );
}
return v12 - a2;
}
| my_strnxfrm_unicode_full_bin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV RBX,RSI
MOV R15D,dword ptr [RBP + 0x10]
LEA RAX,[RBP + -0x24]
MOV dword ptr [RAX],ECX
LEA R14,[RSI + RDX*0x1]
ADD R9,R8
MOV RDX,R14
MOV RCX,RAX
CALL 0x001ce487
LEA RCX,[RBX + RAX*0x1]
TEST R15B,0x40
JNZ 0x001ce5d0
LAB_001ce573:
MOV R12,RCX
LAB_001ce576:
MOV RDI,RBX
MOV RSI,R12
MOV EDX,R15D
XOR ECX,ECX
CALL 0x001b942e
TEST R15B,R15B
SETNS AL
CMP R12,R14
SETNC CL
OR CL,AL
JNZ 0x001ce61c
LAB_001ce59a:
LEA RAX,[R12 + 0x1]
MOV byte ptr [R12],0x0
CMP RAX,R14
JNC 0x001ce5c6
LEA RAX,[R12 + 0x2]
MOV byte ptr [R12 + 0x1],0x0
CMP RAX,R14
JNC 0x001ce5c6
MOV byte ptr [R12 + 0x2],0x20
ADD R12,0x3
MOV RAX,R12
LAB_001ce5c6:
MOV R12,RAX
CMP RAX,R14
JC 0x001ce59a
JMP 0x001ce61f
LAB_001ce5d0:
CMP RAX,R12
JGE 0x001ce573
CMP dword ptr [RBP + -0x24],0x0
JZ 0x001ce573
LAB_001ce5db:
LEA R12,[RCX + 0x1]
MOV byte ptr [RCX],0x0
CMP R12,R14
JNC 0x001ce5ff
LEA R12,[RCX + 0x2]
MOV byte ptr [RCX + 0x1],0x0
CMP R12,R14
JNC 0x001ce5ff
MOV byte ptr [RCX + 0x2],0x20
ADD RCX,0x3
MOV R12,RCX
LAB_001ce5ff:
MOV EAX,dword ptr [RBP + -0x24]
DEC EAX
MOV dword ptr [RBP + -0x24],EAX
CMP R12,R14
JNC 0x001ce576
MOV RCX,R12
TEST EAX,EAX
JNZ 0x001ce5db
JMP 0x001ce576
LAB_001ce61c:
MOV RAX,R12
LAB_001ce61f:
SUB RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long my_strnxfrm_unicode_full_bin
(int8 param_1,long param_2,long param_3,int param_4,long param_5,long param_6,
uint param_7)
{
int1 *puVar1;
long lVar2;
int1 *puVar3;
int1 *puVar4;
int local_2c;
puVar1 = (int1 *)(param_2 + param_3);
local_2c = param_4;
lVar2 = my_strnxfrm_unicode_full_bin_internal
(param_1,param_2,puVar1,&local_2c,param_5,param_6 + param_5);
puVar4 = (int1 *)(param_2 + lVar2);
if (((param_7 & 0x40) != 0) && (lVar2 < param_3)) {
do {
if (local_2c == 0) break;
puVar3 = puVar4 + 1;
*puVar4 = 0;
if (puVar3 < puVar1) {
puVar3 = puVar4 + 2;
puVar4[1] = 0;
if (puVar3 < puVar1) {
puVar4[2] = 0x20;
puVar3 = puVar4 + 3;
}
}
local_2c = local_2c + -1;
puVar4 = puVar3;
} while (puVar3 < puVar1);
}
my_strxfrm_desc_and_reverse(param_2,puVar4,param_7,0);
puVar3 = puVar4;
if (puVar4 < puVar1 && (char)param_7 < '\0') {
do {
puVar4 = puVar3 + 1;
*puVar3 = 0;
if (puVar4 < puVar1) {
puVar4 = puVar3 + 2;
puVar3[1] = 0;
if (puVar4 < puVar1) {
puVar3[2] = 0x20;
puVar4 = puVar3 + 3;
}
}
puVar3 = puVar4;
} while (puVar4 < puVar1);
}
return (long)puVar4 - param_2;
}
| |
43,151 | my_caseup_utf32 | eloqsql/strings/ctype-ucs2.c | static size_t
my_caseup_utf32(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
{
my_toupper_utf32(uni_plane, &wc);
if (res != my_uni_utf32(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_caseup_utf32:
movq %rdx, %rax
cmpq $0x4, %rdx
jl 0x2a9bd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x4, %rcx
movzbl (%rsi), %r9d
shll $0x18, %r9d
movzbl 0x1(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
cmpl $0x10ffff, %r10d # imm = 0x10FFFF
ja 0x2a9bb
movzbl 0x2(%rsi), %ebx
shll $0x8, %ebx
movzbl 0x3(%rsi), %r9d
orq %r9, %rbx
orq %r10, %rbx
cmpq (%rdi), %rbx
ja 0x2a97c
movq 0x8(%rdi), %r10
movl %ebx, %r11d
shrl $0x8, %r11d
movq (%r10,%r11,8), %r10
testq %r10, %r10
je 0x2a97c
leaq (%r9,%r9,2), %r9
movl (%r10,%r9,4), %ebx
cmpq %r8, %rcx
ja 0x2a9bb
cmpl $0x10ffff, %ebx # imm = 0x10FFFF
ja 0x2a9bb
movb $0x0, -0x4(%rcx)
movl %ebx, %r9d
shrl $0x10, %r9d
movb %r9b, -0x3(%rcx)
movb %bh, -0x2(%rcx)
movb %bl, -0x1(%rcx)
leaq 0x4(%rsi), %r9
cmpq %rdx, %r9
jae 0x2a9bb
addq $0x8, %rsi
addq $0x4, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0x2a92c
popq %rbx
popq %rbp
retq
| my_caseup_utf32:
mov rax, rdx
cmp rdx, 4
jl locret_2A9BD
push rbp
mov rbp, rsp
push rbx
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 4
loc_2A92C:
movzx r9d, byte ptr [rsi]
shl r9d, 18h
movzx r10d, byte ptr [rsi+1]
shl r10d, 10h
or r10d, r9d
cmp r10d, offset unk_10FFFF
ja short loc_2A9BB
movzx ebx, byte ptr [rsi+2]
shl ebx, 8
movzx r9d, byte ptr [rsi+3]
or rbx, r9
or rbx, r10
cmp rbx, [rdi]
ja short loc_2A97C
mov r10, [rdi+8]
mov r11d, ebx
shr r11d, 8
mov r10, [r10+r11*8]
test r10, r10
jz short loc_2A97C
lea r9, [r9+r9*2]
mov ebx, [r10+r9*4]
loc_2A97C:
cmp rcx, r8
ja short loc_2A9BB
cmp ebx, offset unk_10FFFF
ja short loc_2A9BB
mov byte ptr [rcx-4], 0
mov r9d, ebx
shr r9d, 10h
mov [rcx-3], r9b
mov [rcx-2], bh
mov [rcx-1], bl
lea r9, [rsi+4]
cmp r9, rdx
jnb short loc_2A9BB
add rsi, 8
add rcx, 4
cmp rsi, rdx
mov rsi, r9
jbe loc_2A92C
loc_2A9BB:
pop rbx
pop rbp
locret_2A9BD:
retn
| long long my_caseup_utf32(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
unsigned long long *v8; // rdi
unsigned long long v9; // rcx
long long v10; // r10
long long v11; // r9
unsigned long long v12; // rbx
long long v13; // r10
bool v14; // cc
result = a3;
if ( a3 >= 4 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(unsigned long long **)(a1 + 120);
v9 = a4 + 4;
do
{
v10 = (*a2 << 24) | (a2[1] << 16);
if ( (unsigned int)v10 > (unsigned int)&unk_10FFFF )
break;
v11 = a2[3];
v12 = v10 | v11 | (a2[2] << 8);
if ( v12 <= *v8 )
{
v13 = *(_QWORD *)(v8[1] + 8LL * ((unsigned int)v12 >> 8));
if ( v13 )
LODWORD(v12) = *(_DWORD *)(v13 + 12 * v11);
}
if ( v9 > v7 )
break;
if ( (unsigned int)v12 > (unsigned int)&unk_10FFFF )
break;
*(_BYTE *)(v9 - 4) = 0;
*(_BYTE *)(v9 - 3) = BYTE2(v12);
*(_BYTE *)(v9 - 2) = BYTE1(v12);
*(_BYTE *)(v9 - 1) = v12;
if ( (unsigned long long)(a2 + 4) >= v6 )
break;
v9 += 4LL;
v14 = (unsigned long long)(a2 + 8) <= v6;
a2 += 4;
}
while ( v14 );
}
return result;
}
| my_caseup_utf32:
MOV RAX,RDX
CMP RDX,0x4
JL 0x0012a9bd
PUSH RBP
MOV RBP,RSP
PUSH RBX
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x4
LAB_0012a92c:
MOVZX R9D,byte ptr [RSI]
SHL R9D,0x18
MOVZX R10D,byte ptr [RSI + 0x1]
SHL R10D,0x10
OR R10D,R9D
CMP R10D,0x10ffff
JA 0x0012a9bb
MOVZX EBX,byte ptr [RSI + 0x2]
SHL EBX,0x8
MOVZX R9D,byte ptr [RSI + 0x3]
OR RBX,R9
OR RBX,R10
CMP RBX,qword ptr [RDI]
JA 0x0012a97c
MOV R10,qword ptr [RDI + 0x8]
MOV R11D,EBX
SHR R11D,0x8
MOV R10,qword ptr [R10 + R11*0x8]
TEST R10,R10
JZ 0x0012a97c
LEA R9,[R9 + R9*0x2]
MOV EBX,dword ptr [R10 + R9*0x4]
LAB_0012a97c:
CMP RCX,R8
JA 0x0012a9bb
CMP EBX,0x10ffff
JA 0x0012a9bb
MOV byte ptr [RCX + -0x4],0x0
MOV R9D,EBX
SHR R9D,0x10
MOV byte ptr [RCX + -0x3],R9B
MOV byte ptr [RCX + -0x2],BH
MOV byte ptr [RCX + -0x1],BL
LEA R9,[RSI + 0x4]
CMP R9,RDX
JNC 0x0012a9bb
ADD RSI,0x8
ADD RCX,0x4
CMP RSI,RDX
MOV RSI,R9
JBE 0x0012a92c
LAB_0012a9bb:
POP RBX
POP RBP
LAB_0012a9bd:
RET
|
void my_caseup_utf32(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
ulong *puVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
byte *pbVar5;
byte *pbVar6;
uint uVar7;
if (3 < param_3) {
puVar1 = *(ulong **)(param_1 + 0x78);
uVar3 = param_4 + 4;
pbVar5 = param_2;
while (uVar7 = (uint)pbVar5[1] << 0x10 | (uint)*pbVar5 << 0x18, uVar7 < 0x110000) {
uVar4 = (ulong)CONCAT11(pbVar5[2],pbVar5[3]) | (ulong)uVar7;
if ((uVar4 <= *puVar1) && (lVar2 = *(long *)(puVar1[1] + (uVar4 >> 8) * 8), lVar2 != 0)) {
uVar4 = (ulong)*(uint *)(lVar2 + (ulong)pbVar5[3] * 0xc);
}
if ((ulong)(param_5 + param_4) < uVar3) {
return;
}
if (0x10ffff < (uint)uVar4) {
return;
}
*(int1 *)(uVar3 - 4) = 0;
*(char *)(uVar3 - 3) = (char)(uVar4 >> 0x10);
*(char *)(uVar3 - 2) = (char)(uVar4 >> 8);
*(char *)(uVar3 - 1) = (char)uVar4;
if (param_2 + param_3 <= pbVar5 + 4) {
return;
}
pbVar6 = pbVar5 + 8;
uVar3 = uVar3 + 4;
pbVar5 = pbVar5 + 4;
if (param_2 + param_3 < pbVar6) {
return;
}
}
}
return;
}
| |
43,152 | void ggml::cpu::aarch64::gemm<block_q4_0, 4l, 4l, (ggml_type)8>(int, float*, unsigned long, void const*, void const*, int, int) | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu-aarch64.cpp | void gemm<block_q4_0, 4, 4, GGML_TYPE_Q8_0>(int n, float * s, size_t bs, const void * vx, const void * vy, int nr, int nc) {
ggml_gemm_q4_0_4x4_q8_0(n, s, bs, vx, vy, nr, nc);
} | O3 | cpp | void ggml::cpu::aarch64::gemm<block_q4_0, 4l, 4l, (ggml_type)8>(int, float*, unsigned long, void const*, void const*, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x38(%rsp)
movq %rcx, -0x70(%rsp)
movq %rsi, -0x68(%rsp)
movq %rdi, -0x60(%rsp)
movq %r9, -0x80(%rsp)
cmpl $0x4, %r9d
jl 0x14653
movl 0x80(%rsp), %ecx
movq -0x60(%rsp), %rax
leal 0x1f(%rax), %esi
testl %eax, %eax
cmovnsl %eax, %esi
sarl $0x5, %esi
movq -0x80(%rsp), %rax
shrl $0x2, %eax
movq %rax, -0x80(%rsp)
leal 0x3(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
sarl $0x2, %eax
movq %rax, -0x20(%rsp)
movq %rdx, %rax
shlq $0x4, %rax
movq %rax, -0x30(%rsp)
shlq $0x2, %rdx
movq %rsi, -0x8(%rsp)
movslq %esi, %rcx
movq -0x70(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rsp)
movq %rcx, -0x40(%rsp)
leaq (,%rcx,8), %rax
leaq (%rax,%rax,8), %rax
movq %rax, -0x28(%rsp)
movq $0x0, -0x78(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq %rsp, %rdi
movq 0x46ac6(%rip), %rax # 0x5af60
vpbroadcastb 0x34b29(%rip), %xmm1 # 0x48fcc
movl 0x80(%rsp), %ecx
cmpl $0x4, %ecx
jl 0x14631
movq -0x78(%rsp), %rcx
imulq -0x40(%rsp), %rcx
movq %rcx, %rsi
shlq $0x7, %rsi
leaq (%rsi,%rcx,8), %r8
addq -0x38(%rsp), %r8
movq -0x68(%rsp), %r9
movq -0x70(%rsp), %rcx
movq %rcx, -0x50(%rsp)
movq -0x48(%rsp), %rcx
movq %rcx, -0x58(%rsp)
xorl %esi, %esi
movq %rsi, -0x18(%rsp)
movq %r9, -0x10(%rsp)
vmovups %ymm0, 0x20(%rsp)
vmovups %ymm0, (%rsp)
cmpl $0x20, -0x60(%rsp)
jl 0x145eb
movq -0x50(%rsp), %rcx
movq -0x58(%rsp), %r15
xorl %r13d, %r13d
movq %r13, %rsi
shlq $0x7, %rsi
leaq (%rsi,%r13,8), %r11
addq %r8, %r11
movq %r15, %r14
xorl %r9d, %r9d
movq %r9, %r12
shlq $0x4, %r12
movq %rdi, %rbp
xorl %esi, %esi
movzwl (%r11,%rsi,2), %ebx
vmovss (%rax,%rbx,4), %xmm2
leaq (%r12,%rsi,4), %rbx
vpmovsxbd 0x48(%r11,%rbx), %xmm3
vpmovsxbd 0x8(%r11,%rbx), %xmm4
xorl %ebx, %ebx
vmovd (%r14,%rbx,4), %xmm5
vpand %xmm1, %xmm5, %xmm6
vpmovsxbd %xmm6, %xmm6
vpmulld %xmm6, %xmm3, %xmm6
vpsllw $0x4, %xmm5, %xmm5
vpand %xmm1, %xmm5, %xmm5
vpmovsxbd %xmm5, %xmm5
vpmulld %xmm4, %xmm5, %xmm5
vpaddd %xmm5, %xmm6, %xmm5
vpsrad $0x4, %xmm5, %xmm5
vphaddd %xmm5, %xmm5, %xmm5
vphaddd %xmm5, %xmm5, %xmm5
vcvtdq2ps %xmm5, %xmm5
movzwl (%rcx,%rbx,2), %r10d
vmulss (%rax,%r10,4), %xmm5, %xmm5
vfmadd213ss (%rbp,%rbx,4), %xmm2, %xmm5 # xmm5 = (xmm2 * xmm5) + mem
vmovss %xmm5, (%rbp,%rbx,4)
incq %rbx
cmpq $0x4, %rbx
jne 0x14554
incq %rsi
addq $0x10, %rbp
cmpq $0x4, %rsi
jne 0x14536
incq %r9
addq $0x10, %r14
cmpq $0x4, %r9
jne 0x1452a
incq %r13
addq $0x48, %r15
addq $0x48, %rcx
cmpq -0x8(%rsp), %r13
jne 0x14516
movq -0x10(%rsp), %r9
movq %r9, %rcx
xorl %esi, %esi
vmovups (%rsp,%rsi), %xmm2
vmovups %xmm2, (%rcx)
addq $0x10, %rsi
addq %rdx, %rcx
cmpq $0x40, %rsi
jne 0x145f5
movq -0x18(%rsp), %rsi
incq %rsi
movq -0x28(%rsp), %rcx
addq %rcx, -0x58(%rsp)
addq %rcx, -0x50(%rsp)
addq $0x10, %r9
cmpq -0x20(%rsp), %rsi
jne 0x144e9
movq -0x78(%rsp), %rsi
incq %rsi
movq -0x30(%rsp), %rcx
addq %rcx, -0x68(%rsp)
movq %rsi, -0x78(%rsp)
cmpq -0x80(%rsp), %rsi
jne 0x144a3
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
| _ZN4ggml3cpu7aarch644gemmI10block_q4_0Ll4ELl4EL9ggml_type8EEEviPfmPKvS7_ii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov [rsp+78h+var_B0], r8
mov [rsp+78h+var_E8], rcx
mov [rsp+78h+var_E0], rsi
mov [rsp+78h+var_D8], rdi
mov [rsp+78h+var_F8], r9
cmp r9d, 4
jl loc_14653
mov ecx, [rsp+78h+arg_0]
mov rax, [rsp+78h+var_D8]
lea esi, [rax+1Fh]
test eax, eax
cmovns esi, eax
sar esi, 5
mov rax, [rsp+78h+var_F8]
shr eax, 2
mov [rsp+78h+var_F8], rax
lea eax, [rcx+3]
test ecx, ecx
cmovns eax, ecx
sar eax, 2
mov [rsp+78h+var_98], rax
mov rax, rdx
shl rax, 4
mov [rsp+78h+var_A8], rax
shl rdx, 2
mov [rsp+78h+var_80], rsi
movsxd rcx, esi
mov rax, [rsp+78h+var_E8]
add rax, 8
mov [rsp+78h+var_C0], rax
mov [rsp+78h+var_B8], rcx
lea rax, ds:0[rcx*8]
lea rax, [rax+rax*8]
mov [rsp+78h+var_A0], rax
mov [rsp+78h+var_F0], 0
vxorps xmm0, xmm0, xmm0
mov rdi, rsp
mov rax, cs:ggml_table_f32_f16_ptr
vpbroadcastb xmm1, cs:byte_48FCC
loc_144A3:
mov ecx, [rsp+78h+arg_0]
cmp ecx, 4
jl loc_14631
mov rcx, [rsp+78h+var_F0]
imul rcx, [rsp+78h+var_B8]
mov rsi, rcx
shl rsi, 7
lea r8, [rsi+rcx*8]
add r8, [rsp+78h+var_B0]
mov r9, [rsp+78h+var_E0]
mov rcx, [rsp+78h+var_E8]
mov [rsp+78h+var_C8], rcx
mov rcx, [rsp+78h+var_C0]
mov [rsp+78h+var_D0], rcx
xor esi, esi
loc_144E9:
mov [rsp+78h+var_90], rsi
mov [rsp+78h+var_88], r9
vmovups [rsp+78h+var_58], ymm0
vmovups [rsp+78h+var_78], ymm0
cmp dword ptr [rsp+78h+var_D8], 20h ; ' '
jl loc_145EB
mov rcx, [rsp+78h+var_C8]
mov r15, [rsp+78h+var_D0]
xor r13d, r13d
loc_14516:
mov rsi, r13
shl rsi, 7
lea r11, [rsi+r13*8]
add r11, r8
mov r14, r15
xor r9d, r9d
loc_1452A:
mov r12, r9
shl r12, 4
mov rbp, rdi
xor esi, esi
loc_14536:
movzx ebx, word ptr [r11+rsi*2]
vmovss xmm2, dword ptr [rax+rbx*4]
lea rbx, [r12+rsi*4]
vpmovsxbd xmm3, dword ptr [r11+rbx+48h]
vpmovsxbd xmm4, dword ptr [r11+rbx+8]
xor ebx, ebx
loc_14554:
vmovd xmm5, dword ptr [r14+rbx*4]
vpand xmm6, xmm5, xmm1
vpmovsxbd xmm6, xmm6
vpmulld xmm6, xmm3, xmm6
vpsllw xmm5, xmm5, 4
vpand xmm5, xmm5, xmm1
vpmovsxbd xmm5, xmm5
vpmulld xmm5, xmm5, xmm4
vpaddd xmm5, xmm6, xmm5
vpsrad xmm5, xmm5, 4
vphaddd xmm5, xmm5, xmm5
vphaddd xmm5, xmm5, xmm5
vcvtdq2ps xmm5, xmm5
movzx r10d, word ptr [rcx+rbx*2]
vmulss xmm5, xmm5, dword ptr [rax+r10*4]
vfmadd213ss xmm5, xmm2, dword ptr [rbp+rbx*4+0]
vmovss dword ptr [rbp+rbx*4+0], xmm5
inc rbx
cmp rbx, 4
jnz short loc_14554
inc rsi
add rbp, 10h
cmp rsi, 4
jnz loc_14536
inc r9
add r14, 10h
cmp r9, 4
jnz loc_1452A
inc r13
add r15, 48h ; 'H'
add rcx, 48h ; 'H'
cmp r13, [rsp+78h+var_80]
jnz loc_14516
loc_145EB:
mov r9, [rsp+78h+var_88]
mov rcx, r9
xor esi, esi
loc_145F5:
vmovups xmm2, xmmword ptr [rsp+rsi+78h+var_78]
vmovups xmmword ptr [rcx], xmm2
add rsi, 10h
add rcx, rdx
cmp rsi, 40h ; '@'
jnz short loc_145F5
mov rsi, [rsp+78h+var_90]
inc rsi
mov rcx, [rsp+78h+var_A0]
add [rsp+78h+var_D0], rcx
add [rsp+78h+var_C8], rcx
add r9, 10h
cmp rsi, [rsp+78h+var_98]
jnz loc_144E9
loc_14631:
mov rsi, [rsp+78h+var_F0]
inc rsi
mov rcx, [rsp+78h+var_A8]
add [rsp+78h+var_E0], rcx
mov [rsp+78h+var_F0], rsi
cmp rsi, [rsp+78h+var_F8]
jnz loc_144A3
loc_14653:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
vzeroupper
retn
| void ggml::cpu::aarch64::gemm<block_q4_0,4l,4l,(ggml_type)8>(
int a1,
long long a2,
long long a3,
long long a4,
long long a5,
int a6,
__m128 _XMM0,
int a8)
{
long long v9; // rdx
long long v13; // r9
long long v14; // rsi
long long v15; // rcx
long long v16; // r15
long long v17; // r13
long long i; // r9
long long j; // rsi
long long v47; // [rsp+0h] [rbp-F8h]
long long v48; // [rsp+8h] [rbp-F0h]
long long v51; // [rsp+28h] [rbp-D0h]
long long v52; // [rsp+30h] [rbp-C8h]
long long v53; // [rsp+40h] [rbp-B8h]
long long v54; // [rsp+50h] [rbp-A8h]
long long v55; // [rsp+58h] [rbp-A0h]
long long v56; // [rsp+68h] [rbp-90h]
long long v57; // [rsp+70h] [rbp-88h]
__m256 v58; // [rsp+80h] [rbp-78h] BYREF
if ( a6 >= 4 )
{
v47 = (unsigned int)a6 >> 2;
v54 = 16 * a3;
v9 = 4 * a3;
v53 = a1 / 32;
v55 = 72 * v53;
v48 = 0LL;
__asm { vxorps xmm0, xmm0, xmm0 }
_RAX = &ggml_table_f32_f16;
__asm { vpbroadcastb xmm1, cs:byte_48FCC }
do
{
if ( a8 >= 4 )
{
v13 = a2;
v52 = a4;
v51 = a4 + 8;
v14 = 0LL;
do
{
v56 = v14;
v57 = v13;
__asm
{
vmovups [rsp+78h+var_58], ymm0
vmovups [rsp+78h+var_78], ymm0
}
if ( a1 >= 32 )
{
v15 = v52;
v16 = v51;
v17 = 0LL;
do
{
_R11 = a5 + 136 * v53 * v48 + 136 * v17;
_R14 = v16;
for ( i = 0LL; i != 4; ++i )
{
_RBP = &v58;
for ( j = 0LL; j != 4; ++j )
{
_RBX = *(unsigned __int16 *)(_R11 + 2 * j);
__asm { vmovss xmm2, dword ptr [rax+rbx*4] }
_RBX = 16 * i + 4 * j;
__asm
{
vpmovsxbd xmm3, dword ptr [r11+rbx+48h]
vpmovsxbd xmm4, dword ptr [r11+rbx+8]
}
for ( _RBX = 0LL; _RBX != 4; ++_RBX )
{
__asm
{
vmovd xmm5, dword ptr [r14+rbx*4]
vpand xmm6, xmm5, xmm1
vpmovsxbd xmm6, xmm6
vpmulld xmm6, xmm3, xmm6
vpsllw xmm5, xmm5, 4
vpand xmm5, xmm5, xmm1
vpmovsxbd xmm5, xmm5
vpmulld xmm5, xmm5, xmm4
vpaddd xmm5, xmm6, xmm5
vpsrad xmm5, xmm5, 4
vphaddd xmm5, xmm5, xmm5
vphaddd xmm5, xmm5, xmm5
vcvtdq2ps xmm5, xmm5
vmulss xmm5, xmm5, dword ptr [rax+r10*4]
vfmadd213ss xmm5, xmm2, dword ptr [rbp+rbx*4+0]
vmovss dword ptr [rbp+rbx*4+0], xmm5
}
}
_RBP = (__m256 *)((char *)_RBP + 16);
}
_R14 += 16LL;
}
++v17;
v16 += 72LL;
v15 += 72LL;
}
while ( v17 != a1 / 32 );
}
_RCX = v57;
for ( _RSI = 0LL; _RSI != 64; _RSI += 16LL )
{
__asm
{
vmovups xmm2, xmmword ptr [rsp+rsi+78h+var_78]
vmovups xmmword ptr [rcx], xmm2
}
_RCX += v9;
}
v14 = v56 + 1;
v51 += v55;
v52 += v55;
v13 = v57 + 16;
}
while ( v56 + 1 != a8 / 4 );
}
a2 += v54;
++v48;
}
while ( v48 != v47 );
}
__asm { vzeroupper }
}
| gemm<block_q4_0,4l,4l,(ggml_type)8>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RSP + -0x38],R8
MOV qword ptr [RSP + -0x70],RCX
MOV qword ptr [RSP + -0x68],RSI
MOV qword ptr [RSP + -0x60],RDI
MOV qword ptr [RSP + -0x80],R9
CMP R9D,0x4
JL 0x00114653
MOV ECX,dword ptr [RSP + 0x80]
MOV RAX,qword ptr [RSP + -0x60]
LEA ESI,[RAX + 0x1f]
TEST EAX,EAX
CMOVNS ESI,EAX
SAR ESI,0x5
MOV RAX,qword ptr [RSP + -0x80]
SHR EAX,0x2
MOV qword ptr [RSP + -0x80],RAX
LEA EAX,[RCX + 0x3]
TEST ECX,ECX
CMOVNS EAX,ECX
SAR EAX,0x2
MOV qword ptr [RSP + -0x20],RAX
MOV RAX,RDX
SHL RAX,0x4
MOV qword ptr [RSP + -0x30],RAX
SHL RDX,0x2
MOV qword ptr [RSP + -0x8],RSI
MOVSXD RCX,ESI
MOV RAX,qword ptr [RSP + -0x70]
ADD RAX,0x8
MOV qword ptr [RSP + -0x48],RAX
MOV qword ptr [RSP + -0x40],RCX
LEA RAX,[RCX*0x8]
LEA RAX,[RAX + RAX*0x8]
MOV qword ptr [RSP + -0x28],RAX
MOV qword ptr [RSP + -0x78],0x0
VXORPS XMM0,XMM0,XMM0
MOV RDI,RSP
MOV RAX,qword ptr [0x0015af60]
VPBROADCASTB XMM1,byte ptr [0x00148fcc]
LAB_001144a3:
MOV ECX,dword ptr [RSP + 0x80]
CMP ECX,0x4
JL 0x00114631
MOV RCX,qword ptr [RSP + -0x78]
IMUL RCX,qword ptr [RSP + -0x40]
MOV RSI,RCX
SHL RSI,0x7
LEA R8,[RSI + RCX*0x8]
ADD R8,qword ptr [RSP + -0x38]
MOV R9,qword ptr [RSP + -0x68]
MOV RCX,qword ptr [RSP + -0x70]
MOV qword ptr [RSP + -0x50],RCX
MOV RCX,qword ptr [RSP + -0x48]
MOV qword ptr [RSP + -0x58],RCX
XOR ESI,ESI
LAB_001144e9:
MOV qword ptr [RSP + -0x18],RSI
MOV qword ptr [RSP + -0x10],R9
VMOVUPS ymmword ptr [RSP + 0x20],YMM0
VMOVUPS ymmword ptr [RSP],YMM0
CMP dword ptr [RSP + -0x60],0x20
JL 0x001145eb
MOV RCX,qword ptr [RSP + -0x50]
MOV R15,qword ptr [RSP + -0x58]
XOR R13D,R13D
LAB_00114516:
MOV RSI,R13
SHL RSI,0x7
LEA R11,[RSI + R13*0x8]
ADD R11,R8
MOV R14,R15
XOR R9D,R9D
LAB_0011452a:
MOV R12,R9
SHL R12,0x4
MOV RBP,RDI
XOR ESI,ESI
LAB_00114536:
MOVZX EBX,word ptr [R11 + RSI*0x2]
VMOVSS XMM2,dword ptr [RAX + RBX*0x4]
LEA RBX,[R12 + RSI*0x4]
VPMOVSXBD XMM3,dword ptr [R11 + RBX*0x1 + 0x48]
VPMOVSXBD XMM4,dword ptr [R11 + RBX*0x1 + 0x8]
XOR EBX,EBX
LAB_00114554:
VMOVD XMM5,dword ptr [R14 + RBX*0x4]
VPAND XMM6,XMM5,XMM1
VPMOVSXBD XMM6,XMM6
VPMULLD XMM6,XMM3,XMM6
VPSLLW XMM5,XMM5,0x4
VPAND XMM5,XMM5,XMM1
VPMOVSXBD XMM5,XMM5
VPMULLD XMM5,XMM5,XMM4
VPADDD XMM5,XMM6,XMM5
VPSRAD XMM5,XMM5,0x4
VPHADDD XMM5,XMM5,XMM5
VPHADDD XMM5,XMM5,XMM5
VCVTDQ2PS XMM5,XMM5
MOVZX R10D,word ptr [RCX + RBX*0x2]
VMULSS XMM5,XMM5,dword ptr [RAX + R10*0x4]
VFMADD213SS XMM5,XMM2,dword ptr [RBP + RBX*0x4]
VMOVSS dword ptr [RBP + RBX*0x4],XMM5
INC RBX
CMP RBX,0x4
JNZ 0x00114554
INC RSI
ADD RBP,0x10
CMP RSI,0x4
JNZ 0x00114536
INC R9
ADD R14,0x10
CMP R9,0x4
JNZ 0x0011452a
INC R13
ADD R15,0x48
ADD RCX,0x48
CMP R13,qword ptr [RSP + -0x8]
JNZ 0x00114516
LAB_001145eb:
MOV R9,qword ptr [RSP + -0x10]
MOV RCX,R9
XOR ESI,ESI
LAB_001145f5:
VMOVUPS XMM2,xmmword ptr [RSP + RSI*0x1]
VMOVUPS xmmword ptr [RCX],XMM2
ADD RSI,0x10
ADD RCX,RDX
CMP RSI,0x40
JNZ 0x001145f5
MOV RSI,qword ptr [RSP + -0x18]
INC RSI
MOV RCX,qword ptr [RSP + -0x28]
ADD qword ptr [RSP + -0x58],RCX
ADD qword ptr [RSP + -0x50],RCX
ADD R9,0x10
CMP RSI,qword ptr [RSP + -0x20]
JNZ 0x001144e9
LAB_00114631:
MOV RSI,qword ptr [RSP + -0x78]
INC RSI
MOV RCX,qword ptr [RSP + -0x30]
ADD qword ptr [RSP + -0x68],RCX
MOV qword ptr [RSP + -0x78],RSI
CMP RSI,qword ptr [RSP + -0x80]
JNZ 0x001144a3
LAB_00114653:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
VZEROUPPER
RET
|
/* void ggml::cpu::aarch64::gemm<block_q4_0, 4l, 4l, (ggml_type)8>(int, float*, unsigned long, void
const*, void const*, int, int) */
void ggml::cpu::aarch64::gemm<block_q4_0,4l,4l,(ggml_type)8>
(int param_1,float *param_2,ulong param_3,void *param_4,void *param_5,int param_6,
int param_7)
{
uint uVar1;
int1 auVar2 [16];
int1 auVar3 [16];
int1 auVar4 [16];
long lVar5;
int8 uVar6;
long lVar7;
int *puVar8;
void *pvVar9;
float *pfVar10;
long lVar11;
int8 *puVar12;
uint uVar13;
long lVar15;
ulong uVar16;
float *pfVar17;
long lVar18;
ulong uVar19;
long lVar20;
long lVar21;
int1 auVar22 [16];
int1 auVar23 [16];
int1 auVar24 [16];
ulong local_f0;
float *local_e0;
long local_d0;
void *local_c8;
int8 local_78 [9];
int iVar14;
puVar8 = PTR_ggml_table_f32_f16_0015af60;
if (3 < param_6) {
iVar14 = param_1 + 0x1f;
if (-1 < param_1) {
iVar14 = param_1;
}
uVar13 = iVar14 >> 5;
iVar14 = param_7 + 3;
if (-1 < param_7) {
iVar14 = param_7;
}
lVar5 = (long)(int)uVar13 * 0x48;
local_f0 = 0;
auVar22[1] = DAT_00148fcc;
auVar22[0] = DAT_00148fcc;
auVar22[2] = DAT_00148fcc;
auVar22[3] = DAT_00148fcc;
auVar22[4] = DAT_00148fcc;
auVar22[5] = DAT_00148fcc;
auVar22[6] = DAT_00148fcc;
auVar22[7] = DAT_00148fcc;
auVar22[8] = DAT_00148fcc;
auVar22[9] = DAT_00148fcc;
auVar22[10] = DAT_00148fcc;
auVar22[0xb] = DAT_00148fcc;
auVar22[0xc] = DAT_00148fcc;
auVar22[0xd] = DAT_00148fcc;
auVar22[0xe] = DAT_00148fcc;
auVar22[0xf] = DAT_00148fcc;
local_e0 = param_2;
do {
if (3 < param_7) {
uVar16 = 0;
pfVar17 = local_e0;
local_d0 = (long)param_4 + 8;
local_c8 = param_4;
do {
local_78[4] = 0;
local_78[5] = 0;
local_78[6] = 0;
local_78[7] = 0;
local_78[0] = 0;
local_78[1] = 0;
local_78[2] = 0;
local_78[3] = 0;
if (0x1f < param_1) {
uVar19 = 0;
pvVar9 = local_c8;
lVar21 = local_d0;
do {
lVar7 = uVar19 * 0x88 + local_f0 * (long)(int)uVar13 * 0x88;
lVar18 = 0;
lVar20 = lVar21;
do {
lVar15 = 0;
puVar12 = local_78;
do {
uVar1 = *(uint *)(puVar8 + (ulong)*(ushort *)((long)param_5 + lVar15 * 2 + lVar7)
* 4);
lVar11 = lVar18 * 0x10 + lVar15 * 4;
auVar2 = vpmovsxbd_avx(ZEXT416(*(uint *)((long)param_5 + lVar11 + lVar7 + 0x48)));
auVar3 = vpmovsxbd_avx(ZEXT416(*(uint *)((long)param_5 + lVar11 + lVar7 + 8)));
lVar11 = 0;
do {
auVar23 = ZEXT416(*(uint *)(lVar20 + lVar11 * 4));
auVar24 = vpand_avx(auVar23,auVar22);
auVar24 = vpmovsxbd_avx(auVar24);
auVar4 = vpmulld_avx(auVar2,auVar24);
auVar24 = vpsllw_avx(auVar23,4);
auVar24 = vpand_avx(auVar24,auVar22);
auVar24 = vpmovsxbd_avx(auVar24);
auVar24 = vpmulld_avx(auVar24,auVar3);
auVar24 = vpaddd_avx(auVar4,auVar24);
auVar24 = vpsrad_avx(auVar24,4);
auVar24 = vphaddd_avx(auVar24,auVar24);
auVar24 = vphaddd_avx(auVar24,auVar24);
auVar24 = vcvtdq2ps_avx(auVar24);
auVar24 = vfmadd213ss_fma(ZEXT416((uint)(auVar24._0_4_ *
*(float *)(puVar8 + (ulong)*(ushort *)
((long)
pvVar9 + lVar11 * 2) * 4))),ZEXT416(uVar1),
ZEXT416(*(uint *)((long)puVar12 + lVar11 * 4)));
*(int *)((long)puVar12 + lVar11 * 4) = auVar24._0_4_;
lVar11 = lVar11 + 1;
} while (lVar11 != 4);
lVar15 = lVar15 + 1;
puVar12 = (int8 *)((long)puVar12 + 0x10);
} while (lVar15 != 4);
lVar18 = lVar18 + 1;
lVar20 = lVar20 + 0x10;
} while (lVar18 != 4);
uVar19 = uVar19 + 1;
lVar21 = lVar21 + 0x48;
pvVar9 = (void *)((long)pvVar9 + 0x48);
} while (uVar19 != uVar13);
}
lVar21 = 0;
pfVar10 = pfVar17;
do {
uVar6 = *(int8 *)((long)local_78 + lVar21 + 8);
*(int8 *)pfVar10 = *(int8 *)((long)local_78 + lVar21);
*(int8 *)(pfVar10 + 2) = uVar6;
lVar21 = lVar21 + 0x10;
pfVar10 = pfVar10 + param_3;
} while (lVar21 != 0x40);
uVar16 = uVar16 + 1;
local_d0 = local_d0 + lVar5;
local_c8 = (void *)((long)local_c8 + lVar5);
pfVar17 = pfVar17 + 4;
} while (uVar16 != (uint)(iVar14 >> 2));
}
local_f0 = local_f0 + 1;
local_e0 = local_e0 + param_3 * 4;
} while (local_f0 != (uint)param_6 >> 2);
}
return;
}
| |
43,153 | minja::Parser::parseString[abi:cxx11]() | monkey531[P]llama/common/minja.hpp | std::unique_ptr<std::string> parseString() {
auto doParse = [&](char quote) -> std::unique_ptr<std::string> {
if (it == end || *it != quote) return nullptr;
std::string result;
bool escape = false;
for (++it; it != end; ++it) {
if (escape) {
escape = false;
switch (*it) {
case 'n': result += '\n'; break;
case 'r': result += '\r'; break;
case 't': result += '\t'; break;
case 'b': result += '\b'; break;
case 'f': result += '\f'; break;
case '\\': result += '\\'; break;
default:
if (*it == quote) {
result += quote;
} else {
result += *it;
}
break;
}
} else if (*it == '\\') {
escape = true;
} else if (*it == quote) {
++it;
return std::make_unique<std::string>(std::move(result));
} else {
result += *it;
}
}
return nullptr;
};
consumeSpaces();
if (it == end) return nullptr;
if (*it == '"') return doParse('"');
if (*it == '\'') return doParse('\'');
return nullptr;
} | O2 | cpp | minja::Parser::parseString[abi:cxx11]():
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rsp)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x7d946
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x82fa3
movzbl (%rax), %eax
cmpl $0x27, %eax
je 0x82fa9
cmpl $0x22, %eax
jne 0x82fa3
movq %rsp, %rsi
pushq $0x22
jmp 0x82fae
andq $0x0, (%rbx)
jmp 0x82fb7
movq %rsp, %rsi
pushq $0x27
popq %rdx
movq %rbx, %rdi
callq 0x8331e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja6Parser11parseStringB5cxx11Ev:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov [rsp+18h+var_18], rsi
push 1
pop rsi
mov rdi, r14
call _ZN5minja6Parser13consumeSpacesENS_13SpaceHandlingE; minja::Parser::consumeSpaces(minja::SpaceHandling)
mov rax, [r14+20h]
cmp rax, [r14+18h]
jz short loc_82FA3
movzx eax, byte ptr [rax]
cmp eax, 27h ; '''
jz short loc_82FA9
cmp eax, 22h ; '"'
jnz short loc_82FA3
mov rsi, rsp
push 22h ; '"'
jmp short loc_82FAE
loc_82FA3:
and qword ptr [rbx], 0
jmp short loc_82FB7
loc_82FA9:
mov rsi, rsp
push 27h ; '''
loc_82FAE:
pop rdx
mov rdi, rbx
call _ZZN5minja6Parser11parseStringB5cxx11EvENKUlcE_clB5cxx11Ec; minja::Parser::parseString(void)::{lambda(char)#1}::operator()(char)
loc_82FB7:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| _QWORD * minja::Parser::parseString[abi:cxx11](_QWORD *a1, long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
unsigned __int8 *v5; // rax
int v6; // eax
char v8[24]; // [rsp+0h] [rbp-18h] BYREF
*(_QWORD *)v8 = a2;
minja::Parser::consumeSpaces(a2, 1);
v5 = *(unsigned __int8 **)(a2 + 32);
if ( v5 == *(unsigned __int8 **)(a2 + 24) )
goto LABEL_5;
v6 = *v5;
if ( v6 == 39 )
{
minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
(_DWORD)a1,
(unsigned int)v8,
39,
v2,
v3,
v4,
v8[0]);
return a1;
}
if ( v6 != 34 )
LABEL_5:
*a1 = 0LL;
else
minja::Parser::parseString[abi:cxx11](void)::{lambda(char)#1}::operator()[abi:cxx11](
(_DWORD)a1,
(unsigned int)v8,
34,
v2,
v3,
v4,
v8[0]);
return a1;
}
| parseString[abi:cxx11]:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV qword ptr [RSP],RSI
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0017d946
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [R14 + 0x18]
JZ 0x00182fa3
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x27
JZ 0x00182fa9
CMP EAX,0x22
JNZ 0x00182fa3
MOV RSI,RSP
PUSH 0x22
JMP 0x00182fae
LAB_00182fa3:
AND qword ptr [RBX],0x0
JMP 0x00182fb7
LAB_00182fa9:
MOV RSI,RSP
PUSH 0x27
LAB_00182fae:
POP RDX
MOV RDI,RBX
CALL 0x0018331e
LAB_00182fb7:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::Parser::parseString[abi:cxx11]() */
void minja::Parser::parseString_abi_cxx11_(void)
{
char cVar1;
long in_RSI;
int8 *in_RDI;
consumeSpaces();
if ((*(char **)(in_RSI + 0x20) == *(char **)(in_RSI + 0x18)) ||
((cVar1 = **(char **)(in_RSI + 0x20), cVar1 != '\'' && (cVar1 != '\"')))) {
*in_RDI = 0;
}
else {
parseString[abi:cxx11]()::{lambda(char)#1}::operator()[abi_cxx11_((char)in_RDI);
}
return;
}
| |
43,154 | test_vector_literals | eshkol/tests/unit/test_lexer.c | static void test_vector_literals(void) {
printf("Testing vector literals...\n");
// Create an arena
Arena* arena = arena_create(1024);
assert(arena != NULL);
// Create a string table
StringTable* strings = string_table_create(arena, 16);
assert(strings != NULL);
// Create a diagnostic context
DiagnosticContext* diag = diagnostic_context_create(arena);
assert(diag != NULL);
// Create a lexer
const char* source = "#(1 2 3)";
Lexer* lexer = lexer_create(arena, strings, diag, source);
assert(lexer != NULL);
// Scan tokens
Token token;
// #(
token = lexer_scan_token(lexer);
assert(token_is(&token, TOKEN_VECTOR_START));
// 1
token = lexer_scan_token(lexer);
assert(token_is(&token, TOKEN_NUMBER));
assert(token.value.number == 1.0);
// 2
token = lexer_scan_token(lexer);
assert(token_is(&token, TOKEN_NUMBER));
assert(token.value.number == 2.0);
// 3
token = lexer_scan_token(lexer);
assert(token_is(&token, TOKEN_NUMBER));
assert(token.value.number == 3.0);
// )
token = lexer_scan_token(lexer);
assert(token_is(&token, TOKEN_RPAREN));
// EOF
token = lexer_scan_token(lexer);
assert(token_is(&token, TOKEN_EOF));
// Destroy the arena
arena_destroy(arena);
printf("PASS: vector_literals\n");
} | O0 | c | test_vector_literals:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
leaq 0x491b(%rip), %rdi # 0x77dd
movb $0x0, %al
callq 0x1080
movl $0x400, %edi # imm = 0x400
callq 0x3a40
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2ee0
jmp 0x2eff
leaq 0x4195(%rip), %rdi # 0x707c
leaq 0x419c(%rip), %rsi # 0x708a
movl $0x19c, %edx # imm = 0x19C
leaq 0x48ff(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x4140
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f1a
jmp 0x2f39
leaq 0x41c6(%rip), %rdi # 0x70e7
leaq 0x4162(%rip), %rsi # 0x708a
movl $0x1a0, %edx # imm = 0x1A0
leaq 0x48c5(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x4830
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2f4f
jmp 0x2f6e
leaq 0x41a1(%rip), %rdi # 0x70f7
leaq 0x412d(%rip), %rsi # 0x708a
movl $0x1a4, %edx # imm = 0x1A4
leaq 0x4890(%rip), %rcx # 0x77f9
callq 0x10a0
leaq 0x48a4(%rip), %rax # 0x7819
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x51c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2f9b
jmp 0x2fba
leaq 0x41a2(%rip), %rdi # 0x7144
leaq 0x40e1(%rip), %rsi # 0x708a
movl $0x1a9, %edx # imm = 0x1A9
leaq 0x4844(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x28(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x5580
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x30, %edx
callq 0x10f0
leaq -0x58(%rbp), %rdi
movl $0x10, %esi
callq 0x5e40
testb $0x1, %al
jne 0x2ff3
jmp 0x2ff5
jmp 0x3014
leaq 0x4826(%rip), %rdi # 0x7822
leaq 0x4087(%rip), %rsi # 0x708a
movl $0x1b0, %edx # imm = 0x1B0
leaq 0x47ea(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x28(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x5580
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
movl $0x30, %edx
callq 0x10f0
leaq -0x58(%rbp), %rdi
movl $0xd, %esi
callq 0x5e40
testb $0x1, %al
jne 0x304d
jmp 0x304f
jmp 0x306e
leaq 0x4363(%rip), %rdi # 0x73b9
leaq 0x402d(%rip), %rsi # 0x708a
movl $0x1b4, %edx # imm = 0x1B4
leaq 0x4790(%rip), %rcx # 0x77f9
callq 0x10a0
movsd -0x30(%rbp), %xmm0
movsd 0x3f95(%rip), %xmm1 # 0x7010
ucomisd %xmm1, %xmm0
jne 0x3085
jp 0x3085
jmp 0x30a4
leaq 0x4366(%rip), %rdi # 0x73f2
leaq 0x3ff7(%rip), %rsi # 0x708a
movl $0x1b5, %edx # imm = 0x1B5
leaq 0x475a(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x28(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x5580
leaq -0x58(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
movl $0x30, %edx
callq 0x10f0
leaq -0x58(%rbp), %rdi
movl $0xd, %esi
callq 0x5e40
testb $0x1, %al
jne 0x30dd
jmp 0x30df
jmp 0x30fe
leaq 0x42d3(%rip), %rdi # 0x73b9
leaq 0x3f9d(%rip), %rsi # 0x708a
movl $0x1b9, %edx # imm = 0x1B9
leaq 0x4700(%rip), %rcx # 0x77f9
callq 0x10a0
movsd -0x30(%rbp), %xmm0
movsd 0x3efd(%rip), %xmm1 # 0x7008
ucomisd %xmm1, %xmm0
jne 0x3115
jp 0x3115
jmp 0x3134
leaq 0x42bc(%rip), %rdi # 0x73d8
leaq 0x3f67(%rip), %rsi # 0x708a
movl $0x1ba, %edx # imm = 0x1BA
leaq 0x46ca(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x28(%rbp), %rsi
leaq -0x118(%rbp), %rdi
callq 0x5580
leaq -0x58(%rbp), %rdi
leaq -0x118(%rbp), %rsi
movl $0x30, %edx
callq 0x10f0
leaq -0x58(%rbp), %rdi
movl $0xd, %esi
callq 0x5e40
testb $0x1, %al
jne 0x316d
jmp 0x316f
jmp 0x318e
leaq 0x4243(%rip), %rdi # 0x73b9
leaq 0x3f0d(%rip), %rsi # 0x708a
movl $0x1be, %edx # imm = 0x1BE
leaq 0x4670(%rip), %rcx # 0x77f9
callq 0x10a0
movsd -0x30(%rbp), %xmm0
movsd 0x3e8d(%rip), %xmm1 # 0x7028
ucomisd %xmm1, %xmm0
jne 0x31a5
jp 0x31a5
jmp 0x31c4
leaq 0x469b(%rip), %rdi # 0x7847
leaq 0x3ed7(%rip), %rsi # 0x708a
movl $0x1bf, %edx # imm = 0x1BF
leaq 0x463a(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x28(%rbp), %rsi
leaq -0x148(%rbp), %rdi
callq 0x5580
leaq -0x58(%rbp), %rdi
leaq -0x148(%rbp), %rsi
movl $0x30, %edx
callq 0x10f0
leaq -0x58(%rbp), %rdi
movl $0x2, %esi
callq 0x5e40
testb $0x1, %al
jne 0x31fd
jmp 0x31ff
jmp 0x321e
leaq 0x413e(%rip), %rdi # 0x7344
leaq 0x3e7d(%rip), %rsi # 0x708a
movl $0x1c3, %edx # imm = 0x1C3
leaq 0x45e0(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x28(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0x5580
leaq -0x58(%rbp), %rdi
leaq -0x178(%rbp), %rsi
movl $0x30, %edx
callq 0x10f0
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x5e40
testb $0x1, %al
jne 0x3254
jmp 0x3256
jmp 0x3275
leaq 0x4203(%rip), %rdi # 0x7460
leaq 0x3e26(%rip), %rsi # 0x708a
movl $0x1c7, %edx # imm = 0x1C7
leaq 0x4589(%rip), %rcx # 0x77f9
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x4020
leaq 0x45dc(%rip), %rdi # 0x7861
movb $0x0, %al
callq 0x1080
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
nopw %cs:(%rax,%rax)
| test_vector_literals:
push rbp
mov rbp, rsp
sub rsp, 180h
lea rdi, aTestingVectorL; "Testing vector literals...\n"
mov al, 0
call _printf
mov edi, 400h
call arena_create
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jz short loc_2EE0
jmp short loc_2EFF
loc_2EE0:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 19Ch
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_2EFF:
mov rdi, [rbp+var_8]
mov esi, 10h
call string_table_create
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jz short loc_2F1A
jmp short loc_2F39
loc_2F1A:
lea rdi, aStringsNull; "strings != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1A0h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_2F39:
mov rdi, [rbp+var_8]
call diagnostic_context_create
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_2F4F
jmp short loc_2F6E
loc_2F4F:
lea rdi, aDiagNull; "diag != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1A4h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_2F6E:
lea rax, a123; "#(1 2 3)"
mov [rbp+var_20], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call lexer_create
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jz short loc_2F9B
jmp short loc_2FBA
loc_2F9B:
lea rdi, aLexerNull; "lexer != NULL"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1A9h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_2FBA:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_88]
call lexer_scan_token
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_88]
mov edx, 30h ; '0'
call _memcpy
lea rdi, [rbp+var_58]
mov esi, 10h
call token_is
test al, 1
jnz short loc_2FF3
jmp short loc_2FF5
loc_2FF3:
jmp short loc_3014
loc_2FF5:
lea rdi, aTokenIsTokenTo_7; "token_is(&token, TOKEN_VECTOR_START)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1B0h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_3014:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_B8]
call lexer_scan_token
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_B8]
mov edx, 30h ; '0'
call _memcpy
lea rdi, [rbp+var_58]
mov esi, 0Dh
call token_is
test al, 1
jnz short loc_304D
jmp short loc_304F
loc_304D:
jmp short loc_306E
loc_304F:
lea rdi, aTokenIsTokenTo_2; "token_is(&token, TOKEN_NUMBER)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1B4h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_306E:
movsd xmm0, [rbp+var_30]
movsd xmm1, cs:qword_7010
ucomisd xmm0, xmm1
jnz short loc_3085
jp short loc_3085
jmp short loc_30A4
loc_3085:
lea rdi, aTokenValueNumb_0; "token.value.number == 1.0"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1B5h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_30A4:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_E8]
call lexer_scan_token
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_E8]
mov edx, 30h ; '0'
call _memcpy
lea rdi, [rbp+var_58]
mov esi, 0Dh
call token_is
test al, 1
jnz short loc_30DD
jmp short loc_30DF
loc_30DD:
jmp short loc_30FE
loc_30DF:
lea rdi, aTokenIsTokenTo_2; "token_is(&token, TOKEN_NUMBER)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1B9h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_30FE:
movsd xmm0, [rbp+var_30]
movsd xmm1, cs:qword_7008
ucomisd xmm0, xmm1
jnz short loc_3115
jp short loc_3115
jmp short loc_3134
loc_3115:
lea rdi, aTokenValueNumb; "token.value.number == 2.0"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1BAh
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_3134:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_118]
call lexer_scan_token
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_118]
mov edx, 30h ; '0'
call _memcpy
lea rdi, [rbp+var_58]
mov esi, 0Dh
call token_is
test al, 1
jnz short loc_316D
jmp short loc_316F
loc_316D:
jmp short loc_318E
loc_316F:
lea rdi, aTokenIsTokenTo_2; "token_is(&token, TOKEN_NUMBER)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1BEh
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_318E:
movsd xmm0, [rbp+var_30]
movsd xmm1, cs:qword_7028
ucomisd xmm0, xmm1
jnz short loc_31A5
jp short loc_31A5
jmp short loc_31C4
loc_31A5:
lea rdi, aTokenValueNumb_3; "token.value.number == 3.0"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1BFh
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_31C4:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_148]
call lexer_scan_token
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_148]
mov edx, 30h ; '0'
call _memcpy
lea rdi, [rbp+var_58]
mov esi, 2
call token_is
test al, 1
jnz short loc_31FD
jmp short loc_31FF
loc_31FD:
jmp short loc_321E
loc_31FF:
lea rdi, aTokenIsTokenTo_1; "token_is(&token, TOKEN_RPAREN)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1C3h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_321E:
mov rsi, [rbp+var_28]
lea rdi, [rbp+var_178]
call lexer_scan_token
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_178]
mov edx, 30h ; '0'
call _memcpy
lea rdi, [rbp+var_58]
xor esi, esi
call token_is
test al, 1
jnz short loc_3254
jmp short loc_3256
loc_3254:
jmp short loc_3275
loc_3256:
lea rdi, aTokenIsTokenTo_3; "token_is(&token, TOKEN_EOF)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/eshkol"...
mov edx, 1C7h
lea rcx, aVoidTestVector; "void test_vector_literals(void)"
call ___assert_fail
loc_3275:
mov rdi, [rbp+var_8]
call arena_destroy
lea rdi, aPassVectorLite; "PASS: vector_literals\n"
mov al, 0
call _printf
add rsp, 180h
pop rbp
retn
| long long test_vector_literals(long long a1, long long a2, long long a3)
{
char v3; // al
char v4; // al
char v5; // al
char v6; // al
char v7; // al
long long v8; // rdx
_BYTE v10[48]; // [rsp+8h] [rbp-178h] BYREF
_BYTE v11[48]; // [rsp+38h] [rbp-148h] BYREF
_BYTE v12[48]; // [rsp+68h] [rbp-118h] BYREF
_BYTE v13[48]; // [rsp+98h] [rbp-E8h] BYREF
_BYTE v14[48]; // [rsp+C8h] [rbp-B8h] BYREF
_BYTE v15[48]; // [rsp+F8h] [rbp-88h] BYREF
_BYTE v16[40]; // [rsp+128h] [rbp-58h] BYREF
double v17; // [rsp+150h] [rbp-30h]
long long v18; // [rsp+158h] [rbp-28h]
const char *v19; // [rsp+160h] [rbp-20h]
long long v20; // [rsp+168h] [rbp-18h]
long long v21; // [rsp+170h] [rbp-10h]
long long v22; // [rsp+178h] [rbp-8h]
printf("Testing vector literals...\n", a2, a3);
v22 = arena_create(1024LL);
if ( !v22 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
412LL,
"void test_vector_literals(void)");
v21 = string_table_create(v22, 16LL);
if ( !v21 )
__assert_fail(
"strings != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
416LL,
"void test_vector_literals(void)");
v20 = diagnostic_context_create(v22);
if ( !v20 )
__assert_fail(
"diag != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
420LL,
"void test_vector_literals(void)");
v19 = "#(1 2 3)";
v18 = lexer_create(v22, v21, v20, "#(1 2 3)");
if ( !v18 )
__assert_fail(
"lexer != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
425LL,
"void test_vector_literals(void)");
lexer_scan_token(v15, v18);
memcpy(v16, v15, 48LL);
if ( (token_is(v16, 16LL) & 1) == 0 )
__assert_fail(
"token_is(&token, TOKEN_VECTOR_START)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
432LL,
"void test_vector_literals(void)");
lexer_scan_token(v14, v18);
memcpy(v16, v14, 48LL);
v3 = token_is(v16, 13LL);
if ( (v3 & 1) == 0 )
__assert_fail(
"token_is(&token, TOKEN_NUMBER)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
436LL,
"void test_vector_literals(void)");
if ( v17 != 1.0 )
__assert_fail(
"token.value.number == 1.0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
437LL,
"void test_vector_literals(void)");
lexer_scan_token(v13, v18);
memcpy(v16, v13, 48LL);
v4 = token_is(v16, 13LL);
if ( (v4 & 1) == 0 )
__assert_fail(
"token_is(&token, TOKEN_NUMBER)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
441LL,
"void test_vector_literals(void)");
if ( v17 != 2.0 )
__assert_fail(
"token.value.number == 2.0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
442LL,
"void test_vector_literals(void)");
lexer_scan_token(v12, v18);
memcpy(v16, v12, 48LL);
v5 = token_is(v16, 13LL);
if ( (v5 & 1) == 0 )
__assert_fail(
"token_is(&token, TOKEN_NUMBER)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
446LL,
"void test_vector_literals(void)");
if ( v17 != 3.0 )
__assert_fail(
"token.value.number == 3.0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
447LL,
"void test_vector_literals(void)");
lexer_scan_token(v11, v18);
memcpy(v16, v11, 48LL);
v6 = token_is(v16, 2LL);
if ( (v6 & 1) == 0 )
__assert_fail(
"token_is(&token, TOKEN_RPAREN)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
451LL,
"void test_vector_literals(void)");
lexer_scan_token(v10, v18);
memcpy(v16, v10, 48LL);
v7 = token_is(v16, 0LL);
if ( (v7 & 1) == 0 )
__assert_fail(
"token_is(&token, TOKEN_EOF)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
455LL,
"void test_vector_literals(void)");
arena_destroy(v22);
return printf("PASS: vector_literals\n", 0LL, v8);
}
| test_vector_literals:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
LEA RDI,[0x1077dd]
MOV AL,0x0
CALL 0x00101080
MOV EDI,0x400
CALL 0x00103a40
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00102ee0
JMP 0x00102eff
LAB_00102ee0:
LEA RDI,[0x10707c]
LEA RSI,[0x10708a]
MOV EDX,0x19c
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00102eff:
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x10
CALL 0x00104140
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00102f1a
JMP 0x00102f39
LAB_00102f1a:
LEA RDI,[0x1070e7]
LEA RSI,[0x10708a]
MOV EDX,0x1a0
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00102f39:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00104830
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00102f4f
JMP 0x00102f6e
LAB_00102f4f:
LEA RDI,[0x1070f7]
LEA RSI,[0x10708a]
MOV EDX,0x1a4
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00102f6e:
LEA RAX,[0x107819]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001051c0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00102f9b
JMP 0x00102fba
LAB_00102f9b:
LEA RDI,[0x107144]
LEA RSI,[0x10708a]
MOV EDX,0x1a9
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00102fba:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x88]
CALL 0x00105580
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x88]
MOV EDX,0x30
CALL 0x001010f0
LEA RDI,[RBP + -0x58]
MOV ESI,0x10
CALL 0x00105e40
TEST AL,0x1
JNZ 0x00102ff3
JMP 0x00102ff5
LAB_00102ff3:
JMP 0x00103014
LAB_00102ff5:
LEA RDI,[0x107822]
LEA RSI,[0x10708a]
MOV EDX,0x1b0
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00103014:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0xb8]
CALL 0x00105580
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0xb8]
MOV EDX,0x30
CALL 0x001010f0
LEA RDI,[RBP + -0x58]
MOV ESI,0xd
CALL 0x00105e40
TEST AL,0x1
JNZ 0x0010304d
JMP 0x0010304f
LAB_0010304d:
JMP 0x0010306e
LAB_0010304f:
LEA RDI,[0x1073b9]
LEA RSI,[0x10708a]
MOV EDX,0x1b4
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_0010306e:
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVSD XMM1,qword ptr [0x00107010]
UCOMISD XMM0,XMM1
JNZ 0x00103085
JP 0x00103085
JMP 0x001030a4
LAB_00103085:
LEA RDI,[0x1073f2]
LEA RSI,[0x10708a]
MOV EDX,0x1b5
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_001030a4:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0xe8]
CALL 0x00105580
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0xe8]
MOV EDX,0x30
CALL 0x001010f0
LEA RDI,[RBP + -0x58]
MOV ESI,0xd
CALL 0x00105e40
TEST AL,0x1
JNZ 0x001030dd
JMP 0x001030df
LAB_001030dd:
JMP 0x001030fe
LAB_001030df:
LEA RDI,[0x1073b9]
LEA RSI,[0x10708a]
MOV EDX,0x1b9
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_001030fe:
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVSD XMM1,qword ptr [0x00107008]
UCOMISD XMM0,XMM1
JNZ 0x00103115
JP 0x00103115
JMP 0x00103134
LAB_00103115:
LEA RDI,[0x1073d8]
LEA RSI,[0x10708a]
MOV EDX,0x1ba
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00103134:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x118]
CALL 0x00105580
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x118]
MOV EDX,0x30
CALL 0x001010f0
LEA RDI,[RBP + -0x58]
MOV ESI,0xd
CALL 0x00105e40
TEST AL,0x1
JNZ 0x0010316d
JMP 0x0010316f
LAB_0010316d:
JMP 0x0010318e
LAB_0010316f:
LEA RDI,[0x1073b9]
LEA RSI,[0x10708a]
MOV EDX,0x1be
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_0010318e:
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVSD XMM1,qword ptr [0x00107028]
UCOMISD XMM0,XMM1
JNZ 0x001031a5
JP 0x001031a5
JMP 0x001031c4
LAB_001031a5:
LEA RDI,[0x107847]
LEA RSI,[0x10708a]
MOV EDX,0x1bf
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_001031c4:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x148]
CALL 0x00105580
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x148]
MOV EDX,0x30
CALL 0x001010f0
LEA RDI,[RBP + -0x58]
MOV ESI,0x2
CALL 0x00105e40
TEST AL,0x1
JNZ 0x001031fd
JMP 0x001031ff
LAB_001031fd:
JMP 0x0010321e
LAB_001031ff:
LEA RDI,[0x107344]
LEA RSI,[0x10708a]
MOV EDX,0x1c3
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_0010321e:
MOV RSI,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x178]
CALL 0x00105580
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x178]
MOV EDX,0x30
CALL 0x001010f0
LEA RDI,[RBP + -0x58]
XOR ESI,ESI
CALL 0x00105e40
TEST AL,0x1
JNZ 0x00103254
JMP 0x00103256
LAB_00103254:
JMP 0x00103275
LAB_00103256:
LEA RDI,[0x107460]
LEA RSI,[0x10708a]
MOV EDX,0x1c7
LEA RCX,[0x1077f9]
CALL 0x001010a0
LAB_00103275:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00104020
LEA RDI,[0x107861]
MOV AL,0x0
CALL 0x00101080
ADD RSP,0x180
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void test_vector_literals(void)
{
ulong uVar1;
int1 local_180 [48];
int1 local_150 [48];
int1 local_120 [48];
int1 local_f0 [48];
int1 local_c0 [48];
int1 local_90 [48];
int1 local_60 [40];
double local_38;
long local_30;
char *local_28;
long local_20;
long local_18;
long local_10;
printf("Testing vector literals...\n");
local_10 = arena_create(0x400);
if (local_10 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
0x19c,"void test_vector_literals(void)");
}
local_18 = string_table_create(local_10,0x10);
if (local_18 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("strings != NULL",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1a0,
"void test_vector_literals(void)");
}
local_20 = diagnostic_context_create(local_10);
if (local_20 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("diag != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
0x1a4,"void test_vector_literals(void)");
}
local_28 = "#(1 2 3)";
local_30 = lexer_create(local_10,local_18,local_20,"#(1 2 3)");
if (local_30 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("lexer != NULL","/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",
0x1a9,"void test_vector_literals(void)");
}
lexer_scan_token(local_90,local_30);
memcpy(local_60,local_90,0x30);
uVar1 = token_is(local_60,0x10);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("token_is(&token, TOKEN_VECTOR_START)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1b0,
"void test_vector_literals(void)");
}
lexer_scan_token(local_c0,local_30);
memcpy(local_60,local_c0,0x30);
uVar1 = token_is(local_60,0xd);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("token_is(&token, TOKEN_NUMBER)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1b4,
"void test_vector_literals(void)");
}
if ((local_38 != DAT_00107010) || (NAN(local_38) || NAN(DAT_00107010))) {
/* WARNING: Subroutine does not return */
__assert_fail("token.value.number == 1.0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1b5,
"void test_vector_literals(void)");
}
lexer_scan_token(local_f0,local_30);
memcpy(local_60,local_f0,0x30);
uVar1 = token_is(local_60,0xd);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("token_is(&token, TOKEN_NUMBER)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1b9,
"void test_vector_literals(void)");
}
if ((local_38 == DAT_00107008) && (!NAN(local_38) && !NAN(DAT_00107008))) {
lexer_scan_token(local_120,local_30);
memcpy(local_60,local_120,0x30);
uVar1 = token_is(local_60,0xd);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("token_is(&token, TOKEN_NUMBER)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1be,
"void test_vector_literals(void)");
}
if ((local_38 != _DAT_00107028) || (NAN(local_38) || NAN(_DAT_00107028))) {
/* WARNING: Subroutine does not return */
__assert_fail("token.value.number == 3.0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1bf,
"void test_vector_literals(void)");
}
lexer_scan_token(local_150,local_30);
memcpy(local_60,local_150,0x30);
uVar1 = token_is(local_60,2);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("token_is(&token, TOKEN_RPAREN)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1c3,
"void test_vector_literals(void)");
}
lexer_scan_token(local_180,local_30);
memcpy(local_60,local_180,0x30);
uVar1 = token_is(local_60,0);
if ((uVar1 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("token_is(&token, TOKEN_EOF)",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1c7,
"void test_vector_literals(void)");
}
arena_destroy(local_10);
printf("PASS: vector_literals\n");
return;
}
/* WARNING: Subroutine does not return */
__assert_fail("token.value.number == 2.0",
"/workspace/llm4binary/github2025/eshkol/tests/unit/test_lexer.c",0x1ba,
"void test_vector_literals(void)");
}
| |
43,155 | google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Close() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc | bool FileOutputStream::CopyingFileOutputStream::Close() {
GOOGLE_CHECK(!is_closed_);
is_closed_ = true;
if (close_no_eintr(file_) != 0) {
// The docs on close() do not specify whether a file descriptor is still
// open after close() fails with EIO. However, the glibc source code
// seems to indicate that it is not.
errno_ = errno;
return false;
}
return true;
} | O3 | cpp | google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Close():
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpb $0x1, 0xd(%rdi)
jne 0xfbc3f
leaq 0xf0551(%rip), %rdx # 0x1ec153
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0xc8, %ecx
callq 0x1072ba
leaq 0xf05b9(%rip), %rsi # 0x1ec1d9
movq %r14, %rdi
callq 0x106db8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x106e92
leaq 0x8(%rsp), %rdi
callq 0x1072d8
movb $0x1, 0xd(%rbx)
movl 0x8(%rbx), %edi
callq 0xfb9fe
movl %eax, %ebp
testl %eax, %eax
je 0xfbc5b
callq 0x1f060
movl (%rax), %eax
movl %eax, 0x10(%rbx)
testl %ebp, %ebp
sete %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0xfbc6b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1072d8
movq %rbx, %rdi
callq 0x1f860
| _ZN6google8protobuf2io16FileOutputStream23CopyingFileOutputStream5CloseEv:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
cmp byte ptr [rdi+0Dh], 1
jnz short loc_FBC3F
lea rdx, aWorkspaceLlm4b_50; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 0C8h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedIsC; "CHECK failed: !is_closed_: "
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax; int
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_FBC3F:
mov byte ptr [rbx+0Dh], 1
mov edi, [rbx+8]; this
call _ZN6google8protobuf2io12_GLOBAL__N_114close_no_eintrEi; google::protobuf::io::`anonymous namespace'::close_no_eintr(int)
mov ebp, eax
test eax, eax
jz short loc_FBC5B
call ___errno_location
mov eax, [rax]
mov [rbx+10h], eax
loc_FBC5B:
test ebp, ebp
setz al
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
jmp short $+2
loc_FBC6B:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| bool google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Close(
google::protobuf::io::FileOutputStream::CopyingFileOutputStream *this)
{
long long v2; // rax
google::protobuf::io::_anonymous_namespace_ *v3; // rdi
int v4; // ebp
char v6; // [rsp+7h] [rbp-51h] BYREF
_BYTE v7[80]; // [rsp+8h] [rbp-50h] BYREF
if ( *((_BYTE *)this + 13) == 1 )
{
google::protobuf::internal::LogMessage::LogMessage(
v7,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc",
200LL);
v2 = google::protobuf::internal::LogMessage::operator<<(v7, "CHECK failed: !is_closed_: ");
google::protobuf::internal::LogFinisher::operator=(&v6, v2);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v7);
}
*((_BYTE *)this + 13) = 1;
v3 = (google::protobuf::io::_anonymous_namespace_ *)*((unsigned int *)this + 2);
v4 = google::protobuf::io::`anonymous namespace'::close_no_eintr(v3);
if ( v4 )
*((_DWORD *)this + 4) = *(_DWORD *)__errno_location(v3);
return v4 == 0;
}
| Close:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
CMP byte ptr [RDI + 0xd],0x1
JNZ 0x001fbc3f
LEA RDX,[0x2ec153]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0xc8
CALL 0x002072ba
LAB_001fbc19:
LEA RSI,[0x2ec1d9]
MOV RDI,R14
CALL 0x00206db8
LAB_001fbc28:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x00206e92
LAB_001fbc35:
LEA RDI,[RSP + 0x8]
CALL 0x002072d8
LAB_001fbc3f:
MOV byte ptr [RBX + 0xd],0x1
MOV EDI,dword ptr [RBX + 0x8]
CALL 0x001fb9fe
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001fbc5b
CALL 0x0011f060
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBX + 0x10],EAX
LAB_001fbc5b:
TEST EBP,EBP
SETZ AL
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
|
/* google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Close() */
bool __thiscall
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Close
(CopyingFileOutputStream *this)
{
int iVar1;
LogMessage *pLVar2;
int *piVar3;
LogFinisher local_51;
LogMessage local_50 [56];
if (this[0xd] == (CopyingFileOutputStream)0x1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc"
,200);
/* try { // try from 001fbc19 to 001fbc27 has its CatchHandler @ 001fbc6b */
pLVar2 = (LogMessage *)internal::LogMessage::operator<<(local_50,"CHECK failed: !is_closed_: ");
/* try { // try from 001fbc28 to 001fbc34 has its CatchHandler @ 001fbc69 */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
}
this[0xd] = (CopyingFileOutputStream)0x1;
iVar1 = (anonymous_namespace)::close_no_eintr(*(int *)(this + 8));
if (iVar1 != 0) {
piVar3 = __errno_location();
*(int *)(this + 0x10) = *piVar3;
}
return iVar1 == 0;
}
| |
43,156 | link_to_file_list | eloqsql/storage/maria/ma_pagecache.c | static void link_to_file_list(PAGECACHE *pagecache,
PAGECACHE_BLOCK_LINK *block,
PAGECACHE_FILE *file, my_bool unlink_flag)
{
if (unlink_flag)
unlink_changed(block);
link_changed(block, &pagecache->file_blocks[FILE_HASH(*file, pagecache)]);
if (block->status & PCBLOCK_CHANGED)
{
block->status&= ~(PCBLOCK_CHANGED | PCBLOCK_DEL_WRITE);
block->rec_lsn= LSN_MAX;
pagecache->blocks_changed--;
pagecache->global_blocks_changed--;
}
} | O3 | c | link_to_file_list:
pushq %rbp
movq %rsp, %rbp
testb %cl, %cl
je 0x5257e
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rax
testq %rcx, %rcx
je 0x52579
movq %rax, 0x18(%rcx)
movq 0x10(%rsi), %rcx
jmp 0x5257b
xorl %ecx, %ecx
movq %rcx, (%rax)
movq 0x130(%rdi), %rax
movl 0x28(%rdi), %ecx
decl %ecx
andl 0x10(%rdx), %ecx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsi)
movq (%rax), %rcx
movq %rcx, 0x10(%rsi)
testq %rcx, %rcx
je 0x525a9
leaq 0x10(%rsi), %rdx
movq %rdx, 0x18(%rcx)
movq %rsi, (%rax)
movzwl 0x74(%rsi), %eax
testb $0x20, %al
je 0x525d9
andl $0xff5f, %eax # imm = 0xFF5F
movw %ax, 0x74(%rsi)
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
movq %rax, 0x88(%rsi)
decq 0x58(%rdi)
decq 0x168(%rdi)
popq %rbp
retq
| link_to_file_list:
push rbp
mov rbp, rsp
test cl, cl
jz short loc_5257E
mov rcx, [rsi+10h]
mov rax, [rsi+18h]
test rcx, rcx
jz short loc_52579
mov [rcx+18h], rax
mov rcx, [rsi+10h]
jmp short loc_5257B
loc_52579:
xor ecx, ecx
loc_5257B:
mov [rax], rcx
loc_5257E:
mov rax, [rdi+130h]
mov ecx, [rdi+28h]
dec ecx
and ecx, [rdx+10h]
lea rax, [rax+rcx*8]
mov [rsi+18h], rax
mov rcx, [rax]
mov [rsi+10h], rcx
test rcx, rcx
jz short loc_525A9
lea rdx, [rsi+10h]
mov [rcx+18h], rdx
loc_525A9:
mov [rax], rsi
movzx eax, word ptr [rsi+74h]
test al, 20h
jz short loc_525D9
and eax, 0FF5Fh
mov [rsi+74h], ax
mov rax, 0FFFFFFFFFFFFFFh
mov [rsi+88h], rax
dec qword ptr [rdi+58h]
dec qword ptr [rdi+168h]
loc_525D9:
pop rbp
retn
| long long link_to_file_list(long long a1, long long a2, long long a3, char a4)
{
long long v4; // rcx
_QWORD *v5; // rax
long long v6; // rcx
long long *v7; // rax
long long v8; // rcx
long long result; // rax
if ( a4 )
{
v4 = *(_QWORD *)(a2 + 16);
v5 = *(_QWORD **)(a2 + 24);
if ( v4 )
{
*(_QWORD *)(v4 + 24) = v5;
v6 = *(_QWORD *)(a2 + 16);
}
else
{
v6 = 0LL;
}
*v5 = v6;
}
v7 = (long long *)(*(_QWORD *)(a1 + 304) + 8LL * (*(_DWORD *)(a3 + 16) & (unsigned int)(*(_DWORD *)(a1 + 40) - 1)));
*(_QWORD *)(a2 + 24) = v7;
v8 = *v7;
*(_QWORD *)(a2 + 16) = *v7;
if ( v8 )
*(_QWORD *)(v8 + 24) = a2 + 16;
*v7 = a2;
result = *(unsigned __int16 *)(a2 + 116);
if ( (result & 0x20) != 0 )
{
*(_WORD *)(a2 + 116) = result & 0xFF5F;
result = 0xFFFFFFFFFFFFFFLL;
*(_QWORD *)(a2 + 136) = 0xFFFFFFFFFFFFFFLL;
--*(_QWORD *)(a1 + 88);
--*(_QWORD *)(a1 + 360);
}
return result;
}
| link_to_file_list:
PUSH RBP
MOV RBP,RSP
TEST CL,CL
JZ 0x0015257e
MOV RCX,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RSI + 0x18]
TEST RCX,RCX
JZ 0x00152579
MOV qword ptr [RCX + 0x18],RAX
MOV RCX,qword ptr [RSI + 0x10]
JMP 0x0015257b
LAB_00152579:
XOR ECX,ECX
LAB_0015257b:
MOV qword ptr [RAX],RCX
LAB_0015257e:
MOV RAX,qword ptr [RDI + 0x130]
MOV ECX,dword ptr [RDI + 0x28]
DEC ECX
AND ECX,dword ptr [RDX + 0x10]
LEA RAX,[RAX + RCX*0x8]
MOV qword ptr [RSI + 0x18],RAX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSI + 0x10],RCX
TEST RCX,RCX
JZ 0x001525a9
LEA RDX,[RSI + 0x10]
MOV qword ptr [RCX + 0x18],RDX
LAB_001525a9:
MOV qword ptr [RAX],RSI
MOVZX EAX,word ptr [RSI + 0x74]
TEST AL,0x20
JZ 0x001525d9
AND EAX,0xff5f
MOV word ptr [RSI + 0x74],AX
MOV RAX,0xffffffffffffff
MOV qword ptr [RSI + 0x88],RAX
DEC qword ptr [RDI + 0x58]
DEC qword ptr [RDI + 0x168]
LAB_001525d9:
POP RBP
RET
|
void link_to_file_list(long param_1,long param_2,long param_3,char param_4)
{
long *plVar1;
int8 *puVar2;
long lVar3;
int8 uVar4;
if (param_4 != '\0') {
puVar2 = *(int8 **)(param_2 + 0x18);
if (*(long *)(param_2 + 0x10) == 0) {
uVar4 = 0;
}
else {
*(int8 **)(*(long *)(param_2 + 0x10) + 0x18) = puVar2;
uVar4 = *(int8 *)(param_2 + 0x10);
}
*puVar2 = uVar4;
}
plVar1 = (long *)(*(long *)(param_1 + 0x130) +
(ulong)(*(int *)(param_1 + 0x28) - 1U & *(uint *)(param_3 + 0x10)) * 8);
*(long **)(param_2 + 0x18) = plVar1;
lVar3 = *plVar1;
*(long *)(param_2 + 0x10) = lVar3;
if (lVar3 != 0) {
*(long *)(lVar3 + 0x18) = param_2 + 0x10;
}
*plVar1 = param_2;
if ((*(ushort *)(param_2 + 0x74) & 0x20) != 0) {
*(ushort *)(param_2 + 0x74) = *(ushort *)(param_2 + 0x74) & 0xff5f;
*(int8 *)(param_2 + 0x88) = 0xffffffffffffff;
*(long *)(param_1 + 0x58) = *(long *)(param_1 + 0x58) + -1;
*(long *)(param_1 + 0x168) = *(long *)(param_1 + 0x168) + -1;
}
return;
}
| |
43,157 | js_async_generator_free | bluesky950520[P]quickjs/quickjs.c | static void js_async_generator_free(JSRuntime *rt,
JSAsyncGeneratorData *s)
{
struct list_head *el, *el1;
JSAsyncGeneratorRequest *req;
list_for_each_safe(el, el1, &s->queue) {
req = list_entry(el, JSAsyncGeneratorRequest, link);
JS_FreeValueRT(rt, req->result);
JS_FreeValueRT(rt, req->promise);
JS_FreeValueRT(rt, req->resolving_funcs[0]);
JS_FreeValueRT(rt, req->resolving_funcs[1]);
js_free_rt(rt, req);
}
if (s->state != JS_ASYNC_GENERATOR_STATE_COMPLETED &&
s->state != JS_ASYNC_GENERATOR_STATE_AWAITING_RETURN) {
async_func_free(rt, &s->func_state);
}
js_free_rt(rt, s);
} | O2 | c | js_async_generator_free:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x78(%rsi), %r12
movq 0x80(%rsi), %r15
cmpq %r12, %r15
je 0x4abf7
movq 0x8(%r15), %r13
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %r14, %rdi
callq 0x1bbe1
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
movq %r14, %rdi
callq 0x1bbe1
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rdx
movq %r14, %rdi
callq 0x1bbe1
movq 0x48(%r15), %rsi
movq 0x50(%r15), %rdx
movq %r14, %rdi
callq 0x1bbe1
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ac7b
movq %r13, %r15
jmp 0x4ab9e
movl 0x8(%rbx), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
je 0x4ac0e
leaq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x37e21
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ac7b
| js_async_generator_free:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rsi
mov r14, rdi
lea r12, [rsi+78h]
mov r15, [rsi+80h]
loc_4AB9E:
cmp r15, r12
jz short loc_4ABF7
mov r13, [r15+8]
mov rsi, [r15+18h]
mov rdx, [r15+20h]
mov rdi, r14
call JS_FreeValueRT
mov rsi, [r15+28h]
mov rdx, [r15+30h]
mov rdi, r14
call JS_FreeValueRT
mov rsi, [r15+38h]
mov rdx, [r15+40h]
mov rdi, r14
call JS_FreeValueRT
mov rsi, [r15+48h]
mov rdx, [r15+50h]
mov rdi, r14
call JS_FreeValueRT
mov rdi, r14
mov rsi, r15
call js_free_rt
mov r15, r13
jmp short loc_4AB9E
loc_4ABF7:
mov eax, [rbx+8]
and eax, 0FFFFFFFEh
cmp eax, 4
jz short loc_4AC0E
lea rsi, [rbx+10h]
mov rdi, r14
call async_func_free
loc_4AC0E:
mov rdi, r14
mov rsi, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp js_free_rt
| long long js_async_generator_free(long long a1, long long a2)
{
long long i; // r15
long long v3; // r13
for ( i = *(_QWORD *)(a2 + 128); i != a2 + 120; i = v3 )
{
v3 = *(_QWORD *)(i + 8);
JS_FreeValueRT(a1, *(unsigned int **)(i + 24), *(_QWORD *)(i + 32));
JS_FreeValueRT(a1, *(unsigned int **)(i + 40), *(_QWORD *)(i + 48));
JS_FreeValueRT(a1, *(unsigned int **)(i + 56), *(_QWORD *)(i + 64));
JS_FreeValueRT(a1, *(unsigned int **)(i + 72), *(_QWORD *)(i + 80));
js_free_rt(a1, i);
}
if ( (*(_DWORD *)(a2 + 8) & 0xFFFFFFFE) != 4 )
async_func_free(a1, a2 + 16);
return js_free_rt(a1, a2);
}
| js_async_generator_free:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
LEA R12,[RSI + 0x78]
MOV R15,qword ptr [RSI + 0x80]
LAB_0014ab9e:
CMP R15,R12
JZ 0x0014abf7
MOV R13,qword ptr [R15 + 0x8]
MOV RSI,qword ptr [R15 + 0x18]
MOV RDX,qword ptr [R15 + 0x20]
MOV RDI,R14
CALL 0x0011bbe1
MOV RSI,qword ptr [R15 + 0x28]
MOV RDX,qword ptr [R15 + 0x30]
MOV RDI,R14
CALL 0x0011bbe1
MOV RSI,qword ptr [R15 + 0x38]
MOV RDX,qword ptr [R15 + 0x40]
MOV RDI,R14
CALL 0x0011bbe1
MOV RSI,qword ptr [R15 + 0x48]
MOV RDX,qword ptr [R15 + 0x50]
MOV RDI,R14
CALL 0x0011bbe1
MOV RDI,R14
MOV RSI,R15
CALL 0x0011ac7b
MOV R15,R13
JMP 0x0014ab9e
LAB_0014abf7:
MOV EAX,dword ptr [RBX + 0x8]
AND EAX,0xfffffffe
CMP EAX,0x4
JZ 0x0014ac0e
LEA RSI,[RBX + 0x10]
MOV RDI,R14
CALL 0x00137e21
LAB_0014ac0e:
MOV RDI,R14
MOV RSI,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x0011ac7b
|
void js_async_generator_free(int8 param_1,long param_2)
{
long lVar1;
long lVar2;
lVar2 = *(long *)(param_2 + 0x80);
while (lVar2 != param_2 + 0x78) {
lVar1 = *(long *)(lVar2 + 8);
JS_FreeValueRT(param_1,*(int8 *)(lVar2 + 0x18),*(int8 *)(lVar2 + 0x20));
JS_FreeValueRT(param_1,*(int8 *)(lVar2 + 0x28),*(int8 *)(lVar2 + 0x30));
JS_FreeValueRT(param_1,*(int8 *)(lVar2 + 0x38),*(int8 *)(lVar2 + 0x40));
JS_FreeValueRT(param_1,*(int8 *)(lVar2 + 0x48),*(int8 *)(lVar2 + 0x50));
js_free_rt(param_1,lVar2);
lVar2 = lVar1;
}
if ((*(uint *)(param_2 + 8) & 0xfffffffe) != 4) {
async_func_free(param_1,param_2 + 0x10);
}
js_free_rt(param_1,param_2);
return;
}
| |
43,158 | matrix_d_create | tsotchke[P]eshkol/src/core/utils/vector.c | MatrixD* matrix_d_create(Arena* arena, size_t rows, size_t cols) {
assert(arena != NULL);
assert(rows > 0 && rows <= VECTOR_MAX_DIM);
assert(cols > 0 && cols <= VECTOR_MAX_DIM);
MatrixD* mat = arena_alloc_aligned(arena, sizeof(MatrixD), VECTOR_ALIGNMENT);
if (!mat) {
return NULL;
}
mat->rows = rows;
mat->cols = cols;
memset(mat->data, 0, sizeof(mat->data));
return mat;
} | O0 | c | matrix_d_create:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x633d
jmp 0x635c
leaq 0x3e91(%rip), %rdi # 0xa1d5
leaq 0x540d(%rip), %rsi # 0xb758
movl $0x2f7, %edx # imm = 0x2F7
leaq 0x585a(%rip), %rcx # 0xbbb1
callq 0x1090
cmpq $0x0, -0x18(%rbp)
jbe 0x636c
cmpq $0x4, -0x18(%rbp)
ja 0x636c
jmp 0x638b
leaq 0x57f8(%rip), %rdi # 0xbb6b
leaq 0x53de(%rip), %rsi # 0xb758
movl $0x2f8, %edx # imm = 0x2F8
leaq 0x582b(%rip), %rcx # 0xbbb1
callq 0x1090
cmpq $0x0, -0x20(%rbp)
jbe 0x639b
cmpq $0x4, -0x20(%rbp)
ja 0x639b
jmp 0x63ba
leaq 0x57ec(%rip), %rdi # 0xbb8e
leaq 0x53af(%rip), %rsi # 0xb758
movl $0x2f9, %edx # imm = 0x2F9
leaq 0x57fc(%rip), %rcx # 0xbbb1
callq 0x1090
movq -0x10(%rbp), %rdi
movl $0xa0, %esi
movl $0x20, %edx
callq 0x43d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x63e2
movq $0x0, -0x8(%rbp)
jmp 0x6418
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10a0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| matrix_d_create:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_10], 0
jz short loc_633D
jmp short loc_635C
loc_633D:
lea rdi, aArenaNull; "arena != NULL"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2F7h
lea rcx, aMatrixdMatrixD; "MatrixD *matrix_d_create(Arena *, size_"...
call ___assert_fail
loc_635C:
cmp [rbp+var_18], 0
jbe short loc_636C
cmp [rbp+var_18], 4
ja short loc_636C
jmp short loc_638B
loc_636C:
lea rdi, aRows0RowsVecto; "rows > 0 && rows <= VECTOR_MAX_DIM"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2F8h
lea rcx, aMatrixdMatrixD; "MatrixD *matrix_d_create(Arena *, size_"...
call ___assert_fail
loc_638B:
cmp [rbp+var_20], 0
jbe short loc_639B
cmp [rbp+var_20], 4
ja short loc_639B
jmp short loc_63BA
loc_639B:
lea rdi, aCols0ColsVecto; "cols > 0 && cols <= VECTOR_MAX_DIM"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 2F9h
lea rcx, aMatrixdMatrixD; "MatrixD *matrix_d_create(Arena *, size_"...
call ___assert_fail
loc_63BA:
mov rdi, [rbp+var_10]
mov esi, 0A0h
mov edx, 20h ; ' '
call arena_alloc_aligned
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_63E2
mov [rbp+var_8], 0
jmp short loc_6418
loc_63E2:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_28]
mov [rax+80h], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_28]
mov [rax+88h], rcx
mov rdi, [rbp+var_28]
xor esi, esi
mov edx, 80h
call _memset
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_6418:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long matrix_d_create(_QWORD *a1, unsigned long long a2, unsigned long long a3)
{
long long v4; // [rsp+8h] [rbp-28h]
if ( !a1 )
__assert_fail(
"arena != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/vector.c",
759LL,
"MatrixD *matrix_d_create(Arena *, size_t, size_t)");
if ( !a2 || a2 > 4 )
__assert_fail(
"rows > 0 && rows <= VECTOR_MAX_DIM",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/vector.c",
760LL,
"MatrixD *matrix_d_create(Arena *, size_t, size_t)");
if ( !a3 || a3 > 4 )
__assert_fail(
"cols > 0 && cols <= VECTOR_MAX_DIM",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/core/utils/vector.c",
761LL,
"MatrixD *matrix_d_create(Arena *, size_t, size_t)");
v4 = arena_alloc_aligned(a1, 160LL, 32LL);
if ( !v4 )
return 0LL;
*(_QWORD *)(v4 + 128) = a2;
*(_QWORD *)(v4 + 136) = a3;
memset(v4, 0LL, 128LL);
return v4;
}
| matrix_d_create:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0010633d
JMP 0x0010635c
LAB_0010633d:
LEA RDI,[0x10a1c3]
LEA RSI,[0x10b724]
MOV EDX,0x2f7
LEA RCX,[0x10bb6b]
CALL 0x00101090
LAB_0010635c:
CMP qword ptr [RBP + -0x18],0x0
JBE 0x0010636c
CMP qword ptr [RBP + -0x18],0x4
JA 0x0010636c
JMP 0x0010638b
LAB_0010636c:
LEA RDI,[0x10bb25]
LEA RSI,[0x10b724]
MOV EDX,0x2f8
LEA RCX,[0x10bb6b]
CALL 0x00101090
LAB_0010638b:
CMP qword ptr [RBP + -0x20],0x0
JBE 0x0010639b
CMP qword ptr [RBP + -0x20],0x4
JA 0x0010639b
JMP 0x001063ba
LAB_0010639b:
LEA RDI,[0x10bb48]
LEA RSI,[0x10b724]
MOV EDX,0x2f9
LEA RCX,[0x10bb6b]
CALL 0x00101090
LAB_001063ba:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0xa0
MOV EDX,0x20
CALL 0x001043d0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001063e2
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00106418
LAB_001063e2:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x80],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x88],RCX
MOV RDI,qword ptr [RBP + -0x28]
XOR ESI,ESI
MOV EDX,0x80
CALL 0x001010a0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
LAB_00106418:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
void * matrix_d_create(long param_1,ulong param_2,ulong param_3)
{
void *local_10;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("arena != NULL","/workspace/llm4binary/github2025/eshkol/src/core/utils/vector.c",
0x2f7,"MatrixD *matrix_d_create(Arena *, size_t, size_t)");
}
if ((param_2 != 0) && (param_2 < 5)) {
if ((param_3 != 0) && (param_3 < 5)) {
local_10 = (void *)arena_alloc_aligned(param_1,0xa0,0x20);
if (local_10 == (void *)0x0) {
local_10 = (void *)0x0;
}
else {
*(ulong *)((long)local_10 + 0x80) = param_2;
*(ulong *)((long)local_10 + 0x88) = param_3;
memset(local_10,0,0x80);
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("cols > 0 && cols <= VECTOR_MAX_DIM",
"/workspace/llm4binary/github2025/eshkol/src/core/utils/vector.c",0x2f9,
"MatrixD *matrix_d_create(Arena *, size_t, size_t)");
}
/* WARNING: Subroutine does not return */
__assert_fail("rows > 0 && rows <= VECTOR_MAX_DIM",
"/workspace/llm4binary/github2025/eshkol/src/core/utils/vector.c",0x2f8,
"MatrixD *matrix_d_create(Arena *, size_t, size_t)");
}
| |
43,159 | google::protobuf::io::CopyingOutputStreamAdaptor::BackUp(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc | void CopyingOutputStreamAdaptor::BackUp(int count) {
if (count == 0) {
Flush();
return;
}
GOOGLE_CHECK_GE(count, 0);
GOOGLE_CHECK_EQ(buffer_used_, buffer_size_)
<< " BackUp() can only be called after Next().";
GOOGLE_CHECK_LE(count, buffer_used_)
<< " Can't back up over more bytes than were returned by the last call"
" to Next().";
buffer_used_ -= count;
} | O3 | cpp | google::protobuf::io::CopyingOutputStreamAdaptor::BackUp(int):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testl %esi, %esi
je 0x9d905
movl %esi, %ebp
jns 0x9d83f
leaq 0x2027e(%rip), %rdx # 0xbda80
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x14e, %ecx # imm = 0x14E
callq 0x169ca
leaq 0x2036e(%rip), %rsi # 0xbdb8e
movq %r14, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x8(%rsp), %rdi
callq 0x169e8
movl 0x2c(%rbx), %eax
cmpl 0x28(%rbx), %eax
je 0x9d89d
leaq 0x20232(%rip), %rdx # 0xbda80
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x14f, %ecx # imm = 0x14F
callq 0x169ca
leaq 0x2050d(%rip), %rsi # 0xbdd79
movq %r14, %rdi
callq 0x164c8
leaq 0x2040a(%rip), %rsi # 0xbdc85
movq %rax, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x8(%rsp), %rdi
callq 0x169e8
movl 0x2c(%rbx), %eax
cmpl %ebp, %eax
jge 0x9d8f7
leaq 0x201d8(%rip), %rdx # 0xbda80
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x151, %ecx # imm = 0x151
callq 0x169ca
leaq 0x203ea(%rip), %rsi # 0xbdcb0
movq %r14, %rdi
callq 0x164c8
leaq 0x20405(%rip), %rsi # 0xbdcda
movq %rax, %rdi
callq 0x164c8
leaq 0x7(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x8(%rsp), %rdi
callq 0x169e8
movl 0x2c(%rbx), %eax
subl %ebp, %eax
movl %eax, 0x2c(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9d6cc
jmp 0x9d91f
jmp 0x9d91f
jmp 0x9d91f
jmp 0x9d91f
jmp 0x9d91f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x169e8
movq %rbx, %rdi
callq 0xf570
| _ZN6google8protobuf2io26CopyingOutputStreamAdaptor6BackUpEi:
push rbp
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
test esi, esi
jz loc_9D905
mov ebp, esi
jns short loc_9D83F
lea rdx, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 14Eh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedCou_0; "CHECK failed: (count) >= (0): "
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_9D83F:
mov eax, [rbx+2Ch]
cmp eax, [rbx+28h]
jz short loc_9D89D
lea rdx, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 14Fh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedBuf_0; "CHECK failed: (buffer_used_) == (buffer"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aBackupCanOnlyB_0; " BackUp() can only be called after Next"...
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov eax, [rbx+2Ch]
loc_9D89D:
cmp eax, ebp
jge short loc_9D8F7
lea rdx, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_50]
mov rdi, r14
mov esi, 3
mov ecx, 151h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedCou_1; "CHECK failed: (count) <= (buffer_used_)"...
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rsi, aCanTBackUpOver; " Can't back up over more bytes than wer"...
mov rdi, rax
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_51]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_50]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov eax, [rbx+2Ch]
loc_9D8F7:
sub eax, ebp
mov [rbx+2Ch], eax
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_9D905:
mov rdi, rbx; this
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZN6google8protobuf2io26CopyingOutputStreamAdaptor11WriteBufferEv; google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(void)
jmp short loc_9D91F
jmp short loc_9D91F
jmp short loc_9D91F
jmp short loc_9D91F
jmp short $+2
loc_9D91F:
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::io::CopyingOutputStreamAdaptor::BackUp(
google::protobuf::io::CopyingOutputStreamAdaptor *this,
int a2)
{
google::protobuf::internal::LogMessage *v2; // rax
int v3; // eax
long long v4; // rax
google::protobuf::internal::LogMessage *v5; // rax
long long v6; // rax
google::protobuf::internal::LogMessage *v7; // rax
long long result; // rax
char v9; // [rsp+7h] [rbp-51h] BYREF
_BYTE v10[80]; // [rsp+8h] [rbp-50h] BYREF
if ( !a2 )
return google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(this);
if ( a2 < 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v10,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_str"
"eam_impl_lite.cc",
334);
v2 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v10,
(long long)"CHECK failed: (count) >= (0): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v9, v2);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v10);
}
v3 = *((_DWORD *)this + 11);
if ( v3 != *((_DWORD *)this + 10) )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v10,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_str"
"eam_impl_lite.cc",
335);
v4 = google::protobuf::internal::LogMessage::operator<<(
(long long)v10,
(long long)"CHECK failed: (buffer_used_) == (buffer_size_): ");
v5 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
v4,
(long long)" BackUp() can only be called after Next().");
google::protobuf::internal::LogFinisher::operator=((long long)&v9, v5);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v10);
v3 = *((_DWORD *)this + 11);
}
if ( v3 < a2 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v10,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_str"
"eam_impl_lite.cc",
337);
v6 = google::protobuf::internal::LogMessage::operator<<(
(long long)v10,
(long long)"CHECK failed: (count) <= (buffer_used_): ");
v7 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
v6,
(long long)" Can't back up over more bytes than were returned by the l"
"ast call to Next().");
google::protobuf::internal::LogFinisher::operator=((long long)&v9, v7);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v10);
v3 = *((_DWORD *)this + 11);
}
result = (unsigned int)(v3 - a2);
*((_DWORD *)this + 11) = result;
return result;
}
| BackUp:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
TEST ESI,ESI
JZ 0x0019d905
MOV EBP,ESI
JNS 0x0019d83f
LEA RDX,[0x1bda80]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x14e
CALL 0x001169ca
LAB_0019d819:
LEA RSI,[0x1bdb8e]
MOV RDI,R14
CALL 0x001164c8
LAB_0019d828:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_0019d835:
LEA RDI,[RSP + 0x8]
CALL 0x001169e8
LAB_0019d83f:
MOV EAX,dword ptr [RBX + 0x2c]
CMP EAX,dword ptr [RBX + 0x28]
JZ 0x0019d89d
LEA RDX,[0x1bda80]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x14f
CALL 0x001169ca
LAB_0019d865:
LEA RSI,[0x1bdd79]
MOV RDI,R14
CALL 0x001164c8
LEA RSI,[0x1bdc85]
MOV RDI,RAX
CALL 0x001164c8
LAB_0019d883:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_0019d890:
LEA RDI,[RSP + 0x8]
CALL 0x001169e8
MOV EAX,dword ptr [RBX + 0x2c]
LAB_0019d89d:
CMP EAX,EBP
JGE 0x0019d8f7
LEA RDX,[0x1bda80]
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x151
CALL 0x001169ca
LAB_0019d8bf:
LEA RSI,[0x1bdcb0]
MOV RDI,R14
CALL 0x001164c8
LEA RSI,[0x1bdcda]
MOV RDI,RAX
CALL 0x001164c8
LAB_0019d8dd:
LEA RDI,[RSP + 0x7]
MOV RSI,RAX
CALL 0x001165a2
LAB_0019d8ea:
LEA RDI,[RSP + 0x8]
CALL 0x001169e8
MOV EAX,dword ptr [RBX + 0x2c]
LAB_0019d8f7:
SUB EAX,EBP
MOV dword ptr [RBX + 0x2c],EAX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0019d905:
MOV RDI,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x0019d6cc
|
/* google::protobuf::io::CopyingOutputStreamAdaptor::BackUp(int) */
void __thiscall
google::protobuf::io::CopyingOutputStreamAdaptor::BackUp
(CopyingOutputStreamAdaptor *this,int param_1)
{
int iVar1;
LogMessage *pLVar2;
LogFinisher local_51;
LogMessage local_50 [56];
if (param_1 != 0) {
if (param_1 < 0) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x14e);
/* try { // try from 0019d819 to 0019d827 has its CatchHandler @ 0019d917 */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<(local_50,"CHECK failed: (count) >= (0): ");
/* try { // try from 0019d828 to 0019d834 has its CatchHandler @ 0019d915 */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
}
iVar1 = *(int *)(this + 0x2c);
if (iVar1 != *(int *)(this + 0x28)) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x14f);
/* try { // try from 0019d865 to 0019d882 has its CatchHandler @ 0019d91f */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(local_50,"CHECK failed: (buffer_used_) == (buffer_size_): ");
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<(pLVar2," BackUp() can only be called after Next().")
;
/* try { // try from 0019d883 to 0019d88f has its CatchHandler @ 0019d91b */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
iVar1 = *(int *)(this + 0x2c);
}
if (iVar1 < param_1) {
internal::LogMessage::LogMessage
(local_50,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x151);
/* try { // try from 0019d8bf to 0019d8dc has its CatchHandler @ 0019d91d */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(local_50,"CHECK failed: (count) <= (buffer_used_): ");
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<
(pLVar2,
" Can\'t back up over more bytes than were returned by the last call to Next()."
);
/* try { // try from 0019d8dd to 0019d8e9 has its CatchHandler @ 0019d919 */
internal::LogFinisher::operator=(&local_51,pLVar2);
internal::LogMessage::~LogMessage(local_50);
iVar1 = *(int *)(this + 0x2c);
}
*(int *)(this + 0x2c) = iVar1 - param_1;
return;
}
WriteBuffer(this);
return;
}
| |
43,160 | my_multi_malloc_large | eloqsql/mysys/mulalloc.c | void *my_multi_malloc_large(PSI_memory_key key, myf myFlags, ...)
{
va_list args;
char **ptr,*start,*res;
ulonglong tot_length,length;
DBUG_ENTER("my_multi_malloc");
va_start(args,myFlags);
tot_length=0;
while ((ptr=va_arg(args, char **)))
{
length=va_arg(args,ulonglong);
tot_length+=ALIGN_SIZE(length);
}
va_end(args);
if (!(start=(char *) my_malloc(key, (size_t) tot_length, myFlags)))
DBUG_RETURN(0); /* purecov: inspected */
va_start(args,myFlags);
res=start;
while ((ptr=va_arg(args, char **)))
{
*ptr=res;
length=va_arg(args,ulonglong);
res+=ALIGN_SIZE(length);
}
va_end(args);
DBUG_RETURN((void*) start);
} | O0 | c | my_multi_malloc_large:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0xb2421
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq $0x0, -0x50(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x28, %eax
ja 0xb24ab
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 0xb24c8
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 0xb2563
leaq -0x30(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0xb251b
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 0xb2538
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 0xb2470
leaq -0x30(%rbp), %rax
movl -0xc(%rbp), %edi
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xba940
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0xb2590
jmp 0xb2583
movq $0x0, -0x8(%rbp)
jmp 0xb26c6
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x150(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0x28, %eax
ja 0xb25f7
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 0xb2614
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 0xb26ba
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 0xb2672
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 0xb268f
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 0xb25bc
leaq -0x30(%rbp), %rax
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_multi_malloc_large:
push rbp
mov rbp, rsp
sub rsp, 170h
test al, al
jz short loc_B2421
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_B2421:
mov [rbp+var_E8], r9
mov [rbp+var_F0], r8
mov [rbp+var_F8], rcx
mov [rbp+var_100], rdx
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov [rbp+var_50], 0
loc_B2470:
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_B24AB
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_B24C8
loc_B24AB:
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_B24C8:
mov rax, [rbp+var_128]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_B2563
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_B251B
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_B2538
loc_B251B:
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_B2538:
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_B2470
loc_B2563:
lea rax, [rbp+var_30]
mov edi, [rbp+var_C]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_18]
call my_malloc
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_B2590
jmp short $+2
loc_B2583:
mov [rbp+var_8], 0
jmp loc_B26C6
loc_B2590:
lea rax, [rbp+var_30]
lea rcx, [rbp+var_110]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
loc_B25BC:
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_B25F7
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_B2614
loc_B25F7:
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_B2614:
mov rax, [rbp+var_158]
mov rax, [rax]
mov [rbp+var_38], rax
cmp rax, 0
jz loc_B26BA
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_B2672
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_B268F
loc_B2672:
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_B268F:
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_B25BC
loc_B26BA:
lea rax, [rbp+var_30]
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_B26C6:
mov rax, [rbp+var_8]
add rsp, 170h
pop rbp
retn
| long long my_multi_malloc_large(unsigned int a1, long long a2, ...)
{
_QWORD *overflow_arg_area; // rax
_QWORD *v3; // rax
_QWORD *v4; // rax
_QWORD *v5; // rax
long long i; // [rsp+120h] [rbp-50h]
long long j; // [rsp+128h] [rbp-48h]
long long v9; // [rsp+130h] [rbp-40h]
va_list va; // [rsp+140h] [rbp-30h] BYREF
long long v11; // [rsp+158h] [rbp-18h]
unsigned int v12; // [rsp+164h] [rbp-Ch]
va_start(va, a2);
v12 = a1;
v11 = a2;
for ( i = 0LL; ; i += (*v3 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
overflow_arg_area = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
overflow_arg_area = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*overflow_arg_area )
break;
if ( va[0].gp_offset > 0x28 )
{
v3 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v3 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
v9 = my_malloc(v12, i, v11);
if ( !v9 )
return 0LL;
va_end(va);
va_start(va, a2);
for ( j = v9; ; j += (*v5 + 7LL) & 0xFFFFFFFFFFFFFFF8LL )
{
if ( va[0].gp_offset > 0x28 )
{
v4 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v4 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
if ( !*v4 )
break;
*(_QWORD *)*v4 = j;
if ( va[0].gp_offset > 0x28 )
{
v5 = va[0].overflow_arg_area;
va[0].overflow_arg_area = (char *)va[0].overflow_arg_area + 8;
}
else
{
v5 = (char *)va[0].reg_save_area + (int)va[0].gp_offset;
va[0].gp_offset += 8;
}
}
return v9;
}
| my_multi_malloc_large:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x170
TEST AL,AL
JZ 0x001b2421
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_001b2421:
MOV qword ptr [RBP + -0xe8],R9
MOV qword ptr [RBP + -0xf0],R8
MOV qword ptr [RBP + -0xf8],RCX
MOV qword ptr [RBP + -0x100],RDX
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV qword ptr [RBP + -0x50],0x0
LAB_001b2470:
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 0x001b24ab
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 0x001b24c8
LAB_001b24ab:
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_001b24c8:
MOV RAX,qword ptr [RBP + -0x128]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001b2563
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 0x001b251b
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 0x001b2538
LAB_001b251b:
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_001b2538:
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 0x001b2470
LAB_001b2563:
LEA RAX,[RBP + -0x30]
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001ba940
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x001b2590
JMP 0x001b2583
LAB_001b2583:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001b26c6
LAB_001b2590:
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0x110]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
LAB_001b25bc:
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 0x001b25f7
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 0x001b2614
LAB_001b25f7:
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_001b2614:
MOV RAX,qword ptr [RBP + -0x158]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JZ 0x001b26ba
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 0x001b2672
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 0x001b268f
LAB_001b2672:
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_001b268f:
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 0x001b25bc
LAB_001b26ba:
LEA RAX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_001b26c6:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x170
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long my_multi_malloc_large
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long *local_178;
long *local_160;
long *local_148;
long *local_130;
long local_118 [4];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
long local_60;
long local_58;
long local_50;
long local_40;
uint local_38;
int4 local_34;
long *local_30;
long *local_28;
int8 local_20;
int4 local_14;
long local_10;
if (in_AL != '\0') {
local_e8 = param_1;
local_d8 = param_2;
local_c8 = param_3;
local_b8 = param_4;
local_a8 = param_5;
local_98 = param_6;
local_88 = param_7;
local_78 = param_8;
}
local_28 = local_118;
local_30 = (long *)&stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
local_58 = 0;
while( true ) {
if (local_38 < 0x29) {
local_130 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_130 = local_30;
local_30 = local_30 + 1;
}
local_40 = *local_130;
if (local_40 == 0) break;
if (local_38 < 0x29) {
local_148 = (long *)((long)local_28 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_148 = local_30;
local_30 = local_30 + 1;
}
local_60 = *local_148;
local_58 = (local_60 + 7U & 0xfffffffffffffff8) + local_58;
}
local_118[2] = param_11;
local_118[3] = param_12;
local_f8 = param_13;
local_f0 = param_14;
local_20 = param_10;
local_14 = param_9;
local_10 = my_malloc(param_9,local_58,param_10);
if (local_10 == 0) {
local_10 = 0;
}
else {
local_30 = (long *)&stack0x00000008;
local_38 = 0x10;
local_50 = local_10;
while( true ) {
if (local_38 < 0x29) {
local_160 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_160 = local_30;
local_30 = local_30 + 1;
}
if ((long *)*local_160 == (long *)0x0) break;
*(long *)*local_160 = local_50;
if (local_38 < 0x29) {
local_178 = (long *)((long)local_118 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_178 = local_30;
local_30 = local_30 + 1;
}
local_50 = (*local_178 + 7U & 0xfffffffffffffff8) + local_50;
}
}
return local_10;
}
| |
43,161 | llama_sampler_chain_free(llama_sampler*) | monkey531[P]llama/src/llama-sampling.cpp | static void llama_sampler_chain_free(struct llama_sampler * smpl) {
auto * chain = (llama_sampler_chain *) smpl->ctx;
for (auto * smpl : chain->samplers) {
llama_sampler_free(smpl);
}
delete chain;
} | O3 | cpp | llama_sampler_chain_free(llama_sampler*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r12
cmpq %r12, %r14
je 0xdccc5
movq (%r14), %r15
testq %r15, %r15
je 0xdccb3
movq (%r15), %rax
movq 0x28(%rax), %rax
testq %rax, %rax
je 0xdcca6
movq %r15, %rdi
callq *%rax
movl $0x10, %esi
movq %r15, %rdi
callq 0x681a0
addq $0x8, %r14
cmpq %r12, %r14
jne 0xdcc8d
testq %rbx, %rbx
je 0xdccd9
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xdccd9
movq 0x18(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x681a0
movl $0x30, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x681a0
| _ZL24llama_sampler_chain_freeP13llama_sampler:
push r15
push r14
push r12
push rbx
push rax
mov rbx, [rdi+8]
mov r14, [rbx+8]
mov r12, [rbx+10h]
cmp r14, r12
jz short loc_DCCC5
loc_DCC8D:
mov r15, [r14]
test r15, r15
jz short loc_DCCB3
mov rax, [r15]
mov rax, [rax+28h]
test rax, rax
jz short loc_DCCA6
mov rdi, r15
call rax
loc_DCCA6:
mov esi, 10h; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_DCCB3:
add r14, 8
cmp r14, r12
jnz short loc_DCC8D
test rbx, rbx
jz short loc_DCCD9
mov r14, [rbx+8]
loc_DCCC5:
test r14, r14
jz short loc_DCCD9
mov rsi, [rbx+18h]
sub rsi, r14; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_DCCD9:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp __ZdlPvm; operator delete(void *,ulong)
| void llama_sampler_chain_free(long long a1)
{
_QWORD *v1; // rbx
_QWORD *v2; // r14
_QWORD *v3; // r12
void *v4; // r15
void ( *v5)(_QWORD); // rax
v1 = *(_QWORD **)(a1 + 8);
v2 = (_QWORD *)v1[1];
v3 = (_QWORD *)v1[2];
if ( v2 == v3 )
{
LABEL_9:
if ( v2 )
operator delete(v2, v1[3] - (_QWORD)v2);
goto LABEL_11;
}
do
{
v4 = (void *)*v2;
if ( *v2 )
{
v5 = *(void ( **)(_QWORD))(*(_QWORD *)v4 + 40LL);
if ( v5 )
v5(*v2);
operator delete(v4, 0x10uLL);
}
++v2;
}
while ( v2 != v3 );
if ( v1 )
{
v2 = (_QWORD *)v1[1];
goto LABEL_9;
}
LABEL_11:
operator delete(v1, 0x30uLL);
}
| llama_sampler_chain_free:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RBX + 0x8]
MOV R12,qword ptr [RBX + 0x10]
CMP R14,R12
JZ 0x001dccc5
LAB_001dcc8d:
MOV R15,qword ptr [R14]
TEST R15,R15
JZ 0x001dccb3
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x001dcca6
MOV RDI,R15
CALL RAX
LAB_001dcca6:
MOV ESI,0x10
MOV RDI,R15
CALL 0x001681a0
LAB_001dccb3:
ADD R14,0x8
CMP R14,R12
JNZ 0x001dcc8d
TEST RBX,RBX
JZ 0x001dccd9
MOV R14,qword ptr [RBX + 0x8]
LAB_001dccc5:
TEST R14,R14
JZ 0x001dccd9
MOV RSI,qword ptr [RBX + 0x18]
SUB RSI,R14
MOV RDI,R14
CALL 0x001681a0
LAB_001dccd9:
MOV ESI,0x30
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x001681a0
|
/* llama_sampler_chain_free(llama_sampler*) */
void llama_sampler_chain_free(llama_sampler *param_1)
{
void *pvVar1;
int8 *puVar2;
long *plVar3;
int8 *puVar4;
pvVar1 = *(void **)(param_1 + 8);
puVar4 = *(int8 **)((long)pvVar1 + 8);
puVar2 = *(int8 **)((long)pvVar1 + 0x10);
if (puVar4 != puVar2) {
do {
plVar3 = (long *)*puVar4;
if (plVar3 != (long *)0x0) {
if (*(code **)(*plVar3 + 0x28) != (code *)0x0) {
(**(code **)(*plVar3 + 0x28))(plVar3);
}
operator_delete(plVar3,0x10);
}
puVar4 = puVar4 + 1;
} while (puVar4 != puVar2);
if (pvVar1 == (void *)0x0) goto LAB_001dccd9;
puVar4 = *(int8 **)((long)pvVar1 + 8);
}
if (puVar4 != (int8 *)0x0) {
operator_delete(puVar4,*(long *)((long)pvVar1 + 0x18) - (long)puVar4);
}
LAB_001dccd9:
operator_delete(pvVar1,0x30);
return;
}
| |
43,162 | js_std_file_puts | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_puts(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f;
int i;
const char *str;
size_t len;
if (magic == 0) {
f = stdout;
} else {
f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
}
for(i = 0; i < argc; i++) {
str = JS_ToCStringLen(ctx, &len, argv[i]);
if (!str)
return JS_EXCEPTION;
fwrite(str, 1, len, f);
JS_FreeCString(ctx, str);
}
return JS_UNDEFINED;
} | O0 | c | js_std_file_puts:
subq $0x68, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movl %r9d, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x12a89
movq 0x123531(%rip), %rax # 0x135fb0
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x12ac2
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x13a80
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x12ac0
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0x12b64
jmp 0x12ac2
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x12b53
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x8(%rsp), %rsi
callq 0x13b30
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x12b1b
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0x12b64
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0xe8c0
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x29e50
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12aca
movl $0x0, 0x58(%rsp)
movq $0x3, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| js_std_file_puts:
sub rsp, 68h
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_28], rdi
mov [rsp+68h+var_2C], ecx
mov [rsp+68h+var_38], r8
mov [rsp+68h+var_3C], r9d
cmp [rsp+68h+var_3C], 0
jnz short loc_12A89
mov rax, cs:stdout_ptr
mov rax, [rax]
mov [rsp+68h+var_48], rax
jmp short loc_12AC2
loc_12A89:
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_18]
call js_std_file_get
mov [rsp+68h+var_48], rax
cmp [rsp+68h+var_48], 0
jnz short loc_12AC0
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp loc_12B64
loc_12AC0:
jmp short $+2
loc_12AC2:
mov [rsp+68h+var_4C], 0
loc_12ACA:
mov eax, [rsp+68h+var_4C]
cmp eax, [rsp+68h+var_2C]
jge short loc_12B53
mov rdi, [rsp+68h+var_28]
mov rax, [rsp+68h+var_38]
movsxd rcx, [rsp+68h+var_4C]
shl rcx, 4
add rax, rcx
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+68h+var_60]
call JS_ToCStringLen
mov [rsp+68h+var_58], rax
cmp [rsp+68h+var_58], 0
jnz short loc_12B1B
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp short loc_12B64
loc_12B1B:
mov rdi, [rsp+68h+var_58]
mov rdx, [rsp+68h+var_60]
mov rcx, [rsp+68h+var_48]
mov esi, 1
call _fwrite
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_58]
call JS_FreeCString
mov eax, [rsp+68h+var_4C]
add eax, 1
mov [rsp+68h+var_4C], eax
jmp loc_12ACA
loc_12B53:
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 3
loc_12B64:
mov rax, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_8]
add rsp, 68h
retn
| long long js_std_file_puts(long long a1, long long a2, long long a3, int a4, long long a5, int a6)
{
long long v7; // [rsp+8h] [rbp-60h] BYREF
long long v8; // [rsp+10h] [rbp-58h]
int i; // [rsp+1Ch] [rbp-4Ch]
long long v10; // [rsp+20h] [rbp-48h]
int v11; // [rsp+2Ch] [rbp-3Ch]
long long v12; // [rsp+30h] [rbp-38h]
int v13; // [rsp+3Ch] [rbp-2Ch]
long long v14; // [rsp+40h] [rbp-28h]
long long v15; // [rsp+48h] [rbp-20h]
long long v16; // [rsp+50h] [rbp-18h]
long long v17; // [rsp+58h] [rbp-10h]
long long v18; // [rsp+60h] [rbp-8h]
v15 = a2;
v16 = a3;
v14 = a1;
v13 = a4;
v12 = a5;
v11 = a6;
if ( a6 )
{
v10 = js_std_file_get(v14, v15, v16);
if ( !v10 )
{
LODWORD(v17) = 0;
v18 = 6LL;
return v17;
}
}
else
{
v10 = stdout;
}
for ( i = 0; i < v13; ++i )
{
v8 = JS_ToCStringLen(v14, &v7, *(_QWORD *)(16LL * i + v12), *(_QWORD *)(16LL * i + v12 + 8));
if ( !v8 )
{
LODWORD(v17) = 0;
v18 = 6LL;
return v17;
}
fwrite(v8, 1LL, v7, v10);
JS_FreeCString(v14, v8);
}
LODWORD(v17) = 0;
v18 = 3LL;
return v17;
}
| js_std_file_puts:
SUB RSP,0x68
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ECX
MOV qword ptr [RSP + 0x30],R8
MOV dword ptr [RSP + 0x2c],R9D
CMP dword ptr [RSP + 0x2c],0x0
JNZ 0x00112a89
MOV RAX,qword ptr [0x00235fb0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00112ac2
LAB_00112a89:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00113a80
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x00112ac0
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x00112b64
LAB_00112ac0:
JMP 0x00112ac2
LAB_00112ac2:
MOV dword ptr [RSP + 0x1c],0x0
LAB_00112aca:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x3c]
JGE 0x00112b53
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x00113b30
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00112b1b
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x00112b64
LAB_00112b1b:
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x20]
MOV ESI,0x1
CALL 0x0010e8c0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00129e50
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x00112aca
LAB_00112b53:
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x3
LAB_00112b64:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
int1 [16]
js_std_file_puts(int8 param_1,int8 param_2,int8 param_3,int param_4,long param_5,
int param_6)
{
int1 auVar1 [16];
int8 *puVar2;
size_t local_60;
void *local_58;
int local_4c;
FILE *local_48;
int local_3c;
long local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 uStack_c;
int8 local_8;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
if (param_6 == 0) {
local_48 = *(FILE **)PTR_stdout_00235fb0;
}
else {
local_48 = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (local_48 == (FILE *)0x0) {
local_8 = 6;
goto LAB_00112b64;
}
}
for (local_4c = 0; local_4c < local_2c; local_4c = local_4c + 1) {
puVar2 = (int8 *)(local_38 + (long)local_4c * 0x10);
local_58 = (void *)JS_ToCStringLen(local_28,&local_60,*puVar2,puVar2[1]);
if (local_58 == (void *)0x0) {
local_8 = 6;
goto LAB_00112b64;
}
fwrite(local_58,1,local_60,local_48);
JS_FreeCString(local_28,local_58);
}
local_8 = 3;
LAB_00112b64:
auVar1._4_8_ = local_8;
auVar1._0_4_ = uStack_c;
auVar1._12_4_ = 0;
return auVar1 << 0x20;
}
| |
43,163 | js_std_file_puts | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_puts(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f;
int i;
const char *str;
size_t len;
if (magic == 0) {
f = stdout;
} else {
f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
}
for(i = 0; i < argc; i++) {
str = JS_ToCStringLen(ctx, &len, argv[i]);
if (!str)
return JS_EXCEPTION;
fwrite(str, 1, len, f);
JS_FreeCString(ctx, str);
}
return JS_UNDEFINED;
} | O1 | c | js_std_file_puts:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movq %rdi, %r14
testl %r9d, %r9d
je 0x15fa6
movq %r14, %rdi
callq 0x16588
movq %rax, %r12
testq %rax, %rax
jne 0x15fb0
movl $0x6, %edx
jmp 0x1600f
movq 0xb7003(%rip), %rax # 0xccfb0
movq (%rax), %r12
movl $0x3, %edx
testl %ebp, %ebp
jle 0x1600f
movl %ebp, %r15d
shlq $0x4, %r15
xorl %r13d, %r13d
movq (%rbx,%r13), %rdx
movq 0x8(%rbx,%r13), %rcx
movq %r14, %rdi
movq %rsp, %rsi
xorl %r8d, %r8d
callq 0x20bf7
testq %rax, %rax
je 0x15f9f
movq %rax, %rbp
movq (%rsp), %rdx
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rcx
callq 0xe8d0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x20edd
addq $0x10, %r13
cmpq %r13, %r15
jne 0x15fc3
movl $0x3, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_std_file_puts:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov ebp, ecx
mov r14, rdi
test r9d, r9d
jz short loc_15FA6
mov rdi, r14
call js_std_file_get
mov r12, rax
test rax, rax
jnz short loc_15FB0
loc_15F9F:
mov edx, 6
jmp short loc_1600F
loc_15FA6:
mov rax, cs:stdout_ptr
mov r12, [rax]
loc_15FB0:
mov edx, 3
test ebp, ebp
jle short loc_1600F
mov r15d, ebp
shl r15, 4
xor r13d, r13d
loc_15FC3:
mov rdx, [rbx+r13]
mov rcx, [rbx+r13+8]
mov rdi, r14
mov rsi, rsp
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_15F9F
mov rbp, rax
mov rdx, [rsp+38h+var_38]
mov esi, 1
mov rdi, rax
mov rcx, r12
call _fwrite
mov rdi, r14
mov rsi, rbp
call JS_FreeCString
add r13, 10h
cmp r15, r13
jnz short loc_15FC3
mov edx, 3
loc_1600F:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_std_file_puts(long long a1, long long a2, long long a3, int a4, long long a5, int a6)
{
long long v6; // rax
long long v9; // r12
long long v10; // r15
long long v11; // r13
long long v12; // rax
long long v13; // rbp
_QWORD v15[7]; // [rsp+0h] [rbp-38h] BYREF
v15[0] = v6;
if ( a6 )
{
v9 = js_std_file_get(a1);
if ( !v9 )
return 0LL;
}
else
{
v9 = stdout;
}
if ( a4 > 0 )
{
v10 = 16LL * (unsigned int)a4;
v11 = 0LL;
do
{
v12 = JS_ToCStringLen2(a1, v15, *(_QWORD *)(a5 + v11), *(_QWORD *)(a5 + v11 + 8), 0LL);
if ( !v12 )
break;
v13 = v12;
fwrite(v12, 1LL, v15[0], v9);
JS_FreeCString(a1, v13);
v11 += 16LL;
}
while ( v10 != v11 );
}
return 0LL;
}
| |||
43,164 | js_std_file_puts | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_file_puts(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
FILE *f;
int i;
const char *str;
size_t len;
if (magic == 0) {
f = stdout;
} else {
f = js_std_file_get(ctx, this_val);
if (!f)
return JS_EXCEPTION;
}
for(i = 0; i < argc; i++) {
str = JS_ToCStringLen(ctx, &len, argv[i]);
if (!str)
return JS_EXCEPTION;
fwrite(str, 1, len, f);
JS_FreeCString(ctx, str);
}
return JS_UNDEFINED;
} | O2 | c | js_std_file_puts:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r15d
movq %rdi, %r12
pushq $0x6
popq %rbx
testl %r9d, %r9d
je 0x10e31
movq %r12, %rdi
callq 0x113c6
movq %rax, %r13
testq %rax, %rax
jne 0x10e3b
jmp 0x10e93
movq 0xaa178(%rip), %rax # 0xbafb0
movq (%rax), %r13
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
shlq $0x4, %r15
cmpq %rbp, %r15
je 0x10e8c
movq (%r14,%rbp), %rdx
movq 0x8(%r14,%rbp), %rcx
movq %r12, %rdi
movq %rsp, %rsi
callq 0x11421
testq %rax, %rax
je 0x10e90
movq %rax, %rbx
movq (%rsp), %rdx
movq %rax, %rdi
pushq $0x1
popq %rsi
movq %r13, %rcx
callq 0xe8f0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1b057
addq $0x10, %rbp
jmp 0x10e48
pushq $0x3
jmp 0x10e92
pushq $0x6
popq %rbx
xorl %eax, %eax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_std_file_puts:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r8
mov r15d, ecx
mov r12, rdi
push 6
pop rbx
test r9d, r9d
jz short loc_10E31
mov rdi, r12
call js_std_file_get
mov r13, rax
test rax, rax
jnz short loc_10E3B
jmp short loc_10E93
loc_10E31:
mov rax, cs:stdout_ptr
mov r13, [rax]
loc_10E3B:
xor ebp, ebp
test r15d, r15d
cmovle r15d, ebp
shl r15, 4
loc_10E48:
cmp r15, rbp
jz short loc_10E8C
mov rdx, [r14+rbp]
mov rcx, [r14+rbp+8]
mov rdi, r12
mov rsi, rsp
call JS_ToCStringLen
test rax, rax
jz short loc_10E90
mov rbx, rax
mov rdx, [rsp+38h+var_38]
mov rdi, rax
push 1
pop rsi
mov rcx, r13
call _fwrite
mov rdi, r12
mov rsi, rbx
call JS_FreeCString
add rbp, 10h
jmp short loc_10E48
loc_10E8C:
push 3
jmp short loc_10E92
loc_10E90:
push 6
loc_10E92:
pop rbx
loc_10E93:
xor eax, eax
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_std_file_puts(long long a1, long long a2, long long a3, unsigned int a4, long long a5, int a6)
{
long long v6; // rax
long long v8; // r15
long long v9; // r13
long long v10; // rbp
long long v11; // r15
long long v12; // rax
long long v13; // rbx
_QWORD v15[7]; // [rsp+0h] [rbp-38h] BYREF
v15[0] = v6;
v8 = a4;
if ( a6 )
{
v9 = js_std_file_get(a1);
if ( !v9 )
return 0LL;
}
else
{
v9 = stdout;
}
v10 = 0LL;
if ( (int)v8 <= 0 )
v8 = 0LL;
v11 = 16 * v8;
while ( v11 != v10 )
{
v12 = JS_ToCStringLen(a1, v15, *(_QWORD *)(a5 + v10), *(_QWORD *)(a5 + v10 + 8));
if ( !v12 )
break;
v13 = v12;
fwrite(v12, 1LL, v15[0], v9);
JS_FreeCString(a1, v13);
v10 += 16LL;
}
return 0LL;
}
| js_std_file_puts:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R8
MOV R15D,ECX
MOV R12,RDI
PUSH 0x6
POP RBX
TEST R9D,R9D
JZ 0x00110e31
MOV RDI,R12
CALL 0x001113c6
MOV R13,RAX
TEST RAX,RAX
JNZ 0x00110e3b
JMP 0x00110e93
LAB_00110e31:
MOV RAX,qword ptr [0x001bafb0]
MOV R13,qword ptr [RAX]
LAB_00110e3b:
XOR EBP,EBP
TEST R15D,R15D
CMOVLE R15D,EBP
SHL R15,0x4
LAB_00110e48:
CMP R15,RBP
JZ 0x00110e8c
MOV RDX,qword ptr [R14 + RBP*0x1]
MOV RCX,qword ptr [R14 + RBP*0x1 + 0x8]
MOV RDI,R12
MOV RSI,RSP
CALL 0x00111421
TEST RAX,RAX
JZ 0x00110e90
MOV RBX,RAX
MOV RDX,qword ptr [RSP]
MOV RDI,RAX
PUSH 0x1
POP RSI
MOV RCX,R13
CALL 0x0010e8f0
MOV RDI,R12
MOV RSI,RBX
CALL 0x0011b057
ADD RBP,0x10
JMP 0x00110e48
LAB_00110e8c:
PUSH 0x3
JMP 0x00110e92
LAB_00110e90:
PUSH 0x6
LAB_00110e92:
POP RBX
LAB_00110e93:
XOR EAX,EAX
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_std_file_puts(int8 param_1,int8 param_2,int8 param_3,uint param_4,long param_5,
int param_6)
{
int1 auVar1 [16];
size_t in_RAX;
FILE *__s;
void *__ptr;
ulong uVar2;
ulong uVar3;
ulong uStack_40;
size_t local_38;
uStack_40 = 6;
local_38 = in_RAX;
if (param_6 == 0) {
__s = *(FILE **)PTR_stdout_001bafb0;
}
else {
__s = (FILE *)js_std_file_get(param_1);
if (__s == (FILE *)0x0) goto LAB_00110e93;
}
uVar2 = 0;
uVar3 = (ulong)param_4;
if ((int)param_4 < 1) {
uVar3 = uVar2;
}
for (; uVar3 * 0x10 != uVar2; uVar2 = uVar2 + 0x10) {
__ptr = (void *)JS_ToCStringLen(param_1,&local_38,*(int8 *)(param_5 + uVar2),
*(int8 *)(param_5 + 8 + uVar2));
if (__ptr == (void *)0x0) {
uStack_40 = 6;
goto LAB_00110e93;
}
fwrite(__ptr,1,local_38,__s);
JS_FreeCString(param_1,__ptr);
}
uStack_40 = 3;
LAB_00110e93:
auVar1._8_8_ = 0;
auVar1._0_8_ = uStack_40;
return auVar1 << 0x40;
}
| |
43,165 | check_variable | eloqsql/libmariadb/unittest/libmariadb/my_test.h | int check_variable(MYSQL *mysql, const char *variable, const char *value)
{
char query[MAX_TEST_QUERY_LENGTH];
MYSQL_RES *result;
MYSQL_ROW row;
sprintf(query, "SELECT %s", variable);
result= mysql_store_result(mysql);
if (!result)
return FAIL;
if ((row = mysql_fetch_row(result)))
if (strcmp(row[0], value) == 0) {
mysql_free_result(result);
return OK;
}
mysql_free_result(result);
return FAIL;
} | O3 | c | check_variable:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rdx, %rbx
movq %rsi, %r8
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x252a3(%rip), %rcx # 0x3923f
leaq -0x150(%rbp), %rdi
movl $0x1, %r14d
movl $0x12c, %edx # imm = 0x12C
movl $0x1, %esi
xorl %eax, %eax
callq 0x132a0
movq %r15, %rdi
callq 0x20549
testq %rax, %rax
je 0x13ff1
movq %rax, %r15
movq %rax, %rdi
callq 0x2074c
testq %rax, %rax
je 0x13fe9
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x13640
testl %eax, %eax
jne 0x13fe9
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x1b2fe
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x14011
movl %r14d, %eax
addq $0x138, %rsp # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| check_variable:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 138h
mov rbx, rdx
mov r8, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
lea rcx, aSelectS; "SELECT %s"
lea rdi, [rbp+var_150]
mov r14d, 1
mov edx, 12Ch
mov esi, 1
xor eax, eax
call ___sprintf_chk
mov rdi, r15
call mysql_store_result
test rax, rax
jz short loc_13FF1
mov r15, rax
mov rdi, rax
call mysql_fetch_row
test rax, rax
jz short loc_13FE9
mov rdi, [rax]
mov rsi, rbx
call _strcmp
test eax, eax
jnz short loc_13FE9
xor r14d, r14d
loc_13FE9:
mov rdi, r15
call mysql_free_result
loc_13FF1:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_14011
mov eax, r14d
add rsp, 138h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_14011:
call ___stack_chk_fail
| _BOOL8 check_variable(long long a1, const char *a2, long long a3)
{
BOOL v4; // r14d
long long v5; // rax
long long v6; // r15
_QWORD *row; // rax
_BYTE v9[304]; // [rsp+0h] [rbp-150h] BYREF
unsigned long long v10; // [rsp+130h] [rbp-20h]
v10 = __readfsqword(0x28u);
v4 = 1;
__sprintf_chk(v9, 1LL, 300LL, "SELECT %s", a2);
v5 = mysql_store_result(a1);
if ( v5 )
{
v6 = v5;
row = (_QWORD *)mysql_fetch_row(v5);
if ( row )
v4 = strcmp(*row, a3) != 0;
mysql_free_result(v6);
}
return v4;
}
| check_variable:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x138
MOV RBX,RDX
MOV R8,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA RCX,[0x13923f]
LEA RDI,[RBP + -0x150]
MOV R14D,0x1
MOV EDX,0x12c
MOV ESI,0x1
XOR EAX,EAX
CALL 0x001132a0
MOV RDI,R15
CALL 0x00120549
TEST RAX,RAX
JZ 0x00113ff1
MOV R15,RAX
MOV RDI,RAX
CALL 0x0012074c
TEST RAX,RAX
JZ 0x00113fe9
MOV RDI,qword ptr [RAX]
MOV RSI,RBX
CALL 0x00113640
TEST EAX,EAX
JNZ 0x00113fe9
XOR R14D,R14D
LAB_00113fe9:
MOV RDI,R15
CALL 0x0011b2fe
LAB_00113ff1:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00114011
MOV EAX,R14D
ADD RSP,0x138
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00114011:
CALL 0x00113500
|
int8 check_variable(int8 param_1,int8 param_2,char *param_3)
{
int iVar1;
long lVar2;
int8 *puVar3;
int8 uVar4;
long in_FS_OFFSET;
int1 local_158 [304];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = 1;
__sprintf_chk(local_158,1,300,"SELECT %s",param_2);
lVar2 = mysql_store_result(param_1);
if (lVar2 != 0) {
puVar3 = (int8 *)mysql_fetch_row(lVar2);
if (puVar3 != (int8 *)0x0) {
iVar1 = strcmp((char *)*puVar3,param_3);
if (iVar1 == 0) {
uVar4 = 0;
}
}
mysql_free_result(lVar2);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,166 | mysql_stmt_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_close_cont(my_bool *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
TRUE,
r_my_bool)
} | O3 | c | mysql_stmt_close_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x2c886
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x2daab
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2c8e9
movl (%r15), %r15d
jmp 0x2c95f
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1c220(%rip), %rax # 0x48ac0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1c205(%rip), %rax # 0x48ad0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, (%rbx)
jmp 0x2c95f
movb $0x0, 0x15(%r15)
js 0x2c8f6
movb 0x8(%r15), %al
jmp 0x2c95a
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1c1ac(%rip), %rax # 0x48ac0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1c191(%rip), %rax # 0x48ad0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movb $0x1, %al
movb %al, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_close_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_2C886
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_2C8E9
mov r15d, [r15]
jmp loc_2C95F
loc_2C886:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov byte ptr [rbx], 1
jmp short loc_2C95F
loc_2C8E9:
mov byte ptr [r15+15h], 0
js short loc_2C8F6
mov al, [r15+8]
jmp short loc_2C95A
loc_2C8F6:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov al, 1
loc_2C95A:
mov [rbx], al
xor r15d, r15d
loc_2C95F:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_close_cont(char *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
char v7; // al
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = *((_BYTE *)v4 + 8);
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_close_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0012c886
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x0012daab
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012c8e9
MOV R15D,dword ptr [R15]
JMP 0x0012c95f
LAB_0012c886:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148ac0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148ad0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV byte ptr [RBX],0x1
JMP 0x0012c95f
LAB_0012c8e9:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0012c8f6
MOV AL,byte ptr [R15 + 0x8]
JMP 0x0012c95a
LAB_0012c8f6:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148ac0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x148ad0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV AL,0x1
LAB_0012c95a:
MOV byte ptr [RBX],AL
XOR R15D,R15D
LAB_0012c95f:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_close_cont(int1 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int1 uVar2;
int iVar3;
int4 uVar4;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar4 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_00148b40,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar3 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar3 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar3 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00148b10,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar2 = 1;
}
else {
uVar2 = *(int1 *)(puVar1 + 2);
}
*param_1 = uVar2;
uVar4 = 0;
}
else {
uVar4 = *puVar1;
}
}
return uVar4;
}
| |
43,167 | ma_update_static_record | eloqsql/storage/maria/ma_statrec.c | my_bool _ma_update_static_record(MARIA_HA *info, MARIA_RECORD_POS pos,
const uchar *oldrec __attribute__ ((unused)),
const uchar *record)
{
info->rec_cache.seek_not_done=1; /* We have done a seek */
return (info->s->file_write(info,
record, info->s->base.reclength,
pos,
MYF(MY_NABP)) != 0);
} | O0 | c | ma_update_static_record:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x598(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x6e8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x398(%rcx), %rdx
movq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ma_update_static_record:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov dword ptr [rax+598h], 1
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+6E8h]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov rdx, [rcx+398h]
mov rcx, [rbp+var_10]
mov r8d, 4
call rax
cmp rax, 0
setnz al
and al, 1
movzx eax, al
add rsp, 20h
pop rbp
retn
| _BOOL8 ma_update_static_record(_DWORD *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
a1[358] = 1;
return (*(long long ( **)(_DWORD *, long long, _QWORD, long long, long long, long long, long long, long long, long long, _DWORD *))(*(_QWORD *)a1 + 1768LL))(
a1,
a4,
*(_QWORD *)(*(_QWORD *)a1 + 920LL),
a2,
4LL,
a6,
a4,
a3,
a2,
a1) != 0;
}
| _ma_update_static_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x598],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x6e8]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x398]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
ADD RSP,0x20
POP RBP
RET
|
bool _ma_update_static_record
(long *param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
long lVar1;
*(int4 *)(param_1 + 0xb3) = 1;
lVar1 = (**(code **)(*param_1 + 0x6e8))
(param_1,param_4,*(int8 *)(*param_1 + 0x398),param_2,4,param_6,param_4,
param_3);
return lVar1 != 0;
}
| |
43,168 | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp | SubdivisionPlanBuilder::SubdivisionPlanBuilder() {
// reserve memory for the proto-nodes store ; this progression curve should be fine
// for most 'non-pathological' topologies
static int const levelSizes[kNumLevels] = { 1, 4, 16, 64, 128, 128, 128, 128, 128, 128, 128 };
for (int level = 0, levelVertOffset = 0; level < kNumLevels; ++level)
_protoNodeStore[level].reserve(levelSizes[level]);
} | O1 | cpp | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x108, %edx # imm = 0x108
xorl %esi, %esi
callq 0x391b0
leaq 0x108(%rbx), %rax
movq %rax, (%rsp)
leaq 0x110(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x108(%rbx)
movl $0x128, %eax # imm = 0x128
movsd 0x1c641(%rip), %xmm0 # 0xc3fa0
movups %xmm0, -0x10(%rbx,%rax)
movl $0x0, (%rbx,%rax)
addq $0x14, %rax
cmpq $0x204, %rax # imm = 0x204
jne 0xa795f
leaq 0x1f8(%rbx), %r12
movq $0x0, 0x1f8(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x200(%rbx)
movaps 0x1c618(%rip), %xmm0 # 0xc3fb0
movups %xmm0, 0x26c(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x208(%rbx)
movups %xmm0, 0x218(%rbx)
movups %xmm0, 0x228(%rbx)
movups %xmm0, 0x238(%rbx)
movups %xmm0, 0x248(%rbx)
movups %xmm0, 0x258(%rbx)
movw $0x0, 0x268(%rbx)
movups %xmm0, 0x27c(%rbx)
movl %ebp, 0x28c(%rbx)
leaq 0x1c657(%rip), %r14 # 0xc4040
movq %rbx, %r13
movslq (%rbp,%r14), %rsi
movq %r13, %rdi
callq 0x38450
addq $0x4, %rbp
addq $0x18, %r13
cmpq $0x2c, %rbp
jne 0xa79ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %r12, %rdi
callq 0x3a400
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa7a2f
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x3ce0a
movq %r13, %rdi
callq 0x3bd70
| _ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilderC2Ev:
push rbp; Alternative name is 'OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void)'
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov edx, 108h
xor esi, esi
call _memset
lea rax, [rbx+108h]
mov [rsp+38h+var_38], rax
lea r15, [rbx+110h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+108h], xmm0
mov eax, 128h
movsd xmm0, cs:qword_C3FA0
loc_A795F:
movups xmmword ptr [rbx+rax-10h], xmm0
mov dword ptr [rbx+rax], 0
add rax, 14h
cmp rax, 204h
jnz short loc_A795F
lea r12, [rbx+1F8h]
mov qword ptr [rbx+1F8h], 0
xor ebp, ebp
mov [rbx+200h], ebp
movaps xmm0, cs:xmmword_C3FB0
movups xmmword ptr [rbx+26Ch], xmm0
xorps xmm0, xmm0
movups xmmword ptr [rbx+208h], xmm0
movups xmmword ptr [rbx+218h], xmm0
movups xmmword ptr [rbx+228h], xmm0
movups xmmword ptr [rbx+238h], xmm0
movups xmmword ptr [rbx+248h], xmm0
movups xmmword ptr [rbx+258h], xmm0
mov word ptr [rbx+268h], 0
movups xmmword ptr [rbx+27Ch], xmm0
mov [rbx+28Ch], ebp
lea r14, _ZZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilderC1EvE10levelSizes; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void)::levelSizes
mov r13, rbx
loc_A79EC:
movsxd rsi, dword ptr [rbp+r14+0]
mov rdi, r13
call __ZNSt6vectorIN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder9ProtoNodeESaIS4_EE7reserveEm; std::vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>::reserve(ulong)
add rbp, 4
add r13, 18h
cmp rbp, 2Ch ; ','
jnz short loc_A79EC
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r13, rax
mov rdi, r12; this
call __ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder24IrregularPatchConversionD2Ev; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::IrregularPatchConversion::~IrregularPatchConversion()
mov rdi, [r15]
test rdi, rdi
jz short loc_A7A2F
mov rax, [rdi]
call qword ptr [rax+8]
loc_A7A2F:
mov rdi, r15
mov rsi, [rsp+0]
mov rdx, rbx
call _ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilderC2Ev_cold_1; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void) [clone]
mov rdi, r13
call __Unwind_Resume
| long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *this)
{
long long i; // rax
long long v2; // rbp
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *v3; // r13
long long result; // rax
memset(this, 0LL, 264LL);
*(_OWORD *)((char *)this + 264) = 0LL;
for ( i = 296LL; i != 516; i += 20LL )
{
*(_OWORD *)((char *)this + i - 16) = 0xFFFFFFFFFFFFFFFFLL;
*(_DWORD *)((char *)this + i) = 0;
}
*((_QWORD *)this + 63) = 0LL;
v2 = 0LL;
*((_DWORD *)this + 128) = 0;
*(_OWORD *)((char *)this + 620) = xmmword_C3FB0;
*(_OWORD *)((char *)this + 520) = 0LL;
*(_OWORD *)((char *)this + 536) = 0LL;
*(_OWORD *)((char *)this + 552) = 0LL;
*(_OWORD *)((char *)this + 568) = 0LL;
*(_OWORD *)((char *)this + 584) = 0LL;
*(_OWORD *)((char *)this + 600) = 0LL;
*((_WORD *)this + 308) = 0;
*(_OWORD *)((char *)this + 636) = 0LL;
*((_DWORD *)this + 163) = 0;
v3 = this;
do
{
result = std::vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>::reserve(
v3,
*(int *)((char *)&OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void)::levelSizes
+ v2));
v2 += 4LL;
v3 = (OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *)((char *)v3 + 24);
}
while ( v2 != 44 );
return result;
}
| SubdivisionPlanBuilder:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EDX,0x108
XOR ESI,ESI
CALL 0x001391b0
LEA RAX,[RBX + 0x108]
MOV qword ptr [RSP],RAX
LEA R15,[RBX + 0x110]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x108],XMM0
MOV EAX,0x128
MOVSD XMM0,qword ptr [0x001c3fa0]
LAB_001a795f:
MOVUPS xmmword ptr [RBX + RAX*0x1 + -0x10],XMM0
MOV dword ptr [RBX + RAX*0x1],0x0
ADD RAX,0x14
CMP RAX,0x204
JNZ 0x001a795f
LEA R12,[RBX + 0x1f8]
MOV qword ptr [RBX + 0x1f8],0x0
XOR EBP,EBP
MOV dword ptr [RBX + 0x200],EBP
MOVAPS XMM0,xmmword ptr [0x001c3fb0]
MOVUPS xmmword ptr [RBX + 0x26c],XMM0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x208],XMM0
MOVUPS xmmword ptr [RBX + 0x218],XMM0
MOVUPS xmmword ptr [RBX + 0x228],XMM0
MOVUPS xmmword ptr [RBX + 0x238],XMM0
MOVUPS xmmword ptr [RBX + 0x248],XMM0
MOVUPS xmmword ptr [RBX + 0x258],XMM0
MOV word ptr [RBX + 0x268],0x0
MOVUPS xmmword ptr [RBX + 0x27c],XMM0
MOV dword ptr [RBX + 0x28c],EBP
LEA R14,[0x1c4040]
MOV R13,RBX
LAB_001a79ec:
MOVSXD RSI,dword ptr [RBP + R14*0x1]
LAB_001a79f1:
MOV RDI,R13
CALL 0x00138450
LAB_001a79f9:
ADD RBP,0x4
ADD R13,0x18
CMP RBP,0x2c
JNZ 0x001a79ec
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder() */
void __thiscall
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder
(SubdivisionPlanBuilder *this)
{
int8 uVar1;
long lVar2;
memset(this,0,0x108);
*(int8 *)(this + 0x108) = 0;
*(int8 *)(this + 0x110) = 0;
uVar1 = DAT_001c3fa0;
lVar2 = 0x128;
do {
*(int8 *)(this + lVar2 + -0x10) = uVar1;
*(int8 *)(this + lVar2 + -0x10 + 8) = 0;
*(int4 *)(this + lVar2) = 0;
lVar2 = lVar2 + 0x14;
} while (lVar2 != 0x204);
*(int8 *)(this + 0x1f8) = 0;
lVar2 = 0;
*(int4 *)(this + 0x200) = 0;
uVar1 = _UNK_001c3fb8;
*(int8 *)(this + 0x26c) = _DAT_001c3fb0;
*(int8 *)(this + 0x274) = uVar1;
*(int8 *)(this + 0x208) = 0;
*(int8 *)(this + 0x210) = 0;
*(int8 *)(this + 0x218) = 0;
*(int8 *)(this + 0x220) = 0;
*(int8 *)(this + 0x228) = 0;
*(int8 *)(this + 0x230) = 0;
*(int8 *)(this + 0x238) = 0;
*(int8 *)(this + 0x240) = 0;
*(int8 *)(this + 0x248) = 0;
*(int8 *)(this + 0x250) = 0;
*(int8 *)(this + 600) = 0;
*(int8 *)(this + 0x260) = 0;
*(int2 *)(this + 0x268) = 0;
*(int8 *)(this + 0x27c) = 0;
*(int8 *)(this + 0x284) = 0;
*(int4 *)(this + 0x28c) = 0;
do {
/* try { // try from 001a79f1 to 001a79f8 has its CatchHandler @ 001a7a16 */
std::
vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode,std::allocator<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>>
::reserve((vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode,std::allocator<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>>
*)this,(long)*(int *)((long)&SubdivisionPlanBuilder()::levelSizes + lVar2));
lVar2 = lVar2 + 4;
this = (SubdivisionPlanBuilder *)
((vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode,std::allocator<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>>
*)this + 0x18);
} while (lVar2 != 0x2c);
return;
}
| |
43,169 | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/tmr/subdivisionPlanBuilder.cpp | SubdivisionPlanBuilder::SubdivisionPlanBuilder() {
// reserve memory for the proto-nodes store ; this progression curve should be fine
// for most 'non-pathological' topologies
static int const levelSizes[kNumLevels] = { 1, 4, 16, 64, 128, 128, 128, 128, 128, 128, 128 };
for (int level = 0, levelVertOffset = 0; level < kNumLevels; ++level)
_protoNodeStore[level].reserve(levelSizes[level]);
} | O2 | cpp | OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x108(%rdi), %rax
movq %rax, (%rsp)
leaq 0x110(%rdi), %r15
xorl %r14d, %r14d
movl $0x118, %edx # imm = 0x118
xorl %esi, %esi
callq 0x50c10
movsd 0x1c395(%rip), %xmm0 # 0xcec40
movups %xmm0, 0x118(%rbx,%r14)
andl $0x0, 0x128(%rbx,%r14)
addq $0x14, %r14
cmpq $0xdc, %r14
jne 0xb28ab
andq $0x0, 0x1f8(%rbx)
andl $0x0, 0x200(%rbx)
leaq 0x1f8(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x208(%rbx)
movups %xmm0, 0x218(%rbx)
movups %xmm0, 0x228(%rbx)
movups %xmm0, 0x238(%rbx)
movups %xmm0, 0x248(%rbx)
movups %xmm0, 0x258(%rbx)
andw $0x0, 0x268(%rbx)
movaps 0x1c334(%rip), %xmm1 # 0xcec50
movups %xmm1, 0x26c(%rbx)
andl $0x0, 0x28c(%rbx)
movups %xmm0, 0x27c(%rbx)
xorl %ebp, %ebp
leaq 0x1c396(%rip), %r14 # 0xcecd0
movq %rbx, %r13
cmpq $0x2c, %rbp
je 0xb295a
movslq (%rbp,%r14), %rsi
movq %r13, %rdi
callq 0x4f850
addq $0x4, %rbp
addq $0x18, %r13
jmp 0xb293d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %r12, %rdi
callq 0x52a30
movq %r15, %rdi
callq 0x516f0
movq (%rsp), %rdi
callq 0x55c90
movl $0xf0, %r14d
leaq (%rbx,%r14), %rdi
callq 0x51f80
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0xb298b
movq %r13, %rdi
callq 0x55300
| _ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilderC2Ev:
push rbp; Alternative name is 'OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void)'
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rax, [rdi+108h]
mov [rsp+38h+var_38], rax
lea r15, [rdi+110h]
xor r14d, r14d
mov edx, 118h
xor esi, esi
call _memset
movsd xmm0, cs:qword_CEC40
loc_B28AB:
movups xmmword ptr [rbx+r14+118h], xmm0
and dword ptr [rbx+r14+128h], 0
add r14, 14h
cmp r14, 0DCh
jnz short loc_B28AB
and qword ptr [rbx+1F8h], 0
and dword ptr [rbx+200h], 0
lea r12, [rbx+1F8h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+208h], xmm0
movups xmmword ptr [rbx+218h], xmm0
movups xmmword ptr [rbx+228h], xmm0
movups xmmword ptr [rbx+238h], xmm0
movups xmmword ptr [rbx+248h], xmm0
movups xmmword ptr [rbx+258h], xmm0
and word ptr [rbx+268h], 0
movaps xmm1, cs:xmmword_CEC50
movups xmmword ptr [rbx+26Ch], xmm1
and dword ptr [rbx+28Ch], 0
movups xmmword ptr [rbx+27Ch], xmm0
xor ebp, ebp
lea r14, _ZZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilderC1EvE10levelSizes; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void)::levelSizes
mov r13, rbx
loc_B293D:
cmp rbp, 2Ch ; ','
jz short loc_B295A
movsxd rsi, dword ptr [rbp+r14+0]
mov rdi, r13
call __ZNSt6vectorIN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder9ProtoNodeESaIS4_EE7reserveEm; std::vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>::reserve(ulong)
add rbp, 4
add r13, 18h
jmp short loc_B293D
loc_B295A:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r13, rax
mov rdi, r12; this
call __ZN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder24IrregularPatchConversionD2Ev; OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::IrregularPatchConversion::~IrregularPatchConversion()
mov rdi, r15
call __ZNSt10unique_ptrIN10OpenSubdiv6v3_6_03Far12PatchBuilderESt14default_deleteIS3_EED2Ev; std::unique_ptr<OpenSubdiv::v3_6_0::Far::PatchBuilder>::~unique_ptr()
mov rdi, [rsp+0]
call __ZNSt10unique_ptrIN10OpenSubdiv6v3_6_03Far15TopologyRefinerESt14default_deleteIS3_EED2Ev; std::unique_ptr<OpenSubdiv::v3_6_0::Far::TopologyRefiner>::~unique_ptr()
mov r14d, 0F0h
loc_B298B:
lea rdi, [rbx+r14]
call __ZNSt12_Vector_baseIN10OpenSubdiv6v3_6_03Tmr22SubdivisionPlanBuilder9ProtoNodeESaIS4_EED2Ev; std::_Vector_base<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>::~_Vector_base()
add r14, 0FFFFFFFFFFFFFFE8h
cmp r14, 0FFFFFFFFFFFFFFE8h
jnz short loc_B298B
mov rdi, r13
call __Unwind_Resume
| long long OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *this)
{
long long v1; // r14
long long result; // rax
long long v3; // rbp
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *v4; // r13
v1 = 0LL;
result = memset(this, 0LL, 280LL);
do
{
*(_OWORD *)((char *)this + v1 + 280) = 0xFFFFFFFFFFFFFFFFLL;
*(_DWORD *)((char *)this + v1 + 296) = 0;
v1 += 20LL;
}
while ( v1 != 220 );
*((_QWORD *)this + 63) = 0LL;
*((_DWORD *)this + 128) = 0;
*(_OWORD *)((char *)this + 520) = 0LL;
*(_OWORD *)((char *)this + 536) = 0LL;
*(_OWORD *)((char *)this + 552) = 0LL;
*(_OWORD *)((char *)this + 568) = 0LL;
*(_OWORD *)((char *)this + 584) = 0LL;
*(_OWORD *)((char *)this + 600) = 0LL;
*((_WORD *)this + 308) = 0;
*(_OWORD *)((char *)this + 620) = xmmword_CEC50;
*((_DWORD *)this + 163) = 0;
*(_OWORD *)((char *)this + 636) = 0LL;
v3 = 0LL;
v4 = this;
while ( v3 != 44 )
{
result = std::vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>::reserve(
v4,
*(int *)((char *)&OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder(void)::levelSizes
+ v3));
v3 += 4LL;
v4 = (OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder *)((char *)v4 + 24);
}
return result;
}
| SubdivisionPlanBuilder:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[RDI + 0x108]
MOV qword ptr [RSP],RAX
LEA R15,[RDI + 0x110]
XOR R14D,R14D
MOV EDX,0x118
XOR ESI,ESI
CALL 0x00150c10
MOVSD XMM0,qword ptr [0x001cec40]
LAB_001b28ab:
MOVUPS xmmword ptr [RBX + R14*0x1 + 0x118],XMM0
AND dword ptr [RBX + R14*0x1 + 0x128],0x0
ADD R14,0x14
CMP R14,0xdc
JNZ 0x001b28ab
AND qword ptr [RBX + 0x1f8],0x0
AND dword ptr [RBX + 0x200],0x0
LEA R12,[RBX + 0x1f8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x208],XMM0
MOVUPS xmmword ptr [RBX + 0x218],XMM0
MOVUPS xmmword ptr [RBX + 0x228],XMM0
MOVUPS xmmword ptr [RBX + 0x238],XMM0
MOVUPS xmmword ptr [RBX + 0x248],XMM0
MOVUPS xmmword ptr [RBX + 0x258],XMM0
AND word ptr [RBX + 0x268],0x0
MOVAPS XMM1,xmmword ptr [0x001cec50]
MOVUPS xmmword ptr [RBX + 0x26c],XMM1
AND dword ptr [RBX + 0x28c],0x0
MOVUPS xmmword ptr [RBX + 0x27c],XMM0
XOR EBP,EBP
LEA R14,[0x1cecd0]
MOV R13,RBX
LAB_001b293d:
CMP RBP,0x2c
JZ 0x001b295a
MOVSXD RSI,dword ptr [RBP + R14*0x1]
LAB_001b2948:
MOV RDI,R13
CALL 0x0014f850
LAB_001b2950:
ADD RBP,0x4
ADD R13,0x18
JMP 0x001b293d
LAB_001b295a:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder() */
void __thiscall
OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::SubdivisionPlanBuilder
(SubdivisionPlanBuilder *this)
{
int8 uVar1;
long lVar2;
lVar2 = 0;
memset(this,0,0x118);
uVar1 = DAT_001cec40;
do {
*(int8 *)(this + lVar2 + 0x118) = uVar1;
*(int8 *)(this + lVar2 + 0x118 + 8) = 0;
*(int4 *)(this + lVar2 + 0x128) = 0;
lVar2 = lVar2 + 0x14;
} while (lVar2 != 0xdc);
*(int8 *)(this + 0x1f8) = 0;
*(int4 *)(this + 0x200) = 0;
*(int8 *)(this + 0x208) = 0;
*(int8 *)(this + 0x210) = 0;
*(int8 *)(this + 0x218) = 0;
*(int8 *)(this + 0x220) = 0;
*(int8 *)(this + 0x228) = 0;
*(int8 *)(this + 0x230) = 0;
*(int8 *)(this + 0x238) = 0;
*(int8 *)(this + 0x240) = 0;
*(int8 *)(this + 0x248) = 0;
*(int8 *)(this + 0x250) = 0;
*(int8 *)(this + 600) = 0;
*(int8 *)(this + 0x260) = 0;
*(int2 *)(this + 0x268) = 0;
uVar1 = _UNK_001cec58;
*(int8 *)(this + 0x26c) = _DAT_001cec50;
*(int8 *)(this + 0x274) = uVar1;
*(int4 *)(this + 0x28c) = 0;
*(int8 *)(this + 0x27c) = 0;
*(int8 *)(this + 0x284) = 0;
for (lVar2 = 0; lVar2 != 0x2c; lVar2 = lVar2 + 4) {
/* try { // try from 001b2948 to 001b294f has its CatchHandler @ 001b2969 */
std::
vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode,std::allocator<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>>
::reserve((vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode,std::allocator<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>>
*)this,(long)*(int *)((long)&SubdivisionPlanBuilder()::levelSizes + lVar2));
this = (SubdivisionPlanBuilder *)
((vector<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode,std::allocator<OpenSubdiv::v3_6_0::Tmr::SubdivisionPlanBuilder::ProtoNode>>
*)this + 0x18);
}
return;
}
| |
43,170 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) | monkey531[P]llama/common/./json.hpp | void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
cmpl $0x1, %esi
sete %cl
movq (%rdi), %rax
testq %rax, %rax
sete %dl
testb %dl, %cl
jne 0x28f60
movl %esi, %r14d
testq %rax, %rax
sete %cl
movl %r14d, %edx
andb $-0x2, %dl
cmpb $0x2, %dl
sete %dl
cmpb $0x8, %r14b
sete %sil
orb %dl, %sil
testb %cl, %sil
jne 0x28f60
movq %rdi, %rbx
leal -0x1(%r14), %ecx
cmpb $0x1, %cl
ja 0x28ecd
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
cmpb $0x2, %r14b
jne 0x28ef8
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
movq %rsp, %rdi
callq 0x28f96
movq (%rbx), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %rsp, %rdx
callq 0x29068
movq %rsp, %r15
leaq 0x20(%rsp), %r12
movq 0x8(%rsp), %rax
cmpq %rax, (%rsp)
je 0x28ec5
movups -0x10(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movb $0x0, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq 0x8(%rsp), %rdi
addq $-0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x28b72
movzbl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x28e83
cmpl $0x2, %eax
jne 0x28eb8
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movq %r15, %rdx
callq 0x29068
movq 0x28(%rsp), %rdi
callq 0x2903e
jmp 0x28eb8
movq 0x28(%rsp), %rbp
movq 0x18(%rbp), %r13
addq $0x8, %rbp
cmpq %rbp, %r13
je 0x28eae
leaq 0x40(%r13), %rsi
movq %r15, %rdi
callq 0x287e2
movq %r13, %rdi
callq 0x21580
movq %rax, %r13
jmp 0x28e90
movq 0x28(%rsp), %rdi
callq 0x290d0
movq %r12, %rdi
callq 0x28b72
jmp 0x28e20
movq %rsp, %rdi
callq 0x29046
movzbl %r14b, %eax
decl %eax
cmpl $0x7, %eax
ja 0x28f60
leaq 0x6a229(%rip), %rcx # 0x9310c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
callq 0x290fe
pushq $0x30
jmp 0x28f57
movq 0x28(%rax), %rsi
movq %rsp, %rdi
callq 0x28f96
movq (%rbx), %r13
movq 0x18(%r13), %r12
addq $0x8, %r13
movq %rsp, %r15
cmpq %r13, %r12
je 0x28e18
leaq 0x40(%r12), %rsi
movq %r15, %rdi
callq 0x287e2
movq %r12, %rdi
callq 0x21580
movq %rax, %r12
jmp 0x28f12
movq (%rbx), %rdi
callq 0x22078
pushq $0x20
jmp 0x28f57
movq (%rbx), %rdi
callq 0x29046
pushq $0x18
jmp 0x28f57
movq (%rbx), %rdi
callq 0x28d04
pushq $0x28
popq %rsi
movq (%rbx), %rdi
callq 0x21820
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28f73
jmp 0x28f78
movq %rax, %rbx
jmp 0x28f85
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x28b72
movq %rsp, %rdi
callq 0x29046
movq %rbx, %rdi
callq 0x21e50
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
cmp esi, 1
setz cl
mov rax, [rdi]
test rax, rax
setz dl
test cl, dl
jnz def_28EEA; jumptable 0000000000028EEA default case, cases 4-7
mov r14d, esi
test rax, rax
setz cl
mov edx, r14d
and dl, 0FEh
cmp dl, 2
setz dl
cmp r14b, 8
setz sil
or sil, dl
test sil, cl
jnz def_28EEA; jumptable 0000000000028EEA default case, cases 4-7
mov rbx, rdi
lea ecx, [r14-1]
cmp cl, 1
ja loc_28ECD
and [rsp+68h+var_58], 0
xorps xmm0, xmm0
movaps [rsp+68h+var_68], xmm0
cmp r14b, 2
jnz loc_28EF8
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov rax, [rbx]
mov rdi, [rax]
mov rsi, [rax+8]
mov rdx, rsp
call _ZNSt11__copy_moveILb1ELb0ESt26random_access_iterator_tagE8__copy_mIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEESt20back_insert_iteratorIS7_ISH_SaISH_EEEEET0_T_SO_SN_; std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
loc_28E18:
mov r15, rsp
lea r12, [rsp+68h+var_48]
loc_28E20:
mov rax, qword ptr [rsp+68h+var_68+8]
cmp qword ptr [rsp+68h+var_68], rax
jz loc_28EC5
movups xmm0, xmmword ptr [rax-10h]
movaps [rsp+68h+var_48], xmm0
mov byte ptr [rax-10h], 0
and qword ptr [rax-8], 0
mov rdi, qword ptr [rsp+68h+var_68+8]
add rdi, 0FFFFFFFFFFFFFFF0h
mov qword ptr [rsp+68h+var_68+8], rdi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
movzx eax, byte ptr [rsp+68h+var_48]
cmp eax, 1
jz short loc_28E83
cmp eax, 2
jnz short loc_28EB8
mov rax, qword ptr [rsp+68h+var_48+8]
mov rdi, [rax]
mov rsi, [rax+8]
mov rdx, r15
call _ZNSt11__copy_moveILb1ELb0ESt26random_access_iterator_tagE8__copy_mIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS4_14adl_serializerES7_IhSaIhEEvEESt20back_insert_iteratorIS7_ISH_SaISH_EEEEET0_T_SO_SN_; std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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, qword ptr [rsp+68h+var_48+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5clearEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::clear(void)
jmp short loc_28EB8
loc_28E83:
mov rbp, qword ptr [rsp+68h+var_48+8]
mov r13, [rbp+18h]
add rbp, 8
loc_28E90:
cmp r13, rbp
jz short loc_28EAE
lea rsi, [r13+40h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r13
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r13, rax
jmp short loc_28E90
loc_28EAE:
mov rdi, qword ptr [rsp+68h+var_48+8]
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE5clearEv; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::clear(void)
loc_28EB8:
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp loc_28E20
loc_28EC5:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
loc_28ECD:
movzx eax, r14b
dec eax; switch 8 cases
cmp eax, 7
ja def_28EEA; jumptable 0000000000028EEA default case, cases 4-7
lea rcx, jpt_28EEA
movsxd rax, ds:(jpt_28EEA - 9310Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_28EEC:
mov rdi, [rbx]; jumptable 0000000000028EEA case 1
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EED2Ev; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::~_Rb_tree()
push 30h ; '0'
jmp short loc_28F57
loc_28EF8:
mov rsi, [rax+28h]
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::reserve(ulong)
mov r13, [rbx]
mov r12, [r13+18h]
add r13, 8
mov r15, rsp
loc_28F12:
cmp r12, r13
jz loc_28E18
lea rsi, [r12+40h]
mov rdi, r15
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r12
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov r12, rax
jmp short loc_28F12
loc_28F35:
mov rdi, [rbx]; jumptable 0000000000028EEA case 3
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
push 20h ; ' '
jmp short loc_28F57
loc_28F41:
mov rdi, [rbx]; jumptable 0000000000028EEA case 2
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
push 18h
jmp short loc_28F57
loc_28F4D:
mov rdi, [rbx]; jumptable 0000000000028EEA case 8
call _ZNSt12_Vector_baseIhSaIhEED2Ev; std::_Vector_base<uchar>::~_Vector_base()
push 28h ; '('
loc_28F57:
pop rsi; unsigned __int64
mov rdi, [rbx]; void *
call __ZdlPvm; operator delete(void *,ulong)
def_28EEA:
add rsp, 38h; jumptable 0000000000028EEA default case, cases 4-7
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_28F73
jmp short loc_28F78
loc_28F73:
mov rbx, rax
jmp short loc_28F85
loc_28F78:
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_28F85:
mov rdi, rsp
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| void nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
void **a1,
int a2)
{
_QWORD *v2; // rax
long long v3; // rax
long long v4; // r13
long long v5; // rbp
long long v6; // r12
long long v7; // r13
__int128 v8; // [rsp+0h] [rbp-68h] BYREF
long long v9; // [rsp+10h] [rbp-58h]
__int128 v10; // [rsp+20h] [rbp-48h] BYREF
v2 = *a1;
if ( (*a1 != 0LL || a2 != 1) && (v2 != 0LL || (a2 & 0xFE) != 2 && (_BYTE)a2 != 8) )
{
if ( (unsigned __int8)(a2 - 1) <= 1u )
{
v9 = 0LL;
v8 = 0LL;
if ( (_BYTE)a2 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v8,
(long long)(v2[1] - *v2) >> 4);
std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<std::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::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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,
*((_QWORD *)*a1 + 1),
&v8);
}
else
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::reserve(
&v8,
v2[5]);
v6 = *((_QWORD *)*a1 + 3);
v7 = (long long)*a1 + 8;
while ( v6 != v7 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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)&v8,
v6 + 64);
v6 = std::_Rb_tree_increment(v6);
}
}
while ( 1 )
{
v3 = *((_QWORD *)&v8 + 1);
if ( (_QWORD)v8 == *((_QWORD *)&v8 + 1) )
break;
v10 = *(_OWORD *)(*((_QWORD *)&v8 + 1) - 16LL);
*(_BYTE *)(*((_QWORD *)&v8 + 1) - 16LL) = 0;
*(_QWORD *)(v3 - 8) = 0LL;
*((_QWORD *)&v8 + 1) -= 16LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(*((_QWORD *)&v8 + 1));
if ( (unsigned __int8)v10 == 1 )
{
v4 = *(_QWORD *)(*((_QWORD *)&v10 + 1) + 24LL);
v5 = *((_QWORD *)&v10 + 1) + 8LL;
while ( v4 != v5 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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<std::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)&v8,
v4 + 64);
v4 = std::_Rb_tree_increment(v4);
}
std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>::clear(*((_QWORD *)&v10 + 1));
}
else if ( (unsigned __int8)v10 == 2 )
{
std::__copy_move<true,false,std::random_access_iterator_tag>::__copy_m<nlohmann::json_abi_v3_11_3::basic_json<std::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::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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 **)&v10 + 1),
*(_QWORD *)(*((_QWORD *)&v10 + 1) + 8LL),
&v8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::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>>::clear(*((_QWORD *)&v10 + 1));
}
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v10);
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(&v8);
}
switch ( (char)a2 )
{
case 1:
std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::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>>>>::~_Rb_tree(*a1);
operator delete(*a1, 0x30uLL);
break;
case 2:
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~vector(*a1);
operator delete(*a1, 0x18uLL);
break;
case 3:
std::string::~string(*a1);
operator delete(*a1, 0x20uLL);
break;
case 8:
std::_Vector_base<unsigned char>::~_Vector_base(*a1);
operator delete(*a1, 0x28uLL);
break;
default:
return;
}
}
}
| destroy:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
CMP ESI,0x1
SETZ CL
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
SETZ DL
TEST CL,DL
JNZ 0x00128f60
MOV R14D,ESI
TEST RAX,RAX
SETZ CL
MOV EDX,R14D
AND DL,0xfe
CMP DL,0x2
SETZ DL
CMP R14B,0x8
SETZ SIL
OR SIL,DL
TEST SIL,CL
JNZ 0x00128f60
MOV RBX,RDI
LEA ECX,[R14 + -0x1]
CMP CL,0x1
JA 0x00128ecd
AND qword ptr [RSP + 0x10],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
CMP R14B,0x2
JNZ 0x00128ef8
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
LAB_00128dfe:
MOV RDI,RSP
CALL 0x00128f96
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
MOV RDX,RSP
CALL 0x00129068
LAB_00128e18:
MOV R15,RSP
LEA R12,[RSP + 0x20]
LAB_00128e20:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RSP],RAX
JZ 0x00128ec5
MOVUPS XMM0,xmmword ptr [RAX + -0x10]
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV byte ptr [RAX + -0x10],0x0
AND qword ptr [RAX + -0x8],0x0
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,-0x10
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00128b72
MOVZX EAX,byte ptr [RSP + 0x20]
CMP EAX,0x1
JZ 0x00128e83
CMP EAX,0x2
JNZ 0x00128eb8
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
LAB_00128e6f:
MOV RDX,R15
CALL 0x00129068
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0012903e
JMP 0x00128eb8
LAB_00128e83:
MOV RBP,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RBP + 0x18]
ADD RBP,0x8
LAB_00128e90:
CMP R13,RBP
JZ 0x00128eae
LEA RSI,[R13 + 0x40]
LAB_00128e99:
MOV RDI,R15
CALL 0x001287e2
MOV RDI,R13
CALL 0x00121580
MOV R13,RAX
JMP 0x00128e90
LAB_00128eae:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001290d0
LAB_00128eb8:
MOV RDI,R12
CALL 0x00128b72
JMP 0x00128e20
LAB_00128ec5:
MOV RDI,RSP
CALL 0x00129046
LAB_00128ecd:
MOVZX EAX,R14B
DEC EAX
CMP EAX,0x7
JA 0x00128f60
LEA RCX,[0x19310c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBX]
CALL 0x001290fe
PUSH 0x30
JMP 0x00128f57
LAB_00128ef8:
MOV RSI,qword ptr [RAX + 0x28]
LAB_00128efc:
MOV RDI,RSP
CALL 0x00128f96
MOV R13,qword ptr [RBX]
MOV R12,qword ptr [R13 + 0x18]
ADD R13,0x8
MOV R15,RSP
LAB_00128f12:
CMP R12,R13
JZ 0x00128e18
LEA RSI,[R12 + 0x40]
LAB_00128f20:
MOV RDI,R15
CALL 0x001287e2
LAB_00128f28:
MOV RDI,R12
CALL 0x00121580
MOV R12,RAX
JMP 0x00128f12
caseD_3:
MOV RDI,qword ptr [RBX]
CALL 0x00122078
PUSH 0x20
JMP 0x00128f57
caseD_2:
MOV RDI,qword ptr [RBX]
CALL 0x00129046
PUSH 0x18
JMP 0x00128f57
caseD_8:
MOV RDI,qword ptr [RBX]
CALL 0x00128d04
PUSH 0x28
LAB_00128f57:
POP RSI
MOV RDI,qword ptr [RBX]
CALL 0x00121820
caseD_4:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,uint param_2)
{
long *plVar1;
long lVar2;
_Rb_tree_node_base *p_Var3;
byte bVar4;
_Rb_tree_node_base *p_Var5;
ulong uStack_70;
data *local_68;
data *pdStack_60;
int8 local_58;
int8 local_48;
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*pvStack_40;
plVar1 = *(long **)this;
if ((param_2 != 1 || plVar1 != (long *)0x0) &&
(bVar4 = (byte)param_2, bVar4 != 8 && (bVar4 & 0xfe) != 2 || plVar1 != (long *)0x0)) {
if ((byte)(bVar4 - 1) < 2) {
local_58 = 0;
local_68 = (data *)0x0;
pdStack_60 = (data *)0x0;
if (bVar4 == 2) {
/* try { // try from 00128dfe to 00128e17 has its CatchHandler @ 00128f6f */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,plVar1[1] - *plVar1 >> 4);
std::__copy_move<true,false,std::random_access_iterator_tag>::
__copy_m<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
(**(int8 **)this,(*(int8 **)this)[1],&local_68);
}
else {
/* try { // try from 00128efc to 00128f03 has its CatchHandler @ 00128f6f */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::reserve((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,plVar1[5]);
lVar2 = *(long *)this;
for (p_Var3 = *(_Rb_tree_node_base **)(lVar2 + 0x18);
p_Var3 != (_Rb_tree_node_base *)(lVar2 + 8);
p_Var3 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var3)) {
/* try { // try from 00128f20 to 00128f27 has its CatchHandler @ 00128f73 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(p_Var3 + 0x40));
}
}
while (local_68 != pdStack_60) {
local_48 = *(int8 *)(pdStack_60 + -0x10);
pvStack_40 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pdStack_60 + -8);
pdStack_60[-0x10] = (data)0x0;
*(int8 *)(pdStack_60 + -8) = 0;
pdStack_60 = pdStack_60 + -0x10;
data::~data(pdStack_60);
if (local_48._0_1_ == (data)0x1) {
p_Var5 = (_Rb_tree_node_base *)(pvStack_40 + 8);
for (p_Var3 = *(_Rb_tree_node_base **)(pvStack_40 + 0x18); p_Var3 != p_Var5;
p_Var3 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var3)) {
/* try { // try from 00128e99 to 00128ea0 has its CatchHandler @ 00128f78 */
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68,(basic_json *)(p_Var3 + 0x40));
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::clear((_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)pvStack_40);
}
else if (local_48._0_1_ == (data)0x2) {
/* try { // try from 00128e6f to 00128e76 has its CatchHandler @ 00128f71 */
std::__copy_move<true,false,std::random_access_iterator_tag>::
__copy_m<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::back_insert_iterator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
(*(int8 *)pvStack_40,*(int8 *)(pvStack_40 + 8),&local_68);
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::clear(pvStack_40);
}
data::~data((data *)&local_48);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector((vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)&local_68);
}
switch(param_2 & 0xff) {
case 1:
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::~_Rb_tree(*(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
uStack_70 = 0x30;
break;
case 2:
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
uStack_70 = 0x18;
break;
case 3:
std::__cxx11::string::~string(*(string **)this);
uStack_70 = 0x20;
break;
default:
goto switchD_00128eea_caseD_4;
case 8:
std::_Vector_base<unsigned_char,std::allocator<unsigned_char>>::~_Vector_base
(*(_Vector_base<unsigned_char,std::allocator<unsigned_char>> **)this);
uStack_70 = 0x28;
}
operator_delete(*(void **)this,uStack_70);
}
switchD_00128eea_caseD_4:
return;
}
| |
43,171 | set_page_bits | eloqsql/storage/maria/ma_bitmap.c | static my_bool set_page_bits(MARIA_HA *info, MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page, uint fill_pattern)
{
pgcache_page_no_t bitmap_page;
uint offset_page, offset, tmp, org_tmp, used_offset;
uchar *data;
DBUG_ENTER("set_page_bits");
DBUG_ASSERT(fill_pattern <= 7);
bitmap_page= page - page % bitmap->pages_covered;
if (bitmap_page != bitmap->page &&
_ma_change_bitmap_page(info, bitmap, bitmap_page))
DBUG_RETURN(1);
/* Find page number from start of bitmap */
offset_page= (uint) (page - bitmap->page - 1);
/*
Mark place used by reading/writing 2 bytes at a time to handle
bitmaps in overlapping bytes
*/
offset_page*= 3;
offset= offset_page & 7;
data= bitmap->map + offset_page / 8;
org_tmp= tmp= uint2korr(data);
tmp= (tmp & ~(7 << offset)) | (fill_pattern << offset);
if (tmp == org_tmp)
DBUG_RETURN(0); /* No changes */
/*
Take care to not write bytes outside of bitmap.
fill_pattern is 3 bits, so we need to write two bytes
if bit position we write to is > (8-3)
*/
if (offset > 5)
int2store(data, tmp);
else
data[0]= tmp;
/*
Reset full_head_size or full_tail_size if we are releasing data before
it. Increase used_size if we are allocating data.
*/
used_offset= (uint) (data - bitmap->map);
if (fill_pattern < 4)
set_if_smaller(bitmap->full_head_size, used_offset);
if (fill_pattern == 0 || (fill_pattern > 4 && fill_pattern < 7))
set_if_smaller(bitmap->full_tail_size, used_offset);
if (fill_pattern != 0)
{
/* Calulcate which was the last changed byte */
used_offset+= offset > 5 ? 2 : 1;
set_if_bigger(bitmap->used_size, used_offset);
}
_ma_check_bitmap(bitmap);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
if (fill_pattern != FULL_HEAD_PAGE && fill_pattern != FULL_TAIL_PAGE)
set_if_smaller(info->s->state.first_bitmap_with_space, bitmap_page);
/*
Note that if the condition above is false (page is full), and all pages of
this bitmap are now full, and that bitmap page was
first_bitmap_with_space, we don't modify first_bitmap_with_space, indeed
its value still tells us where to start our search for a bitmap with space
(which is for sure after this full one).
That does mean that first_bitmap_with_space is only a lower bound.
*/
DBUG_RETURN(0);
} | O3 | c | set_page_bits:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, %rax
xorl %edx, %edx
divq 0x138(%rsi)
movq %r13, %r14
subq %rdx, %r14
movq %r14, %rax
cmpq 0x10(%rsi), %r14
je 0x54718
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x53cfd
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x547e0
movq 0x10(%r12), %rax
notl %eax
addl %eax, %r13d
leal (%r13,%r13,2), %edx
movl %edx, %ecx
andl $0x7, %ecx
movq 0x8(%r12), %rax
shrl $0x3, %edx
movzwl (%rax,%rdx), %edi
movl $0x7, %r8d
shll %cl, %r8d
movl %r15d, %esi
shll %cl, %esi
notl %r8d
andl %edi, %r8d
orl %r8d, %esi
cmpl %edi, %esi
je 0x547de
addq %rdx, %rax
cmpl $0x6, %ecx
jb 0x5475f
movw %si, (%rax)
jmp 0x54762
movb %sil, (%rax)
subl 0x8(%r12), %eax
cmpl $0x3, %r15d
ja 0x54779
cmpl %eax, 0x28(%r12)
jbe 0x54779
movl %eax, 0x28(%r12)
cmpl $0x6, %r15d
ja 0x5479b
movl $0x61, %edx
btl %r15d, %edx
jae 0x5479b
cmpl %eax, 0x2c(%r12)
jbe 0x54796
movl %eax, 0x2c(%r12)
testl %r15d, %r15d
je 0x547c5
cmpl $0x6, %ecx
sbbl $-0x1, %eax
incl %eax
cmpl %eax, 0x24(%r12)
jae 0x547af
movl %eax, 0x24(%r12)
movb $0x1, 0x20(%r12)
xorl %eax, %eax
cmpl $0x4, %r15d
je 0x547e0
cmpl $0x7, %r15d
je 0x547e0
jmp 0x547cb
movb $0x1, 0x20(%r12)
movq (%rbx), %rax
cmpq %r14, 0xd0(%rax)
jbe 0x547de
movq %r14, 0xd0(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| set_page_bits:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, ecx
mov r13, rdx
mov r12, rsi
mov rbx, rdi
mov rax, rdx
xor edx, edx
div qword ptr [rsi+138h]
mov r14, r13
sub r14, rdx
mov rax, r14
cmp r14, [rsi+10h]
jz short loc_54718
mov rdi, rbx
mov rsi, r12
mov rdx, r14
call _ma_change_bitmap_page
mov ecx, eax
mov al, 1
test cl, cl
jnz loc_547E0
mov rax, [r12+10h]
loc_54718:
not eax
add r13d, eax
lea edx, [r13+r13*2+0]
mov ecx, edx
and ecx, 7
mov rax, [r12+8]
shr edx, 3
movzx edi, word ptr [rax+rdx]
mov r8d, 7
shl r8d, cl
mov esi, r15d
shl esi, cl
not r8d
and r8d, edi
or esi, r8d
cmp esi, edi
jz loc_547DE
add rax, rdx
cmp ecx, 6
jb short loc_5475F
mov [rax], si
jmp short loc_54762
loc_5475F:
mov [rax], sil
loc_54762:
sub eax, [r12+8]
cmp r15d, 3
ja short loc_54779
cmp [r12+28h], eax
jbe short loc_54779
mov [r12+28h], eax
loc_54779:
cmp r15d, 6
ja short loc_5479B
mov edx, 61h ; 'a'
bt edx, r15d
jnb short loc_5479B
cmp [r12+2Ch], eax
jbe short loc_54796
mov [r12+2Ch], eax
loc_54796:
test r15d, r15d
jz short loc_547C5
loc_5479B:
cmp ecx, 6
sbb eax, 0FFFFFFFFh
inc eax
cmp [r12+24h], eax
jnb short loc_547AF
mov [r12+24h], eax
loc_547AF:
mov byte ptr [r12+20h], 1
xor eax, eax
cmp r15d, 4
jz short loc_547E0
cmp r15d, 7
jz short loc_547E0
jmp short loc_547CB
loc_547C5:
mov byte ptr [r12+20h], 1
loc_547CB:
mov rax, [rbx]
cmp [rax+0D0h], r14
jbe short loc_547DE
mov [rax+0D0h], r14
loc_547DE:
xor eax, eax
loc_547E0:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char set_page_bits(long long *a1, long long a2, unsigned long long a3, unsigned int a4)
{
int v5; // r13d
unsigned long long v8; // r14
long long v9; // rax
char v10; // cl
char result; // al
int v12; // r13d
unsigned int v13; // ecx
long long v14; // rax
long long v15; // rdx
int v16; // edi
int v17; // esi
_BYTE *v18; // rax
unsigned int v19; // eax
int v20; // edx
unsigned int v21; // eax
v5 = a3;
v8 = a3 - a3 % *(_QWORD *)(a2 + 312);
LODWORD(v9) = a3 - a3 % *(_QWORD *)(a2 + 312);
if ( v8 != *(_QWORD *)(a2 + 16) )
{
v10 = ma_change_bitmap_page(a1, a2, a3 - a3 % *(_QWORD *)(a2 + 312));
result = 1;
if ( v10 )
return result;
v9 = *(_QWORD *)(a2 + 16);
}
v12 = ~(_DWORD)v9 + v5;
v13 = (3 * (_BYTE)v12) & 7;
v14 = *(_QWORD *)(a2 + 8);
v15 = (unsigned int)(3 * v12) >> 3;
v16 = *(unsigned __int16 *)(v14 + v15);
v17 = v16 & ~(7 << v13) | (a4 << v13);
if ( v17 == v16 )
return 0;
v18 = (_BYTE *)(v15 + v14);
if ( v13 < 6 )
*v18 = v17;
else
*(_WORD *)v18 = v17;
v19 = (_DWORD)v18 - *(_DWORD *)(a2 + 8);
if ( a4 <= 3 && *(_DWORD *)(a2 + 40) > v19 )
*(_DWORD *)(a2 + 40) = v19;
if ( a4 <= 6 )
{
v20 = 97;
if ( _bittest(&v20, a4) )
{
if ( *(_DWORD *)(a2 + 44) > v19 )
*(_DWORD *)(a2 + 44) = v19;
if ( !a4 )
{
*(_BYTE *)(a2 + 32) = 1;
LABEL_22:
if ( *(_QWORD *)(*a1 + 208) > v8 )
*(_QWORD *)(*a1 + 208) = v8;
return 0;
}
}
}
v21 = v19 - ((v13 < 6) - 1) + 1;
if ( *(_DWORD *)(a2 + 36) < v21 )
*(_DWORD *)(a2 + 36) = v21;
*(_BYTE *)(a2 + 32) = 1;
result = 0;
if ( a4 != 4 && a4 != 7 )
goto LABEL_22;
return result;
}
| set_page_bits:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,ECX
MOV R13,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,RDX
XOR EDX,EDX
DIV qword ptr [RSI + 0x138]
MOV R14,R13
SUB R14,RDX
MOV RAX,R14
CMP R14,qword ptr [RSI + 0x10]
JZ 0x00154718
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R14
CALL 0x00153cfd
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x001547e0
MOV RAX,qword ptr [R12 + 0x10]
LAB_00154718:
NOT EAX
ADD R13D,EAX
LEA EDX,[R13 + R13*0x2]
MOV ECX,EDX
AND ECX,0x7
MOV RAX,qword ptr [R12 + 0x8]
SHR EDX,0x3
MOVZX EDI,word ptr [RAX + RDX*0x1]
MOV R8D,0x7
SHL R8D,CL
MOV ESI,R15D
SHL ESI,CL
NOT R8D
AND R8D,EDI
OR ESI,R8D
CMP ESI,EDI
JZ 0x001547de
ADD RAX,RDX
CMP ECX,0x6
JC 0x0015475f
MOV word ptr [RAX],SI
JMP 0x00154762
LAB_0015475f:
MOV byte ptr [RAX],SIL
LAB_00154762:
SUB EAX,dword ptr [R12 + 0x8]
CMP R15D,0x3
JA 0x00154779
CMP dword ptr [R12 + 0x28],EAX
JBE 0x00154779
MOV dword ptr [R12 + 0x28],EAX
LAB_00154779:
CMP R15D,0x6
JA 0x0015479b
MOV EDX,0x61
BT EDX,R15D
JNC 0x0015479b
CMP dword ptr [R12 + 0x2c],EAX
JBE 0x00154796
MOV dword ptr [R12 + 0x2c],EAX
LAB_00154796:
TEST R15D,R15D
JZ 0x001547c5
LAB_0015479b:
CMP ECX,0x6
SBB EAX,-0x1
INC EAX
CMP dword ptr [R12 + 0x24],EAX
JNC 0x001547af
MOV dword ptr [R12 + 0x24],EAX
LAB_001547af:
MOV byte ptr [R12 + 0x20],0x1
XOR EAX,EAX
CMP R15D,0x4
JZ 0x001547e0
CMP R15D,0x7
JZ 0x001547e0
JMP 0x001547cb
LAB_001547c5:
MOV byte ptr [R12 + 0x20],0x1
LAB_001547cb:
MOV RAX,qword ptr [RBX]
CMP qword ptr [RAX + 0xd0],R14
JBE 0x001547de
MOV qword ptr [RAX + 0xd0],R14
LAB_001547de:
XOR EAX,EAX
LAB_001547e0:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 set_page_bits(long *param_1,long param_2,ulong param_3,uint param_4)
{
char cVar1;
int2 *puVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
uVar7 = param_3 - param_3 % *(ulong *)(param_2 + 0x138);
uVar5 = (uint)uVar7;
if (uVar7 != *(ulong *)(param_2 + 0x10)) {
cVar1 = _ma_change_bitmap_page(param_1,param_2,uVar7);
if (cVar1 != '\0') {
return 1;
}
uVar5 = (uint)*(int8 *)(param_2 + 0x10);
}
uVar5 = ((int)param_3 + ~uVar5) * 3;
uVar3 = uVar5 & 7;
uVar4 = (ulong)(uVar5 >> 3);
uVar6 = (uint)*(ushort *)(*(long *)(param_2 + 8) + uVar4);
uVar5 = param_4 << (sbyte)uVar3 | ~(7 << (sbyte)uVar3) & uVar6;
if (uVar5 == uVar6) {
return 0;
}
puVar2 = (int2 *)(*(long *)(param_2 + 8) + uVar4);
if (uVar3 < 6) {
*(char *)puVar2 = (char)uVar5;
}
else {
*puVar2 = (short)uVar5;
}
uVar5 = (int)puVar2 - *(int *)(param_2 + 8);
if ((param_4 < 4) && (uVar5 < *(uint *)(param_2 + 0x28))) {
*(uint *)(param_2 + 0x28) = uVar5;
}
if ((param_4 < 7) && ((0x61U >> (param_4 & 0x1f) & 1) != 0)) {
if (uVar5 < *(uint *)(param_2 + 0x2c)) {
*(uint *)(param_2 + 0x2c) = uVar5;
}
if (param_4 == 0) {
*(int1 *)(param_2 + 0x20) = 1;
goto LAB_001547cb;
}
}
uVar5 = (uVar5 - (uVar3 < 6)) + 2;
if (*(uint *)(param_2 + 0x24) < uVar5) {
*(uint *)(param_2 + 0x24) = uVar5;
}
*(int1 *)(param_2 + 0x20) = 1;
if (param_4 == 4) {
return 0;
}
if (param_4 == 7) {
return 0;
}
LAB_001547cb:
if (uVar7 < *(ulong *)(*param_1 + 0xd0)) {
*(ulong *)(*param_1 + 0xd0) = uVar7;
}
return 0;
}
| |
43,172 | Table_triggers_list::reset_extra_null_bitmap() | eloqsql/sql/sql_trigger.h | void reset_extra_null_bitmap()
{
size_t null_bytes= (trigger_table->s->fields -
trigger_table->s->null_fields + 7)/8;
bzero(extra_null_bitmap, null_bytes);
} | O0 | c | Table_triggers_list::reset_extra_null_bitmap():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movq (%rcx), %rcx
movl 0x36c(%rcx), %ecx
movq 0x58(%rax), %rdx
movq (%rdx), %rdx
subl 0x37c(%rdx), %ecx
addl $0x7, %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
movq %rcx, -0x10(%rbp)
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x7584b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN19Table_triggers_list23reset_extra_null_bitmapEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rcx, [rax+58h]
mov rcx, [rcx]
mov ecx, [rcx+36Ch]
mov rdx, [rax+58h]
mov rdx, [rdx]
sub ecx, [rdx+37Ch]
add ecx, 7
shr ecx, 3
mov ecx, ecx
mov [rbp+var_10], rcx
mov rdi, [rax+38h]
mov rdx, [rbp+var_10]
xor esi, esi
call _memset
add rsp, 10h
pop rbp
retn
| long long Table_triggers_list::reset_extra_null_bitmap(Table_triggers_list *this)
{
return memset(
*((_QWORD *)this + 7),
0LL,
(unsigned int)(*(_DWORD *)(**((_QWORD **)this + 11) + 876LL)
- *(_DWORD *)(**((_QWORD **)this + 11) + 892LL)
+ 7) >> 3);
}
| _GLOBAL__sub_I_rpl_utility.cc:
PUSH RBP
MOV RBP,RSP
CALL 0x00870990
CALL 0x008709b0
CALL 0x008709d0
CALL 0x008709f0
CALL 0x00870a10
CALL 0x00870a30
CALL 0x00870a50
CALL 0x00870a70
CALL 0x00870a90
CALL 0x00870ab0
CALL 0x00870ad0
CALL 0x00870af0
CALL 0x00870b10
POP RBP
RET
|
void _GLOBAL__sub_I_rpl_utility_cc(void)
{
__cxx_global_var_init();
__cxx_global_var_init_1();
__cxx_global_var_init_2();
__cxx_global_var_init_3();
__cxx_global_var_init_4();
__cxx_global_var_init_5();
__cxx_global_var_init_6();
__cxx_global_var_init_7();
__cxx_global_var_init_8();
__cxx_global_var_init_9();
__cxx_global_var_init_10();
__cxx_global_var_init_11();
__cxx_global_var_init_12();
return;
}
| |
43,173 | ftxui::borderLight(std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/border.cpp | Element borderLight(Element child) {
return std::make_shared<Border>(unpack(std::move(child)), LIGHT);
} | O1 | cpp | ftxui::borderLight(std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq (%rsi), %rcx
leaq 0x18(%rsp), %rax
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rdx
movq %rcx, 0x8(%rsi)
movq %rdx, 0x8(%rax)
movq %rcx, (%rsi)
movq %rsp, %rdi
movq %rax, %rsi
callq 0x22c33
movl $0x80, %edi
callq 0xb3e0
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x3696e(%rip), %rax # 0x580a0
movq %rax, (%r14)
movq %r14, %r15
addq $0x10, %r15
movq (%rsp), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x21dd2
leaq 0x28(%rsp), %rdi
callq 0x151c0
movq %r15, (%rbx)
movq %r14, 0x8(%rbx)
movq %rsp, %rdi
callq 0x151c0
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x21795
callq 0x14c7c
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x151c0
movl $0x80, %esi
movq %r14, %rdi
callq 0xb400
jmp 0x217c1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x151c0
jmp 0x217ce
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x217dd
callq 0x14c7c
movq %rbx, %rdi
callq 0xb780
| _ZN5ftxui11borderLightESt10shared_ptrINS_4NodeEE:
push r15
push r14
push rbx
sub rsp, 40h
mov rbx, rdi
mov rcx, [rsi]
lea rax, [rsp+58h+var_40]
mov [rax], rcx
xor ecx, ecx
mov [rax+8], rcx
mov rdx, [rsi+8]
mov [rsi+8], rcx
mov [rax+8], rdx
mov [rsi], rcx
mov rdi, rsp
mov rsi, rax
call _ZN5ftxui6unpackIJSt10shared_ptrINS_4NodeEEEEESt6vectorIS3_SaIS3_EEDpT_; ftxui::unpack<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>)
mov edi, 80h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, 100000001h
mov [r14+8], rax
lea rax, off_580A0
mov [r14], rax
mov r15, r14
add r15, 10h
mov rax, qword ptr [rsp+58h+var_58]
lea rsi, [rsp+58h+var_30]
mov [rsi], rax
movups xmm0, [rsp+58h+var_58+8]
movups xmmword ptr [rsi+8], xmm0
xorps xmm0, xmm0
movaps [rsp+58h+var_58], xmm0
mov [rsp+58h+var_48], 0
mov rdi, r15
xor edx, edx
xor ecx, ecx
call _ZN5ftxui12_GLOBAL__N_16BorderC2ESt6vectorISt10shared_ptrINS_4NodeEESaIS5_EENS_11BorderStyleESt8optionalINS_5ColorEE; ftxui::`anonymous namespace'::Border::Border(std::vector<std::shared_ptr<ftxui::Node>>,ftxui::BorderStyle,std::optional<ftxui::Color>)
lea rdi, [rsp+58h+var_30]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov [rbx], r15
mov [rbx+8], r14
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, [rsp+58h+var_38]
test rdi, rdi
jz short loc_21795
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_21795:
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_20]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov esi, 80h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_217C1
mov rbx, rax
loc_217C1:
mov rdi, rsp
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
jmp short loc_217CE
mov rbx, rax
loc_217CE:
mov rdi, [rsp+arg_18]
test rdi, rdi
jz short loc_217DD
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_217DD:
mov rdi, rbx
call __Unwind_Resume
| _QWORD * ftxui::borderLight(_QWORD *a1, long long *a2, long long a3, long long a4, int a5, int a6)
{
volatile signed __int32 *v6; // rdx
_QWORD *v7; // r14
int v8; // r8d
int v9; // r9d
void *v11; // [rsp+0h] [rbp-58h] BYREF
__int128 v12; // [rsp+8h] [rbp-50h]
long long v13; // [rsp+18h] [rbp-40h] BYREF
volatile signed __int32 *v14; // [rsp+20h] [rbp-38h]
void *v15; // [rsp+28h] [rbp-30h] BYREF
__int128 v16; // [rsp+30h] [rbp-28h]
v13 = *a2;
v14 = 0LL;
v6 = (volatile signed __int32 *)a2[1];
a2[1] = 0LL;
v14 = v6;
*a2 = 0LL;
ftxui::unpack<std::shared_ptr<ftxui::Node>>(
(unsigned int)&v11,
(unsigned int)&v13,
(_DWORD)v6,
0,
a5,
a6,
(_DWORD)v11,
v12);
v7 = (_QWORD *)operator new(0x80uLL);
v7[1] = 0x100000001LL;
*v7 = off_580A0;
v15 = v11;
v16 = v12;
ftxui::`anonymous namespace'::Border::Border((_DWORD)v7 + 16, (unsigned int)&v15, 0, 0, v8, v9, 0LL, 0LL, 0LL);
std::vector<std::shared_ptr<ftxui::Node>>::~vector(&v15);
*a1 = v7 + 2;
a1[1] = v7;
std::vector<std::shared_ptr<ftxui::Node>>::~vector(&v11);
if ( v14 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v14);
return a1;
}
| borderLight:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
MOV RCX,qword ptr [RSI]
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX],RCX
XOR ECX,ECX
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RSI],RCX
LAB_00121705:
MOV RDI,RSP
MOV RSI,RAX
CALL 0x00122c33
LAB_00121710:
MOV EDI,0x80
CALL 0x0010b3e0
MOV R14,RAX
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x1580a0]
MOV qword ptr [R14],RAX
MOV R15,R14
ADD R15,0x10
MOV RAX,qword ptr [RSP]
LEA RSI,[RSP + 0x28]
MOV qword ptr [RSI],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RSI + 0x8],XMM0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
LAB_00121761:
MOV RDI,R15
XOR EDX,EDX
XOR ECX,ECX
CALL 0x00121dd2
LAB_0012176d:
LEA RDI,[RSP + 0x28]
CALL 0x001151c0
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],R14
MOV RDI,RSP
CALL 0x001151c0
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00121795
CALL 0x00114c7c
LAB_00121795:
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
|
/* ftxui::borderLight(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::borderLight(ftxui *this,int8 *param_2)
{
int8 *puVar1;
int8 local_58;
int8 uStack_50;
int8 uStack_48;
int8 local_40;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_38;
int8 local_30;
int8 local_28;
int8 uStack_20;
local_40 = *param_2;
local_38 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 00121705 to 0012170f has its CatchHandler @ 001217cb */
unpack<std::shared_ptr<ftxui::Node>>((ftxui *)&local_58,&local_40);
/* try { // try from 00121710 to 00121719 has its CatchHandler @ 001217be */
puVar1 = (int8 *)operator_new(0x80);
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_001580a0;
local_30 = local_58;
local_28 = uStack_50;
uStack_20 = uStack_48;
local_58 = 0;
uStack_50 = 0;
uStack_48 = 0;
/* try { // try from 00121761 to 0012176c has its CatchHandler @ 001217a2 */
(anonymous_namespace)::Border::Border((Border *)(puVar1 + 2),&local_30,0,0);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_30);
*(Border **)this = (Border *)(puVar1 + 2);
*(int8 **)(this + 8) = puVar1;
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
&local_58);
if (local_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_38);
}
return this;
}
| |
43,174 | c4_tx_create_from_address | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_tx.c | INTERNAL bool c4_tx_create_from_address(verify_ctx_t* ctx, bytes_t raw_tx, uint8_t* address) {
buffer_t buf = {0};
bytes32_t raw_hash = {0};
bytes_t last_item;
tx_type_t type = 0;
if (!get_and_remove_tx_type(ctx, &raw_tx, &type)) RETURN_VERIFY_ERROR(ctx, "invalid tx data, missing type!");
if (rlp_decode(&raw_tx, 0, &raw_tx) != RLP_LIST) RETURN_VERIFY_ERROR(ctx, "invalid tx data!");
rlp_type_defs_t defs = tx_type_defs[type];
rlp_decode(&raw_tx, defs.len - 4, &last_item);
buffer_append(&buf, bytes(raw_tx.data, last_item.data + last_item.len - raw_tx.data));
uint64_t v = 0;
if (type == TX_TYPE_LEGACY) {
v = rlp_get_uint64(raw_tx, 6);
if (v > 28) {
rlp_add_uint64(&buf, (v - 36 + v % 2) / 2);
rlp_add_item(&buf, NULL_BYTES);
rlp_add_item(&buf, NULL_BYTES);
}
}
else
v = rlp_get_uint64(raw_tx, defs.len - 3);
rlp_to_list(&buf);
if (type != TX_TYPE_LEGACY) {
buffer_splice(&buf, 0, 0, bytes(NULL, 1));
buf.data.data[0] = (uint8_t) type;
}
keccak(buf.data, raw_hash);
buffer_free(&buf);
// if (type == TX_TYPE_EIP4844) RETURN_VERIFY_ERROR(ctx, "invalid tx data, EIP4844 not supported (yet)!");
uint8_t sig[65] = {0};
uint8_t pubkey[64] = {0};
rlp_decode(&raw_tx, defs.len - 2, &last_item);
memcpy(sig + 32 - last_item.len, last_item.data, last_item.len);
rlp_decode(&raw_tx, defs.len - 1, &last_item);
memcpy(sig + 64 - last_item.len, last_item.data, last_item.len);
sig[64] = (uint8_t) (v > 28 ? (v % 2 ? 27 : 28) : v);
if (!secp256k1_recover(raw_hash, bytes(sig, 65), pubkey)) RETURN_VERIFY_ERROR(ctx, "invalid signature!");
keccak(bytes(pubkey, 64), sig);
memcpy(address, sig + 12, 20);
return true;
} | O0 | c | c4_tx_create_from_address:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x5110
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x5110
movl $0x0, -0x74(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x74(%rbp), %rdx
callq 0x10530
testb $0x1, %al
jne 0x101ad
jmp 0x10188
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x430b5(%rip), %rsi # 0x5324c
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x10520
leaq -0x18(%rbp), %rdx
xorl %esi, %esi
movq %rdx, %rdi
callq 0x15f10
cmpl $0x2, %eax
je 0x101e7
jmp 0x101c2
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x4309a(%rip), %rsi # 0x5326b
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x10520
movl -0x74(%rbp), %eax
movl %eax, %ecx
leaq 0x5c0ed(%rip), %rax # 0x6c2e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
movl -0x80(%rbp), %esi
subl $0x4, %esi
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x15f10
movq -0x68(%rbp), %rax
movl -0x70(%rbp), %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x98(%rbp), %esi
movq -0x90(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x18bd0
movq $0x0, -0xa0(%rbp)
cmpl $0x0, -0x74(%rbp)
jne 0x1030b
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x6, %edx
callq 0x16660
movq %rax, -0xa0(%rbp)
cmpq $0x1c, -0xa0(%rbp)
jbe 0x10309
movq -0xa0(%rbp), %rsi
subq $0x24, %rsi
movq -0xa0(%rbp), %rax
andq $0x1, %rax
addq %rax, %rsi
shrq %rsi
leaq -0x40(%rbp), %rdi
callq 0x16590
movl $0x0, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
movl -0xb0(%rbp), %esi
movq -0xa8(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x16350
movl $0x0, -0xc0(%rbp)
movq $0x0, -0xb8(%rbp)
movl -0xc0(%rbp), %esi
movq -0xb8(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x16350
jmp 0x10324
movl -0x80(%rbp), %edx
subl $0x3, %edx
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x16660
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x165f0
cmpl $0x0, -0x74(%rbp)
je 0x1036f
movl $0x1, -0xd0(%rbp)
movq $0x0, -0xc8(%rbp)
movl -0xd0(%rbp), %ecx
movq -0xc8(%rbp), %r8
leaq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x18ca0
movl -0x74(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
leaq -0x60(%rbp), %rdx
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
callq 0x1f4e0
leaq -0x40(%rbp), %rdi
callq 0x18d90
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x41, %edx
callq 0x5110
leaq -0x160(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x5110
movl -0x80(%rbp), %esi
subl $0x2, %esi
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x15f10
leaq -0x120(%rbp), %rdi
addq $0x20, %rdi
movl -0x70(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x68(%rbp), %rsi
movl -0x70(%rbp), %eax
movl %eax, %edx
callq 0x5060
movl -0x80(%rbp), %esi
subl $0x1, %esi
leaq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x15f10
leaq -0x120(%rbp), %rdi
addq $0x40, %rdi
movl -0x70(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x68(%rbp), %rsi
movl -0x70(%rbp), %eax
movl %eax, %edx
callq 0x5060
cmpq $0x1c, -0xa0(%rbp)
jbe 0x10451
movq -0xa0(%rbp), %rdx
andq $0x1, %rdx
movl $0x1c, %eax
movl $0x1b, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
cltq
movq %rax, -0x188(%rbp)
jmp 0x1045f
movq -0xa0(%rbp), %rax
movq %rax, -0x188(%rbp)
movq -0x188(%rbp), %rax
movb %al, -0xe0(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x41, -0x170(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x168(%rbp)
leaq -0x160(%rbp), %rcx
movl -0x170(%rbp), %esi
movq -0x168(%rbp), %rdx
callq 0x1f8e0
testb $0x1, %al
jne 0x104c9
jmp 0x104a7
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
leaq 0x42dc6(%rip), %rsi # 0x5327c
callq 0x22510
movq -0x20(%rbp), %rax
movb $0x0, 0x68(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x10520
movl $0x40, -0x180(%rbp)
leaq -0x160(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x120(%rbp), %rdx
movl -0x180(%rbp), %edi
movq -0x178(%rbp), %rsi
callq 0x1f4e0
movq -0x28(%rbp), %rax
movq -0x114(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10c(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x104(%rbp), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x190, %rsp # imm = 0x190
popq %rbp
retq
nop
| c4_tx_create_from_address:
push rbp
mov rbp, rsp
sub rsp, 190h
mov [rbp+var_18], esi
mov [rbp+var_10], rdx
mov [rbp+var_20], rdi
mov [rbp+var_28], rcx
lea rdi, [rbp+var_40]
xor esi, esi
mov edx, 18h
call _memset
lea rdi, [rbp+var_60]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov [rbp+var_74], 0
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_18]
lea rdx, [rbp+var_74]
call get_and_remove_tx_type
test al, 1
jnz short loc_101AD
jmp short $+2
loc_10188:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidTxDataM; "invalid tx data, missing type!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_10520
loc_101AD:
lea rdx, [rbp+var_18]
xor esi, esi
mov rdi, rdx
call rlp_decode
cmp eax, 2
jz short loc_101E7
jmp short $+2
loc_101C2:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidTxData; "invalid tx data!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp loc_10520
loc_101E7:
mov eax, [rbp+var_74]
mov ecx, eax
lea rax, tx_type_defs
shl rcx, 4
add rax, rcx
mov rcx, [rax]
mov [rbp+var_88], rcx
mov rax, [rax+8]
mov [rbp+var_80], rax
mov esi, dword ptr [rbp+var_80]
sub esi, 4
lea rdi, [rbp+var_18]
lea rdx, [rbp+var_70]
call rlp_decode
mov rax, [rbp+var_68]
mov ecx, [rbp+var_70]
add rax, rcx
mov rcx, [rbp+var_10]
sub rax, rcx
mov [rbp+var_98], eax
mov rax, [rbp+var_10]
mov [rbp+var_90], rax
mov esi, [rbp+var_98]
mov rdx, [rbp+var_90]
lea rdi, [rbp+var_40]
call buffer_append
mov [rbp+var_A0], 0
cmp [rbp+var_74], 0
jnz loc_1030B
mov edi, [rbp+var_18]
mov rsi, [rbp+var_10]
mov edx, 6
call rlp_get_uint64
mov [rbp+var_A0], rax
cmp [rbp+var_A0], 1Ch
jbe short loc_10309
mov rsi, [rbp+var_A0]
sub rsi, 24h ; '$'
mov rax, [rbp+var_A0]
and rax, 1
add rsi, rax
shr rsi, 1
lea rdi, [rbp+var_40]
call rlp_add_uint64
mov [rbp+var_B0], 0
mov [rbp+var_A8], 0
mov esi, [rbp+var_B0]
mov rdx, [rbp+var_A8]
lea rdi, [rbp+var_40]
call rlp_add_item
mov [rbp+var_C0], 0
mov [rbp+var_B8], 0
mov esi, [rbp+var_C0]
mov rdx, [rbp+var_B8]
lea rdi, [rbp+var_40]
call rlp_add_item
loc_10309:
jmp short loc_10324
loc_1030B:
mov edx, dword ptr [rbp+var_80]
sub edx, 3
mov edi, [rbp+var_18]
mov rsi, [rbp+var_10]
call rlp_get_uint64
mov [rbp+var_A0], rax
loc_10324:
lea rdi, [rbp+var_40]
call rlp_to_list
cmp [rbp+var_74], 0
jz short loc_1036F
mov [rbp+var_D0], 1
mov [rbp+var_C8], 0
mov ecx, [rbp+var_D0]
mov r8, [rbp+var_C8]
lea rdi, [rbp+var_40]
xor eax, eax
mov esi, eax
xor edx, edx
call buffer_splice
mov eax, [rbp+var_74]
mov cl, al
mov rax, [rbp+var_38]
mov [rax], cl
loc_1036F:
lea rdx, [rbp+var_60]
mov edi, [rbp+var_40]
mov rsi, [rbp+var_38]
call keccak
lea rdi, [rbp+var_40]
call buffer_free
lea rdi, [rbp+var_120]
xor esi, esi
mov edx, 41h ; 'A'
call _memset
lea rdi, [rbp+var_160]
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov esi, dword ptr [rbp+var_80]
sub esi, 2
lea rdi, [rbp+var_18]
lea rdx, [rbp+var_70]
call rlp_decode
lea rdi, [rbp+var_120]
add rdi, 20h ; ' '
mov eax, [rbp+var_70]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov rsi, [rbp+var_68]
mov eax, [rbp+var_70]
mov edx, eax
call _memcpy
mov esi, dword ptr [rbp+var_80]
sub esi, 1
lea rdi, [rbp+var_18]
lea rdx, [rbp+var_70]
call rlp_decode
lea rdi, [rbp+var_120]
add rdi, 40h ; '@'
mov eax, [rbp+var_70]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rdi, rax
mov rsi, [rbp+var_68]
mov eax, [rbp+var_70]
mov edx, eax
call _memcpy
cmp [rbp+var_A0], 1Ch
jbe short loc_10451
mov rdx, [rbp+var_A0]
and rdx, 1
mov eax, 1Ch
mov ecx, 1Bh
cmp rdx, 0
cmovnz eax, ecx
cdqe
mov [rbp+var_188], rax
jmp short loc_1045F
loc_10451:
mov rax, [rbp+var_A0]
mov [rbp+var_188], rax
loc_1045F:
mov rax, [rbp+var_188]
mov [rbp+var_E0], al
lea rdi, [rbp+var_60]
mov [rbp+var_170], 41h ; 'A'
lea rax, [rbp+var_120]
mov [rbp+var_168], rax
lea rcx, [rbp+var_160]
mov esi, [rbp+var_170]
mov rdx, [rbp+var_168]
call secp256k1_recover
test al, 1
jnz short loc_104C9
jmp short $+2
loc_104A7:
mov rdi, [rbp+var_20]
add rdi, 70h ; 'p'
lea rsi, aInvalidSignatu; "invalid signature!"
call c4_state_add_error
mov rax, [rbp+var_20]
mov byte ptr [rax+68h], 0
mov [rbp+var_1], 0
jmp short loc_10520
loc_104C9:
mov [rbp+var_180], 40h ; '@'
lea rax, [rbp+var_160]
mov [rbp+var_178], rax
lea rdx, [rbp+var_120]
mov edi, [rbp+var_180]
mov rsi, [rbp+var_178]
call keccak
mov rax, [rbp+var_28]
mov rcx, [rbp+var_114]
mov [rax], rcx
mov rcx, [rbp+var_10C]
mov [rax+8], rcx
mov ecx, [rbp+var_104]
mov [rax+10h], ecx
mov [rbp+var_1], 1
loc_10520:
mov al, [rbp+var_1]
and al, 1
add rsp, 190h
pop rbp
retn
| char c4_tx_create_from_address(long long a1, unsigned int a2, long long a3, _QWORD *a4)
{
char **v4; // rax
char v5; // al
_QWORD *v6; // rax
char v8; // [rsp+8h] [rbp-188h]
_BYTE v9[64]; // [rsp+30h] [rbp-160h] BYREF
_BYTE v10[12]; // [rsp+70h] [rbp-120h] BYREF
long long v11; // [rsp+7Ch] [rbp-114h]
long long v12; // [rsp+84h] [rbp-10Ch]
int v13; // [rsp+8Ch] [rbp-104h]
_BYTE v15[16]; // [rsp+B0h] [rbp-E0h] BYREF
int v16; // [rsp+C0h] [rbp-D0h]
long long v17; // [rsp+C8h] [rbp-C8h]
int v18; // [rsp+D0h] [rbp-C0h]
long long v19; // [rsp+D8h] [rbp-B8h]
int v20; // [rsp+E0h] [rbp-B0h]
long long v21; // [rsp+E8h] [rbp-A8h]
unsigned long long uint64; // [rsp+F0h] [rbp-A0h]
unsigned int v23; // [rsp+F8h] [rbp-98h]
long long v24; // [rsp+100h] [rbp-90h]
char *v25; // [rsp+108h] [rbp-88h]
char *v26; // [rsp+110h] [rbp-80h]
unsigned int v27; // [rsp+11Ch] [rbp-74h] BYREF
unsigned int v28; // [rsp+120h] [rbp-70h]
long long v29; // [rsp+128h] [rbp-68h]
_BYTE v30[32]; // [rsp+130h] [rbp-60h] BYREF
unsigned int v31; // [rsp+150h] [rbp-40h] BYREF
_BYTE *v32; // [rsp+158h] [rbp-38h]
_QWORD *v33; // [rsp+168h] [rbp-28h]
long long v34; // [rsp+170h] [rbp-20h]
unsigned int v35; // [rsp+178h] [rbp-18h] BYREF
long long v36; // [rsp+180h] [rbp-10h]
v35 = a2;
v36 = a3;
v34 = a1;
v33 = a4;
memset(&v31, 0LL, 24LL);
memset(v30, 0LL, sizeof(v30));
v27 = 0;
if ( (get_and_remove_tx_type(v34, &v35, &v27) & 1) != 0 )
{
if ( (unsigned int)rlp_decode(&v35, 0LL) == 2 )
{
v4 = &(&tx_type_defs)[2 * v27];
v25 = *v4;
v26 = v4[1];
rlp_decode(&v35, (unsigned int)((_DWORD)v26 - 4));
v23 = v28 + v29 - v36;
v24 = v36;
buffer_append(&v31, v23, v36);
uint64 = 0LL;
if ( v27 )
{
uint64 = rlp_get_uint64(v35, v36, (unsigned int)((_DWORD)v26 - 3));
}
else
{
uint64 = rlp_get_uint64(v35, v36, 6LL);
if ( uint64 > 0x1C )
{
rlp_add_uint64(&v31, ((uint64 & 1) + uint64 - 36) >> 1);
v20 = 0;
v21 = 0LL;
rlp_add_item(&v31, 0LL, 0LL);
v18 = 0;
v19 = 0LL;
rlp_add_item(&v31, 0LL, 0LL);
}
}
rlp_to_list(&v31);
if ( v27 )
{
v16 = 1;
v17 = 0LL;
buffer_splice(&v31, 0LL, 0LL, 1LL, 0LL);
*v32 = v27;
}
keccak(v31, v32, v30);
buffer_free(&v31);
memset(v10, 0LL, 65LL);
memset(v9, 0LL, sizeof(v9));
rlp_decode(&v35, (unsigned int)((_DWORD)v26 - 2));
memcpy(v15 - v28 + 16, v29, v28);
rlp_decode(&v35, (unsigned int)((_DWORD)v26 - 1));
memcpy(&v15[-v28], v29, v28);
if ( uint64 <= 0x1C )
{
v8 = uint64;
}
else
{
v5 = 28;
if ( (uint64 & 1) != 0 )
v5 = 27;
v8 = v5;
}
v15[0] = v8;
if ( (secp256k1_recover(v30, 65LL, v10, v9) & 1) != 0 )
{
keccak(64LL, v9, v10);
v6 = v33;
*v33 = v11;
v6[1] = v12;
*((_DWORD *)v6 + 4) = v13;
return 1;
}
else
{
c4_state_add_error(v34 + 112, "invalid signature!");
*(_BYTE *)(v34 + 104) = 0;
return 0;
}
}
else
{
c4_state_add_error(v34 + 112, "invalid tx data!");
*(_BYTE *)(v34 + 104) = 0;
return 0;
}
}
else
{
c4_state_add_error(v34 + 112, "invalid tx data, missing type!");
*(_BYTE *)(v34 + 104) = 0;
return 0;
}
}
| c4_tx_create_from_address:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x190
MOV dword ptr [RBP + -0x18],ESI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RCX
LEA RDI,[RBP + -0x40]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00105110
LEA RDI,[RBP + -0x60]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x00105110
MOV dword ptr [RBP + -0x74],0x0
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x18]
LEA RDX,[RBP + -0x74]
CALL 0x00110530
TEST AL,0x1
JNZ 0x001101ad
JMP 0x00110188
LAB_00110188:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x15324c]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00110520
LAB_001101ad:
LEA RDX,[RBP + -0x18]
XOR ESI,ESI
MOV RDI,RDX
CALL 0x00115f10
CMP EAX,0x2
JZ 0x001101e7
JMP 0x001101c2
LAB_001101c2:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x15326b]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00110520
LAB_001101e7:
MOV EAX,dword ptr [RBP + -0x74]
MOV ECX,EAX
LEA RAX,[0x16c2e0]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x80],RAX
MOV ESI,dword ptr [RBP + -0x80]
SUB ESI,0x4
LEA RDI,[RBP + -0x18]
LEA RDX,[RBP + -0x70]
CALL 0x00115f10
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x70]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
MOV dword ptr [RBP + -0x98],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x90],RAX
MOV ESI,dword ptr [RBP + -0x98]
MOV RDX,qword ptr [RBP + -0x90]
LEA RDI,[RBP + -0x40]
CALL 0x00118bd0
MOV qword ptr [RBP + -0xa0],0x0
CMP dword ptr [RBP + -0x74],0x0
JNZ 0x0011030b
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,0x6
CALL 0x00116660
MOV qword ptr [RBP + -0xa0],RAX
CMP qword ptr [RBP + -0xa0],0x1c
JBE 0x00110309
MOV RSI,qword ptr [RBP + -0xa0]
SUB RSI,0x24
MOV RAX,qword ptr [RBP + -0xa0]
AND RAX,0x1
ADD RSI,RAX
SHR RSI,0x1
LEA RDI,[RBP + -0x40]
CALL 0x00116590
MOV dword ptr [RBP + -0xb0],0x0
MOV qword ptr [RBP + -0xa8],0x0
MOV ESI,dword ptr [RBP + -0xb0]
MOV RDX,qword ptr [RBP + -0xa8]
LEA RDI,[RBP + -0x40]
CALL 0x00116350
MOV dword ptr [RBP + -0xc0],0x0
MOV qword ptr [RBP + -0xb8],0x0
MOV ESI,dword ptr [RBP + -0xc0]
MOV RDX,qword ptr [RBP + -0xb8]
LEA RDI,[RBP + -0x40]
CALL 0x00116350
LAB_00110309:
JMP 0x00110324
LAB_0011030b:
MOV EDX,dword ptr [RBP + -0x80]
SUB EDX,0x3
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00116660
MOV qword ptr [RBP + -0xa0],RAX
LAB_00110324:
LEA RDI,[RBP + -0x40]
CALL 0x001165f0
CMP dword ptr [RBP + -0x74],0x0
JZ 0x0011036f
MOV dword ptr [RBP + -0xd0],0x1
MOV qword ptr [RBP + -0xc8],0x0
MOV ECX,dword ptr [RBP + -0xd0]
MOV R8,qword ptr [RBP + -0xc8]
LEA RDI,[RBP + -0x40]
XOR EAX,EAX
MOV ESI,EAX
XOR EDX,EDX
CALL 0x00118ca0
MOV EAX,dword ptr [RBP + -0x74]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
LAB_0011036f:
LEA RDX,[RBP + -0x60]
MOV EDI,dword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0011f4e0
LEA RDI,[RBP + -0x40]
CALL 0x00118d90
LEA RDI,[RBP + -0x120]
XOR ESI,ESI
MOV EDX,0x41
CALL 0x00105110
LEA RDI,[RBP + -0x160]
XOR ESI,ESI
MOV EDX,0x40
CALL 0x00105110
MOV ESI,dword ptr [RBP + -0x80]
SUB ESI,0x2
LEA RDI,[RBP + -0x18]
LEA RDX,[RBP + -0x70]
CALL 0x00115f10
LEA RDI,[RBP + -0x120]
ADD RDI,0x20
MOV EAX,dword ptr [RBP + -0x70]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RBP + -0x70]
MOV EDX,EAX
CALL 0x00105060
MOV ESI,dword ptr [RBP + -0x80]
SUB ESI,0x1
LEA RDI,[RBP + -0x18]
LEA RDX,[RBP + -0x70]
CALL 0x00115f10
LEA RDI,[RBP + -0x120]
ADD RDI,0x40
MOV EAX,dword ptr [RBP + -0x70]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x68]
MOV EAX,dword ptr [RBP + -0x70]
MOV EDX,EAX
CALL 0x00105060
CMP qword ptr [RBP + -0xa0],0x1c
JBE 0x00110451
MOV RDX,qword ptr [RBP + -0xa0]
AND RDX,0x1
MOV EAX,0x1c
MOV ECX,0x1b
CMP RDX,0x0
CMOVNZ EAX,ECX
CDQE
MOV qword ptr [RBP + -0x188],RAX
JMP 0x0011045f
LAB_00110451:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x188],RAX
LAB_0011045f:
MOV RAX,qword ptr [RBP + -0x188]
MOV byte ptr [RBP + -0xe0],AL
LEA RDI,[RBP + -0x60]
MOV dword ptr [RBP + -0x170],0x41
LEA RAX,[RBP + -0x120]
MOV qword ptr [RBP + -0x168],RAX
LEA RCX,[RBP + -0x160]
MOV ESI,dword ptr [RBP + -0x170]
MOV RDX,qword ptr [RBP + -0x168]
CALL 0x0011f8e0
TEST AL,0x1
JNZ 0x001104c9
JMP 0x001104a7
LAB_001104a7:
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x70
LEA RSI,[0x15327c]
CALL 0x00122510
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x68],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00110520
LAB_001104c9:
MOV dword ptr [RBP + -0x180],0x40
LEA RAX,[RBP + -0x160]
MOV qword ptr [RBP + -0x178],RAX
LEA RDX,[RBP + -0x120]
MOV EDI,dword ptr [RBP + -0x180]
MOV RSI,qword ptr [RBP + -0x178]
CALL 0x0011f4e0
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x114]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x10c]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x104]
MOV dword ptr [RAX + 0x10],ECX
MOV byte ptr [RBP + -0x1],0x1
LAB_00110520:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x190
POP RBP
RET
|
int1
c4_tx_create_from_address(long param_1,int4 param_2,int8 param_3,int8 *param_4)
{
int iVar1;
ulong uVar2;
int1 local_190;
int1 local_168 [64];
int1 local_128 [12];
int8 local_11c;
int8 local_114;
int4 local_10c;
int1 auStack_108 [32];
int1 local_e8 [16];
int4 local_d8;
int8 local_d0;
int4 local_c8;
int8 local_c0;
int4 local_b8;
int8 local_b0;
ulong local_a8;
int local_a0;
int8 local_98;
int8 local_90;
int8 local_88;
uint local_7c;
uint local_78 [2];
void *local_70;
int1 local_68 [32];
int4 local_48 [2];
int1 *local_40;
int8 *local_30;
long local_28;
int4 local_20 [2];
int8 local_18;
int1 local_9;
local_30 = param_4;
local_28 = param_1;
local_20[0] = param_2;
local_18 = param_3;
memset(local_48,0,0x18);
memset(local_68,0,0x20);
local_7c = 0;
uVar2 = get_and_remove_tx_type(local_28,local_20,&local_7c);
if ((uVar2 & 1) == 0) {
c4_state_add_error(local_28 + 0x70,"invalid tx data, missing type!");
*(int1 *)(local_28 + 0x68) = 0;
local_9 = 0;
}
else {
iVar1 = rlp_decode(local_20,0);
if (iVar1 == 2) {
local_90 = *(int8 *)(tx_type_defs + (ulong)local_7c * 0x10);
local_88 = *(int8 *)(tx_type_defs + (ulong)local_7c * 0x10 + 8);
rlp_decode(local_20,(int)local_88 + -4,local_78);
local_a0 = ((int)local_70 + local_78[0]) - (int)local_18;
local_98 = local_18;
buffer_append(local_48,local_a0,local_18);
local_a8 = 0;
if (local_7c == 0) {
local_a8 = rlp_get_uint64(local_20[0],local_18,6);
if (0x1c < local_a8) {
rlp_add_uint64(local_48,(local_a8 - 0x24) + (local_a8 & 1) >> 1);
local_b8 = 0;
local_b0 = 0;
rlp_add_item(local_48,0,0);
local_c8 = 0;
local_c0 = 0;
rlp_add_item(local_48,0,0);
}
}
else {
local_a8 = rlp_get_uint64(local_20[0],local_18,(int)local_88 + -3);
}
rlp_to_list(local_48);
if (local_7c != 0) {
local_d8 = 1;
local_d0 = 0;
buffer_splice(local_48,0,0,1,0);
*local_40 = (char)local_7c;
}
keccak(local_48[0],local_40,local_68);
buffer_free(local_48);
memset(local_128,0,0x41);
memset(local_168,0,0x40);
rlp_decode(local_20,(int)local_88 + -2,local_78);
memcpy(auStack_108 + -(ulong)local_78[0],local_70,(ulong)local_78[0]);
rlp_decode(local_20,(int)local_88 + -1,local_78);
memcpy(local_e8 + -(ulong)local_78[0],local_70,(ulong)local_78[0]);
if (local_a8 < 0x1d) {
local_190 = (int1)local_a8;
}
else {
local_190 = 0x1c;
if ((local_a8 & 1) != 0) {
local_190 = 0x1b;
}
}
local_e8[0] = local_190;
uVar2 = secp256k1_recover(local_68,0x41,local_128,local_168);
if ((uVar2 & 1) == 0) {
c4_state_add_error(local_28 + 0x70,"invalid signature!");
*(int1 *)(local_28 + 0x68) = 0;
local_9 = 0;
}
else {
keccak(0x40,local_168,local_128);
*local_30 = local_11c;
local_30[1] = local_114;
*(int4 *)(local_30 + 2) = local_10c;
local_9 = 1;
}
}
else {
c4_state_add_error(local_28 + 0x70,"invalid tx data!");
*(int1 *)(local_28 + 0x68) = 0;
local_9 = 0;
}
}
return local_9;
}
| |
43,175 | c4_tx_create_from_address | corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_tx.c | INTERNAL bool c4_tx_create_from_address(verify_ctx_t* ctx, bytes_t raw_tx, uint8_t* address) {
buffer_t buf = {0};
bytes32_t raw_hash = {0};
bytes_t last_item;
tx_type_t type = 0;
if (!get_and_remove_tx_type(ctx, &raw_tx, &type)) RETURN_VERIFY_ERROR(ctx, "invalid tx data, missing type!");
if (rlp_decode(&raw_tx, 0, &raw_tx) != RLP_LIST) RETURN_VERIFY_ERROR(ctx, "invalid tx data!");
rlp_type_defs_t defs = tx_type_defs[type];
rlp_decode(&raw_tx, defs.len - 4, &last_item);
buffer_append(&buf, bytes(raw_tx.data, last_item.data + last_item.len - raw_tx.data));
uint64_t v = 0;
if (type == TX_TYPE_LEGACY) {
v = rlp_get_uint64(raw_tx, 6);
if (v > 28) {
rlp_add_uint64(&buf, (v - 36 + v % 2) / 2);
rlp_add_item(&buf, NULL_BYTES);
rlp_add_item(&buf, NULL_BYTES);
}
}
else
v = rlp_get_uint64(raw_tx, defs.len - 3);
rlp_to_list(&buf);
if (type != TX_TYPE_LEGACY) {
buffer_splice(&buf, 0, 0, bytes(NULL, 1));
buf.data.data[0] = (uint8_t) type;
}
keccak(buf.data, raw_hash);
buffer_free(&buf);
// if (type == TX_TYPE_EIP4844) RETURN_VERIFY_ERROR(ctx, "invalid tx data, EIP4844 not supported (yet)!");
uint8_t sig[65] = {0};
uint8_t pubkey[64] = {0};
rlp_decode(&raw_tx, defs.len - 2, &last_item);
memcpy(sig + 32 - last_item.len, last_item.data, last_item.len);
rlp_decode(&raw_tx, defs.len - 1, &last_item);
memcpy(sig + 64 - last_item.len, last_item.data, last_item.len);
sig[64] = (uint8_t) (v > 28 ? (v % 2 ? 27 : 28) : v);
if (!secp256k1_recover(raw_hash, bytes(sig, 65), pubkey)) RETURN_VERIFY_ERROR(ctx, "invalid signature!");
keccak(bytes(pubkey, 64), sig);
memcpy(address, sig + 12, 20);
return true;
} | O1 | c | c4_tx_create_from_address:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movl %esi, (%rax)
movq %rdx, 0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
leaq 0x1c(%rsp), %rdx
movl $0x0, (%rdx)
movq %rax, %rsi
callq 0xd4e5
testb %al, %al
je 0xd2fa
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rdi, %rdx
callq 0x10ef0
cmpl $0x2, %eax
jne 0xd307
movq %r14, 0x38(%rsp)
movl 0x1c(%rsp), %r14d
movq %r14, %rax
shlq $0x4, %rax
leaq 0x4a03c(%rip), %rcx # 0x572e0
movl 0x8(%rax,%rcx), %r15d
leal -0x4(%r15), %esi
leaq 0x8(%rsp), %r12
leaq 0x60(%rsp), %r13
movq %r12, %rdi
movq %r13, %rdx
callq 0x10ef0
movl 0x8(%r13), %esi
addl (%r13), %esi
movq 0x8(%r12), %rdx
subl %edx, %esi
leaq 0x20(%rsp), %rdi
callq 0x1294d
testq %r14, %r14
je 0xd331
leal -0x3(%r15), %edx
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x1137e
movq %rax, %r12
jmp 0xd383
leaq 0x70(%rbx), %rdi
leaq 0x30f60(%rip), %rsi # 0x3e265
jmp 0xd312
leaq 0x70(%rbx), %rdi
leaq 0x30f72(%rip), %rsi # 0x3e284
callq 0x18879
movb $0x0, 0x68(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
movl $0x6, %edx
callq 0x1137e
movq %rax, %r12
cmpq $0x1d, %rax
jb 0xd383
movl %r12d, %eax
andl $0x1, %eax
leaq (%r12,%rax), %rsi
addq $-0x24, %rsi
shrq %rsi
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x112e6
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11188
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11188
leaq 0x20(%rsp), %rdi
callq 0x1132d
testl %r14d, %r14d
je 0xd3b2
leaq 0x20(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x129b0
movq 0x8(%r13), %rax
movb %r14b, (%rax)
leaq 0x20(%rsp), %r13
movl (%r13), %edi
movq 0x8(%r13), %rsi
leaq 0x40(%rsp), %rdx
callq 0x16aa8
movq %r13, %rdi
callq 0x12a33
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %r13
movaps %xmm0, -0x10(%r13)
movaps %xmm0, -0x20(%r13)
movaps %xmm0, -0x30(%r13)
movaps %xmm0, -0x40(%r13)
movb $0x0, (%r13)
leaq 0x90(%rsp), %rbp
leaq 0xc0(%rsp), %rax
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leal -0x2(%r15), %esi
leaq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %r14
movq %r14, %rdx
callq 0x10ef0
movl (%r14), %edx
movq %rbp, %rdi
subq %rdx, %rdi
movq 0x8(%r14), %rsi
callq 0x5060
decl %r15d
leaq 0x8(%rsp), %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x10ef0
movl (%r14), %edx
subq %rdx, %r13
movq 0x8(%r14), %rsi
movq %r13, %rdi
callq 0x5060
movl %r12d, %eax
andb $0x1, %al
movb $0x1c, %cl
subb %al, %cl
cmpq $0x1d, %r12
movzbl %cl, %eax
cmovael %eax, %r12d
movb %r12b, 0x20(%rbp)
leaq 0x70(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movl $0x41, %esi
leaq 0xc0(%rsp), %rcx
callq 0x16d8d
movl %eax, %ebp
testb %al, %al
je 0xd4cc
leaq 0xc0(%rsp), %rsi
leaq 0x70(%rsp), %rbx
movl $0x40, %edi
movq %rbx, %rdx
callq 0x16aa8
movl 0x1c(%rbx), %eax
movq 0x38(%rsp), %rcx
movl %eax, 0x10(%rcx)
movups 0xc(%rbx), %xmm0
movups %xmm0, (%rcx)
jmp 0xd31d
leaq 0x70(%rbx), %rdi
leaq 0x30dbe(%rip), %rsi # 0x3e295
callq 0x18879
movb $0x0, 0x68(%rbx)
jmp 0xd31d
| c4_tx_create_from_address:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
mov r14, rcx
mov rbx, rdi
lea rax, [rsp+138h+var_130]
mov [rax], esi
mov [rax+8], rdx
xorps xmm0, xmm0
movaps [rsp+138h+var_118], xmm0
mov [rsp+138h+var_108], 0
movaps [rsp+138h+var_E8], xmm0
movaps [rsp+138h+var_F8], xmm0
lea rdx, [rsp+138h+var_11C]
mov dword ptr [rdx], 0
mov rsi, rax
call get_and_remove_tx_type
test al, al
jz loc_D2FA
lea rdi, [rsp+138h+var_130]
xor esi, esi
mov rdx, rdi
call rlp_decode
cmp eax, 2
jnz short loc_D307
mov [rsp+138h+var_100], r14
mov r14d, [rsp+138h+var_11C]
mov rax, r14
shl rax, 4
lea rcx, tx_type_defs
mov r15d, [rax+rcx+8]
lea esi, [r15-4]
lea r12, [rsp+138h+var_130]
lea r13, [rsp+138h+var_D8]
mov rdi, r12
mov rdx, r13
call rlp_decode
mov esi, [r13+8]
add esi, [r13+0]
mov rdx, [r12+8]
sub esi, edx
lea rdi, [rsp+138h+var_118]
call buffer_append
test r14, r14
jz short loc_D331
lea edx, [r15-3]
mov edi, [rsp+138h+var_130]
mov rsi, [rsp+138h+var_128]
call rlp_get_uint64
mov r12, rax
jmp loc_D383
loc_D2FA:
lea rdi, [rbx+70h]
lea rsi, aInvalidTxDataM; "invalid tx data, missing type!"
jmp short loc_D312
loc_D307:
lea rdi, [rbx+70h]
lea rsi, aInvalidTxData; "invalid tx data!"
loc_D312:
call c4_state_add_error
mov byte ptr [rbx+68h], 0
xor ebp, ebp
loc_D31D:
mov eax, ebp
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_D331:
mov edi, [rsp+138h+var_130]
mov rsi, [rsp+138h+var_128]
mov edx, 6
call rlp_get_uint64
mov r12, rax
cmp rax, 1Dh
jb short loc_D383
mov eax, r12d
and eax, 1
lea rsi, [r12+rax]
add rsi, 0FFFFFFFFFFFFFFDCh
shr rsi, 1
lea r13, [rsp+138h+var_118]
mov rdi, r13
call rlp_add_uint64
mov rdi, r13
xor esi, esi
xor edx, edx
call rlp_add_item
mov rdi, r13
xor esi, esi
xor edx, edx
call rlp_add_item
loc_D383:
lea rdi, [rsp+138h+var_118]
call rlp_to_list
test r14d, r14d
jz short loc_D3B2
lea r13, [rsp+138h+var_118]
mov rdi, r13
xor esi, esi
xor edx, edx
mov ecx, 1
xor r8d, r8d
call buffer_splice
mov rax, [r13+8]
mov [rax], r14b
loc_D3B2:
lea r13, [rsp+138h+var_118]
mov edi, [r13+0]
mov rsi, [r13+8]
lea rdx, [rsp+138h+var_F8]
call keccak
mov rdi, r13
call buffer_free
xorps xmm0, xmm0
lea r13, [rsp+138h+var_88]
movaps xmmword ptr [r13-10h], xmm0
movaps xmmword ptr [r13-20h], xmm0
movaps xmmword ptr [r13-30h], xmm0
movaps xmmword ptr [r13-40h], xmm0
mov byte ptr [r13+0], 0
lea rbp, [rsp+138h+var_A8]
lea rax, [rsp+138h+var_78]
movaps xmmword ptr [rax+30h], xmm0
movaps xmmword ptr [rax+20h], xmm0
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax], xmm0
lea esi, [r15-2]
lea rdi, [rsp+138h+var_130]
lea r14, [rsp+138h+var_D8]
mov rdx, r14
call rlp_decode
mov edx, [r14]
mov rdi, rbp
sub rdi, rdx
mov rsi, [r14+8]
call _memcpy
dec r15d
lea rdi, [rsp+138h+var_130]
mov esi, r15d
mov rdx, r14
call rlp_decode
mov edx, [r14]
sub r13, rdx
mov rsi, [r14+8]
mov rdi, r13
call _memcpy
mov eax, r12d
and al, 1
mov cl, 1Ch
sub cl, al
cmp r12, 1Dh
movzx eax, cl
cmovnb r12d, eax
mov [rbp+20h], r12b
lea rdx, [rsp+138h+var_C8]
lea rdi, [rsp+138h+var_F8]
mov esi, 41h ; 'A'
lea rcx, [rsp+138h+var_78]
call secp256k1_recover
mov ebp, eax
test al, al
jz short loc_D4CC
lea rsi, [rsp+138h+var_78]
lea rbx, [rsp+138h+var_C8]
mov edi, 40h ; '@'
mov rdx, rbx
call keccak
mov eax, [rbx+1Ch]
mov rcx, [rsp+138h+var_100]
mov [rcx+10h], eax
movups xmm0, xmmword ptr [rbx+0Ch]
movups xmmword ptr [rcx], xmm0
jmp loc_D31D
loc_D4CC:
lea rdi, [rbx+70h]
lea rsi, aInvalidSignatu; "invalid signature!"
call c4_state_add_error
mov byte ptr [rbx+68h], 0
jmp loc_D31D
| long long c4_tx_create_from_address(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v6; // r14
int v7; // r15d
unsigned long long uint64; // r12
long long v9; // rdi
const char *v10; // rsi
unsigned int v11; // ebp
unsigned long long v13; // rax
_OWORD *v14; // rcx
unsigned int v15; // [rsp+8h] [rbp-130h] BYREF
long long v16; // [rsp+10h] [rbp-128h]
unsigned int v17; // [rsp+1Ch] [rbp-11Ch] BYREF
__int128 v18; // [rsp+20h] [rbp-118h] BYREF
long long v19; // [rsp+30h] [rbp-108h]
long long v20; // [rsp+38h] [rbp-100h]
_OWORD v21[2]; // [rsp+40h] [rbp-F8h] BYREF
unsigned int v22; // [rsp+60h] [rbp-D8h] BYREF
long long v23; // [rsp+68h] [rbp-D0h]
_DWORD v24[8]; // [rsp+70h] [rbp-C8h] BYREF
_BYTE v25[32]; // [rsp+90h] [rbp-A8h] BYREF
char v26; // [rsp+B0h] [rbp-88h] BYREF
_BYTE v27[120]; // [rsp+C0h] [rbp-78h] BYREF
v15 = a2;
v16 = a3;
v18 = 0LL;
v19 = 0LL;
memset(v21, 0, sizeof(v21));
v17 = 0;
if ( !(unsigned __int8)get_and_remove_tx_type(a1, &v15, &v17) )
{
v9 = a1 + 112;
v10 = "invalid tx data, missing type!";
LABEL_7:
c4_state_add_error(v9, v10);
*(_BYTE *)(a1 + 104) = 0;
return 0;
}
if ( (unsigned int)rlp_decode(&v15, 0LL, &v15) != 2 )
{
v9 = a1 + 112;
v10 = "invalid tx data!";
goto LABEL_7;
}
v20 = a4;
v6 = v17;
v7 = (int)(&tx_type_defs)[2 * v17 + 1];
rlp_decode(&v15, (unsigned int)(v7 - 4), &v22);
buffer_append(&v18, v22 + (unsigned int)v23 - (unsigned int)v16, v16);
if ( v6 )
{
uint64 = rlp_get_uint64(v15, v16, (unsigned int)(v7 - 3));
}
else
{
v13 = rlp_get_uint64(v15, v16, 6LL);
uint64 = v13;
if ( v13 >= 0x1D )
{
rlp_add_uint64(&v18, (v13 + (v13 & 1) - 36) >> 1);
rlp_add_item(&v18, 0LL);
rlp_add_item(&v18, 0LL);
}
}
rlp_to_list(&v18);
if ( (_DWORD)v6 )
{
buffer_splice(&v18, 0LL, 0LL, 1LL, 0LL);
**((_BYTE **)&v18 + 1) = v6;
}
keccak((unsigned int)v18, *((_QWORD *)&v18 + 1), v21);
buffer_free(&v18);
memset(v25, 0, sizeof(v25));
memset(v24, 0, sizeof(v24));
v26 = 0;
memset(v27, 0, 64);
rlp_decode(&v15, (unsigned int)(v7 - 2), &v22);
memcpy(&v25[-v22], v23, v22);
rlp_decode(&v15, (unsigned int)(v7 - 1), &v22);
memcpy(v27 - v22 + 14, v23, v22);
if ( uint64 >= 0x1D )
LOBYTE(uint64) = 28 - (uint64 & 1);
v26 = uint64;
v11 = secp256k1_recover(v21, 65LL, v24, v27);
if ( (_BYTE)v11 )
{
keccak(64LL, v27, v24);
v14 = (_OWORD *)v20;
*(_DWORD *)(v20 + 16) = v24[7];
*v14 = *(_OWORD *)&v24[3];
}
else
{
c4_state_add_error(a1 + 112, "invalid signature!");
*(_BYTE *)(a1 + 104) = 0;
}
return v11;
}
| c4_tx_create_from_address:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOV R14,RCX
MOV RBX,RDI
LEA RAX,[RSP + 0x8]
MOV dword ptr [RAX],ESI
MOV qword ptr [RAX + 0x8],RDX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
LEA RDX,[RSP + 0x1c]
MOV dword ptr [RDX],0x0
MOV RSI,RAX
CALL 0x0010d4e5
TEST AL,AL
JZ 0x0010d2fa
LEA RDI,[RSP + 0x8]
XOR ESI,ESI
MOV RDX,RDI
CALL 0x00110ef0
CMP EAX,0x2
JNZ 0x0010d307
MOV qword ptr [RSP + 0x38],R14
MOV R14D,dword ptr [RSP + 0x1c]
MOV RAX,R14
SHL RAX,0x4
LEA RCX,[0x1572e0]
MOV R15D,dword ptr [RAX + RCX*0x1 + 0x8]
LEA ESI,[R15 + -0x4]
LEA R12,[RSP + 0x8]
LEA R13,[RSP + 0x60]
MOV RDI,R12
MOV RDX,R13
CALL 0x00110ef0
MOV ESI,dword ptr [R13 + 0x8]
ADD ESI,dword ptr [R13]
MOV RDX,qword ptr [R12 + 0x8]
SUB ESI,EDX
LEA RDI,[RSP + 0x20]
CALL 0x0011294d
TEST R14,R14
JZ 0x0010d331
LEA EDX,[R15 + -0x3]
MOV EDI,dword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0011137e
MOV R12,RAX
JMP 0x0010d383
LAB_0010d2fa:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x13e265]
JMP 0x0010d312
LAB_0010d307:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x13e284]
LAB_0010d312:
CALL 0x00118879
MOV byte ptr [RBX + 0x68],0x0
XOR EBP,EBP
LAB_0010d31d:
MOV EAX,EBP
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010d331:
MOV EDI,dword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,0x6
CALL 0x0011137e
MOV R12,RAX
CMP RAX,0x1d
JC 0x0010d383
MOV EAX,R12D
AND EAX,0x1
LEA RSI,[R12 + RAX*0x1]
ADD RSI,-0x24
SHR RSI,0x1
LEA R13,[RSP + 0x20]
MOV RDI,R13
CALL 0x001112e6
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00111188
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00111188
LAB_0010d383:
LEA RDI,[RSP + 0x20]
CALL 0x0011132d
TEST R14D,R14D
JZ 0x0010d3b2
LEA R13,[RSP + 0x20]
MOV RDI,R13
XOR ESI,ESI
XOR EDX,EDX
MOV ECX,0x1
XOR R8D,R8D
CALL 0x001129b0
MOV RAX,qword ptr [R13 + 0x8]
MOV byte ptr [RAX],R14B
LAB_0010d3b2:
LEA R13,[RSP + 0x20]
MOV EDI,dword ptr [R13]
MOV RSI,qword ptr [R13 + 0x8]
LEA RDX,[RSP + 0x40]
CALL 0x00116aa8
MOV RDI,R13
CALL 0x00112a33
XORPS XMM0,XMM0
LEA R13,[RSP + 0xb0]
MOVAPS xmmword ptr [R13 + -0x10],XMM0
MOVAPS xmmword ptr [R13 + -0x20],XMM0
MOVAPS xmmword ptr [R13 + -0x30],XMM0
MOVAPS xmmword ptr [R13 + -0x40],XMM0
MOV byte ptr [R13],0x0
LEA RBP,[RSP + 0x90]
LEA RAX,[RSP + 0xc0]
MOVAPS xmmword ptr [RAX + 0x30],XMM0
MOVAPS xmmword ptr [RAX + 0x20],XMM0
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX],XMM0
LEA ESI,[R15 + -0x2]
LEA RDI,[RSP + 0x8]
LEA R14,[RSP + 0x60]
MOV RDX,R14
CALL 0x00110ef0
MOV EDX,dword ptr [R14]
MOV RDI,RBP
SUB RDI,RDX
MOV RSI,qword ptr [R14 + 0x8]
CALL 0x00105060
DEC R15D
LEA RDI,[RSP + 0x8]
MOV ESI,R15D
MOV RDX,R14
CALL 0x00110ef0
MOV EDX,dword ptr [R14]
SUB R13,RDX
MOV RSI,qword ptr [R14 + 0x8]
MOV RDI,R13
CALL 0x00105060
MOV EAX,R12D
AND AL,0x1
MOV CL,0x1c
SUB CL,AL
CMP R12,0x1d
MOVZX EAX,CL
CMOVNC R12D,EAX
MOV byte ptr [RBP + 0x20],R12B
LEA RDX,[RSP + 0x70]
LEA RDI,[RSP + 0x40]
MOV ESI,0x41
LEA RCX,[RSP + 0xc0]
CALL 0x00116d8d
MOV EBP,EAX
TEST AL,AL
JZ 0x0010d4cc
LEA RSI,[RSP + 0xc0]
LEA RBX,[RSP + 0x70]
MOV EDI,0x40
MOV RDX,RBX
CALL 0x00116aa8
MOV EAX,dword ptr [RBX + 0x1c]
MOV RCX,qword ptr [RSP + 0x38]
MOV dword ptr [RCX + 0x10],EAX
MOVUPS XMM0,xmmword ptr [RBX + 0xc]
MOVUPS xmmword ptr [RCX],XMM0
JMP 0x0010d31d
LAB_0010d4cc:
LEA RDI,[RBX + 0x70]
LEA RSI,[0x13e295]
CALL 0x00118879
MOV byte ptr [RBX + 0x68],0x0
JMP 0x0010d31d
|
int4
c4_tx_create_from_address(long param_1,int4 param_2,int8 param_3,int8 *param_4)
{
uint uVar1;
char cVar2;
int iVar3;
int4 uVar4;
ulong uVar5;
char *pcVar6;
int4 local_130 [2];
int8 local_128;
uint local_11c;
ulong local_118;
int1 *puStack_110;
int8 local_108;
int8 *local_100;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
uint local_d8 [2];
int local_d0;
int4 uStack_cc;
int8 local_c8;
int4 uStack_c0;
int4 uStack_bc;
int4 local_b8;
int4 uStack_b4;
int4 uStack_b0;
int4 uStack_ac;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
byte local_88 [16];
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
local_118 = 0;
puStack_110 = (int1 *)0x0;
local_108 = 0;
local_e8 = 0;
uStack_e0 = 0;
local_f8 = 0;
uStack_f0 = 0;
local_11c = 0;
local_130[0] = param_2;
local_128 = param_3;
cVar2 = get_and_remove_tx_type(param_1,local_130);
if (cVar2 == '\0') {
pcVar6 = "invalid tx data, missing type!";
}
else {
iVar3 = rlp_decode(local_130,0,local_130);
uVar1 = local_11c;
if (iVar3 == 2) {
uVar5 = (ulong)local_11c;
iVar3 = *(int *)(tx_type_defs + uVar5 * 0x10 + 8);
local_100 = param_4;
rlp_decode(local_130,iVar3 + -4,local_d8);
buffer_append(&local_118,(local_d0 + local_d8[0]) - (int)local_128);
if (uVar5 == 0) {
uVar5 = rlp_get_uint64(local_130[0],local_128,6);
if (0x1c < uVar5) {
rlp_add_uint64(&local_118,(uVar5 + ((uint)uVar5 & 1)) - 0x24 >> 1);
rlp_add_item(&local_118,0,0);
rlp_add_item(&local_118,0,0);
}
}
else {
uVar5 = rlp_get_uint64(local_130[0],local_128,iVar3 + -3);
}
rlp_to_list(&local_118);
if (uVar1 != 0) {
buffer_splice(&local_118,0,0,1,0);
*puStack_110 = (char)uVar1;
}
keccak(local_118 & 0xffffffff,puStack_110,&local_f8);
buffer_free(&local_118);
local_98 = 0;
uStack_90 = 0;
local_a8 = 0;
uStack_a0 = 0;
local_b8 = 0;
uStack_b4 = 0;
uStack_b0 = 0;
uStack_ac = 0;
local_c8 = 0;
uStack_c0 = 0;
uStack_bc = 0;
local_88[0] = 0;
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
local_68 = 0;
uStack_60 = 0;
local_78 = 0;
uStack_70 = 0;
rlp_decode(local_130,iVar3 + -2,local_d8);
memcpy((void *)((long)&local_a8 - (ulong)local_d8[0]),(void *)CONCAT44(uStack_cc,local_d0),
(ulong)local_d8[0]);
rlp_decode(local_130,iVar3 + -1,local_d8);
memcpy(local_88 + -(ulong)local_d8[0],(void *)CONCAT44(uStack_cc,local_d0),(ulong)local_d8[0])
;
local_88[0] = (byte)uVar5;
if (0x1c < uVar5) {
local_88[0] = 0x1c - ((byte)uVar5 & 1);
}
uVar4 = secp256k1_recover(&local_f8,0x41,&local_c8,&local_78);
if ((char)uVar4 != '\0') {
keccak(0x40,&local_78,&local_c8);
*(int4 *)(local_100 + 2) = uStack_ac;
*local_100 = CONCAT44(local_b8,uStack_bc);
local_100[1] = CONCAT44(uStack_b0,uStack_b4);
return uVar4;
}
c4_state_add_error(param_1 + 0x70,"invalid signature!");
*(int1 *)(param_1 + 0x68) = 0;
return uVar4;
}
pcVar6 = "invalid tx data!";
}
c4_state_add_error(param_1 + 0x70,pcVar6);
*(int1 *)(param_1 + 0x68) = 0;
return 0;
}
| |
43,176 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | virtual P prep(Context& sharedContext) {
// Default implementation returns default-constructed P
// Handle void case explicitly if needed, though default works ok.
if constexpr (std::is_same_v<P, void>) {
return; // Or handle differently if void needs special logic
} else {
return P{};
}
} | O0 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
popq %rbp
retq
| _ZN10pocketflow8BaseNodeIDniE4prepERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
xor eax, eax
pop rbp
retn
| long long pocketflow::BaseNode<decltype(nullptr),int>::prep()
{
return 0LL;
}
| prep:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
XOR EAX,EAX
POP RBP
RET
|
/* pocketflow::BaseNode<decltype(nullptr), int>::prep(std::map<std::__cxx11::string, std::any,
std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const, std::any>
> >&) */
int8 pocketflow::BaseNode<decltype(nullptr),int>::prep(map *param_1)
{
return 0;
}
| |
43,177 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | virtual P prep(Context& sharedContext) {
// Default implementation returns default-constructed P
// Handle void case explicitly if needed, though default works ok.
if constexpr (std::is_same_v<P, void>) {
return; // Or handle differently if void needs special logic
} else {
return P{};
}
} | O1 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
xorl %eax, %eax
retq
nop
| _ZN10pocketflow8BaseNodeIiDnE4prepERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
xor eax, eax
retn
| long long pocketflow::BaseNode<int,decltype(nullptr)>::prep()
{
return 0LL;
}
| prep:
XOR EAX,EAX
RET
|
/* pocketflow::BaseNode<int, decltype(nullptr)>::prep(std::map<std::__cxx11::string, std::any,
std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const, std::any>
> >&) */
int8 pocketflow::BaseNode<int,decltype(nullptr)>::prep(map *param_1)
{
return 0;
}
| |
43,178 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | virtual P prep(Context& sharedContext) {
// Default implementation returns default-constructed P
// Handle void case explicitly if needed, though default works ok.
if constexpr (std::is_same_v<P, void>) {
return; // Or handle differently if void needs special logic
} else {
return P{};
}
} | O2 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
xorl %eax, %eax
retq
nop
| _ZN10pocketflow8BaseNodeIiDnE4prepERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
xor eax, eax
retn
| long long pocketflow::BaseNode<int,decltype(nullptr)>::prep()
{
return 0LL;
}
| prep:
XOR EAX,EAX
RET
|
/* pocketflow::BaseNode<int, decltype(nullptr)>::prep(std::map<std::__cxx11::string, std::any,
std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const, std::any>
> >&) */
int8 pocketflow::BaseNode<int,decltype(nullptr)>::prep(map *param_1)
{
return 0;
}
| |
43,179 | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&) | The-Pocket[P]PocketFlow-CPP/pocketflow.h | virtual P prep(Context& sharedContext) {
// Default implementation returns default-constructed P
// Handle void case explicitly if needed, though default works ok.
if constexpr (std::is_same_v<P, void>) {
return; // Or handle differently if void needs special logic
} else {
return P{};
}
} | O3 | c | pocketflow::BaseNode<std::nullptr_t, std::optional<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::prep(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::any, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::any>>>&):
xorl %eax, %eax
retq
nop
| _ZN10pocketflow8BaseNodeIiDnE4prepERSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt3anySt4lessIS8_ESaISt4pairIKS8_S9_EEE:
xor eax, eax
retn
| long long pocketflow::BaseNode<int,decltype(nullptr)>::prep()
{
return 0LL;
}
| prep:
XOR EAX,EAX
RET
|
/* pocketflow::BaseNode<int, decltype(nullptr)>::prep(std::map<std::__cxx11::string, std::any,
std::less<std::__cxx11::string >, std::allocator<std::pair<std::__cxx11::string const, std::any>
> >&) */
int8 pocketflow::BaseNode<int,decltype(nullptr)>::prep(map *param_1)
{
return 0;
}
| |
43,180 | my_b_write | eloqsql/include/my_sys.h | static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
MEM_CHECK_DEFINED(Buffer, Count);
if (info->write_pos + Count <= info->write_end)
{
if (Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return 0;
}
return _my_b_write(info, Buffer, Count);
} | O0 | c | my_b_write:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
ja 0xaaabf
cmpq $0x0, -0x20(%rbp)
je 0xaaab6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a090
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xaaad3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe0f00
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| my_b_write_1:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+48h]
ja short loc_AAABF
cmp [rbp+var_20], 0
jz short loc_AAAB6
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
loc_AAAB6:
mov [rbp+var_4], 0
jmp short loc_AAAD3
loc_AAABF:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _my_b_write
mov [rbp+var_4], eax
loc_AAAD3:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_b_write_1(long long a1, long long a2, long long a3)
{
if ( (unsigned long long)(a3 + *(_QWORD *)(a1 + 64)) > *(_QWORD *)(a1 + 72) )
{
return (unsigned int)my_b_write(a1, a2, a3);
}
else
{
if ( a3 )
{
memcpy(*(_QWORD *)(a1 + 64), a2, a3);
*(_QWORD *)(a1 + 64) += a3;
}
return 0;
}
}
| my_b_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x48]
JA 0x001aaabf
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001aaab6
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
LAB_001aaab6:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001aaad3
LAB_001aaabf:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001e0f00
MOV dword ptr [RBP + -0x4],EAX
LAB_001aaad3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_b_write(long param_1,void *param_2,size_t param_3)
{
int4 local_c;
if (*(ulong *)(param_1 + 0x48) < *(long *)(param_1 + 0x40) + param_3) {
local_c = _my_b_write(param_1,param_2,param_3);
}
else {
if (param_3 != 0) {
memcpy(*(void **)(param_1 + 0x40),param_2,param_3);
*(size_t *)(param_1 + 0x40) = param_3 + *(long *)(param_1 + 0x40);
}
local_c = 0;
}
return local_c;
}
| |
43,181 | mysql_stmt_reset_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_reset_start(my_bool *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_reset,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
TRUE,
r_my_bool,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_reset(stmt);
return 0;
})
} | O0 | c | mysql_stmt_reset_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x41a88
movq -0x18(%rbp), %rdi
callq 0x30480
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x41b96
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xe2(%rip), %rsi # 0x41ba0
leaq -0x30(%rbp), %rdx
callq 0x43410
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x41af6
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x41b96
cmpl $0x0, -0x1c(%rbp)
jge 0x41b82
jmp 0x41b02
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x23706(%rip), %rax # 0x65230
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x236e4(%rip), %rax # 0x65240
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
jmp 0x41b8f
movq -0x28(%rbp), %rax
movb 0x8(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| mysql_stmt_reset_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_41A88
mov rdi, [rbp+var_18]
call mysql_stmt_reset
mov cl, al
mov rax, [rbp+var_10]
mov [rax], cl
mov [rbp+var_4], 0
jmp loc_41B96
loc_41A88:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_reset_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_41AF6
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_41B96
loc_41AF6:
cmp [rbp+var_1C], 0
jge loc_41B82
jmp short $+2
loc_41B02:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov byte ptr [rax], 1
jmp short loc_41B8F
loc_41B82:
mov rax, [rbp+var_28]
mov cl, [rax+8]
mov rax, [rbp+var_10]
mov [rax], cl
loc_41B8F:
mov [rbp+var_4], 0
loc_41B96:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_stmt_reset_start(char *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
_BYTE *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
char *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(_BYTE **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
v4[20] = 1;
v5 = my_context_spawn(v4 + 56, mysql_stmt_reset_start_internal, &v3);
v4[21] = 0;
v4[20] = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[8];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
v4[21] = 1;
return *(unsigned int *)v4;
}
}
else
{
*v7 = mysql_stmt_reset(v6);
return 0;
}
}
| mysql_stmt_reset_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x00141a88
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00130480
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00141b96
LAB_00141a88:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x141ba0]
LEA RDX,[RBP + -0x30]
CALL 0x00143410
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00141af6
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00141b96
LAB_00141af6:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x00141b82
JMP 0x00141b02
LAB_00141b02:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x165230]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x165240]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],0x1
JMP 0x00141b8f
LAB_00141b82:
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
LAB_00141b8f:
MOV dword ptr [RBP + -0x4],0x0
LAB_00141b96:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_reset_start(int1 *param_1,long param_2)
{
int1 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int1 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_reset(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_reset_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_00165280,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = *(int1 *)(local_30 + 2);
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
| |
43,182 | js_proxy_isArray | bluesky950520[P]quickjs/quickjs.c | static int js_proxy_isArray(JSContext *ctx, JSValue obj)
{
JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
if (!s)
return FALSE;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
if (s->is_revoked) {
JS_ThrowTypeErrorRevokedProxy(ctx);
return -1;
}
return JS_IsArray(ctx, s->target);
} | O0 | c | js_proxy_isArray:
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x30, %edx
callq 0x3e640
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x3ff5e
movl $0x0, 0x44(%rsp)
jmp 0x3ffd5
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x53fd0
cmpl $0x0, %eax
je 0x3ff93
movq 0x28(%rsp), %rdi
callq 0x664d0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x3ffd5
movq 0x20(%rsp), %rax
cmpb $0x0, 0x21(%rax)
je 0x3ffbb
movq 0x28(%rsp), %rdi
callq 0x66510
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x3ffd5
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x3fe90
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
| js_proxy_isArray:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_10]
mov edx, 30h ; '0'
call JS_GetOpaque
mov [rsp+48h+var_28], rax
cmp [rsp+48h+var_28], 0
jnz short loc_3FF5E
mov [rsp+48h+var_4], 0
jmp short loc_3FFD5
loc_3FF5E:
mov rax, [rsp+48h+var_20]
mov rdi, [rax+18h]
xor eax, eax
mov esi, eax
call js_check_stack_overflow
cmp eax, 0
jz short loc_3FF93
mov rdi, [rsp+48h+var_20]
call JS_ThrowStackOverflow
mov [rsp+48h+var_38], rax
mov [rsp+48h+var_30], rdx
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_3FFD5
loc_3FF93:
mov rax, [rsp+48h+var_28]
cmp byte ptr [rax+21h], 0
jz short loc_3FFBB
mov rdi, [rsp+48h+var_20]
call JS_ThrowTypeErrorRevokedProxy
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_40], rdx
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_3FFD5
loc_3FFBB:
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_28]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_IsArray
mov [rsp+48h+var_4], eax
loc_3FFD5:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
| long long js_proxy_isArray(long long a1, long long a2, int a3)
{
long long Opaque; // [rsp+20h] [rbp-28h]
Opaque = JS_GetOpaque(a2, a3, 48);
if ( Opaque )
{
if ( (unsigned int)js_check_stack_overflow(*(_QWORD *)(a1 + 24), 0LL) )
{
JS_ThrowStackOverflow(a1);
return (unsigned int)-1;
}
else if ( *(_BYTE *)(Opaque + 33) )
{
JS_ThrowTypeErrorRevokedProxy(a1);
return (unsigned int)-1;
}
else
{
return (unsigned int)JS_IsArray(a1, *(_QWORD *)Opaque, *(_QWORD *)(Opaque + 8));
}
}
else
{
return 0;
}
}
| js_proxy_isArray:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
MOV EDX,0x30
CALL 0x0013e640
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x0013ff5e
MOV dword ptr [RSP + 0x44],0x0
JMP 0x0013ffd5
LAB_0013ff5e:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x18]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00153fd0
CMP EAX,0x0
JZ 0x0013ff93
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001664d0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x0013ffd5
LAB_0013ff93:
MOV RAX,qword ptr [RSP + 0x20]
CMP byte ptr [RAX + 0x21],0x0
JZ 0x0013ffbb
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00166510
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x0013ffd5
LAB_0013ffbb:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x0013fe90
MOV dword ptr [RSP + 0x44],EAX
LAB_0013ffd5:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4 js_proxy_isArray(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 *puVar2;
int4 local_4;
puVar2 = (int8 *)JS_GetOpaque(param_2,param_3,0x30);
if (puVar2 == (int8 *)0x0) {
local_4 = 0;
}
else {
iVar1 = js_check_stack_overflow(*(int8 *)(param_1 + 0x18),0);
if (iVar1 == 0) {
if (*(char *)((long)puVar2 + 0x21) == '\0') {
local_4 = JS_IsArray(param_1,*puVar2,puVar2[1]);
}
else {
JS_ThrowTypeErrorRevokedProxy(param_1);
local_4 = 0xffffffff;
}
}
else {
JS_ThrowStackOverflow(param_1);
local_4 = 0xffffffff;
}
}
return local_4;
}
| |
43,183 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long) | monkey531[P]llama/common/./json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x4aaaa(%rip), %rsi # 0xbc5ff
leaq 0x4aaa4(%rip), %rdx # 0xbc600
callq 0x590a2
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x2ad73
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
mov qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rax, [rbx+40h]
mov [rbx+30h], rax
lea rsi, aMinExp0+0Ah; "0"
lea rdx, aMinExp0+0Bh; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rax, [rbx+60h]
mov [rbx+50h], rax
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>(a1 + 48, "0", (long long)"");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
MOV qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LEA RAX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RAX
LAB_00171b4e:
LEA RSI,[0x1bc5ff]
LEA RDX,[0x1bc600]
CALL 0x001590a2
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >
>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this,int4 *param_2,int8 param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[2];
uVar4 = param_2[3];
uVar5 = param_2[5];
uVar6 = param_2[6];
uVar7 = param_2[7];
*(int4 *)(this + 0x10) = param_2[4];
*(int4 *)(this + 0x14) = uVar5;
*(int4 *)(this + 0x18) = uVar6;
*(int4 *)(this + 0x1c) = uVar7;
*(int4 *)this = uVar1;
*(int4 *)(this + 4) = uVar2;
*(int4 *)(this + 8) = uVar3;
*(int4 *)(this + 0xc) = uVar4;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 0x30) = this + 0x40;
/* try { // try from 00171b4e to 00171b60 has its CatchHandler @ 00171b77 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x30,"0","");
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
)0x0;
return;
}
| |
43,184 | js_parse_error | bluesky950520[P]quickjs/quickjs.c | int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
{
JSContext *ctx = s->ctx;
va_list ap;
int backtrace_flags;
va_start(ap, fmt);
JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
va_end(ap);
backtrace_flags = 0;
if (s->cur_func && s->cur_func->backtrace_barrier)
backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
build_backtrace(ctx, ctx->rt->current_exception, JS_UNDEFINED, s->filename,
s->line_num, s->col_num, backtrace_flags);
return -1;
} | O1 | c | js_parse_error:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2fd4b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq (%rdi), %rbx
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x3, %esi
movq %r10, %rdx
xorl %r8d, %r8d
callq 0x2fdef
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x2fda1
xorl %r15d, %r15d
cmpl $0x0, 0x80(%rax)
setne %r15b
addl %r15d, %r15d
movq 0x18(%rbx), %rax
movq 0x18(%r14), %r9
movl 0x10(%r14), %r10d
movl 0x14(%r14), %r11d
movq 0xf0(%rax), %rsi
movq 0xf8(%rax), %rdx
subq $0x8, %rsp
movl $0x3, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
pushq %r15
pushq %r11
pushq %r10
callq 0x2fe72
addq $0x20, %rsp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
| js_parse_error:
push r15
push r14
push rbx
sub rsp, 0D0h
mov r10, rsi
mov r14, rdi
lea rsi, [rsp+0E8h+var_C8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_2FD4B
movaps [rsp+0E8h+var_98], xmm0
movaps [rsp+0E8h+var_88], xmm1
movaps [rsp+0E8h+var_78], xmm2
movaps [rsp+0E8h+var_68], xmm3
movaps [rsp+0E8h+var_58], xmm4
movaps [rsp+0E8h+var_48], xmm5
movaps [rsp+0E8h+var_38], xmm6
movaps [rsp+0E8h+var_28], xmm7
loc_2FD4B:
mov rbx, [rdi]
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0E8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
xor r15d, r15d
mov rdi, rbx
mov esi, 3
mov rdx, r10
xor r8d, r8d
call JS_ThrowError2
mov rax, [r14+90h]
test rax, rax
jz short loc_2FDA1
xor r15d, r15d
cmp dword ptr [rax+80h], 0
setnz r15b
add r15d, r15d
loc_2FDA1:
mov rax, [rbx+18h]
mov r9, [r14+18h]
mov r10d, [r14+10h]
mov r11d, [r14+14h]
mov rsi, [rax+0F0h]
mov rdx, [rax+0F8h]
sub rsp, 8
mov r8d, 3
mov rdi, rbx
xor ecx, ecx
push r15
push r11
push r10
call build_backtrace
add rsp, 20h
mov eax, 0FFFFFFFFh
add rsp, 0D0h
pop rbx
pop r14
pop r15
retn
| long long js_parse_error(
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)
{
long long v15; // rbx
int v16; // r15d
long long v17; // rax
_QWORD v19[4]; // [rsp+0h] [rbp-E8h] BYREF
char v20; // [rsp+20h] [rbp-C8h] BYREF
long long v21; // [rsp+30h] [rbp-B8h]
long long v22; // [rsp+38h] [rbp-B0h]
long long v23; // [rsp+40h] [rbp-A8h]
long long v24; // [rsp+48h] [rbp-A0h]
__m128 v25; // [rsp+50h] [rbp-98h]
__m128 v26; // [rsp+60h] [rbp-88h]
__m128 v27; // [rsp+70h] [rbp-78h]
__m128 v28; // [rsp+80h] [rbp-68h]
__m128 v29; // [rsp+90h] [rbp-58h]
__m128 v30; // [rsp+A0h] [rbp-48h]
__m128 v31; // [rsp+B0h] [rbp-38h]
__m128 v32; // [rsp+C0h] [rbp-28h]
v25 = a7;
v26 = a8;
v27 = a9;
v28 = a10;
v29 = a11;
v30 = a12;
v31 = a13;
v32 = a14;
v21 = a3;
v22 = a4;
v23 = a5;
v24 = a6;
v15 = *a1;
v19[2] = &v20;
v19[1] = &a15;
v19[0] = 0x3000000010LL;
v16 = 0;
JS_ThrowError2(v15, 3LL, a2, v19, 0LL);
v17 = a1[18];
if ( v17 )
v16 = 2 * (*(_DWORD *)(v17 + 128) != 0);
build_backtrace(
v15,
*(_QWORD *)(*(_QWORD *)(v15 + 24) + 240LL),
*(_QWORD *)(*(_QWORD *)(v15 + 24) + 248LL),
0,
3,
a1[3],
*((_DWORD *)a1 + 4),
*((_DWORD *)a1 + 5),
v16);
return 0xFFFFFFFFLL;
}
| js_parse_error:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xd0
MOV R10,RSI
MOV R14,RDI
LEA RSI,[RSP + 0x20]
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 0x0012fd4b
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0012fd4b:
MOV RBX,qword ptr [RDI]
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xf0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
XOR R15D,R15D
MOV RDI,RBX
MOV ESI,0x3
MOV RDX,R10
XOR R8D,R8D
CALL 0x0012fdef
MOV RAX,qword ptr [R14 + 0x90]
TEST RAX,RAX
JZ 0x0012fda1
XOR R15D,R15D
CMP dword ptr [RAX + 0x80],0x0
SETNZ R15B
ADD R15D,R15D
LAB_0012fda1:
MOV RAX,qword ptr [RBX + 0x18]
MOV R9,qword ptr [R14 + 0x18]
MOV R10D,dword ptr [R14 + 0x10]
MOV R11D,dword ptr [R14 + 0x14]
MOV RSI,qword ptr [RAX + 0xf0]
MOV RDX,qword ptr [RAX + 0xf8]
SUB RSP,0x8
MOV R8D,0x3
MOV RDI,RBX
XOR ECX,ECX
PUSH R15
PUSH R11
PUSH R10
CALL 0x0012fe72
ADD RSP,0x20
MOV EAX,0xffffffff
ADD RSP,0xd0
POP RBX
POP R14
POP R15
RET
|
int8
js_parse_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long *param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
long lVar1;
char in_AL;
char cVar2;
int8 local_e8;
int1 *local_e0;
int1 *local_d8;
int1 local_c8 [16];
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
local_d8 = local_c8;
if (in_AL != '\0') {
local_98 = param_1;
local_88 = param_2;
local_78 = param_3;
local_68 = param_4;
local_58 = param_5;
local_48 = param_6;
local_38 = param_7;
local_28 = param_8;
}
lVar1 = *param_9;
local_e0 = &stack0x00000008;
local_e8 = 0x3000000010;
cVar2 = '\0';
local_b8 = param_11;
local_b0 = param_12;
local_a8 = param_13;
local_a0 = param_14;
JS_ThrowError2(lVar1,3,param_10,&local_e8,0);
if (param_9[0x12] != 0) {
cVar2 = (*(int *)(param_9[0x12] + 0x80) != 0) * '\x02';
}
build_backtrace(lVar1,*(int8 *)(*(long *)(lVar1 + 0x18) + 0xf0),
*(int8 *)(*(long *)(lVar1 + 0x18) + 0xf8),0,3,param_9[3],(int)param_9[2],
*(int4 *)((long)param_9 + 0x14),cVar2);
return 0xffffffff;
}
| |
43,185 | js_parse_error | bluesky950520[P]quickjs/quickjs.c | int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
{
JSContext *ctx = s->ctx;
va_list ap;
int backtrace_flags;
va_start(ap, fmt);
JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
va_end(ap);
backtrace_flags = 0;
if (s->cur_func && s->cur_func->backtrace_barrier)
backtrace_flags = JS_BACKTRACE_FLAG_SINGLE_LEVEL;
build_backtrace(ctx, ctx->rt->current_exception, JS_UNDEFINED, s->filename,
s->line_num, s->col_num, backtrace_flags);
return -1;
} | O2 | c | js_parse_error:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
movq %rdi, %r14
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x284b9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq (%rdi), %rbx
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
pushq $0x3
popq %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r10, %rdx
xorl %r8d, %r8d
callq 0x28557
movq 0x90(%r14), %rax
testq %rax, %rax
je 0x2850d
xorl %r15d, %r15d
cmpl $0x0, 0x80(%rax)
setne %r15b
addl %r15d, %r15d
movq 0x18(%rbx), %rax
movq 0x18(%r14), %r9
movl 0x10(%r14), %r10d
movl 0x14(%r14), %r11d
movq 0xf0(%rax), %rsi
movq 0xf8(%rax), %rdx
subq $0x8, %rsp
pushq $0x3
popq %r8
movq %rbx, %rdi
xorl %ecx, %ecx
pushq %r15
pushq %r11
pushq %r10
callq 0x285b2
addq $0x20, %rsp
pushq $-0x1
popq %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
| js_parse_error:
push r15
push r14
push rbx
sub rsp, 0D0h
mov r10, rsi
mov r14, rdi
lea rsi, [rsp+0E8h+var_C8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_284B9
movaps [rsp+0E8h+var_98], xmm0
movaps [rsp+0E8h+var_88], xmm1
movaps [rsp+0E8h+var_78], xmm2
movaps [rsp+0E8h+var_68], xmm3
movaps [rsp+0E8h+var_58], xmm4
movaps [rsp+0E8h+var_48], xmm5
movaps [rsp+0E8h+var_38], xmm6
movaps [rsp+0E8h+var_28], xmm7
loc_284B9:
mov rbx, [rdi]
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0E8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
push 3
pop rsi
xor r15d, r15d
mov rdi, rbx
mov rdx, r10
xor r8d, r8d
call JS_ThrowError2
mov rax, [r14+90h]
test rax, rax
jz short loc_2850D
xor r15d, r15d
cmp dword ptr [rax+80h], 0
setnz r15b
add r15d, r15d
loc_2850D:
mov rax, [rbx+18h]
mov r9, [r14+18h]
mov r10d, [r14+10h]
mov r11d, [r14+14h]
mov rsi, [rax+0F0h]
mov rdx, [rax+0F8h]
sub rsp, 8
push 3
pop r8
mov rdi, rbx
xor ecx, ecx
push r15
push r11
push r10
call build_backtrace
add rsp, 20h
push 0FFFFFFFFFFFFFFFFh
pop rax
add rsp, 0D0h
pop rbx
pop r14
pop r15
retn
| long long js_parse_error(
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)
{
long long v15; // rbx
int v16; // r15d
long long v17; // rax
_QWORD v19[4]; // [rsp+0h] [rbp-E8h] BYREF
char v20; // [rsp+20h] [rbp-C8h] BYREF
long long v21; // [rsp+30h] [rbp-B8h]
long long v22; // [rsp+38h] [rbp-B0h]
long long v23; // [rsp+40h] [rbp-A8h]
long long v24; // [rsp+48h] [rbp-A0h]
__m128 v25; // [rsp+50h] [rbp-98h]
__m128 v26; // [rsp+60h] [rbp-88h]
__m128 v27; // [rsp+70h] [rbp-78h]
__m128 v28; // [rsp+80h] [rbp-68h]
__m128 v29; // [rsp+90h] [rbp-58h]
__m128 v30; // [rsp+A0h] [rbp-48h]
__m128 v31; // [rsp+B0h] [rbp-38h]
__m128 v32; // [rsp+C0h] [rbp-28h]
v25 = a7;
v26 = a8;
v27 = a9;
v28 = a10;
v29 = a11;
v30 = a12;
v31 = a13;
v32 = a14;
v21 = a3;
v22 = a4;
v23 = a5;
v24 = a6;
v15 = *a1;
v19[2] = &v20;
v19[1] = &a15;
v19[0] = 0x3000000010LL;
v16 = 0;
JS_ThrowError2(v15, 3LL, a2, v19, 0LL);
v17 = a1[18];
if ( v17 )
v16 = 2 * (*(_DWORD *)(v17 + 128) != 0);
build_backtrace(
v15,
*(_QWORD *)(*(_QWORD *)(v15 + 24) + 240LL),
*(_QWORD *)(*(_QWORD *)(v15 + 24) + 248LL),
0,
3,
a1[3],
*((_DWORD *)a1 + 4),
*((_DWORD *)a1 + 5),
v16);
return -1LL;
}
| js_parse_error:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xd0
MOV R10,RSI
MOV R14,RDI
LEA RSI,[RSP + 0x20]
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 0x001284b9
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_001284b9:
MOV RBX,qword ptr [RDI]
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xf0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
PUSH 0x3
POP RSI
XOR R15D,R15D
MOV RDI,RBX
MOV RDX,R10
XOR R8D,R8D
CALL 0x00128557
MOV RAX,qword ptr [R14 + 0x90]
TEST RAX,RAX
JZ 0x0012850d
XOR R15D,R15D
CMP dword ptr [RAX + 0x80],0x0
SETNZ R15B
ADD R15D,R15D
LAB_0012850d:
MOV RAX,qword ptr [RBX + 0x18]
MOV R9,qword ptr [R14 + 0x18]
MOV R10D,dword ptr [R14 + 0x10]
MOV R11D,dword ptr [R14 + 0x14]
MOV RSI,qword ptr [RAX + 0xf0]
MOV RDX,qword ptr [RAX + 0xf8]
SUB RSP,0x8
PUSH 0x3
POP R8
MOV RDI,RBX
XOR ECX,ECX
PUSH R15
PUSH R11
PUSH R10
CALL 0x001285b2
ADD RSP,0x20
PUSH -0x1
POP RAX
ADD RSP,0xd0
POP RBX
POP R14
POP R15
RET
|
int8
js_parse_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long *param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
long lVar1;
char in_AL;
char cVar2;
int8 local_e8;
int1 *local_e0;
int1 *local_d8;
int1 local_c8 [16];
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
local_d8 = local_c8;
if (in_AL != '\0') {
local_98 = param_1;
local_88 = param_2;
local_78 = param_3;
local_68 = param_4;
local_58 = param_5;
local_48 = param_6;
local_38 = param_7;
local_28 = param_8;
}
lVar1 = *param_9;
local_e0 = &stack0x00000008;
local_e8 = 0x3000000010;
cVar2 = '\0';
local_b8 = param_11;
local_b0 = param_12;
local_a8 = param_13;
local_a0 = param_14;
JS_ThrowError2(lVar1,3,param_10,&local_e8,0);
if (param_9[0x12] != 0) {
cVar2 = (*(int *)(param_9[0x12] + 0x80) != 0) * '\x02';
}
build_backtrace(lVar1,*(int8 *)(*(long *)(lVar1 + 0x18) + 0xf0),
*(int8 *)(*(long *)(lVar1 + 0x18) + 0xf8),0,3,param_9[3],(int)param_9[2],
*(int4 *)((long)param_9 + 0x14),cVar2);
return 0xffffffffffffffff;
}
| |
43,186 | my_clear_highest_bit(unsigned int) | eloqsql/include/my_bit.h | static inline uint32 my_clear_highest_bit(uint32 v)
{
uint32 w=v >> 1;
w|= w >> 1;
w|= w >> 2;
w|= w >> 4;
w|= w >> 8;
w|= w >> 16;
return v & w;
} | O0 | c | my_clear_highest_bit(unsigned int):
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x2, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x4, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x10, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
andl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL20my_clear_highest_bitj:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
shr eax, 1
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
shr eax, 1
or eax, [rbp+var_8]
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
shr eax, 2
or eax, [rbp+var_8]
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
shr eax, 4
or eax, [rbp+var_8]
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
shr eax, 8
or eax, [rbp+var_8]
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
shr eax, 10h
or eax, [rbp+var_8]
mov [rbp+var_8], eax
mov eax, [rbp+var_4]
and eax, [rbp+var_8]
pop rbp
retn
| long long my_clear_highest_bit(unsigned int a1)
{
unsigned int v2; // [rsp+0h] [rbp-8h]
unsigned int v3; // [rsp+0h] [rbp-8h]
v2 = (a1 >> 1) | (a1 >> 2) | (((a1 >> 1) | (a1 >> 2)) >> 2);
v3 = v2 | (v2 >> 4) | ((v2 | (v2 >> 4)) >> 8);
return (v3 | HIWORD(v3)) & a1;
}
| my_clear_highest_bit:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x1
OR EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x2
OR EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x4
OR EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x8
OR EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
SHR EAX,0x10
OR EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
/* my_clear_highest_bit(unsigned int) */
uint my_clear_highest_bit(uint param_1)
{
uint uVar1;
uVar1 = param_1 >> 1 | param_1;
uVar1 = uVar1 >> 3 | uVar1 >> 1;
uVar1 = uVar1 >> 4 | uVar1;
uVar1 = uVar1 >> 8 | uVar1;
return param_1 & (uVar1 >> 0x10 | uVar1);
}
| |
43,187 | my_hash_sort_utf8mb4 | eloqsql/strings/ctype-utf8.c | static void
my_hash_sort_utf8mb4(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
/*
Remove end space. We do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *e= skip_trailing_space(s, slen);
my_hash_sort_utf8mb4_nopad(cs, s, e - s, nr1, nr2);
} | O3 | c | my_hash_sort_utf8mb4:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r10
cmpq $0x15, %rdx
jb 0x536d7
movq %r10, %r9
andq $-0x4, %r9
cmpq %rsi, %r9
jbe 0x536d7
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r10, %rax
movb -0x1(%r10), %r11b
cmpq %r9, %r10
jbe 0x536fc
leaq -0x1(%rax), %r10
cmpb $0x20, %r11b
je 0x536bf
jmp 0x536da
movq %r10, %rax
movq %rax, %r9
subq %rsi, %r9
movq %r9, %rdx
cmpq %rsi, %rax
jbe 0x536f6
cmpb $0x20, -0x1(%rax)
leaq -0x1(%rax), %rax
leaq -0x1(%rdx), %r9
je 0x536e0
popq %rbp
jmp 0x53980
cmpb $0x20, %r11b
setne %r10b
cmpq %r9, %rdx
setae %r9b
orb %r10b, %r9b
jne 0x536da
movq %rax, %r9
movq %r9, %rax
cmpq %rdx, %r9
jbe 0x536da
leaq -0x4(%rax), %r9
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x53713
jmp 0x536da
| my_hash_sort_utf8mb4:
push rbp
mov rbp, rsp
lea r10, [rsi+rdx]
cmp rdx, 15h
jb short loc_536D7
mov r9, r10
and r9, 0FFFFFFFFFFFFFFFCh
cmp r9, rsi
jbe short loc_536D7
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_536BF:
mov rax, r10
mov r11b, [r10-1]
cmp r10, r9
jbe short loc_536FC
lea r10, [rax-1]
cmp r11b, 20h ; ' '
jz short loc_536BF
jmp short loc_536DA
loc_536D7:
mov rax, r10
loc_536DA:
mov r9, rax
sub r9, rsi
loc_536E0:
mov rdx, r9
cmp rax, rsi
jbe short loc_536F6
cmp byte ptr [rax-1], 20h ; ' '
lea rax, [rax-1]
lea r9, [rdx-1]
jz short loc_536E0
loc_536F6:
pop rbp
jmp my_hash_sort_utf8mb4_nopad
loc_536FC:
cmp r11b, 20h ; ' '
setnz r10b
cmp rdx, r9
setnb r9b
or r9b, r10b
jnz short loc_536DA
mov r9, rax
loc_53713:
mov rax, r9
cmp r9, rdx
jbe short loc_536DA
lea r9, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_53713
jmp short loc_536DA
| long long my_hash_sort_utf8mb4(long long a1, unsigned long long a2, unsigned long long a3, long long a4, long long a5)
{
unsigned long long v5; // r10
unsigned long long v6; // r9
unsigned long long v7; // rdx
unsigned long long v8; // rax
char v9; // r11
unsigned long long v10; // r9
unsigned long long v11; // rdx
bool v12; // zf
unsigned long long v14; // r9
v5 = a2 + a3;
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= a2) )
{
v8 = a2 + a3;
}
else
{
v7 = (a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v14 = v5;
do
{
v8 = v14;
if ( v14 <= v7 )
break;
v14 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = v10;
if ( v8 <= a2 )
break;
v12 = *(_BYTE *)--v8 == 32;
--v10;
}
while ( v12 );
return my_hash_sort_utf8mb4_nopad(a1, a2, v11, a4, a5, v10);
}
| my_hash_sort_utf8mb4:
PUSH RBP
MOV RBP,RSP
LEA R10,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x001536d7
MOV R9,R10
AND R9,-0x4
CMP R9,RSI
JBE 0x001536d7
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_001536bf:
MOV RAX,R10
MOV R11B,byte ptr [R10 + -0x1]
CMP R10,R9
JBE 0x001536fc
LEA R10,[RAX + -0x1]
CMP R11B,0x20
JZ 0x001536bf
JMP 0x001536da
LAB_001536d7:
MOV RAX,R10
LAB_001536da:
MOV R9,RAX
SUB R9,RSI
LAB_001536e0:
MOV RDX,R9
CMP RAX,RSI
JBE 0x001536f6
CMP byte ptr [RAX + -0x1],0x20
LEA RAX,[RAX + -0x1]
LEA R9,[RDX + -0x1]
JZ 0x001536e0
LAB_001536f6:
POP RBP
JMP 0x00153980
LAB_001536fc:
CMP R11B,0x20
SETNZ R10B
CMP RDX,R9
SETNC R9B
OR R9B,R10B
JNZ 0x001536da
MOV R9,RAX
LAB_00153713:
MOV RAX,R9
CMP R9,RDX
JBE 0x001536da
LEA R9,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x00153713
JMP 0x001536da
|
void my_hash_sort_utf8mb4(int8 param_1,ulong param_2,ulong param_3)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar3 = param_2 + param_3;
if ((0x14 < param_3) && (uVar5 = uVar3 & 0xfffffffffffffffc, param_2 < uVar5)) {
uVar4 = param_2 + 3 & 0xfffffffffffffffc;
uVar2 = uVar3;
do {
uVar3 = uVar2;
if (uVar3 <= uVar5) {
uVar2 = uVar3;
if (uVar4 < uVar5 && *(char *)(uVar3 - 1) == ' ') goto LAB_00153713;
break;
}
uVar2 = uVar3 - 1;
} while (*(char *)(uVar3 - 1) == ' ');
}
goto LAB_001536e0;
while (uVar2 = uVar3 - 4, *(int *)(uVar3 - 4) == 0x20202020) {
LAB_00153713:
uVar3 = uVar2;
if (uVar3 <= uVar4) break;
}
LAB_001536e0:
do {
if (uVar3 <= param_2) break;
pcVar1 = (char *)(uVar3 - 1);
uVar3 = uVar3 - 1;
} while (*pcVar1 == ' ');
my_hash_sort_utf8mb4_nopad();
return;
}
| |
43,188 | allocate_dynamic | eloqsql/mysys/array.c | my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements)
{
DBUG_ENTER("allocate_dynamic");
if (max_elements >= array->max_element)
{
uint size;
uchar *new_ptr;
size= (max_elements + array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this senerio, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (uchar *) my_malloc(array->m_psi_key, size *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr= (uchar*) my_realloc(array->m_psi_key,
array->buffer,size *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(TRUE);
array->buffer= new_ptr;
array->max_element= size;
}
DBUG_RETURN(FALSE);
} | O0 | c | allocate_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x5c7c5
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x5c76e
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
orq $0x10, %rdx
callq 0x5d530
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5c733
jmp 0x5c72a
movb $0x0, -0x1(%rbp)
jmp 0x5c7cb
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x26280
movq -0x10(%rbp), %rax
movabsq $0xfffffeff, %rcx # imm = 0xFFFFFEFF
andq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x5c7b0
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x50, %rcx
callq 0x5d700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x5c7ae
jmp 0x5c7a8
movb $0x1, -0x1(%rbp)
jmp 0x5c7cb
jmp 0x5c7b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x5c7c7
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| allocate_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb loc_5C7C5
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
xor edx, edx
div dword ptr [rcx+10h]
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov eax, [rax+10h]
imul eax, [rbp+var_18]
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz short loc_5C76E
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov eax, [rbp+var_18]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
or rdx, 10h
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_5C733
jmp short $+2
loc_5C72A:
mov [rbp+var_1], 0
jmp loc_5C7CB
loc_5C733:
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rbp+var_10]
mov rcx, 0FFFFFEFFh
and rcx, [rax+20h]
mov [rax+20h], rcx
jmp short loc_5C7B0
loc_5C76E:
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov eax, [rbp+var_18]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 50h
call my_realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_5C7AE
jmp short $+2
loc_5C7A8:
mov [rbp+var_1], 1
jmp short loc_5C7CB
loc_5C7AE:
jmp short $+2
loc_5C7B0:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
loc_5C7C5:
jmp short $+2
loc_5C7C7:
mov [rbp+var_1], 0
loc_5C7CB:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char allocate_dynamic(long long a1, unsigned int a2)
{
long long v3; // [rsp+0h] [rbp-20h]
unsigned int v4; // [rsp+8h] [rbp-18h]
if ( a2 < *(_DWORD *)(a1 + 12) )
return 0;
v4 = (*(_DWORD *)(a1 + 16) + a2) / *(_DWORD *)(a1 + 16) * *(_DWORD *)(a1 + 16);
if ( (*(_QWORD *)(a1 + 32) & 0x100LL) == 0 )
{
v3 = my_realloc(*(unsigned int *)(a1 + 24), *(_QWORD *)a1, *(_DWORD *)(a1 + 20) * v4, *(_QWORD *)(a1 + 32) | 0x50LL);
if ( !v3 )
return 1;
goto LABEL_8;
}
v3 = my_malloc(*(unsigned int *)(a1 + 24), *(_DWORD *)(a1 + 20) * v4, *(_QWORD *)(a1 + 32) | 0x10LL);
if ( v3 )
{
memcpy(v3, *(_QWORD *)a1, (unsigned int)(*(_DWORD *)(a1 + 20) * *(_DWORD *)(a1 + 8)));
*(_QWORD *)(a1 + 32) &= 0xFFFFFEFFuLL;
LABEL_8:
*(_QWORD *)a1 = v3;
*(_DWORD *)(a1 + 12) = v4;
return 0;
}
return 0;
}
| allocate_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x0015c7c5
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV dword ptr [RCX + 0x10]
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
IMUL EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x0015c76e
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV EAX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
OR RDX,0x10
CALL 0x0015d530
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0015c733
JMP 0x0015c72a
LAB_0015c72a:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0015c7cb
LAB_0015c733:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x00126280
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xfffffeff
AND RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x0015c7b0
LAB_0015c76e:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x50
CALL 0x0015d700
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0015c7ae
JMP 0x0015c7a8
LAB_0015c7a8:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015c7cb
LAB_0015c7ae:
JMP 0x0015c7b0
LAB_0015c7b0:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
LAB_0015c7c5:
JMP 0x0015c7c7
LAB_0015c7c7:
MOV byte ptr [RBP + -0x1],0x0
LAB_0015c7cb:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 allocate_dynamic(int8 *param_1,uint param_2)
{
int iVar1;
void *local_28;
if (*(uint *)((long)param_1 + 0xc) <= param_2) {
iVar1 = *(int *)(param_1 + 2) * ((param_2 + *(int *)(param_1 + 2)) / *(uint *)(param_1 + 2));
if ((param_1[4] & 0x100) == 0) {
local_28 = (void *)my_realloc(*(int4 *)(param_1 + 3),*param_1,
iVar1 * *(int *)((long)param_1 + 0x14),param_1[4] | 0x50);
if (local_28 == (void *)0x0) {
return 1;
}
}
else {
local_28 = (void *)my_malloc(*(int4 *)(param_1 + 3),
iVar1 * *(int *)((long)param_1 + 0x14),param_1[4] | 0x10);
if (local_28 == (void *)0x0) {
return 0;
}
memcpy(local_28,(void *)*param_1,
(ulong)(uint)(*(int *)(param_1 + 1) * *(int *)((long)param_1 + 0x14)));
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = local_28;
*(int *)((long)param_1 + 0xc) = iVar1;
}
return 0;
}
| |
43,189 | allocate_dynamic | eloqsql/mysys/array.c | my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements)
{
DBUG_ENTER("allocate_dynamic");
if (max_elements >= array->max_element)
{
uint size;
uchar *new_ptr;
size= (max_elements + array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this senerio, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (uchar *) my_malloc(array->m_psi_key, size *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr= (uchar*) my_realloc(array->m_psi_key,
array->buffer,size *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(TRUE);
array->buffer= new_ptr;
array->max_element= size;
}
DBUG_RETURN(FALSE);
} | O3 | c | allocate_dynamic:
cmpl %esi, 0xc(%rdi)
jbe 0x47ecd
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x10(%rdi), %ecx
movl 0x18(%rdi), %edi
addl %ecx, %ebx
movl %ebx, %eax
xorl %edx, %edx
divl %ecx
subl %edx, %ebx
movq 0x20(%r14), %rcx
btl $0x8, %ecx
jb 0x47f15
movq (%r14), %rsi
movl 0x14(%r14), %edx
imull %ebx, %edx
orq $0x50, %rcx
callq 0x487b8
movq %rax, %r15
testq %rax, %rax
jne 0x47f4d
movb $0x1, %al
jmp 0x47f56
movl 0x14(%r14), %esi
imull %ebx, %esi
orq $0x10, %rcx
movq %rcx, %rdx
callq 0x48695
testq %rax, %rax
je 0x47f54
movq %rax, %r15
movq (%r14), %rsi
movl 0x14(%r14), %edx
imull 0x8(%r14), %edx
movq %rax, %rdi
callq 0x26290
movl $0xfffffeff, %eax # imm = 0xFFFFFEFF
andq %rax, 0x20(%r14)
movq %r15, (%r14)
movl %ebx, 0xc(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| allocate_dynamic:
cmp [rdi+0Ch], esi
jbe short loc_47ECD
xor eax, eax
retn
loc_47ECD:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov ecx, [rdi+10h]
mov edi, [rdi+18h]
add ebx, ecx
mov eax, ebx
xor edx, edx
div ecx
sub ebx, edx
mov rcx, [r14+20h]
bt ecx, 8
jb short loc_47F15
mov rsi, [r14]
mov edx, [r14+14h]
imul edx, ebx
or rcx, 50h
call my_realloc
mov r15, rax
test rax, rax
jnz short loc_47F4D
mov al, 1
jmp short loc_47F56
loc_47F15:
mov esi, [r14+14h]
imul esi, ebx
or rcx, 10h
mov rdx, rcx
call my_malloc
test rax, rax
jz short loc_47F54
mov r15, rax
mov rsi, [r14]
mov edx, [r14+14h]
imul edx, [r14+8]
mov rdi, rax
call _memcpy
mov eax, 0FFFFFEFFh
and [r14+20h], rax
loc_47F4D:
mov [r14], r15
mov [r14+0Ch], ebx
loc_47F54:
xor eax, eax
loc_47F56:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long allocate_dynamic(long long a1, unsigned int a2)
{
unsigned int v4; // ecx
long long v5; // rdi
unsigned int v6; // ebx
long long v7; // rcx
long long v8; // r15
long long v9; // rax
if ( *(_DWORD *)(a1 + 12) > a2 )
return 0LL;
v4 = *(_DWORD *)(a1 + 16);
v5 = *(unsigned int *)(a1 + 24);
v6 = v4 + a2 - (v4 + a2) % v4;
v7 = *(_QWORD *)(a1 + 32);
if ( (v7 & 0x100) == 0 )
{
v8 = my_realloc(v5, *(_QWORD *)a1, v6 * *(_DWORD *)(a1 + 20), v7 | 0x50);
if ( !v8 )
return 1LL;
goto LABEL_8;
}
v9 = my_malloc(v5, v6 * *(_DWORD *)(a1 + 20), v7 | 0x10);
if ( v9 )
{
v8 = v9;
memcpy(v9, *(_QWORD *)a1, (unsigned int)(*(_DWORD *)(a1 + 8) * *(_DWORD *)(a1 + 20)));
*(_QWORD *)(a1 + 32) &= 0xFFFFFEFFuLL;
LABEL_8:
*(_QWORD *)a1 = v8;
*(_DWORD *)(a1 + 12) = v6;
}
return 0LL;
}
| allocate_dynamic:
CMP dword ptr [RDI + 0xc],ESI
JBE 0x00147ecd
XOR EAX,EAX
RET
LAB_00147ecd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x10]
MOV EDI,dword ptr [RDI + 0x18]
ADD EBX,ECX
MOV EAX,EBX
XOR EDX,EDX
DIV ECX
SUB EBX,EDX
MOV RCX,qword ptr [R14 + 0x20]
BT ECX,0x8
JC 0x00147f15
MOV RSI,qword ptr [R14]
MOV EDX,dword ptr [R14 + 0x14]
IMUL EDX,EBX
OR RCX,0x50
CALL 0x001487b8
MOV R15,RAX
TEST RAX,RAX
JNZ 0x00147f4d
MOV AL,0x1
JMP 0x00147f56
LAB_00147f15:
MOV ESI,dword ptr [R14 + 0x14]
IMUL ESI,EBX
OR RCX,0x10
MOV RDX,RCX
CALL 0x00148695
TEST RAX,RAX
JZ 0x00147f54
MOV R15,RAX
MOV RSI,qword ptr [R14]
MOV EDX,dword ptr [R14 + 0x14]
IMUL EDX,dword ptr [R14 + 0x8]
MOV RDI,RAX
CALL 0x00126290
MOV EAX,0xfffffeff
AND qword ptr [R14 + 0x20],RAX
LAB_00147f4d:
MOV qword ptr [R14],R15
MOV dword ptr [R14 + 0xc],EBX
LAB_00147f54:
XOR EAX,EAX
LAB_00147f56:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 allocate_dynamic(long *param_1,uint param_2)
{
ulong uVar1;
void *__dest;
int iVar2;
if (param_2 < *(uint *)((long)param_1 + 0xc)) {
return 0;
}
param_2 = param_2 + *(uint *)(param_1 + 2);
iVar2 = param_2 - param_2 % *(uint *)(param_1 + 2);
uVar1 = param_1[4];
if (((uint)uVar1 >> 8 & 1) == 0) {
__dest = (void *)my_realloc((int)param_1[3],*param_1,*(int *)((long)param_1 + 0x14) * iVar2,
uVar1 | 0x50);
if (__dest == (void *)0x0) {
return 1;
}
}
else {
__dest = (void *)my_malloc((int)param_1[3],*(int *)((long)param_1 + 0x14) * iVar2,uVar1 | 0x10);
if (__dest == (void *)0x0) {
return 0;
}
memcpy(__dest,(void *)*param_1,(ulong)(uint)(*(int *)((long)param_1 + 0x14) * (int)param_1[1]));
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = (long)__dest;
*(int *)((long)param_1 + 0xc) = iVar2;
return 0;
}
| |
43,190 | mbedtls_ct_hmac | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/constant_time.c | int mbedtls_ct_hmac(mbedtls_md_context_t *ctx,
const unsigned char *add_data,
size_t add_data_len,
const unsigned char *data,
size_t data_len_secret,
size_t min_data_len,
size_t max_data_len,
unsigned char *output)
{
/*
* This function breaks the HMAC abstraction and uses the md_clone()
* extension to the MD API in order to get constant-flow behaviour.
*
* HMAC(msg) is defined as HASH(okey + HASH(ikey + msg)) where + means
* concatenation, and okey/ikey are the XOR of the key with some fixed bit
* patterns (see RFC 2104, sec. 2), which are stored in ctx->hmac_ctx.
*
* We'll first compute inner_hash = HASH(ikey + msg) by hashing up to
* minlen, then cloning the context, and for each byte up to maxlen
* finishing up the hash computation, keeping only the correct result.
*
* Then we only need to compute HASH(okey + inner_hash) and we're done.
*/
const mbedtls_md_type_t md_alg = mbedtls_md_get_type(ctx->md_info);
/* TLS 1.0-1.2 only support SHA-384, SHA-256, SHA-1, MD-5,
* all of which have the same block size except SHA-384. */
const size_t block_size = md_alg == MBEDTLS_MD_SHA384 ? 128 : 64;
const unsigned char * const ikey = ctx->hmac_ctx;
const unsigned char * const okey = ikey + block_size;
const size_t hash_size = mbedtls_md_get_size(ctx->md_info);
unsigned char aux_out[MBEDTLS_MD_MAX_SIZE];
mbedtls_md_context_t aux;
size_t offset;
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_md_init(&aux);
#define MD_CHK(func_call) \
do { \
ret = (func_call); \
if (ret != 0) \
goto cleanup; \
} while (0)
MD_CHK(mbedtls_md_setup(&aux, ctx->md_info, 0));
/* After hmac_start() of hmac_reset(), ikey has already been hashed,
* so we can start directly with the message */
MD_CHK(mbedtls_md_update(ctx, add_data, add_data_len));
MD_CHK(mbedtls_md_update(ctx, data, min_data_len));
/* Fill the hash buffer in advance with something that is
* not a valid hash (barring an attack on the hash and
* deliberately-crafted input), in case the caller doesn't
* check the return status properly. */
memset(output, '!', hash_size);
/* For each possible length, compute the hash up to that point */
for (offset = min_data_len; offset <= max_data_len; offset++) {
MD_CHK(mbedtls_md_clone(&aux, ctx));
MD_CHK(mbedtls_md_finish(&aux, aux_out));
/* Keep only the correct inner_hash in the output buffer */
mbedtls_ct_memcpy_if_eq(output, aux_out, hash_size,
offset, data_len_secret);
if (offset < max_data_len) {
MD_CHK(mbedtls_md_update(ctx, data + offset, 1));
}
}
/* The context needs to finish() before it starts() again */
MD_CHK(mbedtls_md_finish(ctx, aux_out));
/* Now compute HASH(okey + inner_hash) */
MD_CHK(mbedtls_md_starts(ctx));
MD_CHK(mbedtls_md_update(ctx, okey, block_size));
MD_CHK(mbedtls_md_update(ctx, output, hash_size));
MD_CHK(mbedtls_md_finish(ctx, output));
/* Done, get ready for next time */
MD_CHK(mbedtls_md_hmac_reset(ctx));
#undef MD_CHK
cleanup:
mbedtls_md_free(&aux);
return ret;
} | O3 | c | mbedtls_ct_hmac:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r9, %r15
movq %r8, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, (%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x8abc0
xorl %r14d, %r14d
cmpl $0x7, %eax
sete %r14b
shll $0x6, %r14d
addq $0x40, %r14
movq 0x10(%r12), %rbp
addq %r14, %rbp
movq (%r12), %rdi
callq 0x8abb4
movl %eax, %r13d
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x8a365
movq (%r12), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x8a4a1
testl %eax, %eax
jne 0x826bf
movq %rbp, 0x10(%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq (%rsp), %rdx
callq 0x8a65b
testl %eax, %eax
jne 0x826bf
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x8a65b
testl %eax, %eax
je 0x826df
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x8a374
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, (%rsp)
movq 0xc8(%rsp), %rdi
movzbl %r13b, %r12d
movl $0x21, %esi
movq %r12, %rdx
callq 0xf2b0
cmpq 0xc0(%rsp), %r15
movq 0x18(%rsp), %r13
ja 0x827a0
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0x8a403
testl %eax, %eax
jne 0x826bf
movq %rbp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x8a6b6
testl %eax, %eax
jne 0x826bf
testb %r12b, %r12b
movq 0xc8(%rsp), %rsi
je 0x82761
xorl %eax, %eax
leaq (%rsi,%rax), %rcx
cmpq %r13, %r15
leaq 0x40(%rsp,%rax), %rdx
cmovneq %rcx, %rdx
movb (%rdx), %cl
movb %cl, (%rsi,%rax)
incq %rax
cmpq %rax, %r12
jne 0x82744
cmpq 0xc0(%rsp), %r15
jae 0x8278a
movq 0x8(%rsp), %rax
leaq (%rax,%r15), %rsi
movl $0x1, %edx
movq (%rsp), %rdi
callq 0x8a65b
testl %eax, %eax
jne 0x826bf
incq %r15
cmpq 0xc0(%rsp), %r15
leaq 0x28(%rsp), %rbp
jbe 0x82714
leaq 0x40(%rsp), %rsi
movq (%rsp), %r15
movq %r15, %rdi
callq 0x8a6b6
testl %eax, %eax
jne 0x826bf
movq %r15, %rdi
callq 0x8a5e0
testl %eax, %eax
jne 0x826bf
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x8a65b
testl %eax, %eax
jne 0x826bf
movq %r15, %rdi
movq 0xc8(%rsp), %r14
movq %r14, %rsi
movq %r12, %rdx
callq 0x8a65b
testl %eax, %eax
jne 0x826bf
movq %r15, %rdi
movq %r14, %rsi
callq 0x8a6b6
testl %eax, %eax
jne 0x826bf
movq %r15, %rdi
callq 0x8aa61
jmp 0x826bf
| mbedtls_ct_hmac:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov r15, r9
mov [rsp+0B8h+var_A0], r8
mov [rsp+0B8h+var_B0], rcx
mov [rsp+0B8h+var_B8], rdx
mov [rsp+0B8h+var_98], rsi
mov r12, rdi
mov rdi, [rdi]
call mbedtls_md_get_type
xor r14d, r14d
cmp eax, 7
setz r14b
shl r14d, 6
add r14, 40h ; '@'
mov rbp, [r12+10h]
add rbp, r14
mov rdi, [r12]
call mbedtls_md_get_size
mov r13d, eax
lea rbx, [rsp+0B8h+var_90]
mov rdi, rbx
call mbedtls_md_init
mov rsi, [r12]
mov rdi, rbx
xor edx, edx
call mbedtls_md_setup
test eax, eax
jnz short loc_826BF
mov [rsp+0B8h+var_A8], rbp
mov rdi, r12
mov rsi, [rsp+0B8h+var_98]
mov rdx, [rsp+0B8h+var_B8]
call mbedtls_md_update
test eax, eax
jnz short loc_826BF
mov rdi, r12
mov rsi, [rsp+0B8h+var_B0]
mov rdx, r15
call mbedtls_md_update
test eax, eax
jz short loc_826DF
loc_826BF:
mov ebx, eax
lea rdi, [rsp+0B8h+var_90]
call mbedtls_md_free
mov eax, ebx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_826DF:
mov [rsp+0B8h+var_B8], r12
mov rdi, [rsp+0B8h+arg_8]
movzx r12d, r13b
mov esi, 21h ; '!'
mov rdx, r12
call _memset
cmp r15, [rsp+0B8h+arg_0]
mov r13, [rsp+0B8h+var_A0]
ja loc_827A0
lea rbp, [rsp+0B8h+var_90]
loc_82714:
mov rdi, rbp
mov rsi, [rsp+0B8h+var_B8]
call mbedtls_md_clone
test eax, eax
jnz short loc_826BF
mov rdi, rbp
lea rsi, [rsp+0B8h+var_78]
call mbedtls_md_finish
test eax, eax
jnz short loc_826BF
test r12b, r12b
mov rsi, [rsp+0B8h+arg_8]
jz short loc_82761
xor eax, eax
loc_82744:
lea rcx, [rsi+rax]
cmp r15, r13
lea rdx, [rsp+rax+0B8h+var_78]
cmovnz rdx, rcx
mov cl, [rdx]
mov [rsi+rax], cl
inc rax
cmp r12, rax
jnz short loc_82744
loc_82761:
cmp r15, [rsp+0B8h+arg_0]
jnb short loc_8278A
mov rax, [rsp+0B8h+var_B0]
lea rsi, [rax+r15]
mov edx, 1
mov rdi, [rsp+0B8h+var_B8]
call mbedtls_md_update
test eax, eax
jnz loc_826BF
loc_8278A:
inc r15
cmp r15, [rsp+0B8h+arg_0]
lea rbp, [rsp+0B8h+var_90]
jbe loc_82714
loc_827A0:
lea rsi, [rsp+0B8h+var_78]
mov r15, [rsp+0B8h+var_B8]
mov rdi, r15
call mbedtls_md_finish
test eax, eax
jnz loc_826BF
mov rdi, r15
call mbedtls_md_starts
test eax, eax
jnz loc_826BF
mov rdi, r15
mov rsi, [rsp+0B8h+var_A8]
mov rdx, r14
call mbedtls_md_update
test eax, eax
jnz loc_826BF
mov rdi, r15
mov r14, [rsp+0B8h+arg_8]
mov rsi, r14
mov rdx, r12
call mbedtls_md_update
test eax, eax
jnz loc_826BF
mov rdi, r15
mov rsi, r14
call mbedtls_md_finish
test eax, eax
jnz loc_826BF
mov rdi, r15
call mbedtls_md_hmac_reset
jmp loc_826BF
| long long mbedtls_ct_hmac(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5,
unsigned long long a6,
unsigned long long a7,
long long a8)
{
long long v9; // r14
long long v10; // rbp
unsigned __int8 size; // r13
unsigned int v12; // eax
unsigned int v13; // ebx
long long i; // rax
_BYTE *v16; // rdx
_BYTE v20[24]; // [rsp+28h] [rbp-90h] BYREF
_BYTE v21[120]; // [rsp+40h] [rbp-78h] BYREF
v9 = ((unsigned __int8)((unsigned int)mbedtls_md_get_type(*a1) == 7) << 6) + 64LL;
v10 = v9 + a1[2];
size = mbedtls_md_get_size(*a1);
mbedtls_md_init(v20);
v12 = mbedtls_md_setup(v20, *a1, 0LL);
if ( !v12 )
{
v12 = mbedtls_md_update(a1, a2, a3);
if ( !v12 )
{
v12 = mbedtls_md_update(a1, a4, a6);
if ( !v12 )
{
memset(a8, 33LL, size);
if ( a6 > a7 )
{
LABEL_16:
v12 = mbedtls_md_finish(a1, v21);
if ( !v12 )
{
v12 = mbedtls_md_starts(a1);
if ( !v12 )
{
v12 = mbedtls_md_update(a1, v10, v9);
if ( !v12 )
{
v12 = mbedtls_md_update(a1, a8, size);
if ( !v12 )
{
v12 = mbedtls_md_finish(a1, a8);
if ( !v12 )
v12 = mbedtls_md_hmac_reset(a1);
}
}
}
}
}
else
{
while ( 1 )
{
v12 = mbedtls_md_clone(v20, a1);
if ( v12 )
break;
v12 = mbedtls_md_finish(v20, v21);
if ( v12 )
break;
if ( size )
{
for ( i = 0LL; i != size; *(_BYTE *)(a8 + i++) = *v16 )
{
v16 = &v21[i];
if ( a6 != a5 )
v16 = (_BYTE *)(a8 + i);
}
}
if ( a6 < a7 )
{
v12 = mbedtls_md_update(a1, a4 + a6, 1LL);
if ( v12 )
break;
}
if ( ++a6 > a7 )
goto LABEL_16;
}
}
}
}
}
v13 = v12;
mbedtls_md_free(v20);
return v13;
}
| mbedtls_ct_hmac:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R15,R9
MOV qword ptr [RSP + 0x18],R8
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x20],RSI
MOV R12,RDI
MOV RDI,qword ptr [RDI]
CALL 0x0018abc0
XOR R14D,R14D
CMP EAX,0x7
SETZ R14B
SHL R14D,0x6
ADD R14,0x40
MOV RBP,qword ptr [R12 + 0x10]
ADD RBP,R14
MOV RDI,qword ptr [R12]
CALL 0x0018abb4
MOV R13D,EAX
LEA RBX,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0018a365
MOV RSI,qword ptr [R12]
MOV RDI,RBX
XOR EDX,EDX
CALL 0x0018a4a1
TEST EAX,EAX
JNZ 0x001826bf
MOV qword ptr [RSP + 0x10],RBP
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP]
CALL 0x0018a65b
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,R12
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x0018a65b
TEST EAX,EAX
JZ 0x001826df
LAB_001826bf:
MOV EBX,EAX
LEA RDI,[RSP + 0x28]
CALL 0x0018a374
MOV EAX,EBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001826df:
MOV qword ptr [RSP],R12
MOV RDI,qword ptr [RSP + 0xc8]
MOVZX R12D,R13B
MOV ESI,0x21
MOV RDX,R12
CALL 0x0010f2b0
CMP R15,qword ptr [RSP + 0xc0]
MOV R13,qword ptr [RSP + 0x18]
JA 0x001827a0
LEA RBP,[RSP + 0x28]
LAB_00182714:
MOV RDI,RBP
MOV RSI,qword ptr [RSP]
CALL 0x0018a403
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,RBP
LEA RSI,[RSP + 0x40]
CALL 0x0018a6b6
TEST EAX,EAX
JNZ 0x001826bf
TEST R12B,R12B
MOV RSI,qword ptr [RSP + 0xc8]
JZ 0x00182761
XOR EAX,EAX
LAB_00182744:
LEA RCX,[RSI + RAX*0x1]
CMP R15,R13
LEA RDX,[RSP + RAX*0x1 + 0x40]
CMOVNZ RDX,RCX
MOV CL,byte ptr [RDX]
MOV byte ptr [RSI + RAX*0x1],CL
INC RAX
CMP R12,RAX
JNZ 0x00182744
LAB_00182761:
CMP R15,qword ptr [RSP + 0xc0]
JNC 0x0018278a
MOV RAX,qword ptr [RSP + 0x8]
LEA RSI,[RAX + R15*0x1]
MOV EDX,0x1
MOV RDI,qword ptr [RSP]
CALL 0x0018a65b
TEST EAX,EAX
JNZ 0x001826bf
LAB_0018278a:
INC R15
CMP R15,qword ptr [RSP + 0xc0]
LEA RBP,[RSP + 0x28]
JBE 0x00182714
LAB_001827a0:
LEA RSI,[RSP + 0x40]
MOV R15,qword ptr [RSP]
MOV RDI,R15
CALL 0x0018a6b6
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,R15
CALL 0x0018a5e0
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R14
CALL 0x0018a65b
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,R15
MOV R14,qword ptr [RSP + 0xc8]
MOV RSI,R14
MOV RDX,R12
CALL 0x0018a65b
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,R15
MOV RSI,R14
CALL 0x0018a6b6
TEST EAX,EAX
JNZ 0x001826bf
MOV RDI,R15
CALL 0x0018aa61
JMP 0x001826bf
|
int mbedtls_ct_hmac(int8 *param_1,int8 param_2,int8 param_3,long param_4,
ulong param_5,ulong param_6,ulong param_7,int1 *param_8)
{
long lVar1;
int1 *puVar2;
byte bVar3;
int iVar4;
ulong uVar5;
ulong __n;
long lVar6;
int1 local_90 [24];
int1 local_78 [72];
iVar4 = mbedtls_md_get_type(*param_1);
lVar6 = (ulong)(iVar4 == 7) * 0x40 + 0x40;
lVar1 = param_1[2];
bVar3 = mbedtls_md_get_size(*param_1);
mbedtls_md_init(local_90);
iVar4 = mbedtls_md_setup(local_90,*param_1,0);
if (((iVar4 == 0) && (iVar4 = mbedtls_md_update(param_1,param_2,param_3), iVar4 == 0)) &&
(iVar4 = mbedtls_md_update(param_1,param_4,param_6), iVar4 == 0)) {
__n = (ulong)bVar3;
memset(param_8,0x21,__n);
if (param_6 <= param_7) {
do {
iVar4 = mbedtls_md_clone(local_90,param_1);
if ((iVar4 != 0) || (iVar4 = mbedtls_md_finish(local_90,local_78), iVar4 != 0))
goto LAB_001826bf;
if (bVar3 != 0) {
uVar5 = 0;
do {
puVar2 = local_78;
if (param_6 != param_5) {
puVar2 = param_8;
}
param_8[uVar5] = puVar2[uVar5];
uVar5 = uVar5 + 1;
} while (__n != uVar5);
}
if ((param_6 < param_7) &&
(iVar4 = mbedtls_md_update(param_1,param_4 + param_6,1), iVar4 != 0)) goto LAB_001826bf;
param_6 = param_6 + 1;
} while (param_6 <= param_7);
}
iVar4 = mbedtls_md_finish(param_1,local_78);
if ((((iVar4 == 0) && (iVar4 = mbedtls_md_starts(param_1), iVar4 == 0)) &&
(iVar4 = mbedtls_md_update(param_1,lVar1 + lVar6,lVar6), iVar4 == 0)) &&
((iVar4 = mbedtls_md_update(param_1,param_8,__n), iVar4 == 0 &&
(iVar4 = mbedtls_md_finish(param_1,param_8), iVar4 == 0)))) {
iVar4 = mbedtls_md_hmac_reset(param_1);
}
}
LAB_001826bf:
mbedtls_md_free(local_90);
return iVar4;
}
| |
43,191 | json_validate | xtate/src/crypto/crypto-json.c | bool json_validate(const char *json) {
const char *s = json;
skip_space(&s);
if (!parse_value(&s, NULL))
return false;
skip_space(&s);
if (*s != 0)
return false;
return true;
} | O3 | c | json_validate:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x100002600, %r14 # imm = 0x100002600
movzbl (%rdi), %eax
cmpq $0x20, %rax
ja 0x1c145
btq %rax, %r14
jae 0x1c145
incq %rdi
jmp 0x1c131
movq %rsp, %rax
movq %rdi, (%rax)
xorl %ebx, %ebx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1b533
testb %al, %al
je 0x1c17e
movq (%rsp), %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x1c17c
btq %rcx, %r14
jae 0x1c173
incq %rax
jmp 0x1c15f
testq %rcx, %rcx
jne 0x1c17c
movb $0x1, %bl
jmp 0x1c17e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| json_validate:
push r14
push rbx
push rax
mov r14, 100002600h
loc_1C131:
movzx eax, byte ptr [rdi]
cmp rax, 20h ; ' '
ja short loc_1C145
bt r14, rax
jnb short loc_1C145
inc rdi
jmp short loc_1C131
loc_1C145:
mov rax, rsp
mov [rax], rdi
xor ebx, ebx
mov rdi, rax
xor esi, esi
call parse_value
test al, al
jz short loc_1C17E
mov rax, [rsp+18h+var_18]
loc_1C15F:
movzx ecx, byte ptr [rax]
cmp rcx, 20h ; ' '
ja short loc_1C17C
bt r14, rcx
jnb short loc_1C173
inc rax
jmp short loc_1C15F
loc_1C173:
test rcx, rcx
jnz short loc_1C17C
mov bl, 1
jmp short loc_1C17E
loc_1C17C:
xor ebx, ebx
loc_1C17E:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
retn
| long long json_validate(_BYTE *a1, long long a2, long long a3, long long a4)
{
_BYTE *v4; // rax
long long v5; // r14
unsigned long long v6; // rax
unsigned int v7; // ebx
_BYTE *i; // rax
unsigned long long v9; // rcx
_BYTE *v11; // [rsp+0h] [rbp-18h] BYREF
v11 = v4;
v5 = 0x100002600LL;
while ( 1 )
{
v6 = (unsigned __int8)*a1;
if ( v6 > 0x20 || !_bittest64(&v5, v6) )
break;
++a1;
}
v11 = a1;
v7 = 0;
if ( (unsigned __int8)parse_value(&v11, 0LL, a3, a4) )
{
for ( i = v11; ; ++i )
{
v9 = (unsigned __int8)*i;
if ( v9 > 0x20 )
break;
if ( !_bittest64(&v5, v9) )
{
if ( !*i )
{
LOBYTE(v7) = 1;
return v7;
}
return 0;
}
}
return 0;
}
return v7;
}
| json_validate:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,0x100002600
LAB_0011c131:
MOVZX EAX,byte ptr [RDI]
CMP RAX,0x20
JA 0x0011c145
BT R14,RAX
JNC 0x0011c145
INC RDI
JMP 0x0011c131
LAB_0011c145:
MOV RAX,RSP
MOV qword ptr [RAX],RDI
XOR EBX,EBX
MOV RDI,RAX
XOR ESI,ESI
CALL 0x0011b533
TEST AL,AL
JZ 0x0011c17e
MOV RAX,qword ptr [RSP]
LAB_0011c15f:
MOVZX ECX,byte ptr [RAX]
CMP RCX,0x20
JA 0x0011c17c
BT R14,RCX
JNC 0x0011c173
INC RAX
JMP 0x0011c15f
LAB_0011c173:
TEST RCX,RCX
JNZ 0x0011c17c
MOV BL,0x1
JMP 0x0011c17e
LAB_0011c17c:
XOR EBX,EBX
LAB_0011c17e:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int8 json_validate(byte *param_1)
{
char cVar1;
ulong uVar2;
byte *local_18;
while (((ulong)*param_1 < 0x21 && ((0x100002600U >> ((ulong)*param_1 & 0x3f) & 1) != 0))) {
param_1 = param_1 + 1;
}
local_18 = param_1;
cVar1 = parse_value(&local_18,0);
if (cVar1 != '\0') {
for (; uVar2 = (ulong)*local_18, uVar2 < 0x21; local_18 = local_18 + 1) {
if ((0x100002600U >> (uVar2 & 0x3f) & 1) == 0) {
if (uVar2 != 0) {
return 0;
}
return 1;
}
}
}
return 0;
}
| |
43,192 | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset() | monkey531[P]llama/common/json.hpp | void reset() noexcept
{
token_buffer.clear();
token_string.clear();
token_string.push_back(char_traits<char_type>::to_char_type(current));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::reset():
pushq %rax
movq %rdi, %rax
movq $0x0, 0x58(%rdi)
movq 0x50(%rdi), %rcx
movb $0x0, (%rcx)
addq $0x38, %rdi
movq 0x38(%rax), %rcx
cmpq %rcx, 0x40(%rax)
je 0x5a2d7
movq %rcx, 0x40(%rax)
movb 0x14(%rax), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
callq 0x5a18c
popq %rax
retq
movq %rax, %rdi
callq 0x21535
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv:
push rax
mov rax, rdi
mov qword ptr [rdi+58h], 0
mov rcx, [rdi+50h]
mov byte ptr [rcx], 0
add rdi, 38h ; '8'
mov rcx, [rax+38h]
cmp [rax+40h], rcx
jz short loc_5A2D7
mov [rax+40h], rcx
loc_5A2D7:
mov al, [rax+14h]
lea rsi, [rsp+8+var_1]
mov [rsi], al
call _ZNSt6vectorIcSaIcEE12emplace_backIJcEEERcDpOT_; std::vector<char>::emplace_back<char>(char &&)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::reset(
long long a1)
{
long long v2; // rdi
long long v3; // rcx
char v4; // [rsp+1h] [rbp-1h] BYREF
*(_QWORD *)(a1 + 88) = 0LL;
**(_BYTE **)(a1 + 80) = 0;
v2 = a1 + 56;
v3 = *(_QWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 64) != v3 )
*(_QWORD *)(a1 + 64) = v3;
v4 = *(_BYTE *)(a1 + 20);
std::vector<char>::emplace_back<char>(v2, &v4);
}
| reset:
PUSH RAX
MOV RAX,RDI
MOV qword ptr [RDI + 0x58],0x0
MOV RCX,qword ptr [RDI + 0x50]
MOV byte ptr [RCX],0x0
ADD RDI,0x38
MOV RCX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x40],RCX
JZ 0x0015a2d7
MOV qword ptr [RAX + 0x40],RCX
LAB_0015a2d7:
MOV AL,byte ptr [RAX + 0x14]
LEA RSI,[RSP + 0x7]
MOV byte ptr [RSI],AL
LAB_0015a2e1:
CALL 0x0015a18c
POP RAX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::reset() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::reset(lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int8 in_RAX;
int8 uStack_8;
*(int8 *)(this + 0x58) = 0;
**(int1 **)(this + 0x50) = 0;
if (*(long *)(this + 0x40) != *(long *)(this + 0x38)) {
*(long *)(this + 0x40) = *(long *)(this + 0x38);
}
uStack_8 = CONCAT17(this[0x14],(int7)in_RAX);
/* try { // try from 0015a2e1 to 0015a2e5 has its CatchHandler @ 0015a2e8 */
std::vector<char,std::allocator<char>>::emplace_back<char>
((vector<char,std::allocator<char>> *)(this + 0x38),(char *)((long)&uStack_8 + 7));
return uStack_8;
}
| |
43,193 | blst_uint64_from_scalar | corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c | void blst_uint64_from_scalar(unsigned long long ret[4], const pow256 a)
{
const union {
long one;
char little;
} is_endian = { 1 };
size_t i;
if ((uptr_t)ret==(uptr_t)a && is_endian.little)
return;
for(i = 0; i < 4; i++) {
unsigned long long w = (unsigned long long)(*a++);
w |= (unsigned long long)(*a++) << 8;
w |= (unsigned long long)(*a++) << 16;
w |= (unsigned long long)(*a++) << 24;
w |= (unsigned long long)(*a++) << 32;
w |= (unsigned long long)(*a++) << 40;
w |= (unsigned long long)(*a++) << 48;
w |= (unsigned long long)(*a++) << 56;
ret[i] = w;
}
} | O3 | c | blst_uint64_from_scalar:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
je 0x65a84
xorl %eax, %eax
movq (%rsi,%rax,8), %rcx
movq %rcx, (%rdi,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x65a73
popq %rbp
retq
| blst_uint64_from_scalar:
push rbp
mov rbp, rsp
cmp rdi, rsi
jz short loc_65A84
xor eax, eax
loc_65A73:
mov rcx, [rsi+rax*8]
mov [rdi+rax*8], rcx
inc rax
cmp rax, 4
jnz short loc_65A73
loc_65A84:
pop rbp
retn
| void blst_uint64_from_scalar(long long a1, long long a2)
{
long long i; // rax
if ( a1 != a2 )
{
for ( i = 0LL; i != 4; ++i )
*(_QWORD *)(a1 + 8 * i) = *(_QWORD *)(a2 + 8 * i);
}
}
| blst_uint64_from_scalar:
PUSH RBP
MOV RBP,RSP
CMP RDI,RSI
JZ 0x00165a84
XOR EAX,EAX
LAB_00165a73:
MOV RCX,qword ptr [RSI + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],RCX
INC RAX
CMP RAX,0x4
JNZ 0x00165a73
LAB_00165a84:
POP RBP
RET
|
void blst_uint64_from_scalar(long param_1,long param_2)
{
long lVar1;
if (param_1 != param_2) {
lVar1 = 0;
do {
*(int8 *)(param_1 + lVar1 * 8) = *(int8 *)(param_2 + lVar1 * 8);
lVar1 = lVar1 + 1;
} while (lVar1 != 4);
}
return;
}
| |
43,194 | promise_reaction_job | bluesky950520[P]quickjs/quickjs.c | static JSValue promise_reaction_job(JSContext *ctx, int argc,
JSValue *argv)
{
JSValue handler, arg, func;
JSValue res, res2;
BOOL is_reject;
assert(argc == 5);
handler = argv[2];
is_reject = JS_ToBool(ctx, argv[3]);
arg = argv[4];
promise_trace(ctx, "promise_reaction_job: is_reject=%d\n", is_reject);
if (JS_IsUndefined(handler)) {
if (is_reject) {
res = JS_Throw(ctx, js_dup(arg));
} else {
res = js_dup(arg);
}
} else {
res = JS_Call(ctx, handler, JS_UNDEFINED, 1, &arg);
}
is_reject = JS_IsException(res);
if (is_reject)
res = JS_GetException(ctx);
func = argv[is_reject];
/* as an extension, we support undefined as value to avoid
creating a dummy promise in the 'await' implementation of async
functions */
if (!JS_IsUndefined(func)) {
res2 = JS_Call(ctx, func, JS_UNDEFINED,
1, &res);
} else {
res2 = JS_UNDEFINED;
}
JS_FreeValue(ctx, res);
return res2;
} | O0 | c | promise_reaction_job:
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x100(%rsp)
movl %esi, 0xfc(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0xe0(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0xe8(%rsp)
movq 0x100(%rsp), %rdi
movq 0xf0(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x37270
movl %eax, 0xac(%rsp)
movq 0xf0(%rsp), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0xd0(%rsp)
movq 0x48(%rax), %rax
movq %rax, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x2cfa0
cmpl $0x0, %eax
je 0x73e49
cmpl $0x0, 0xac(%rsp)
je 0x73e08
movq 0x100(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x20410
movq 0x10(%rsp), %rdi
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x2bc40
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0x73e47
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x20410
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0xb8(%rsp)
jmp 0x73eb7
movq 0x100(%rsp), %rdi
movl $0x0, 0x58(%rsp)
movq $0x3, 0x60(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %r8
movl $0x1, %r9d
leaq 0xd0(%rsp), %rax
movq %rax, (%rsp)
callq 0x38d90
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x22a00
movl %eax, 0xac(%rsp)
cmpl $0x0, 0xac(%rsp)
je 0x73f0e
movq 0x100(%rsp), %rdi
callq 0x2bcb0
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rax
movslq 0xac(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0xc0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0x2cfa0
cmpl $0x0, %eax
jne 0x73fc6
movq 0x100(%rsp), %rdi
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
movl $0x1, %r9d
leaq 0xb0(%rsp), %rax
movq %rax, (%rsp)
callq 0x38d90
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x110(%rsp)
jmp 0x73ff1
movl $0x0, 0x18(%rsp)
movq $0x3, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x229d0
movq 0x108(%rsp), %rax
movq 0x110(%rsp), %rdx
addq $0x118, %rsp # imm = 0x118
retq
nopw %cs:(%rax,%rax)
| promise_reaction_job:
sub rsp, 118h
mov [rsp+118h+var_18], rdi
mov [rsp+118h+var_1C], esi
mov [rsp+118h+var_28], rdx
mov rax, [rsp+118h+var_28]
mov rcx, [rax+20h]
mov [rsp+118h+var_38], rcx
mov rax, [rax+28h]
mov [rsp+118h+var_30], rax
mov rdi, [rsp+118h+var_18]
mov rax, [rsp+118h+var_28]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_ToBool
mov [rsp+118h+var_6C], eax
mov rax, [rsp+118h+var_28]
mov rcx, [rax+40h]
mov [rsp+118h+var_48], rcx
mov rax, [rax+48h]
mov [rsp+118h+var_40], rax
mov rdi, [rsp+118h+var_38]
mov rsi, [rsp+118h+var_30]
call JS_IsUndefined_0
cmp eax, 0
jz loc_73E49
cmp [rsp+118h+var_6C], 0
jz short loc_73E08
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_108], rax
mov rdi, [rsp+118h+var_48]
mov rsi, [rsp+118h+var_40]
call js_dup
mov rdi, [rsp+118h+var_108]
mov [rsp+118h+var_90], rax
mov [rsp+118h+var_88], rdx
mov rsi, [rsp+118h+var_90]
mov rdx, [rsp+118h+var_88]
call JS_Throw
mov [rsp+118h+var_80], rax
mov [rsp+118h+var_78], rdx
mov rax, [rsp+118h+var_80]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_78]
mov [rsp+118h+var_60], rax
jmp short loc_73E47
loc_73E08:
mov rdi, [rsp+118h+var_48]
mov rsi, [rsp+118h+var_40]
call js_dup
mov [rsp+118h+var_A0], rax
mov [rsp+118h+var_98], rdx
mov rax, [rsp+118h+var_A0]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_98]
mov [rsp+118h+var_60], rax
loc_73E47:
jmp short loc_73EB7
loc_73E49:
mov rdi, [rsp+118h+var_18]
mov dword ptr [rsp+118h+var_C0], 0
mov [rsp+118h+var_B8], 3
mov rsi, [rsp+118h+var_38]
mov rdx, [rsp+118h+var_30]
mov rcx, [rsp+118h+var_C0]
mov r8, [rsp+118h+var_B8]
mov r9d, 1
lea rax, [rsp+118h+var_48]
mov [rsp+118h+var_118], rax
call JS_Call
mov [rsp+118h+var_B0], rax
mov [rsp+118h+var_A8], rdx
mov rax, [rsp+118h+var_B0]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_A8]
mov [rsp+118h+var_60], rax
loc_73EB7:
mov rdi, [rsp+118h+var_68]
mov rsi, [rsp+118h+var_60]
call JS_IsException_1
mov [rsp+118h+var_6C], eax
cmp [rsp+118h+var_6C], 0
jz short loc_73F0E
mov rdi, [rsp+118h+var_18]
call JS_GetException
mov [rsp+118h+var_D0], rax
mov [rsp+118h+var_C8], rdx
mov rax, [rsp+118h+var_D0]
mov [rsp+118h+var_68], rax
mov rax, [rsp+118h+var_C8]
mov [rsp+118h+var_60], rax
loc_73F0E:
mov rax, [rsp+118h+var_28]
movsxd rcx, [rsp+118h+var_6C]
shl rcx, 4
add rax, rcx
mov rcx, [rax]
mov [rsp+118h+var_58], rcx
mov rax, [rax+8]
mov [rsp+118h+var_50], rax
mov rdi, [rsp+118h+var_58]
mov rsi, [rsp+118h+var_50]
call JS_IsUndefined_0
cmp eax, 0
jnz short loc_73FC6
mov rdi, [rsp+118h+var_18]
mov dword ptr [rsp+118h+var_F0], 0
mov [rsp+118h+var_E8], 3
mov rsi, [rsp+118h+var_58]
mov rdx, [rsp+118h+var_50]
mov rcx, [rsp+118h+var_F0]
mov r8, [rsp+118h+var_E8]
mov r9d, 1
lea rax, [rsp+118h+var_68]
mov [rsp+118h+var_118], rax
call JS_Call
mov [rsp+118h+var_E0], rax
mov [rsp+118h+var_D8], rdx
mov rax, [rsp+118h+var_E0]
mov [rsp+118h+var_10], rax
mov rax, [rsp+118h+var_D8]
mov [rsp+118h+var_8], rax
jmp short loc_73FF1
loc_73FC6:
mov dword ptr [rsp+118h+var_100], 0
mov [rsp+118h+var_F8], 3
mov rax, [rsp+118h+var_100]
mov [rsp+118h+var_10], rax
mov rax, [rsp+118h+var_F8]
mov [rsp+118h+var_8], rax
loc_73FF1:
mov rdi, [rsp+118h+var_18]
mov rsi, [rsp+118h+var_68]
mov rdx, [rsp+118h+var_60]
call JS_FreeValue
mov rax, [rsp+118h+var_10]
mov rdx, [rsp+118h+var_8]
add rsp, 118h
retn
| long long promise_reaction_job(long long a1, int a2, long long a3)
{
long long v3; // rdx
long long v4; // rdx
long long v5; // rdx
long long v6; // rdx
long long *v7; // rax
long long v8; // rdx
long long v10; // [rsp+18h] [rbp-100h]
_DWORD *v11; // [rsp+88h] [rbp-90h]
int v12; // [rsp+ACh] [rbp-6Ch]
BOOL IsException_1; // [rsp+ACh] [rbp-6Ch]
long long Exception; // [rsp+B0h] [rbp-68h] BYREF
long long v15; // [rsp+B8h] [rbp-60h]
long long v16; // [rsp+C0h] [rbp-58h]
long long v17; // [rsp+C8h] [rbp-50h]
_DWORD *v18; // [rsp+D0h] [rbp-48h] BYREF
long long v19; // [rsp+D8h] [rbp-40h]
long long v20; // [rsp+E0h] [rbp-38h]
long long v21; // [rsp+E8h] [rbp-30h]
long long v22; // [rsp+F0h] [rbp-28h]
int v23; // [rsp+FCh] [rbp-1Ch]
long long v24; // [rsp+100h] [rbp-18h]
long long v25; // [rsp+108h] [rbp-10h]
long long v26; // [rsp+110h] [rbp-8h]
v24 = a1;
v23 = a2;
v22 = a3;
v20 = *(_QWORD *)(a3 + 32);
v21 = *(_QWORD *)(a3 + 40);
v12 = JS_ToBool(a1, *(_DWORD **)(a3 + 48), *(_QWORD *)(a3 + 56));
v18 = *(_DWORD **)(v22 + 64);
v19 = *(_QWORD *)(v22 + 72);
if ( JS_IsUndefined_0(v20, v21) )
{
if ( v12 )
{
v11 = js_dup(v18, v19);
Exception = JS_Throw(v24, (long long)v11, v3);
}
else
{
Exception = (long long)js_dup(v18, v19);
}
v15 = v4;
}
else
{
Exception = JS_Call(v24, v20, v21, 0, 3, 1, (long long)&v18);
v15 = v5;
}
IsException_1 = JS_IsException_1(Exception, v15);
if ( IsException_1 )
{
Exception = JS_GetException(v24);
v15 = v6;
}
v7 = (long long *)(16LL * IsException_1 + v22);
v16 = *v7;
v17 = v7[1];
if ( JS_IsUndefined_0(v16, v17) )
{
LODWORD(v10) = 0;
v25 = v10;
v26 = 3LL;
}
else
{
v25 = JS_Call(v24, v16, v17, 0, 3, 1, (long long)&Exception);
v26 = v8;
}
JS_FreeValue(v24, Exception, v15);
return v25;
}
| promise_reaction_job:
SUB RSP,0x118
MOV qword ptr [RSP + 0x100],RDI
MOV dword ptr [RSP + 0xfc],ESI
MOV qword ptr [RSP + 0xf0],RDX
MOV RAX,qword ptr [RSP + 0xf0]
MOV RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0xe0],RCX
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RAX,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x00137270
MOV dword ptr [RSP + 0xac],EAX
MOV RAX,qword ptr [RSP + 0xf0]
MOV RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RSP + 0xd0],RCX
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xe8]
CALL 0x0012cfa0
CMP EAX,0x0
JZ 0x00173e49
CMP dword ptr [RSP + 0xac],0x0
JZ 0x00173e08
MOV RAX,qword ptr [RSP + 0x100]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x00120410
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x0012bc40
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xa0],RDX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0xb8],RAX
JMP 0x00173e47
LAB_00173e08:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x00120410
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x80],RDX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xb8],RAX
LAB_00173e47:
JMP 0x00173eb7
LAB_00173e49:
MOV RDI,qword ptr [RSP + 0x100]
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x3
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xe8]
MOV RCX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x60]
MOV R9D,0x1
LEA RAX,[RSP + 0xd0]
MOV qword ptr [RSP],RAX
CALL 0x00138d90
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xb8],RAX
LAB_00173eb7:
MOV RDI,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xb8]
CALL 0x00122a00
MOV dword ptr [RSP + 0xac],EAX
CMP dword ptr [RSP + 0xac],0x0
JZ 0x00173f0e
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x0012bcb0
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0xb0],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xb8],RAX
LAB_00173f0e:
MOV RAX,qword ptr [RSP + 0xf0]
MOVSXD RCX,dword ptr [RSP + 0xac]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0xc0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xc8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
CALL 0x0012cfa0
CMP EAX,0x0
JNZ 0x00173fc6
MOV RDI,qword ptr [RSP + 0x100]
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,qword ptr [RSP + 0x30]
MOV R9D,0x1
LEA RAX,[RSP + 0xb0]
MOV qword ptr [RSP],RAX
CALL 0x00138d90
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x110],RAX
JMP 0x00173ff1
LAB_00173fc6:
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x3
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x108],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x110],RAX
LAB_00173ff1:
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0x108]
MOV RDX,qword ptr [RSP + 0x110]
ADD RSP,0x118
RET
|
int1 [16] promise_reaction_job(int8 param_1,int4 param_2,long param_3)
{
int8 uVar1;
int iVar2;
int iVar3;
int8 *puVar4;
int1 auVar5 [16];
uint uStack_fc;
uint uStack_ec;
uint uStack_bc;
int1 local_68 [16];
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
long local_28;
int4 local_1c;
int8 local_18;
int1 local_10 [16];
local_38 = *(int8 *)(param_3 + 0x20);
local_30 = *(int8 *)(param_3 + 0x28);
local_28 = param_3;
local_1c = param_2;
local_18 = param_1;
iVar2 = JS_ToBool(param_1,*(int8 *)(param_3 + 0x30),*(int8 *)(param_3 + 0x38));
local_48 = *(int8 *)(local_28 + 0x40);
local_40 = *(int8 *)(local_28 + 0x48);
iVar3 = JS_IsUndefined(local_38,local_30);
uVar1 = local_18;
if (iVar3 == 0) {
local_68 = JS_Call(local_18,local_38,local_30,(ulong)uStack_bc << 0x20,3,1,&local_48);
}
else if (iVar2 == 0) {
local_68 = js_dup(local_48,local_40);
}
else {
auVar5 = js_dup(local_48,local_40);
local_68 = JS_Throw(uVar1,auVar5._0_8_,auVar5._8_8_);
}
iVar2 = JS_IsException(local_68._0_8_,local_68._8_8_);
auVar5 = local_68;
if (iVar2 != 0) {
auVar5 = JS_GetException(local_18);
}
puVar4 = (int8 *)(local_28 + (long)iVar2 * 0x10);
local_58 = *puVar4;
local_50 = puVar4[1];
local_68 = auVar5;
iVar2 = JS_IsUndefined(local_58,local_50);
if (iVar2 == 0) {
local_10 = JS_Call(local_18,local_58,local_50,(ulong)uStack_ec << 0x20,3,1,local_68);
}
else {
local_10._8_8_ = 3;
local_10._0_8_ = (ulong)uStack_fc << 0x20;
}
JS_FreeValue(local_18,local_68._0_8_,local_68._8_8_);
return local_10;
}
| |
43,195 | promise_reaction_job | bluesky950520[P]quickjs/quickjs.c | static JSValue promise_reaction_job(JSContext *ctx, int argc,
JSValue *argv)
{
JSValue handler, arg, func;
JSValue res, res2;
BOOL is_reject;
assert(argc == 5);
handler = argv[2];
is_reject = JS_ToBool(ctx, argv[3]);
arg = argv[4];
promise_trace(ctx, "promise_reaction_job: is_reject=%d\n", is_reject);
if (JS_IsUndefined(handler)) {
if (is_reject) {
res = JS_Throw(ctx, js_dup(arg));
} else {
res = js_dup(arg);
}
} else {
res = JS_Call(ctx, handler, JS_UNDEFINED, 1, &arg);
}
is_reject = JS_IsException(res);
if (is_reject)
res = JS_GetException(ctx);
func = argv[is_reject];
/* as an extension, we support undefined as value to avoid
creating a dummy promise in the 'await' implementation of async
functions */
if (!JS_IsUndefined(func)) {
res2 = JS_Call(ctx, func, JS_UNDEFINED,
1, &res);
} else {
res2 = JS_UNDEFINED;
}
JS_FreeValue(ctx, res);
return res2;
} | O1 | c | promise_reaction_job:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x20(%rdx), %r15
movq 0x28(%rdx), %r12
movq 0x30(%rdx), %rsi
movq 0x38(%rdx), %rdx
movq %rsi, 0x20(%rsp)
cmpl $-0x9, %edx
jb 0x4367b
movq 0x20(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
callq 0x220f9
movups 0x40(%r14), %xmm0
movaps %xmm0, 0x40(%rsp)
cmpl $0x3, %r12d
jne 0x436f4
movq 0x40(%rsp), %r13
movq 0x48(%rsp), %r15
testl %eax, %eax
je 0x43746
movq %r13, 0x20(%rsp)
cmpl $-0x9, %r15d
jb 0x436b7
movq 0x20(%rsp), %rax
incl (%rax)
movq 0x18(%rbx), %r12
movq 0xf0(%r12), %rsi
movq 0xf8(%r12), %rdx
movq %r12, %rdi
callq 0x1ccb2
movq %r13, 0xf0(%r12)
movq %r15, 0xf8(%r12)
movq $0x0, 0x30(%rsp)
movl $0x6, %r15d
jmp 0x4375d
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x278b6
movq %rdx, %r15
movq %rax, 0x30(%rsp)
jmp 0x4375d
movq %r13, 0x20(%rsp)
cmpl $-0x9, %r15d
jb 0x43758
movq 0x20(%rsp), %rax
incl (%rax)
movq %r13, 0x30(%rsp)
movq %r15, 0x38(%rsp)
movl %r15d, %eax
cmpq $0x6, %rax
jne 0x43790
movq 0x18(%rbx), %rcx
movups 0xf0(%rcx), %xmm0
movl $0x0, 0xf0(%rcx)
movq $0x4, 0xf8(%rcx)
movaps %xmm0, 0x30(%rsp)
xorl %ecx, %ecx
cmpl $0x6, %eax
sete %cl
shll $0x4, %ecx
movq 0x8(%r14,%rcx), %rdx
cmpl $0x3, %edx
jne 0x437b2
movl $0x3, %r14d
xorl %r15d, %r15d
xorl %ecx, %ecx
jmp 0x4380d
addq %rcx, %r14
movq (%r14), %rsi
movl $0x0, 0x20(%rsp)
movq $0x3, 0x28(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x278b6
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r15d
orq %rcx, %r15
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x18(%rbx), %rdi
callq 0x1ccb2
movq %r15, %rax
movq %r14, %rdx
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| promise_reaction_job:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 50h
mov r14, rdx
mov rbx, rdi
mov r15, [rdx+20h]
mov r12, [rdx+28h]
mov rsi, [rdx+30h]
mov rdx, [rdx+38h]
mov qword ptr [rsp+78h+var_58], rsi
cmp edx, 0FFFFFFF7h
jb short loc_4367B
mov rax, qword ptr [rsp+78h+var_58]
inc dword ptr [rax]
loc_4367B:
mov rdi, rbx
call JS_ToBoolFree
movups xmm0, xmmword ptr [r14+40h]
movaps [rsp+78h+var_38], xmm0
cmp r12d, 3
jnz short loc_436F4
mov r13, qword ptr [rsp+78h+var_38]
mov r15, qword ptr [rsp+78h+var_38+8]
test eax, eax
jz loc_43746
mov qword ptr [rsp+78h+var_58], r13
cmp r15d, 0FFFFFFF7h
jb short loc_436B7
mov rax, qword ptr [rsp+78h+var_58]
inc dword ptr [rax]
loc_436B7:
mov r12, [rbx+18h]
mov rsi, [r12+0F0h]
mov rdx, [r12+0F8h]
mov rdi, r12
call JS_FreeValueRT
mov [r12+0F0h], r13
mov [r12+0F8h], r15
mov qword ptr [rsp+78h+var_48], 0
mov r15d, 6
jmp short loc_4375D
loc_436F4:
mov dword ptr [rsp+78h+var_58], 0
mov qword ptr [rsp+78h+var_58+8], 3
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
lea rax, [rsp+78h+var_38]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 2
mov r8d, 3
mov rdi, rbx
mov rsi, r15
mov rdx, r12
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov r15, rdx
mov qword ptr [rsp+78h+var_48], rax
jmp short loc_4375D
loc_43746:
mov qword ptr [rsp+78h+var_58], r13
cmp r15d, 0FFFFFFF7h
jb short loc_43758
mov rax, qword ptr [rsp+78h+var_58]
inc dword ptr [rax]
loc_43758:
mov qword ptr [rsp+78h+var_48], r13
loc_4375D:
mov qword ptr [rsp+78h+var_48+8], r15
mov eax, r15d
cmp rax, 6
jnz short loc_43790
mov rcx, [rbx+18h]
movups xmm0, xmmword ptr [rcx+0F0h]
mov dword ptr [rcx+0F0h], 0
mov qword ptr [rcx+0F8h], 4
movaps [rsp+78h+var_48], xmm0
loc_43790:
xor ecx, ecx
cmp eax, 6
setz cl
shl ecx, 4
mov rdx, [r14+rcx+8]
cmp edx, 3
jnz short loc_437B2
mov r14d, 3
xor r15d, r15d
xor ecx, ecx
jmp short loc_4380D
loc_437B2:
add r14, rcx
mov rsi, [r14]
mov dword ptr [rsp+78h+var_58], 0
mov qword ptr [rsp+78h+var_58+8], 3
movups xmm0, [rsp+78h+var_58]
movups [rsp+78h+var_78], xmm0
lea rax, [rsp+78h+var_48]
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 2
mov r8d, 3
mov rdi, rbx
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r15d, eax
loc_4380D:
or r15, rcx
mov rsi, qword ptr [rsp+78h+var_48]
mov rdx, qword ptr [rsp+78h+var_48+8]
mov rdi, [rbx+18h]
call JS_FreeValueRT
mov rax, r15
mov rdx, r14
add rsp, 50h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| unsigned long long promise_reaction_job(
long long a1,
double a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11)
{
long long v12; // r15
long long v13; // r12
_DWORD *v14; // rsi
long long v15; // rdx
int v16; // eax
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // r13
long long v20; // r15
long long v21; // r12
unsigned long long v22; // rax
long long v23; // rdx
long long v24; // rcx
__int128 v25; // xmm0
long long v26; // rcx
long long v27; // rdx
long long v28; // r15
unsigned long long v29; // rcx
unsigned long long v30; // rax
unsigned long long v31; // r15
__m128 v33; // [rsp+20h] [rbp-58h]
__int128 v34; // [rsp+30h] [rbp-48h] BYREF
__int128 v35; // [rsp+40h] [rbp-38h] BYREF
v12 = *(_QWORD *)(a11 + 32);
v13 = *(_QWORD *)(a11 + 40);
v14 = *(_DWORD **)(a11 + 48);
v15 = *(_QWORD *)(a11 + 56);
v33.m128_i32[1] = HIDWORD(v14);
if ( (unsigned int)v15 >= 0xFFFFFFF7 )
++*v14;
v16 = JS_ToBoolFree(a1, (long long)v14, v15);
v35 = *(_OWORD *)(a11 + 64);
if ( (_DWORD)v13 == 3 )
{
v20 = *((_QWORD *)&v35 + 1);
v19 = v35;
if ( v16 )
{
v33.m128_i32[1] = DWORD1(v35);
if ( DWORD2(v35) >= 0xFFFFFFF7 )
++*(_DWORD *)v35;
v21 = *(_QWORD *)(a1 + 24);
JS_FreeValueRT(v21, *(_DWORD **)(v21 + 240), *(_QWORD *)(v21 + 248));
*(_QWORD *)(v21 + 240) = v19;
*(_QWORD *)(v21 + 248) = v20;
*(_QWORD *)&v34 = 0LL;
v20 = 6LL;
}
else
{
v33.m128_i32[1] = DWORD1(v35);
if ( DWORD2(v35) >= 0xFFFFFFF7 )
++*(_DWORD *)v35;
*(_QWORD *)&v34 = v19;
}
}
else
{
v33.m128_i32[0] = 0;
v33.m128_u64[1] = 3LL;
v22 = JS_CallInternal(
a1,
v12,
v13,
0LL,
3LL,
1LL,
v33,
a3,
a4,
a5,
v17,
v18,
a8,
a9,
v33.m128_i8[0],
3,
(long long)&v35,
2u);
v20 = v23;
*(_QWORD *)&v34 = v22;
}
*((_QWORD *)&v34 + 1) = v20;
if ( (unsigned int)v20 == 6LL )
{
v24 = *(_QWORD *)(a1 + 24);
v25 = *(_OWORD *)(v24 + 240);
*(_DWORD *)(v24 + 240) = 0;
*(_QWORD *)(v24 + 248) = 4LL;
v34 = v25;
}
v26 = 16 * (unsigned int)((_DWORD)v20 == 6);
v27 = *(_QWORD *)(a11 + v26 + 8);
if ( (_DWORD)v27 == 3 )
{
v28 = 0LL;
v29 = 0LL;
}
else
{
v33.m128_i32[0] = 0;
v33.m128_u64[1] = 3LL;
v30 = JS_CallInternal(
a1,
*(_QWORD *)(v26 + a11),
v27,
0LL,
3LL,
1LL,
v33,
a3,
a4,
a5,
v17,
v18,
a8,
a9,
v33.m128_i8[0],
3,
(long long)&v34,
2u);
v29 = v30 & 0xFFFFFFFF00000000LL;
v28 = (unsigned int)v30;
}
v31 = v29 | v28;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v34, *((long long *)&v34 + 1));
return v31;
}
| promise_reaction_job:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x50
MOV R14,RDX
MOV RBX,RDI
MOV R15,qword ptr [RDX + 0x20]
MOV R12,qword ptr [RDX + 0x28]
MOV RSI,qword ptr [RDX + 0x30]
MOV RDX,qword ptr [RDX + 0x38]
MOV qword ptr [RSP + 0x20],RSI
CMP EDX,-0x9
JC 0x0014367b
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_0014367b:
MOV RDI,RBX
CALL 0x001220f9
MOVUPS XMM0,xmmword ptr [R14 + 0x40]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CMP R12D,0x3
JNZ 0x001436f4
MOV R13,qword ptr [RSP + 0x40]
MOV R15,qword ptr [RSP + 0x48]
TEST EAX,EAX
JZ 0x00143746
MOV qword ptr [RSP + 0x20],R13
CMP R15D,-0x9
JC 0x001436b7
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_001436b7:
MOV R12,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [R12 + 0xf0]
MOV RDX,qword ptr [R12 + 0xf8]
MOV RDI,R12
CALL 0x0011ccb2
MOV qword ptr [R12 + 0xf0],R13
MOV qword ptr [R12 + 0xf8],R15
MOV qword ptr [RSP + 0x30],0x0
MOV R15D,0x6
JMP 0x0014375d
LAB_001436f4:
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV R8D,0x3
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R12
XOR ECX,ECX
MOV R9D,0x1
CALL 0x001278b6
MOV R15,RDX
MOV qword ptr [RSP + 0x30],RAX
JMP 0x0014375d
LAB_00143746:
MOV qword ptr [RSP + 0x20],R13
CMP R15D,-0x9
JC 0x00143758
MOV RAX,qword ptr [RSP + 0x20]
INC dword ptr [RAX]
LAB_00143758:
MOV qword ptr [RSP + 0x30],R13
LAB_0014375d:
MOV qword ptr [RSP + 0x38],R15
MOV EAX,R15D
CMP RAX,0x6
JNZ 0x00143790
MOV RCX,qword ptr [RBX + 0x18]
MOVUPS XMM0,xmmword ptr [RCX + 0xf0]
MOV dword ptr [RCX + 0xf0],0x0
MOV qword ptr [RCX + 0xf8],0x4
MOVAPS xmmword ptr [RSP + 0x30],XMM0
LAB_00143790:
XOR ECX,ECX
CMP EAX,0x6
SETZ CL
SHL ECX,0x4
MOV RDX,qword ptr [R14 + RCX*0x1 + 0x8]
CMP EDX,0x3
JNZ 0x001437b2
MOV R14D,0x3
XOR R15D,R15D
XOR ECX,ECX
JMP 0x0014380d
LAB_001437b2:
ADD R14,RCX
MOV RSI,qword ptr [R14]
MOV dword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RSP],XMM0
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV R8D,0x3
MOV RDI,RBX
XOR ECX,ECX
MOV R9D,0x1
CALL 0x001278b6
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV R15D,EAX
LAB_0014380d:
OR R15,RCX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x0011ccb2
MOV RAX,R15
MOV RDX,R14
ADD RSP,0x50
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] promise_reaction_job(long param_1,int8 param_2,long param_3)
{
int1 (*pauVar1) [16];
int8 uVar2;
int *piVar3;
int8 uVar4;
int iVar5;
long lVar6;
ulong uVar7;
int8 uVar8;
ulong uVar9;
int1 auVar10 [16];
int1 auVar11 [16];
int1 local_48 [16];
int4 local_38;
int4 uStack_34;
uint uStack_30;
int4 uStack_2c;
uVar8 = *(int8 *)(param_3 + 0x20);
uVar2 = *(int8 *)(param_3 + 0x28);
if (0xfffffff6 < (uint)*(int8 *)(param_3 + 0x38)) {
**(int **)(param_3 + 0x30) = **(int **)(param_3 + 0x30) + 1;
}
iVar5 = JS_ToBoolFree(param_1);
pauVar1 = (int1 (*) [16])(param_3 + 0x40);
local_38 = *(int4 *)*pauVar1;
uStack_34 = *(int4 *)(param_3 + 0x44);
piVar3 = *(int **)*pauVar1;
uStack_30 = *(uint *)(param_3 + 0x48);
uStack_2c = *(int4 *)(param_3 + 0x4c);
uVar4 = *(int8 *)(param_3 + 0x48);
auVar11 = *pauVar1;
if ((int)uVar2 == 3) {
if (iVar5 == 0) {
auVar10 = *pauVar1;
if (0xfffffff6 < uStack_30) {
*piVar3 = *piVar3 + 1;
auVar10 = auVar11;
}
}
else {
if (0xfffffff6 < uStack_30) {
*piVar3 = *piVar3 + 1;
}
lVar6 = *(long *)(param_1 + 0x18);
JS_FreeValueRT(lVar6,*(int8 *)(lVar6 + 0xf0),*(int8 *)(lVar6 + 0xf8));
*(int **)(lVar6 + 0xf0) = piVar3;
*(int8 *)(lVar6 + 0xf8) = uVar4;
auVar10 = ZEXT816(6) << 0x40;
}
}
else {
auVar10 = JS_CallInternal(param_1,uVar8,uVar2,0,3,1,0,3,&local_38,2);
}
local_48 = auVar10;
if ((auVar10._8_8_ & 0xffffffff) == 6) {
lVar6 = *(long *)(param_1 + 0x18);
local_48 = *(int1 (*) [16])(lVar6 + 0xf0);
*(int4 *)(lVar6 + 0xf0) = 0;
*(int8 *)(lVar6 + 0xf8) = 4;
}
lVar6 = (ulong)(auVar10._8_4_ == 6) * 0x10;
uVar8 = *(int8 *)(param_3 + 8 + lVar6);
if ((int)uVar8 == 3) {
uVar8 = 3;
uVar9 = 0;
uVar7 = 0;
}
else {
auVar11 = JS_CallInternal(param_1,*(int8 *)(param_3 + lVar6),uVar8,0,3,1,0,3,local_48,2);
uVar8 = auVar11._8_8_;
uVar7 = auVar11._0_8_ & 0xffffffff00000000;
uVar9 = auVar11._0_8_ & 0xffffffff;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),local_48._0_8_,local_48._8_8_);
auVar11._8_8_ = uVar8;
auVar11._0_8_ = uVar9 | uVar7;
return auVar11;
}
| |
43,196 | my_b_write | eloqsql/include/my_sys.h | static inline int my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
MEM_CHECK_DEFINED(Buffer, Count);
if (info->write_pos + Count <= info->write_end)
{
if (Count)
{
memcpy(info->write_pos, Buffer, Count);
info->write_pos+= Count;
}
return 0;
}
return _my_b_write(info, Buffer, Count);
} | O0 | c | my_b_write:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
ja 0xe17ef
cmpq $0x0, -0x20(%rbp)
je 0xe17e6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a090
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe1803
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe08b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| my_b_write_3:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov rax, [rax+40h]
add rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx+48h]
ja short loc_E17EF
cmp [rbp+var_20], 0
jz short loc_E17E6
mov rax, [rbp+var_10]
mov rdi, [rax+40h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax+40h]
mov [rax+40h], rcx
loc_E17E6:
mov [rbp+var_4], 0
jmp short loc_E1803
loc_E17EF:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _my_b_write
mov [rbp+var_4], eax
loc_E1803:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_b_write_3(long long a1, const char *a2, long long a3)
{
if ( (unsigned long long)(a3 + *(_QWORD *)(a1 + 64)) > *(_QWORD *)(a1 + 72) )
{
return (unsigned int)my_b_write(a1, a2, a3);
}
else
{
if ( a3 )
{
memcpy(*(_QWORD *)(a1 + 64), a2, a3);
*(_QWORD *)(a1 + 64) += a3;
}
return 0;
}
}
| my_b_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
ADD RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x48]
JA 0x001e17ef
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e17e6
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x40]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x40]
MOV qword ptr [RAX + 0x40],RCX
LAB_001e17e6:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e1803
LAB_001e17ef:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001e08b0
MOV dword ptr [RBP + -0x4],EAX
LAB_001e1803:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_b_write(long param_1,void *param_2,size_t param_3)
{
int4 local_c;
if (*(ulong *)(param_1 + 0x48) < *(long *)(param_1 + 0x40) + param_3) {
local_c = _my_b_write(param_1,param_2,param_3);
}
else {
if (param_3 != 0) {
memcpy(*(void **)(param_1 + 0x40),param_2,param_3);
*(size_t *)(param_1 + 0x40) = param_3 + *(long *)(param_1 + 0x40);
}
local_c = 0;
}
return local_c;
}
| |
43,197 | stop_waiting_locked | eloqsql/mysys/waiting_threads.c | static int stop_waiting_locked(WT_THD *thd)
{
int ret;
WT_RESOURCE *rc= thd->waiting_for;
DBUG_ENTER("stop_waiting_locked");
DBUG_ASSERT(rc->waiter_count);
DBUG_ASSERT(rc->state == ACTIVE);
rc->waiter_count--;
thd->waiting_for= 0;
ret= unlock_lock_and_free_resource(thd, rc);
DBUG_RETURN((thd->killed || ret) ? WT_DEADLOCK : WT_OK);
} | O0 | c | stop_waiting_locked:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x100f7a
jmp 0x100f7c
jmp 0x100f7e
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x101630
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x60(%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x100fc3
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| stop_waiting_locked:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+28h]
mov [rbp+var_18], rax
jmp short $+2
loc_100F7A:
jmp short $+2
loc_100F7C:
jmp short $+2
loc_100F7E:
mov rax, [rbp+var_18]
mov ecx, [rax+10h]
add ecx, 0FFFFFFFFh
mov [rax+10h], ecx
mov rax, [rbp+var_8]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call unlock_lock_and_free_resource
mov [rbp+var_C], eax
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax+60h]
mov al, 1
cmp ecx, 0
mov [rbp+var_19], al
jnz short loc_100FC3
cmp [rbp+var_C], 0
setnz al
mov [rbp+var_19], al
loc_100FC3:
mov dl, [rbp+var_19]
xor eax, eax
mov ecx, 0FFFFFFFFh
test dl, 1
cmovnz eax, ecx
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
| long long stop_waiting_locked(long long a1)
{
long long result; // rax
bool v2; // [rsp+7h] [rbp-19h]
long long v3; // [rsp+8h] [rbp-18h]
int v4; // [rsp+14h] [rbp-Ch]
v3 = *(_QWORD *)(a1 + 40);
--*(_DWORD *)(v3 + 16);
*(_QWORD *)(a1 + 40) = 0LL;
v4 = unlock_lock_and_free_resource(a1, v3);
v2 = 1;
if ( !*(_BYTE *)(a1 + 96) )
v2 = v4 != 0;
LODWORD(result) = 0;
if ( v2 )
LODWORD(result) = -1;
return (unsigned int)result;
}
| |||
43,198 | stop_waiting_locked | eloqsql/mysys/waiting_threads.c | static int stop_waiting_locked(WT_THD *thd)
{
int ret;
WT_RESOURCE *rc= thd->waiting_for;
DBUG_ENTER("stop_waiting_locked");
DBUG_ASSERT(rc->waiter_count);
DBUG_ASSERT(rc->state == ACTIVE);
rc->waiter_count--;
thd->waiting_for= 0;
ret= unlock_lock_and_free_resource(thd, rc);
DBUG_RETURN((thd->killed || ret) ? WT_DEADLOCK : WT_OK);
} | O3 | c | stop_waiting_locked:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rsi
decl 0x10(%rsi)
movq $0x0, 0x28(%rdi)
popq %rbp
jmp 0xa7b49
| stop_waiting_locked:
push rbp
mov rbp, rsp
mov rsi, [rdi+28h]
dec dword ptr [rsi+10h]
mov qword ptr [rdi+28h], 0
pop rbp
jmp unlock_lock_and_free_resource
| long long stop_waiting_locked(long long a1)
{
--*(_DWORD *)(*(_QWORD *)(a1 + 40) + 16LL);
*(_QWORD *)(a1 + 40) = 0LL;
return unlock_lock_and_free_resource(a1);
}
| stop_waiting_locked:
PUSH RBP
MOV RBP,RSP
MOV RSI,qword ptr [RDI + 0x28]
DEC dword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x28],0x0
POP RBP
JMP 0x001a7b49
|
void stop_waiting_locked(long param_1)
{
int *piVar1;
piVar1 = (int *)(*(long *)(param_1 + 0x28) + 0x10);
*piVar1 = *piVar1 + -1;
*(int8 *)(param_1 + 0x28) = 0;
unlock_lock_and_free_resource();
return;
}
| |
43,199 | minja::Value::set(minja::Value const&, minja::Value const&) | monkey531[P]llama/common/minja.hpp | void set(const Value& key, const Value& value) {
if (!object_) throw std::runtime_error("Value is not an object: " + dump());
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
(*object_)[key.primitive_] = value;
} | O1 | cpp | minja::Value::set(minja::Value const&, minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x55d67
cmpq $0x0, 0x10(%rsi)
jne 0x55dc4
cmpq $0x0, 0x20(%rsi)
jne 0x55dc4
cmpq $0x0, 0x30(%rsi)
jne 0x55dc4
movq %rdx, %rbx
addq $0x40, %rsi
callq 0x55ef0
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x54e94
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
leaq 0x28(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x54e94
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
leaq 0x38(%r14), %rdi
leaq 0x38(%rbx), %rsi
callq 0x54e94
addq $0x40, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x302d2
addq $0x40, %r14
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2fff8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4326e
movq %rbx, %rdi
callq 0x501da
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1a390
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43576
leaq 0x5e0ca(%rip), %rsi # 0xb3e59
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x29fff
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ac00
xorl %ebp, %ebp
movq 0x9023d(%rip), %rsi # 0xe5ff0
movq 0x901b6(%rip), %rdx # 0xe5f70
movq %rbx, %rdi
callq 0x1acd0
jmp 0x55e1f
movl $0x10, %edi
callq 0x1a390
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43576
leaq 0x5e086(%rip), %rsi # 0xb3e72
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x29fff
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ac00
xorl %ebp, %ebp
movq 0x901e0(%rip), %rsi # 0xe5ff0
movq 0x90159(%rip), %rdx # 0xe5f70
movq %rbx, %rdi
callq 0x1acd0
jmp 0x55e23
jmp 0x55e43
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55e49
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a740
jmp 0x55e49
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55e6e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a740
jmp 0x55e6e
jmp 0x55e68
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x55e7b
movq %rbx, %rdi
callq 0x1a530
movq %r14, %rdi
callq 0x1ad30
movq %rax, %rdi
callq 0x20d37
nop
| _ZN5minja5Value3setERKS0_S2_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+20h]
test rdi, rdi
jz loc_55D67
cmp qword ptr [rsi+10h], 0
jnz loc_55DC4
cmp qword ptr [rsi+20h], 0
jnz loc_55DC4
cmp qword ptr [rsi+30h], 0
jnz loc_55DC4
mov rbx, rdx
add rsi, 40h ; '@'
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator[](nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov r14, rax
mov rax, [rbx+10h]
mov [r14+10h], rax
lea rdi, [r14+18h]
lea rsi, [rbx+18h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
mov rax, [rbx+20h]
mov [r14+20h], rax
lea rdi, [r14+28h]
lea rsi, [rbx+28h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
mov rax, [rbx+30h]
mov [r14+30h], rax
lea rdi, [r14+38h]
lea rsi, [rbx+38h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEaSERKS2_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(std::__shared_count<(__gnu_cxx::_Lock_policy)2> const&)
add rbx, 40h ; '@'
mov rdi, rsp
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
add r14, 40h ; '@'
mov rbx, rsp
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_55D67:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnOb; "Value is not an object: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_55E1F
loc_55DC4:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_55E1F:
jmp short loc_55E23
jmp short loc_55E43
loc_55E23:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_55E49
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_55E49
loc_55E43:
mov r14, rax
mov bpl, 1
loc_55E49:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_55E6E
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_55E6E
jmp short $+2
loc_55E68:
mov r14, rax
mov bpl, 1
loc_55E6E:
test bpl, bpl
jz short loc_55E7B
mov rdi, rbx; void *
call ___cxa_free_exception
loc_55E7B:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| char * minja::Value::set(minja::Value *this, const minja::Value *a2, const minja::Value *a3)
{
long long v4; // rdi
long long v6; // r14
char *result; // rax
void *exception; // rbx
void *v9; // rbx
void *v10[2]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+20h] [rbp-38h] BYREF
v4 = *((_QWORD *)this + 4);
if ( !v4 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v11, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Value is not an object: ", (long long)v11);
std::runtime_error::runtime_error(exception, v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v11, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v10, (long long)"Unashable type: ", (long long)v11);
std::runtime_error::runtime_error(v9, v10);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 = nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator[](
v4,
(char *)a2 + 64);
*(_QWORD *)(v6 + 16) = *((_QWORD *)a3 + 2);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(
(volatile signed __int32 **)(v6 + 24),
(volatile signed __int32 **)a3 + 3);
*(_QWORD *)(v6 + 32) = *((_QWORD *)a3 + 4);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(
(volatile signed __int32 **)(v6 + 40),
(volatile signed __int32 **)a3 + 5);
*(_QWORD *)(v6 + 48) = *((_QWORD *)a3 + 6);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=(
(volatile signed __int32 **)(v6 + 56),
(volatile signed __int32 **)a3 + 7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v10,
(long long)a3 + 64);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
(char *)(v6 + 64),
(char *)v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v10);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v10);
return result;
}
| set:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x20]
TEST RDI,RDI
JZ 0x00155d67
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x00155dc4
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x00155dc4
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x00155dc4
MOV RBX,RDX
ADD RSI,0x40
CALL 0x00155ef0
MOV R14,RAX
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [R14 + 0x10],RAX
LEA RDI,[R14 + 0x18]
LEA RSI,[RBX + 0x18]
CALL 0x00154e94
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [R14 + 0x20],RAX
LEA RDI,[R14 + 0x28]
LEA RSI,[RBX + 0x28]
CALL 0x00154e94
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x30],RAX
LEA RDI,[R14 + 0x38]
LEA RSI,[RBX + 0x38]
CALL 0x00154e94
ADD RBX,0x40
LAB_00155d2f:
MOV RDI,RSP
MOV RSI,RBX
CALL 0x001302d2
LAB_00155d3a:
ADD R14,0x40
MOV RBX,RSP
MOV RDI,R14
MOV RSI,RBX
CALL 0x0012fff8
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0014326e
MOV RDI,RBX
CALL 0x001501da
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_00155d67:
MOV EDI,0x10
CALL 0x0011a390
MOV RBX,RAX
LAB_00155d74:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00143576
LAB_00155d88:
LEA RSI,[0x1b3e59]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00129fff
MOV BPL,0x1
LAB_00155d9f:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011ac00
XOR EBP,EBP
MOV RSI,qword ptr [0x001e5ff0]
MOV RDX,qword ptr [0x001e5f70]
MOV RDI,RBX
CALL 0x0011acd0
LAB_00155dc4:
MOV EDI,0x10
CALL 0x0011a390
MOV RBX,RAX
LAB_00155dd1:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00143576
LAB_00155de5:
LEA RSI,[0x1b3e72]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x00129fff
MOV BPL,0x1
LAB_00155dfc:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x0011ac00
XOR EBP,EBP
MOV RSI,qword ptr [0x001e5ff0]
MOV RDX,qword ptr [0x001e5f70]
MOV RDI,RBX
CALL 0x0011acd0
|
/* minja::Value::set(minja::Value const&, minja::Value const&) */
void __thiscall minja::Value::set(Value *this,Value *param_1,Value *param_2)
{
long lVar1;
runtime_error *prVar2;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
abStack_58 [32];
int1 local_38 [32];
if (*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20) ==
(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)0x0) {
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00155d74 to 00155d87 has its CatchHandler @ 00155e68 */
dump_abi_cxx11_((int)local_38,SUB81(this,0));
/* try { // try from 00155d88 to 00155d9b has its CatchHandler @ 00155e43 */
std::operator+((char *)abStack_58,(string *)"Value is not an object: ");
/* try { // try from 00155d9f to 00155dc1 has its CatchHandler @ 00155e23 */
std::runtime_error::runtime_error(prVar2,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_001e5ff0,PTR__runtime_error_001e5f70);
}
if (((*(long *)(param_1 + 0x10) == 0) && (*(long *)(param_1 + 0x20) == 0)) &&
(*(long *)(param_1 + 0x30) == 0)) {
lVar1 = nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::operator[](*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),(basic_json *)(param_1 + 0x40));
*(int8 *)(lVar1 + 0x10) = *(int8 *)(param_2 + 0x10);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(lVar1 + 0x18),
(__shared_count *)(param_2 + 0x18));
*(int8 *)(lVar1 + 0x20) = *(int8 *)(param_2 + 0x20);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(lVar1 + 0x28),
(__shared_count *)(param_2 + 0x28));
*(int8 *)(lVar1 + 0x30) = *(int8 *)(param_2 + 0x30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::operator=
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(lVar1 + 0x38),
(__shared_count *)(param_2 + 0x38));
/* try { // try from 00155d2f to 00155d39 has its CatchHandler @ 00155e83 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(abStack_58,(basic_json *)(param_2 + 0x40));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(lVar1 + 0x40),abStack_58);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(abStack_58,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)abStack_58);
return;
}
prVar2 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00155dd1 to 00155de4 has its CatchHandler @ 00155e66 */
dump_abi_cxx11_((int)local_38,SUB81(this,0));
/* try { // try from 00155de5 to 00155df8 has its CatchHandler @ 00155e21 */
std::operator+((char *)abStack_58,(string *)"Unashable type: ");
/* try { // try from 00155dfc to 00155e1e has its CatchHandler @ 00155e1f */
std::runtime_error::runtime_error(prVar2,(string *)abStack_58);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar2,PTR_typeinfo_001e5ff0,PTR__runtime_error_001e5f70);
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.