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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
34,200 | minja::ForNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
// https://jinja.palletsprojects.com/en/3.0.x/templates/#for
if (!iterable) throw std::runtime_error("ForNode.iterable is null");
if (!body) throw std::runtime_error("ForNode.body is null");
auto iterable_value = iterable->evaluate(context);
Value::CallableType loop_function;
std::function<void(Value&)> visit = [&](Value& iter) {
auto filtered_items = Value::array();
if (!iter.is_null()) {
if (!iterable_value.is_iterable()) {
throw std::runtime_error("For loop iterable must be iterable: " + iterable_value.dump());
}
iterable_value.for_each([&](Value & item) {
destructuring_assign(var_names, context, item);
if (!condition || condition->evaluate(context).to_bool()) {
filtered_items.push_back(item);
}
});
}
if (filtered_items.empty()) {
if (else_body) {
else_body->render(out, context);
}
} else {
auto loop = recursive ? Value::callable(loop_function) : Value::object();
loop.set("length", (int64_t) filtered_items.size());
size_t cycle_index = 0;
loop.set("cycle", Value::callable([&](const std::shared_ptr<Context> &, ArgumentsValue & args) {
if (args.args.empty() || !args.kwargs.empty()) {
throw std::runtime_error("cycle() expects at least 1 positional argument and no named arg");
}
auto item = args.args[cycle_index];
cycle_index = (cycle_index + 1) % args.args.size();
return item;
}));
auto loop_context = Context::make(Value::object(), context);
loop_context->set("loop", loop);
for (size_t i = 0, n = filtered_items.size(); i < n; ++i) {
auto & item = filtered_items.at(i);
destructuring_assign(var_names, loop_context, item);
loop.set("index", (int64_t) i + 1);
loop.set("index0", (int64_t) i);
loop.set("revindex", (int64_t) (n - i));
loop.set("revindex0", (int64_t) (n - i - 1));
loop.set("length", (int64_t) n);
loop.set("first", i == 0);
loop.set("last", i == (n - 1));
loop.set("previtem", i > 0 ? filtered_items.at(i - 1) : Value());
loop.set("nextitem", i < n - 1 ? filtered_items.at(i + 1) : Value());
try {
body->render(out, loop_context);
} catch (const LoopControlException & e) {
if (e.control_type == LoopControlType::Break) break;
if (e.control_type == LoopControlType::Continue) continue;
}
}
}
};
if (recursive) {
loop_function = [&](const std::shared_ptr<Context> &, ArgumentsValue & args) {
if (args.args.size() != 1 || !args.kwargs.empty() || !args.args[0].is_array()) {
throw std::runtime_error("loop() expects exactly 1 positional iterable argument");
}
auto & items = args.args[0];
visit(items);
return Value();
};
}
visit(iterable_value);
} | O2 | cpp | minja::ForNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
je 0x739ea
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x73a06
movq %rdx, %r15
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x62ea2
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
leaq 0x40(%rsp), %rsi
movq %r12, (%rsi)
movq %rbx, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %r14, 0x18(%rsi)
movq %rax, 0x20(%rsi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x73ad2
cmpb $0x1, 0x68(%rbx)
jne 0x739b0
leaq 0x40(%rsp), %rsi
movq %r14, (%rsi)
movq %rsp, %rdi
callq 0x73b1a
leaq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x6dc7c
leaq 0x20(%rsp), %rdi
callq 0x47f7a
movq %rsp, %rdi
callq 0x47f7a
leaq 0x68(%rsp), %rdi
callq 0x63132
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %r14
leaq 0x42f16(%rip), %rsi # 0xb6912
movq %rax, %rdi
callq 0x24320
jmp 0x73a20
pushq $0x10
popq %rdi
callq 0x24460
movq %rax, %r14
leaq 0x42f13(%rip), %rsi # 0xb692b
movq %rax, %rdi
callq 0x24320
movq 0x8c5c9(%rip), %rsi # 0xffff0
movq 0x8c522(%rip), %rdx # 0xfff50
movq %r14, %rdi
callq 0x24ee0
jmp 0x73a38
movq %rax, %rbx
movq %r14, %rdi
callq 0x24670
jmp 0x73a69
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x47f7a
jmp 0x73a57
movq %rax, %rbx
movq %rsp, %rdi
callq 0x47f7a
leaq 0x68(%rsp), %rdi
callq 0x63132
movq %rbx, %rdi
callq 0x24f60
nop
| _ZNK5minja7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 0B8h
mov r14, rsi
mov rsi, [rdi+38h]
test rsi, rsi
jz loc_739EA
mov rbx, rdi
cmp qword ptr [rdi+58h], 0
jz loc_73A06
mov r15, rdx
lea r12, [rsp+0D8h+var_70]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
xorps xmm0, xmm0
mov rax, rsp
movaps xmmword ptr [rax+10h], xmm0
movaps xmmword ptr [rax], xmm0
lea rsi, [rsp+0D8h+var_98]
mov [rsi], r12
mov [rsi+8], rbx
mov [rsi+10h], r15
mov [rsi+18h], r14
mov [rsi+20h], rax
lea r14, [rsp+0D8h+var_B8]
mov rdi, r14
call _ZNSt8functionIFvRN5minja5ValueEEEC2IZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS0_7ContextEEEUlS2_E_vEEOT_; std::function<void ()(minja::Value &)>::function<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1},void>(minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1} &&)
cmp byte ptr [rbx+68h], 1
jnz short loc_739B0
lea rsi, [rsp+0D8h+var_98]
mov [rsi], r14
mov rdi, rsp
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEaSIZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEES6_EUlS6_S8_E_EENSt9enable_ifIXsrNSA_9_CallableIT_NSL_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISN_E4typeEE4typeESA_EE5valueESt5decayISN_EE4type4typeESt15__invoke_resultIRSY_JS6_S8_EEEE5valueERSA_E4typeEOSN_
loc_739B0:
lea rdi, [rsp+0D8h+var_B8]
lea rsi, [rsp+0D8h+var_70]
call _ZNKSt8functionIFvRN5minja5ValueEEEclES2_; std::function<void ()(minja::Value &)>::operator()(minja::Value &)
lea rdi, [rsp+0D8h+var_B8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+0D8h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
add rsp, 0B8h
pop rbx
pop r12
pop r14
pop r15
retn
loc_739EA:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFornodeIterabl; "ForNode.iterable is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_73A20
loc_73A06:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFornodeBodyIsN; "ForNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_73A20:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short $+2
loc_73A38:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_73A69
mov rbx, rax
lea rdi, [rsp+0D8h+var_B8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_73A57
mov rbx, rax
loc_73A57:
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+0D8h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_73A69:
mov rdi, rbx
call __Unwind_Resume
| void minja::ForNode::do_render(long long a1, long long a2, long long a3)
{
void (***v4)(void); // rsi
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
std::runtime_error *exception; // r14
_BYTE v11[32]; // [rsp+0h] [rbp-D8h] BYREF
_BYTE v12[32]; // [rsp+20h] [rbp-B8h] BYREF
_QWORD v13[5]; // [rsp+40h] [rbp-98h] BYREF
_BYTE v14[112]; // [rsp+68h] [rbp-70h] BYREF
v4 = *(void (****)(void))(a1 + 56);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.iterable is null");
goto LABEL_8;
}
if ( !*(_QWORD *)(a1 + 88) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.body is null");
LABEL_8:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v14, v4);
v13[0] = v14;
v13[1] = a1;
v13[2] = a3;
v13[3] = a2;
v13[4] = v11;
std::function<void ()(minja::Value &)>::function<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1},void>(
v12,
v13,
v6,
v7,
v8,
v9,
0LL,
0LL,
0LL,
0LL);
if ( *(_BYTE *)(a1 + 104) == 1 )
{
v13[0] = v12;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator=<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1}>(v11);
}
std::function<void ()(minja::Value &)>::operator()((long long)v12);
std::_Function_base::~_Function_base((std::_Function_base *)v12);
std::_Function_base::~_Function_base((std::_Function_base *)v11);
minja::Value::~Value((minja::Value *)v14);
}
| do_render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R14,RSI
MOV RSI,qword ptr [RDI + 0x38]
TEST RSI,RSI
JZ 0x001739ea
MOV RBX,RDI
CMP qword ptr [RDI + 0x58],0x0
JZ 0x00173a06
MOV R15,RDX
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x00162ea2
XORPS XMM0,XMM0
MOV RAX,RSP
MOVAPS xmmword ptr [RAX + 0x10],XMM0
MOVAPS xmmword ptr [RAX],XMM0
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI],R12
MOV qword ptr [RSI + 0x8],RBX
MOV qword ptr [RSI + 0x10],R15
MOV qword ptr [RSI + 0x18],R14
MOV qword ptr [RSI + 0x20],RAX
LAB_0017398d:
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x00173ad2
CMP byte ptr [RBX + 0x68],0x1
JNZ 0x001739b0
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI],R14
MOV RDI,RSP
CALL 0x00173b1a
LAB_001739b0:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x68]
CALL 0x0016dc7c
LAB_001739bf:
LEA RDI,[RSP + 0x20]
CALL 0x00147f7a
MOV RDI,RSP
CALL 0x00147f7a
LEA RDI,[RSP + 0x68]
CALL 0x00163132
ADD RSP,0xb8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001739ea:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV R14,RAX
LAB_001739f5:
LEA RSI,[0x1b6912]
MOV RDI,RAX
CALL 0x00124320
LAB_00173a04:
JMP 0x00173a20
LAB_00173a06:
PUSH 0x10
POP RDI
CALL 0x00124460
MOV R14,RAX
LAB_00173a11:
LEA RSI,[0x1b692b]
MOV RDI,RAX
CALL 0x00124320
LAB_00173a20:
MOV RSI,qword ptr [0x001ffff0]
MOV RDX,qword ptr [0x001fff50]
MOV RDI,R14
CALL 0x00124ee0
|
/* minja::ForNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void __thiscall minja::ForNode::do_render(ForNode *this,ostringstream *param_1,shared_ptr *param_2)
{
runtime_error *this_00;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
_lambda_minja__Value___1_ local_b8 [32];
Expression *local_98;
ForNode *local_90;
shared_ptr *local_88;
ostringstream *local_80;
int1 *local_78;
Expression local_70 [80];
if (*(shared_ptr **)(this + 0x38) == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001739f5 to 00173a03 has its CatchHandler @ 00173a38 */
std::runtime_error::runtime_error(this_00,"ForNode.iterable is null");
}
else {
if (*(long *)(this + 0x58) != 0) {
Expression::evaluate(local_70,*(shared_ptr **)(this + 0x38));
local_c8 = 0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
/* try { // try from 0017398d to 00173999 has its CatchHandler @ 00173a54 */
local_98 = local_70;
local_90 = this;
local_88 = param_2;
local_80 = param_1;
local_78 = (int1 *)&local_d8;
std::function<void(minja::Value&)>::
function<minja::ForNode::do_render(std::__cxx11::ostringstream&,std::shared_ptr<minja::Context>const&)const::_lambda(minja::Value&)_1_,void>
(local_b8);
if (this[0x68] == (ForNode)0x1) {
local_98 = (Expression *)local_b8;
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
operator=((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>
*)&local_d8,
(_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ *)
&local_98);
}
/* try { // try from 001739b0 to 001739be has its CatchHandler @ 00173a45 */
std::function<void(minja::Value&)>::operator()
((function<void(minja::Value&)> *)local_b8,(Value *)local_70);
std::_Function_base::~_Function_base((_Function_base *)local_b8);
std::_Function_base::~_Function_base((_Function_base *)&local_d8);
Value::~Value((Value *)local_70);
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00173a11 to 00173a1f has its CatchHandler @ 00173a36 */
std::runtime_error::runtime_error(this_00,"ForNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001ffff0,PTR__runtime_error_001fff50);
}
| |
34,201 | fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_validate_filename(const std::string & filename) {
if (!filename.length()) {
// Empty filename invalid
return false;
}
if (filename.length() > 255) {
// Limit at common largest possible filename on Linux filesystems
// to avoid unnecessary further validation
// (On systems with smaller limits it will be caught by the OS)
return false;
}
std::u32string filename_utf32;
try {
#if defined(__clang__)
// disable C++17 deprecation warning for std::codecvt_utf8
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdeprecated-declarations"
#endif
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
#if defined(__clang__)
# pragma clang diagnostic pop
#endif
filename_utf32 = converter.from_bytes(filename);
// If the reverse conversion mismatches, it means overlong UTF-8 sequences were used,
// or invalid encodings were encountered. Reject such attempts
std::string filename_reencoded = converter.to_bytes(filename_utf32);
if (filename_reencoded != filename) {
return false;
}
} catch (const std::exception &) {
return false;
}
// Check for forbidden codepoints:
// - Control characters
// - Unicode equivalents of illegal characters
// - UTF-16 surrogate pairs
// - UTF-8 replacement character
// - Byte order mark (BOM)
// - Illegal characters: / \ : * ? " < > |
for (char32_t c : filename_utf32) {
if (c <= 0x1F // Control characters (C0)
|| c == 0x7F // Control characters (DEL)
|| (c >= 0x80 && c <= 0x9F) // Control characters (C1)
|| c == 0xFF0E // Fullwidth Full Stop (period equivalent)
|| c == 0x2215 // Division Slash (forward slash equivalent)
|| c == 0x2216 // Set Minus (backslash equivalent)
|| (c >= 0xD800 && c <= 0xDFFF) // UTF-16 surrogate pairs
|| c == 0xFFFD // Replacement Character (UTF-8)
|| c == 0xFEFF // Byte Order Mark (BOM)
|| c == '/' || c == '\\' || c == ':' || c == '*' // Illegal characters
|| c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
return false;
}
}
// Reject any leading or trailing ' ', or any trailing '.', these are stripped on Windows and will cause a different filename
// Unicode and other whitespace is not affected, only 0x20 space
if (filename.front() == ' ' || filename.back() == ' ' || filename.back() == '.') {
return false;
}
// Reject any ".." (currently stricter than necessary, it should be fine to just check for == ".." instead)
if (filename.find("..") != std::string::npos) {
return false;
}
// Reject "."
if (filename == ".") {
return false;
}
return true;
} | O0 | cpp | fs_validate_filename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq 0x118(%rsp), %rdi
callq 0x5aab0
cmpq $0x0, %rax
jne 0xf59af
movb $0x0, 0x127(%rsp)
jmp 0xf5d47
movq 0x118(%rsp), %rdi
callq 0x5aab0
cmpq $0xff, %rax
jbe 0xf59d1
movb $0x0, 0x127(%rsp)
jmp 0xf5d47
leaq 0xf8(%rsp), %rdi
callq 0xff330
leaq 0x98(%rsp), %rdi
callq 0xff3b0
jmp 0xf59ed
movq 0x118(%rsp), %rdx
leaq 0x68(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xff470
jmp 0xf5a09
leaq 0xf8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x68(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0xff4f0
movq 0x8(%rsp), %rdi
callq 0xff730
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xff770
jmp 0xf5a48
movq 0x118(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0xff7f0
testb $0x1, %al
jne 0xf5a63
jmp 0xf5ae9
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf5af1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xf5aac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xff820
movl 0x8c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xf5d38
movq 0x90(%rsp), %rdi
callq 0x5a100
movq %rax, 0x38(%rsp)
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
callq 0x5aec0
jmp 0xf5b18
movl $0x0, 0x44(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5b6f8
leaq 0x98(%rsp), %rdi
callq 0xff820
movl 0x44(%rsp), %eax
testl %eax, %eax
jne 0xf5d29
jmp 0xf5b16
jmp 0xf5b36
jmp 0xf5d29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xf5d38
leaq 0xf8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0xff860
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xff890
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xff8f0
testb $0x1, %al
jne 0xf5b79
jmp 0xf5c62
leaq 0x28(%rsp), %rdi
callq 0xff930
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x1f, 0x1c(%rsp)
jbe 0xf5c3c
cmpl $0x7f, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x80, 0x1c(%rsp)
jb 0xf5bb7
cmpl $0x9f, 0x1c(%rsp)
jbe 0xf5c3c
cmpl $0xff0e, 0x1c(%rsp) # imm = 0xFF0E
je 0xf5c3c
cmpl $0x2215, 0x1c(%rsp) # imm = 0x2215
je 0xf5c3c
cmpl $0x2216, 0x1c(%rsp) # imm = 0x2216
je 0xf5c3c
cmpl $0xd800, 0x1c(%rsp) # imm = 0xD800
jb 0xf5be9
cmpl $0xdfff, 0x1c(%rsp) # imm = 0xDFFF
jbe 0xf5c3c
cmpl $0xfffd, 0x1c(%rsp) # imm = 0xFFFD
je 0xf5c3c
cmpl $0xfeff, 0x1c(%rsp) # imm = 0xFEFF
je 0xf5c3c
cmpl $0x2f, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x5c, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x3a, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x2a, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x3f, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x22, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x3c, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x3e, 0x1c(%rsp)
je 0xf5c3c
cmpl $0x7c, 0x1c(%rsp)
jne 0xf5c51
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf5d29
jmp 0xf5c53
leaq 0x28(%rsp), %rdi
callq 0xff940
jmp 0xf5b61
movq 0x118(%rsp), %rdi
callq 0x5a2b0
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xf5ca1
movq 0x118(%rsp), %rdi
callq 0x5b090
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xf5ca1
movq 0x118(%rsp), %rdi
callq 0x5b090
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xf5cb3
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf5d29
movq 0x118(%rsp), %rdi
leaq 0x11c8ca(%rip), %rsi # 0x21258c
xorl %eax, %eax
movl %eax, %edx
callq 0x5a060
cmpq $-0x1, %rax
je 0xf5ce3
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf5d29
movq 0x118(%rsp), %rdi
leaq 0x11c89b(%rip), %rsi # 0x21258d
callq 0x6af30
movb %al, 0x7(%rsp)
jmp 0xf5cfd
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xf5d07
jmp 0xf5d19
movb $0x0, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0xf5d29
movb $0x1, 0x127(%rsp)
movl $0x1, 0x44(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0xff730
jmp 0xf5d47
leaq 0xf8(%rsp), %rdi
callq 0xff730
jmp 0xf5d58
movb 0x127(%rsp), %al
andb $0x1, %al
addq $0x128, %rsp # imm = 0x128
retq
movq 0x90(%rsp), %rdi
callq 0x5ac70
nopw %cs:(%rax,%rax)
| _Z20fs_validate_filenameRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 128h
mov [rsp+128h+var_10], rdi
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 0
jnz short loc_F59AF
mov [rsp+128h+var_1], 0
jmp loc_F5D47
loc_F59AF:
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
cmp rax, 0FFh
jbe short loc_F59D1
mov [rsp+128h+var_1], 0
jmp loc_F5D47
loc_F59D1:
lea rdi, [rsp+128h+var_30]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEC2Ev; std::basic_string<char32_t>::basic_string(void)
lea rdi, [rsp+128h+var_90]; int
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEEC2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(void)
jmp short $+2
loc_F59ED:
mov rdx, [rsp+128h+var_10]
lea rdi, [rsp+128h+var_C0]
lea rsi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE10from_bytesERKNS_12basic_stringIcSt11char_traitsIcES5_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(std::string const&)
jmp short $+2
loc_F5A09:
lea rdi, [rsp+128h+var_30]
mov [rsp+128h+var_118], rdi
lea rsi, [rsp+128h+var_C0]
mov [rsp+128h+var_120], rsi
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEaSEOS4_; std::basic_string<char32_t>::operator=(std::basic_string<char32_t>&&)
mov rdi, [rsp+128h+var_120]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
mov rdx, [rsp+128h+var_118]
lea rdi, [rsp+128h+var_E0]
lea rsi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEE8to_bytesERKNS_12basic_stringIDiSt11char_traitsIDiES4_EE; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(std::basic_string<char32_t> const&)
jmp short $+2
loc_F5A48:
mov rsi, [rsp+128h+var_10]
lea rdi, [rsp+128h+var_E0]
call _ZStneIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EESA_; std::operator!=<char>(std::string const&,std::string const&)
test al, 1
jnz short loc_F5A63
jmp loc_F5AE9
loc_F5A63:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F5AF1
mov rcx, rax
mov eax, edx
mov [rsp+128h+var_98], rcx
mov [rsp+128h+var_9C], eax
jmp short loc_F5AAC
mov rcx, rax
mov eax, edx
mov [rsp+128h+var_98], rcx
mov [rsp+128h+var_9C], eax
lea rdi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
loc_F5AAC:
mov eax, [rsp+128h+var_9C]
mov ecx, 1
cmp eax, ecx
jnz loc_F5D38
mov rdi, [rsp+128h+var_98]; void *
call ___cxa_begin_catch
mov [rsp+128h+var_F0], rax
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
call ___cxa_end_catch
jmp short loc_F5B18
loc_F5AE9:
mov [rsp+128h+var_E4], 0
loc_F5AF1:
lea rdi, [rsp+128h+var_E0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+128h+var_90]
call _ZNSt7__cxx1115wstring_convertISt12codecvt_utf8IDiLm1114111ELSt12codecvt_mode0EEDiSaIDiESaIcEED2Ev; std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert()
mov eax, [rsp+128h+var_E4]
test eax, eax
jnz loc_F5D29
jmp short $+2
loc_F5B16:
jmp short loc_F5B36
loc_F5B18:
jmp loc_F5D29
mov rcx, rax
mov eax, edx
mov [rsp+128h+var_98], rcx
mov [rsp+128h+var_9C], eax
jmp loc_F5D38
loc_F5B36:
lea rax, [rsp+128h+var_30]
mov [rsp+128h+var_F8], rax
mov rdi, [rsp+128h+var_F8]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE5beginEv; std::basic_string<char32_t>::begin(void)
mov [rsp+128h+var_100], rax
mov rdi, [rsp+128h+var_F8]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEE3endEv; std::basic_string<char32_t>::end(void)
mov [rsp+128h+var_108], rax
loc_F5B61:
lea rdi, [rsp+128h+var_100]
lea rsi, [rsp+128h+var_108]
call _ZN9__gnu_cxxneIPDiNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<char32_t *,std::basic_string<char32_t>>(__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>> const&,__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>> const&)
test al, 1
jnz short loc_F5B79
jmp loc_F5C62
loc_F5B79:
lea rdi, [rsp+128h+var_100]
call _ZNK9__gnu_cxx17__normal_iteratorIPDiNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEEdeEv; __gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator*(void)
mov eax, [rax]
mov [rsp+128h+var_10C], eax
cmp [rsp+128h+var_10C], 1Fh
jbe loc_F5C3C
cmp [rsp+128h+var_10C], 7Fh
jz loc_F5C3C
cmp [rsp+128h+var_10C], 80h
jb short loc_F5BB7
cmp [rsp+128h+var_10C], 9Fh
jbe loc_F5C3C
loc_F5BB7:
cmp [rsp+128h+var_10C], 0FF0Eh
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 2215h
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 2216h
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 0D800h
jb short loc_F5BE9
cmp [rsp+128h+var_10C], 0DFFFh
jbe short loc_F5C3C
loc_F5BE9:
cmp [rsp+128h+var_10C], 0FFFDh
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 0FEFFh
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 2Fh ; '/'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 5Ch ; '\'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 3Ah ; ':'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 2Ah ; '*'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 3Fh ; '?'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 22h ; '"'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 3Ch ; '<'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 3Eh ; '>'
jz short loc_F5C3C
cmp [rsp+128h+var_10C], 7Ch ; '|'
jnz short loc_F5C51
loc_F5C3C:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp loc_F5D29
loc_F5C51:
jmp short $+2
loc_F5C53:
lea rdi, [rsp+128h+var_100]
call _ZN9__gnu_cxx17__normal_iteratorIPDiNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEEEEppEv; __gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator++(void)
jmp loc_F5B61
loc_F5C62:
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5frontEv; std::string::front(void)
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_F5CA1
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4backEv; std::string::back(void)
movsx eax, byte ptr [rax]
cmp eax, 20h ; ' '
jz short loc_F5CA1
mov rdi, [rsp+128h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4backEv; std::string::back(void)
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jnz short loc_F5CB3
loc_F5CA1:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F5D29
loc_F5CB3:
mov rdi, [rsp+128h+var_10]
lea rsi, aN0N1+7; ".."
xor eax, eax
mov edx, eax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcm; std::string::find(char const*,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_F5CE3
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F5D29
loc_F5CE3:
mov rdi, [rsp+128h+var_10]
lea rsi, aN0N1+8; "."
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
mov [rsp+128h+var_121], al
jmp short $+2
loc_F5CFD:
mov al, [rsp+128h+var_121]
test al, 1
jnz short loc_F5D07
jmp short loc_F5D19
loc_F5D07:
mov [rsp+128h+var_1], 0
mov [rsp+128h+var_E4], 1
jmp short loc_F5D29
loc_F5D19:
mov [rsp+128h+var_1], 1
mov [rsp+128h+var_E4], 1
loc_F5D29:
lea rdi, [rsp+128h+var_30]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
jmp short loc_F5D47
loc_F5D38:
lea rdi, [rsp+128h+var_30]
call _ZNSt7__cxx1112basic_stringIDiSt11char_traitsIDiESaIDiEED2Ev; std::basic_string<char32_t>::~basic_string()
jmp short loc_F5D58
loc_F5D47:
mov al, [rsp+128h+var_1]
and al, 1
add rsp, 128h
retn
loc_F5D58:
mov rdi, [rsp+128h+var_98]
call __Unwind_Resume
| bool fs_validate_filename(long long a1, int a2)
{
int v2; // edx
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v7; // [rsp+0h] [rbp-128h]
int v8; // [rsp+8h] [rbp-120h]
void *v9; // [rsp+10h] [rbp-118h]
int v10; // [rsp+18h] [rbp-110h]
unsigned int v11; // [rsp+1Ch] [rbp-10Ch]
long long v12; // [rsp+20h] [rbp-108h] BYREF
_QWORD v13[2]; // [rsp+28h] [rbp-100h] BYREF
int v14; // [rsp+44h] [rbp-E4h]
_BYTE v15[32]; // [rsp+48h] [rbp-E0h] BYREF
_BYTE v16[36]; // [rsp+68h] [rbp-C0h] BYREF
int v17[24]; // [rsp+98h] [rbp-90h] BYREF
_BYTE v18[32]; // [rsp+F8h] [rbp-30h] BYREF
long long v19; // [rsp+118h] [rbp-10h]
bool v20; // [rsp+127h] [rbp-1h]
v19 = a1;
if ( std::string::length(a1) )
{
if ( (unsigned long long)std::string::length(v19) <= 0xFF )
{
std::basic_string<char32_t>::basic_string(v18);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::wstring_convert(
(int)v17,
a2,
v2,
v3,
v4,
v5,
v7,
v8,
v9,
v10,
v12);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::from_bytes(
v16,
v17,
v19);
std::basic_string<char32_t>::operator=();
std::basic_string<char32_t>::~basic_string(v16);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::to_bytes(
v15,
v17,
v18);
if ( (std::operator!=<char>(v15, v19) & 1) != 0 )
{
v20 = 0;
v14 = 1;
}
else
{
v14 = 0;
}
std::string::~string(v15);
std::wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>::~wstring_convert(v17);
if ( !v14 )
{
v13[1] = v18;
v13[0] = std::basic_string<char32_t>::begin(v18);
v12 = std::basic_string<char32_t>::end(v18);
while ( (__gnu_cxx::operator!=<char32_t *,std::basic_string<char32_t>>(v13, &v12) & 1) != 0 )
{
v11 = *(_DWORD *)__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator*(v13);
if ( v11 <= 0x1F
|| v11 == 127
|| v11 >= 0x80 && v11 <= 0x9F
|| v11 == 65294
|| v11 == 8725
|| v11 == 8726
|| v11 >= 0xD800 && v11 <= 0xDFFF
|| v11 == 65533
|| v11 == 65279
|| v11 == 47
|| v11 == 92
|| v11 == 58
|| v11 == 42
|| v11 == 63
|| v11 == 34
|| v11 == 60
|| v11 == 62
|| v11 == 124 )
{
v20 = 0;
v14 = 1;
goto LABEL_41;
}
__gnu_cxx::__normal_iterator<char32_t *,std::basic_string<char32_t>>::operator++(v13);
}
if ( *(_BYTE *)std::string::front(v19) == 32
|| *(_BYTE *)std::string::back(v19) == 32
|| *(_BYTE *)std::string::back(v19) == 46 )
{
v20 = 0;
v14 = 1;
}
else
{
v20 = std::string::find(v19, "..", 0LL) == -1 && !std::operator==<char>(v19, (long long)".");
v14 = 1;
}
}
LABEL_41:
std::basic_string<char32_t>::~basic_string(v18);
}
else
{
return 0;
}
}
else
{
return 0;
}
return v20;
}
| fs_validate_filename:
SUB RSP,0x128
MOV qword ptr [RSP + 0x118],RDI
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015aab0
CMP RAX,0x0
JNZ 0x001f59af
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001f5d47
LAB_001f59af:
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015aab0
CMP RAX,0xff
JBE 0x001f59d1
MOV byte ptr [RSP + 0x127],0x0
JMP 0x001f5d47
LAB_001f59d1:
LEA RDI,[RSP + 0xf8]
CALL 0x001ff330
LAB_001f59de:
LEA RDI,[RSP + 0x98]
CALL 0x001ff3b0
JMP 0x001f59ed
LAB_001f59ed:
MOV RDX,qword ptr [RSP + 0x118]
LAB_001f59f5:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x98]
CALL 0x001ff470
JMP 0x001f5a09
LAB_001f5a09:
LEA RDI,[RSP + 0xf8]
MOV qword ptr [RSP + 0x10],RDI
LEA RSI,[RSP + 0x68]
MOV qword ptr [RSP + 0x8],RSI
CALL 0x001ff4f0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001ff730
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x98]
CALL 0x001ff770
LAB_001f5a46:
JMP 0x001f5a48
LAB_001f5a48:
MOV RSI,qword ptr [RSP + 0x118]
LEA RDI,[RSP + 0x48]
CALL 0x001ff7f0
TEST AL,0x1
JNZ 0x001f5a63
JMP 0x001f5ae9
LAB_001f5a63:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f5af1
LAB_001f5ae9:
MOV dword ptr [RSP + 0x44],0x0
LAB_001f5af1:
LEA RDI,[RSP + 0x48]
CALL 0x0015b6f8
LEA RDI,[RSP + 0x98]
CALL 0x001ff820
MOV EAX,dword ptr [RSP + 0x44]
TEST EAX,EAX
JNZ 0x001f5d29
JMP 0x001f5b16
LAB_001f5b16:
JMP 0x001f5b36
LAB_001f5b36:
LEA RAX,[RSP + 0xf8]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001ff860
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x001ff890
MOV qword ptr [RSP + 0x20],RAX
LAB_001f5b61:
LEA RDI,[RSP + 0x28]
LEA RSI,[RSP + 0x20]
CALL 0x001ff8f0
TEST AL,0x1
JNZ 0x001f5b79
JMP 0x001f5c62
LAB_001f5b79:
LEA RDI,[RSP + 0x28]
CALL 0x001ff930
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x1c],EAX
CMP dword ptr [RSP + 0x1c],0x1f
JBE 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x7f
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x80
JC 0x001f5bb7
CMP dword ptr [RSP + 0x1c],0x9f
JBE 0x001f5c3c
LAB_001f5bb7:
CMP dword ptr [RSP + 0x1c],0xff0e
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x2215
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x2216
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0xd800
JC 0x001f5be9
CMP dword ptr [RSP + 0x1c],0xdfff
JBE 0x001f5c3c
LAB_001f5be9:
CMP dword ptr [RSP + 0x1c],0xfffd
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0xfeff
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x2f
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x5c
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x3a
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x2a
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x3f
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x22
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x3c
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x3e
JZ 0x001f5c3c
CMP dword ptr [RSP + 0x1c],0x7c
JNZ 0x001f5c51
LAB_001f5c3c:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f5d29
LAB_001f5c51:
JMP 0x001f5c53
LAB_001f5c53:
LEA RDI,[RSP + 0x28]
CALL 0x001ff940
JMP 0x001f5b61
LAB_001f5c62:
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015a2b0
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001f5ca1
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015b090
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x20
JZ 0x001f5ca1
MOV RDI,qword ptr [RSP + 0x118]
CALL 0x0015b090
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JNZ 0x001f5cb3
LAB_001f5ca1:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f5d29
LAB_001f5cb3:
MOV RDI,qword ptr [RSP + 0x118]
LEA RSI,[0x31258c]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x0015a060
CMP RAX,-0x1
JZ 0x001f5ce3
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f5d29
LAB_001f5ce3:
MOV RDI,qword ptr [RSP + 0x118]
LEA RSI,[0x31258d]
CALL 0x0016af30
LAB_001f5cf7:
MOV byte ptr [RSP + 0x7],AL
JMP 0x001f5cfd
LAB_001f5cfd:
MOV AL,byte ptr [RSP + 0x7]
TEST AL,0x1
JNZ 0x001f5d07
JMP 0x001f5d19
LAB_001f5d07:
MOV byte ptr [RSP + 0x127],0x0
MOV dword ptr [RSP + 0x44],0x1
JMP 0x001f5d29
LAB_001f5d19:
MOV byte ptr [RSP + 0x127],0x1
MOV dword ptr [RSP + 0x44],0x1
LAB_001f5d29:
LEA RDI,[RSP + 0xf8]
CALL 0x001ff730
JMP 0x001f5d47
LAB_001f5d47:
MOV AL,byte ptr [RSP + 0x127]
AND AL,0x1
ADD RSP,0x128
RET
|
/* fs_validate_filename(std::__cxx11::string const&) */
ulong fs_validate_filename(string *param_1)
{
uint uVar1;
bool bVar2;
long lVar3;
ulong uVar4;
uint *puVar5;
char *pcVar6;
int8 local_108;
int8 local_100;
u32string *local_f8;
uint local_e4;
u32string local_e0 [32];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_c0 [48];
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
local_90 [96];
u32string local_30 [32];
string *local_10;
int1 local_1;
local_10 = param_1;
lVar3 = std::__cxx11::string::length();
if (lVar3 == 0) {
local_1 = 0;
uVar4 = 0;
}
else {
uVar4 = std::__cxx11::string::length();
if (uVar4 < 0x100) {
std::__cxx11::u32string::u32string(local_30);
/* try { // try from 001f59de to 001f59ea has its CatchHandler @ 001f5a75 */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::wstring_convert(local_90);
/* try { // try from 001f59f5 to 001f5a45 has its CatchHandler @ 001f5a8b */
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::from_bytes(local_c0,(string *)local_90);
std::__cxx11::u32string::operator=(local_30,(u32string *)local_c0);
std::__cxx11::u32string::~u32string((u32string *)local_c0);
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::to_bytes(local_e0);
bVar2 = std::operator!=((string *)local_e0,local_10);
if (bVar2) {
local_1 = 0;
}
local_e4 = (uint)bVar2;
std::__cxx11::string::~string((string *)local_e0);
std::__cxx11::
wstring_convert<std::codecvt_utf8<char32_t,1114111ul,(std::codecvt_mode)0>,char32_t,std::allocator<char32_t>,std::allocator<char>>
::~wstring_convert(local_90);
if (local_e4 == 0) {
local_f8 = local_30;
local_100 = std::__cxx11::u32string::begin(local_f8);
local_108 = std::__cxx11::u32string::end(local_f8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_100,(__normal_iterator *)&local_108),
bVar2) {
puVar5 = (uint *)__gnu_cxx::__normal_iterator<char32_t*,std::__cxx11::u32string>::
operator*((__normal_iterator<char32_t*,std::__cxx11::u32string> *)
&local_100);
uVar1 = *puVar5;
if ((((((uVar1 < 0x20) || (uVar1 == 0x7f)) || ((0x7f < uVar1 && (uVar1 < 0xa0)))) ||
((uVar1 == 0xff0e || (uVar1 == 0x2215)))) ||
((uVar1 == 0x2216 ||
((((0xd7ff < uVar1 && (uVar1 < 0xe000)) || (uVar1 == 0xfffd)) ||
(((uVar1 == 0xfeff || (uVar1 == 0x2f)) ||
((uVar1 == 0x5c || ((uVar1 == 0x3a || (uVar1 == 0x2a)))))))))))) ||
((uVar1 == 0x3f ||
((((uVar1 == 0x22 || (uVar1 == 0x3c)) || (uVar1 == 0x3e)) || (uVar1 == 0x7c)))))) {
local_1 = 0;
local_e4 = 1;
goto LAB_001f5d29;
}
__gnu_cxx::__normal_iterator<char32_t*,std::__cxx11::u32string>::operator++
((__normal_iterator<char32_t*,std::__cxx11::u32string> *)&local_100);
}
pcVar6 = (char *)std::__cxx11::string::front();
if (((*pcVar6 == ' ') || (pcVar6 = (char *)std::__cxx11::string::back(), *pcVar6 == ' ')) ||
(pcVar6 = (char *)std::__cxx11::string::back(), *pcVar6 == '.')) {
local_1 = 0;
local_e4 = 1;
}
else {
lVar3 = std::__cxx11::string::find((char *)local_10,0x31258c);
if (lVar3 == -1) {
bVar2 = std::operator==(local_10,".");
if (bVar2) {
local_1 = 0;
local_e4 = 1;
}
else {
local_1 = 1;
local_e4 = 1;
}
}
else {
local_1 = 0;
local_e4 = 1;
}
}
}
LAB_001f5d29:
uVar4 = std::__cxx11::u32string::~u32string(local_30);
}
else {
local_1 = 0;
}
}
return CONCAT71((int7)(uVar4 >> 8),local_1) & 0xffffffffffffff01;
}
| |
34,202 | my_strnxfrm_8bit_bin | eloqsql/strings/ctype-bin.c | static size_t
my_strnxfrm_8bit_bin(CHARSET_INFO *cs,
uchar * dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
set_if_smaller(srclen, dstlen);
set_if_smaller(srclen, nweights);
if (srclen && dst != src)
memcpy(dst, src, srclen);
return my_strxfrm_pad_desc_and_reverse(cs, dst, dst + srclen, dst + dstlen,
(uint)(nweights - srclen), flags, 0);
} | O0 | c | my_strnxfrm_8bit_bin:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x36fa4
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x36fa6
jmp 0x36fa8
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x36fbb
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
jmp 0x36fbd
cmpq $0x0, -0x30(%rbp)
je 0x36fdf
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x36fdf
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x24270
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %eax
subq -0x30(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x42d20
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_8bit_bin:
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_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_30]
cmp rax, [rbp+var_18]
jbe short loc_36FA4
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_36FA4:
jmp short $+2
loc_36FA6:
jmp short $+2
loc_36FA8:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_36FBB
mov eax, [rbp+var_1C]
mov [rbp+var_30], rax
loc_36FBB:
jmp short $+2
loc_36FBD:
cmp [rbp+var_30], 0
jz short loc_36FDF
mov rax, [rbp+var_10]
cmp rax, [rbp+var_28]
jz short loc_36FDF
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
call _memcpy
loc_36FDF:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_30]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov eax, [rbp+var_1C]
sub rax, [rbp+var_30]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+40h+var_40], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 40h
pop rbp
retn
| long long my_strnxfrm_8bit_bin(
int a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
int a7)
{
unsigned long long v8; // [rsp+10h] [rbp-30h]
int v10; // [rsp+28h] [rbp-18h]
v10 = a3;
v8 = a6;
if ( a6 > a3 )
v8 = a3;
if ( v8 > a4 )
v8 = a4;
if ( v8 && a2 != a5 )
memcpy(a2, a5, v8);
return my_strxfrm_pad_desc_and_reverse(a1, a2, (int)v8 + (int)a2, v10 + (int)a2, a4 - (unsigned int)v8, a7, 0);
}
| my_strnxfrm_8bit_bin:
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 dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00136fa4
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_00136fa4:
JMP 0x00136fa6
LAB_00136fa6:
JMP 0x00136fa8
LAB_00136fa8:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x00136fbb
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x30],RAX
LAB_00136fbb:
JMP 0x00136fbd
LAB_00136fbd:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00136fdf
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x00136fdf
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x00124270
LAB_00136fdf:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
SUB RAX,qword ptr [RBP + -0x30]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00142d20
ADD RSP,0x40
POP RBP
RET
|
void my_strnxfrm_8bit_bin
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,int4 param_7)
{
int8 local_38;
local_38 = param_6;
if (param_3 < param_6) {
local_38 = param_3;
}
if (param_4 < local_38) {
local_38 = (ulong)param_4;
}
if ((local_38 != 0) && (param_2 != param_5)) {
memcpy(param_2,param_5,local_38);
}
my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + local_38,(long)param_2 + param_3,
param_4 - (int)local_38,param_7,0);
return;
}
| |
34,203 | ftxui::animation::easing::ElasticInOut(float) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/component/animation.cpp | float ElasticInOut(float p) {
if (p < 0.5f) {
return 0.5f * std::sin(13.f * kPi2 * (2.f * p)) *
std::pow(2.f, 10.f * ((2.f * p) - 1.f));
}
return 0.5f * (std::sin(-13.f * kPi2 * ((2.f * p - 1.f) + 1.f)) *
std::pow(2.f, -10.f * (2.f * p - 1.f)) +
2.f);
} | O1 | cpp | ftxui::animation::easing::ElasticInOut(float):
pushq %rax
movaps %xmm0, %xmm1
movss 0x6485(%rip), %xmm0 # 0x3de00
ucomiss %xmm1, %xmm0
jbe 0x379ca
addss %xmm1, %xmm1
movss %xmm1, 0x4(%rsp)
movss 0x89ee(%rip), %xmm0 # 0x40380
mulss %xmm1, %xmm0
callq 0xb330
mulss 0x645d(%rip), %xmm0 # 0x3de00
movss %xmm0, (%rsp)
movss 0x4(%rsp), %xmm0
addss 0x73b2(%rip), %xmm0 # 0x3ed68
mulss 0x89ae(%rip), %xmm0 # 0x4036c
callq 0xb800
mulss (%rsp), %xmm0
jmp 0x37a22
addss %xmm1, %xmm1
addss 0x7392(%rip), %xmm1 # 0x3ed68
movss %xmm1, 0x4(%rsp)
movss 0x6414(%rip), %xmm0 # 0x3ddf8
addss %xmm1, %xmm0
mulss 0x8994(%rip), %xmm0 # 0x40384
callq 0xb330
movss %xmm0, (%rsp)
movss 0x4(%rsp), %xmm0
mulss 0x8968(%rip), %xmm0 # 0x40370
callq 0xb800
mulss (%rsp), %xmm0
addss 0x7352(%rip), %xmm0 # 0x3ed6c
mulss 0x63de(%rip), %xmm0 # 0x3de00
popq %rax
retq
| _ZN5ftxui9animation6easing12ElasticInOutEf:
push rax
movaps xmm1, xmm0
movss xmm0, cs:dword_3DE00
ucomiss xmm0, xmm1
jbe short loc_379CA
addss xmm1, xmm1
movss [rsp+8+var_4], xmm1
movss xmm0, cs:dword_40380
mulss xmm0, xmm1
call _sinf
mulss xmm0, cs:dword_3DE00
movss [rsp+8+var_8], xmm0
movss xmm0, [rsp+8+var_4]
addss xmm0, cs:dword_3ED68
mulss xmm0, cs:dword_4036C
call _exp2f
mulss xmm0, [rsp+8+var_8]
jmp short loc_37A22
loc_379CA:
addss xmm1, xmm1
addss xmm1, cs:dword_3ED68
movss [rsp+8+var_4], xmm1
movss xmm0, cs:dword_3DDF8
addss xmm0, xmm1
mulss xmm0, cs:dword_40384
call _sinf
movss [rsp+8+var_8], xmm0
movss xmm0, [rsp+8+var_4]
mulss xmm0, cs:dword_40370
call _exp2f
mulss xmm0, [rsp+8+var_8]
addss xmm0, cs:dword_3ED6C
mulss xmm0, cs:dword_3DE00
loc_37A22:
pop rax
retn
| long long ftxui::animation::easing::ElasticInOut(ftxui::animation::easing *this, float a2)
{
long long v4; // [rsp+0h] [rbp-8h]
if ( a2 >= 0.5 )
{
*((float *)&v4 + 1) = (float)(a2 + a2) + -1.0;
LODWORD(v4) = sinf(this, (float)(*((float *)&v4 + 1) + 1.0) * -20.420353);
exp2f(this, *((float *)&v4 + 1) * -10.0);
}
else
{
*((float *)&v4 + 1) = a2 + a2;
*(float *)&v4 = sinf(this, 20.420353 * (float)(a2 + a2)) * 0.5;
exp2f(this, (float)((float)(a2 + a2) + -1.0) * 10.0);
}
return v4;
}
| ElasticInOut:
PUSH RAX
MOVAPS XMM1,XMM0
MOVSS XMM0,dword ptr [0x0013de00]
UCOMISS XMM0,XMM1
JBE 0x001379ca
ADDSS XMM1,XMM1
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS XMM0,dword ptr [0x00140380]
MULSS XMM0,XMM1
CALL 0x0010b330
MULSS XMM0,dword ptr [0x0013de00]
MOVSS dword ptr [RSP],XMM0
MOVSS XMM0,dword ptr [RSP + 0x4]
ADDSS XMM0,dword ptr [0x0013ed68]
MULSS XMM0,dword ptr [0x0014036c]
CALL 0x0010b800
MULSS XMM0,dword ptr [RSP]
JMP 0x00137a22
LAB_001379ca:
ADDSS XMM1,XMM1
ADDSS XMM1,dword ptr [0x0013ed68]
MOVSS dword ptr [RSP + 0x4],XMM1
MOVSS XMM0,dword ptr [0x0013ddf8]
ADDSS XMM0,XMM1
MULSS XMM0,dword ptr [0x00140384]
CALL 0x0010b330
MOVSS dword ptr [RSP],XMM0
MOVSS XMM0,dword ptr [RSP + 0x4]
MULSS XMM0,dword ptr [0x00140370]
CALL 0x0010b800
MULSS XMM0,dword ptr [RSP]
ADDSS XMM0,dword ptr [0x0013ed6c]
MULSS XMM0,dword ptr [0x0013de00]
LAB_00137a22:
POP RAX
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ftxui::animation::easing::ElasticInOut(float) */
int8 ftxui::animation::easing::ElasticInOut(float param_1)
{
float fVar1;
float fVar2;
int8 local_8;
if (DAT_0013de00 <= param_1) {
fVar2 = param_1 + param_1 + DAT_0013ed68;
fVar1 = sinf((DAT_0013ddf8 + fVar2) * _DAT_00140384);
local_8 = CONCAT44(fVar2,fVar1);
exp2f(fVar2 * _DAT_00140370);
}
else {
fVar2 = param_1 + param_1;
fVar1 = sinf(DAT_00140380 * fVar2);
local_8 = CONCAT44(fVar2,fVar1 * DAT_0013de00);
exp2f((fVar2 + DAT_0013ed68) * _DAT_0014036c);
}
return local_8;
}
| |
34,204 | inline_mysql_file_rename | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_rename(
#ifdef HAVE_PSI_FILE_INTERFACE
PSI_file_key key, const char *src_file, uint src_line,
#endif
const char *from, const char *to, myf flags)
{
int result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_name_locker)
(&state, key, PSI_FILE_RENAME, from, &locker);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_rename(from, to, flags);
PSI_FILE_CALL(end_file_rename_wait)(locker, from, to, result);
return result;
}
#endif
result= my_rename(from, to, flags);
return result;
} | O3 | c | inline_mysql_file_rename:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %esi
leaq 0x355aaa(%rip), %r13 # 0x387050
movq (%r13), %rax
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %r12
movl $0xf, %edx
movq %r14, %rcx
movq %r12, %r8
callq *0x148(%rax)
movq %rax, (%r12)
testq %rax, %rax
jne 0x315f1
movl $0x10, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa20dc
movl %eax, %r15d
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r13), %r8
leaq 0xa8c1b(%rip), %rdx # 0xda217
movq %rax, %rdi
xorl %esi, %esi
movl %r15d, %ecx
callq *0x210(%r8)
movl $0x10, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa20dc
movl %eax, %r15d
movq (%r13), %rax
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r15d, %ecx
callq *0x230(%rax)
jmp 0x315df
nop
| inline_mysql_file_rename:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rcx
mov r14, rdx
mov r15d, esi
mov esi, edi
lea r13, PSI_server
mov rax, [r13+0]
lea rdi, [rbp+var_78]
lea r12, [rbp+var_30]
mov edx, 0Fh
mov rcx, r14
mov r8, r12
call qword ptr [rax+148h]
mov [r12], rax
test rax, rax
jnz short loc_315F1
mov edx, 10h
mov rdi, r14
mov rsi, rbx
call my_rename
mov r15d, eax
loc_315DF:
mov eax, r15d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_315F1:
mov r8, [r13+0]
lea rdx, aWorkspaceLlm4b_26; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
xor esi, esi
mov ecx, r15d
call qword ptr [r8+210h]
mov edx, 10h
mov rdi, r14
mov rsi, rbx
call my_rename
mov r15d, eax
mov rax, [r13+0]
mov rdi, [rbp+var_30]
mov rsi, r14
mov rdx, rbx
mov ecx, r15d
call qword ptr [rax+230h]
jmp short loc_315DF
| long long inline_mysql_file_rename(unsigned int a1, unsigned int a2, long long a3, long long a4)
{
long long v6; // rax
long long v7; // r15
_BYTE v9[72]; // [rsp+8h] [rbp-78h] BYREF
long long v10[6]; // [rsp+50h] [rbp-30h] BYREF
v6 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v9, a1, 15LL, a3, v10);
v10[0] = v6;
if ( v6 )
{
((void ( *)(long long, _QWORD, const char *, _QWORD))PSI_server[66])(
v6,
0LL,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_init.c",
a2);
v7 = (unsigned int)my_rename(a3, a4, 16LL);
((void ( *)(long long, long long, long long, long long))PSI_server[70])(v10[0], a3, a4, v7);
}
else
{
LODWORD(v7) = my_rename(a3, a4, 16LL);
}
return (unsigned int)v7;
}
| inline_mysql_file_rename:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RCX
MOV R14,RDX
MOV R15D,ESI
MOV ESI,EDI
LEA R13,[0x487050]
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x78]
LEA R12,[RBP + -0x30]
MOV EDX,0xf
MOV RCX,R14
MOV R8,R12
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R12],RAX
TEST RAX,RAX
JNZ 0x001315f1
MOV EDX,0x10
MOV RDI,R14
MOV RSI,RBX
CALL 0x001a20dc
MOV R15D,EAX
LAB_001315df:
MOV EAX,R15D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001315f1:
MOV R8,qword ptr [R13]
LEA RDX,[0x1da217]
MOV RDI,RAX
XOR ESI,ESI
MOV ECX,R15D
CALL qword ptr [R8 + 0x210]
MOV EDX,0x10
MOV RDI,R14
MOV RSI,RBX
CALL 0x001a20dc
MOV R15D,EAX
MOV RAX,qword ptr [R13]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,R14
MOV RDX,RBX
MOV ECX,R15D
CALL qword ptr [RAX + 0x230]
JMP 0x001315df
|
int4
inline_mysql_file_rename
(int4 param_1,int4 param_2,int8 param_3,int8 param_4)
{
int4 uVar1;
int1 local_80 [72];
long local_38;
local_38 = (**(code **)(PSI_server + 0x148))(local_80,param_1,0xf,param_3,&local_38);
if (local_38 == 0) {
uVar1 = my_rename(param_3,param_4,0x10);
}
else {
(**(code **)(PSI_server + 0x210))
(local_38,0,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_init.c",param_2
);
uVar1 = my_rename(param_3,param_4,0x10);
(**(code **)(PSI_server + 0x230))(local_38,param_3,param_4,uVar1);
}
return uVar1;
}
| |
34,205 | get_options(int*, char***) | eloqsql/storage/maria/aria_s3_copy.cc | static void get_options(int *argc, char ***argv)
{
int ho_error;
load_defaults_or_exit("my", load_default_groups, argc, argv);
default_argv= *argv;
if ((ho_error=handle_options(argc, argv, my_long_options, get_one_option)))
my_exit(ho_error);
if (*argc == 0)
{
usage();
my_exit(-1);
}
if (!opt_s3_access_key)
{
fprintf(stderr, "--aws-access-key was not given\n");
my_exit(-1);
}
if (!opt_s3_secret_key)
{
fprintf(stderr, "--aws-secret-access-key was not given\n");
my_exit(-1);
}
if (opt_operation == OP_IMPOSSIBLE)
{
fprintf(stderr, "You must specify an operation with --op=[from_s3|to_s3|delete_from_s3]\n");
my_exit(-1);
}
if (opt_s3_debug)
ms3_debug();
} | O0 | cpp | get_options(int*, char***):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0xf4dff(%rip), %rdi # 0x11d18e
leaq 0x25ecfa(%rip), %rsi # 0x287090
callq 0xaaca0
movl %eax, %ecx
movl %ecx, -0x18(%rbp)
testl %eax, %eax
je 0x283b0
jmp 0x283a6
movl -0x18(%rbp), %eax
subl $0x4, %eax
je 0x283b2
jmp 0x283c0
jmp 0x283d1
xorl %edi, %edi
callq 0xbd720
xorl %edi, %edi
callq 0x275c0
xorl %edi, %edi
callq 0xbd720
movl $0x1, %edi
callq 0x275c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x417e61(%rip) # 0x440240
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x25ecb2(%rip), %rdx # 0x2870a0
leaq -0x6e5(%rip), %rcx # 0x27d10
callq 0xb7780
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x2840a
movl -0x14(%rbp), %edi
callq 0x27da0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x28422
callq 0x27df0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x27da0
cmpq $0x0, 0x417dc6(%rip) # 0x4401f0
jne 0x2844e
movq 0x25eba5(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xf508f(%rip), %rsi # 0x11d4cc
movb $0x0, %al
callq 0x271d0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x27da0
cmpq $0x0, 0x417da2(%rip) # 0x4401f8
jne 0x2847a
movq 0x25eb79(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xf5083(%rip), %rsi # 0x11d4ec
movb $0x0, %al
callq 0x271d0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x27da0
cmpq $0x4, 0x25eba6(%rip) # 0x287028
jne 0x284a6
movq 0x25eb4d(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xf507e(%rip), %rsi # 0x11d513
movb $0x0, %al
callq 0x271d0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
callq 0x27da0
cmpb $0x0, 0x417d9b(%rip) # 0x440248
je 0x284b4
callq 0x2cd90
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZL11get_optionsPiPPPc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdx, [rbp+var_8]
mov rcx, [rbp+var_10]
lea rdi, aMy; "my"
lea rsi, _ZL19load_default_groups; load_default_groups
call load_defaults
mov ecx, eax
mov [rbp+var_18], ecx
test eax, eax
jz short loc_283B0
jmp short $+2
loc_283A6:
mov eax, [rbp+var_18]
sub eax, 4
jz short loc_283B2
jmp short loc_283C0
loc_283B0:
jmp short loc_283D1
loc_283B2:
xor edi, edi
call my_end
xor edi, edi
call _exit
loc_283C0:
xor edi, edi
call my_end
mov edi, 1
call _exit
loc_283D1:
mov rax, [rbp+var_10]
mov rax, [rax]
mov cs:_ZL12default_argv, rax; default_argv
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, _ZL15my_long_options; my_long_options
lea rcx, get_one_option
call handle_options
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_2840A
mov edi, [rbp+var_14]; int
call _ZL7my_exiti; my_exit(int)
loc_2840A:
mov rax, [rbp+var_8]
cmp dword ptr [rax], 0
jnz short loc_28422
call _ZL5usagev; usage(void)
mov edi, 0FFFFFFFFh; int
call _ZL7my_exiti; my_exit(int)
loc_28422:
cmp cs:_ZL17opt_s3_access_key, 0; opt_s3_access_key
jnz short loc_2844E
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aAwsAccessKeyWa; "--aws-access-key was not given\n"
mov al, 0
call _fprintf
mov edi, 0FFFFFFFFh; int
call _ZL7my_exiti; my_exit(int)
loc_2844E:
cmp cs:_ZL17opt_s3_secret_key, 0; opt_s3_secret_key
jnz short loc_2847A
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aAwsSecretAcces; "--aws-secret-access-key was not given\n"
mov al, 0
call _fprintf
mov edi, 0FFFFFFFFh; int
call _ZL7my_exiti; my_exit(int)
loc_2847A:
cmp cs:_ZL13opt_operation, 4; opt_operation
jnz short loc_284A6
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aYouMustSpecify; "You must specify an operation with --op"...
mov al, 0
call _fprintf
mov edi, 0FFFFFFFFh; int
call _ZL7my_exiti; my_exit(int)
loc_284A6:
cmp cs:_ZL12opt_s3_debug, 0; opt_s3_debug
jz short loc_284B4
call ms3_debug
loc_284B4:
add rsp, 20h
pop rbp
retn
| int * get_options(int *a1, char ***a2)
{
unsigned int v2; // eax
int *result; // rax
int defaults; // [rsp+8h] [rbp-18h]
defaults = load_defaults("my", &load_default_groups, a1, a2);
if ( defaults )
{
if ( defaults != 4 )
{
my_end(0LL);
exit(1LL);
}
my_end(0LL);
exit(0LL);
}
default_argv = (long long)*a2;
v2 = handle_options(a1, a2, &my_long_options, get_one_option);
if ( v2 )
my_exit(v2);
result = a1;
if ( !*a1 )
{
usage();
my_exit(0xFFFFFFFF);
}
if ( !opt_s3_access_key )
{
fprintf(stderr, "--aws-access-key was not given\n");
my_exit(0xFFFFFFFF);
}
if ( !opt_s3_secret_key )
{
fprintf(stderr, "--aws-secret-access-key was not given\n");
my_exit(0xFFFFFFFF);
}
if ( opt_operation == 4 )
{
fprintf(stderr, "You must specify an operation with --op=[from_s3|to_s3|delete_from_s3]\n");
my_exit(0xFFFFFFFF);
}
if ( opt_s3_debug )
return (int *)ms3_debug();
return result;
}
| get_options:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
LEA RDI,[0x21d18e]
LEA RSI,[0x387090]
CALL 0x001aaca0
MOV ECX,EAX
MOV dword ptr [RBP + -0x18],ECX
TEST EAX,EAX
JZ 0x001283b0
JMP 0x001283a6
LAB_001283a6:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x4
JZ 0x001283b2
JMP 0x001283c0
LAB_001283b0:
JMP 0x001283d1
LAB_001283b2:
XOR EDI,EDI
CALL 0x001bd720
XOR EDI,EDI
CALL 0x001275c0
LAB_001283c0:
XOR EDI,EDI
CALL 0x001bd720
MOV EDI,0x1
CALL 0x001275c0
LAB_001283d1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [0x00540240],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[0x3870a0]
LEA RCX,[0x127d10]
CALL 0x001b7780
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x0012840a
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x00127da0
LAB_0012840a:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX],0x0
JNZ 0x00128422
CALL 0x00127df0
MOV EDI,0xffffffff
CALL 0x00127da0
LAB_00128422:
CMP qword ptr [0x005401f0],0x0
JNZ 0x0012844e
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x21d4cc]
MOV AL,0x0
CALL 0x001271d0
MOV EDI,0xffffffff
CALL 0x00127da0
LAB_0012844e:
CMP qword ptr [0x005401f8],0x0
JNZ 0x0012847a
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x21d4ec]
MOV AL,0x0
CALL 0x001271d0
MOV EDI,0xffffffff
CALL 0x00127da0
LAB_0012847a:
CMP qword ptr [0x00387028],0x4
JNZ 0x001284a6
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x21d513]
MOV AL,0x0
CALL 0x001271d0
MOV EDI,0xffffffff
CALL 0x00127da0
LAB_001284a6:
CMP byte ptr [0x00540248],0x0
JZ 0x001284b4
CALL 0x0012cd90
LAB_001284b4:
ADD RSP,0x20
POP RBP
RET
|
/* get_options(int*, char***) */
void get_options(int *param_1,char ***param_2)
{
int iVar1;
iVar1 = load_defaults(&DAT_0021d18e,load_default_groups,param_1,param_2);
if (iVar1 == 0) {
default_argv = *param_2;
iVar1 = handle_options(param_1,param_2,my_long_options,get_one_option);
if (iVar1 != 0) {
my_exit(iVar1);
}
if (*param_1 == 0) {
usage();
my_exit(-1);
}
if (opt_s3_access_key == 0) {
fprintf(*(FILE **)PTR_stderr_00386fd8,"--aws-access-key was not given\n");
my_exit(-1);
}
if (opt_s3_secret_key == 0) {
fprintf(*(FILE **)PTR_stderr_00386fd8,"--aws-secret-access-key was not given\n");
my_exit(-1);
}
if (opt_operation == 4) {
fprintf(*(FILE **)PTR_stderr_00386fd8,
"You must specify an operation with --op=[from_s3|to_s3|delete_from_s3]\n");
my_exit(-1);
}
if (opt_s3_debug != '\0') {
ms3_debug();
}
return;
}
if (iVar1 != 4) {
my_end(0);
/* WARNING: Subroutine does not return */
exit(1);
}
my_end();
/* WARNING: Subroutine does not return */
exit(0);
}
| |
34,206 | google::protobuf::compiler::PluginMain(int, char**, google::protobuf::compiler::CodeGenerator const*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/plugin.cc | int PluginMain(int argc, char* argv[], const CodeGenerator* generator) {
if (argc > 1) {
std::cerr << argv[0] << ": Unknown option: " << argv[1] << std::endl;
return 1;
}
#ifdef _WIN32
setmode(STDIN_FILENO, _O_BINARY);
setmode(STDOUT_FILENO, _O_BINARY);
#endif
CodeGeneratorRequest request;
if (!request.ParseFromFileDescriptor(STDIN_FILENO)) {
std::cerr << argv[0] << ": protoc sent unparseable request to plugin."
<< std::endl;
return 1;
}
std::string error_msg;
CodeGeneratorResponse response;
if (GenerateCode(request, *generator, &response, &error_msg)) {
if (!response.SerializeToFileDescriptor(STDOUT_FILENO)) {
std::cerr << argv[0] << ": Error writing to stdout." << std::endl;
return 1;
}
} else {
if (!error_msg.empty()) {
std::cerr << argv[0] << ": " << error_msg << std::endl;
}
return 1;
}
return 0;
} | O3 | cpp | google::protobuf::compiler::PluginMain(int, char**, google::protobuf::compiler::CodeGenerator const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jl 0xaca31
movq (%rbx), %r14
testq %r14, %r14
je 0xacb06
movq %r14, %rdi
callq 0xf180
movq 0x555c7(%rip), %rdi # 0x101fe8
movq %r14, %rsi
movq %rax, %rdx
callq 0xf3a0
jmp 0xacb24
movq %rdx, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xadab2
movq %r15, %rdi
xorl %esi, %esi
callq 0x9dd98
testb %al, %al
je 0xacadb
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xaecb6
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rsi
callq 0xac720
testb %al, %al
je 0xacbad
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x9e412
xorl %ebp, %ebp
testb %al, %al
jne 0xacd25
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xaccc0
movq %rbx, %rdi
callq 0xf180
movq 0x5551d(%rip), %rdi # 0x101fe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf3a0
jmp 0xaccde
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xacbe4
movq %rbx, %rdi
callq 0xf180
movq 0x554f2(%rip), %rdi # 0x101fe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf3a0
jmp 0xacc02
movq 0x554db(%rip), %rax # 0x101fe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0xf530
movq 0x554bd(%rip), %r14 # 0x101fe8
leaq 0x12dca(%rip), %rsi # 0xbf8fc
movl $0x12, %edx
movq %r14, %rdi
callq 0xf3a0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xacb64
movq %rbx, %rdi
callq 0xf180
movq 0x55491(%rip), %rdi # 0x101fe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf3a0
jmp 0xacb7c
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xf530
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xf340
movsbl %al, %esi
movq %r14, %rdi
callq 0xf040
movq %rax, %rdi
callq 0xf260
movl $0x1, %ebp
jmp 0xacd47
cmpq $0x0, 0x8(%rsp)
je 0xacc52
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xacc5c
movq %rbx, %rdi
callq 0xf180
movq 0x55414(%rip), %rdi # 0x101fe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0xf3a0
jmp 0xacc7a
movq 0x553fd(%rip), %rax # 0x101fe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0xf530
movq 0x553df(%rip), %rbx # 0x101fe8
leaq 0x12cff(%rip), %rsi # 0xbf90f
movl $0x2c, %edx
movq %rbx, %rdi
callq 0xf3a0
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0xf340
movsbl %al, %esi
movq 0x553ad(%rip), %rdi # 0x101fe8
callq 0xf040
movl $0x1, %ebp
movq %rax, %rdi
callq 0xf260
jmp 0xacd3d
movl $0x1, %ebp
jmp 0xacd25
movq 0x55385(%rip), %rax # 0x101fe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0xf530
movq 0x55367(%rip), %rdi # 0x101fe8
leaq 0xd7c2(%rip), %rsi # 0xba44a
movl $0x2, %edx
callq 0xf3a0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x55346(%rip), %rdi # 0x101fe8
callq 0xf3a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xf340
jmp 0xacd0d
movq 0x55321(%rip), %rax # 0x101fe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0xf530
movq 0x55303(%rip), %rbx # 0x101fe8
leaq 0x12c50(%rip), %rsi # 0xbf93c
movl $0x1a, %edx
movq %rbx, %rdi
callq 0xf3a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xf340
movsbl %al, %esi
movq %rbx, %rdi
callq 0xf040
movl $0x1, %ebp
movq %rax, %rdi
callq 0xf260
leaq 0x20(%rsp), %rdi
callq 0xaedc8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xacd3d
callq 0xf330
leaq 0x60(%rsp), %rdi
callq 0xadc3e
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xacd69
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xaedc8
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xacd7c
callq 0xf330
jmp 0xacd7c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0xadc3e
movq %rbx, %rdi
callq 0xf570
| _ZN6google8protobuf8compiler10PluginMainEiPPcPKNS1_13CodeGeneratorE:
push rbp
push r15
push r14
push rbx
sub rsp, 0B8h
mov rbx, rsi
cmp edi, 2
jl short loc_ACA31
mov r14, [rbx]
test r14, r14
jz loc_ACB06
mov rdi, r14
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_ACB24
loc_ACA31:
mov r14, rdx
lea r15, [rsp+0D8h+var_78]
mov rdi, r15
xor esi, esi
xor edx, edx
call _ZN6google8protobuf8compiler20CodeGeneratorRequestC2EPNS0_5ArenaEb; google::protobuf::compiler::CodeGeneratorRequest::CodeGeneratorRequest(google::protobuf::Arena *,bool)
mov rdi, r15; this
xor esi, esi; int
call _ZN6google8protobuf11MessageLite23ParseFromFileDescriptorEi; google::protobuf::MessageLite::ParseFromFileDescriptor(int)
test al, al
jz loc_ACADB
lea r15, [rsp+0D8h+var_C8]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
lea rdi, [rsp+0D8h+var_B8]
xor esi, esi
xor edx, edx
call _ZN6google8protobuf8compiler21CodeGeneratorResponseC2EPNS0_5ArenaEb; google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse(google::protobuf::Arena *,bool)
lea rdi, [rsp+0D8h+var_78]; int
lea rdx, [rsp+0D8h+var_B8]; int
mov rcx, rsp; int
mov rsi, r14; int
call _ZN6google8protobuf8compiler12GenerateCodeERKNS1_20CodeGeneratorRequestERKNS1_13CodeGeneratorEPNS1_21CodeGeneratorResponseEPNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::compiler::GenerateCode(google::protobuf::compiler::CodeGeneratorRequest const&,google::protobuf::compiler::CodeGenerator const&,google::protobuf::compiler::CodeGeneratorResponse *,std::string *)
test al, al
jz loc_ACBAD
lea rdi, [rsp+0D8h+var_B8]; this
mov esi, 1; int
call _ZNK6google8protobuf11MessageLite25SerializeToFileDescriptorEi; google::protobuf::MessageLite::SerializeToFileDescriptor(int)
xor ebp, ebp
test al, al
jnz loc_ACD25
mov rbx, [rbx]
test rbx, rbx
jz loc_ACCC0
mov rdi, rbx
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, rbx
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_ACCDE
loc_ACADB:
mov rbx, [rbx]
test rbx, rbx
jz loc_ACBE4
mov rdi, rbx
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, rbx
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_ACC02
loc_ACB06:
mov rax, cs:_ZSt4cerr_ptr
mov rcx, [rax]
mov rcx, [rcx-18h]
lea rdi, [rax+rcx]
mov esi, [rax+rcx+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_ACB24:
mov r14, cs:_ZSt4cerr_ptr
lea rsi, aUnknownOption; ": Unknown option: "
mov edx, 12h
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, [rbx+8]
test rbx, rbx
jz short loc_ACB64
mov rdi, rbx
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, rbx
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_ACB7C
loc_ACB64:
mov rax, [r14]
mov rax, [rax-18h]
lea rdi, [r14+rax]
mov esi, [r14+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_ACB7C:
mov rax, [r14]
mov rdi, [rax-18h]
add rdi, r14
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r14; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
mov ebp, 1
jmp loc_ACD47
loc_ACBAD:
cmp [rsp+0D8h+var_D0], 0
jz loc_ACC52
mov rbx, [rbx]
test rbx, rbx
jz loc_ACC5C
mov rdi, rbx
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, rbx
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp loc_ACC7A
loc_ACBE4:
mov rax, cs:_ZSt4cerr_ptr
mov rcx, [rax]
mov rcx, [rcx-18h]
lea rdi, [rax+rcx]
mov esi, [rax+rcx+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_ACC02:
mov rbx, cs:_ZSt4cerr_ptr
lea rsi, aProtocSentUnpa; ": protoc sent unparseable request to pl"...
mov edx, 2Ch ; ','
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [rbx]
add rbx, [rax-18h]
mov rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, cs:_ZSt4cerr_ptr; this
call __ZNSo3putEc; std::ostream::put(char)
mov ebp, 1
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
jmp loc_ACD3D
loc_ACC52:
mov ebp, 1
jmp loc_ACD25
loc_ACC5C:
mov rax, cs:_ZSt4cerr_ptr
mov rcx, [rax]
mov rcx, [rcx-18h]
lea rdi, [rax+rcx]
mov esi, [rax+rcx+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_ACC7A:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aField+0Fh; ": "
mov edx, 2
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rsi, [rsp+0D8h+var_D8]
mov rdx, [rsp+0D8h+var_D0]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rbx, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
jmp short loc_ACD0D
loc_ACCC0:
mov rax, cs:_ZSt4cerr_ptr
mov rcx, [rax]
mov rcx, [rcx-18h]
lea rdi, [rax+rcx]
mov esi, [rax+rcx+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_ACCDE:
mov rbx, cs:_ZSt4cerr_ptr
lea rsi, aErrorWritingTo; ": Error writing to stdout."
mov edx, 1Ah
mov rdi, rbx
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rax, [rbx]
mov rdi, [rax-18h]
add rdi, rbx
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
loc_ACD0D:
movsx esi, al; char
mov rdi, rbx; this
call __ZNSo3putEc; std::ostream::put(char)
mov ebp, 1
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
loc_ACD25:
lea rdi, [rsp+0D8h+var_B8]; this
call _ZN6google8protobuf8compiler21CodeGeneratorResponseD2Ev; google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse()
mov rdi, [rsp+0D8h+var_D8]; void *
cmp rdi, r15
jz short loc_ACD3D
call __ZdlPv; operator delete(void *)
loc_ACD3D:
lea rdi, [rsp+0D8h+var_78]; this
call _ZN6google8protobuf8compiler20CodeGeneratorRequestD2Ev; google::protobuf::compiler::CodeGeneratorRequest::~CodeGeneratorRequest()
loc_ACD47:
mov eax, ebp
add rsp, 0B8h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
jmp short loc_ACD69
mov rbx, rax
lea rdi, [rsp+arg_18]; this
call _ZN6google8protobuf8compiler21CodeGeneratorResponseD2Ev; google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse()
loc_ACD69:
mov rdi, [rsp+0]; void *
cmp rdi, r15
jz short loc_ACD7C
call __ZdlPv; operator delete(void *)
jmp short loc_ACD7C
mov rbx, rax
loc_ACD7C:
lea rdi, [rsp+arg_58]; this
call _ZN6google8protobuf8compiler20CodeGeneratorRequestD2Ev; google::protobuf::compiler::CodeGeneratorRequest::~CodeGeneratorRequest()
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::compiler::PluginMain(
google::protobuf::compiler *this,
_QWORD *a2,
char **a3,
const google::protobuf::compiler::CodeGenerator *a4)
{
long long v4; // r14
long long v5; // rax
unsigned int v7; // ebp
long long v8; // rbx
long long v9; // rax
long long v10; // rbx
long long v11; // rax
long long v12; // rbx
long long v13; // rax
char v14; // al
std::ostream *v15; // rax
long long v16; // rbx
long long v17; // rax
char v18; // al
std::ostream *v19; // rax
std::ostream *v20; // rbx
char v21; // al
std::ostream *v22; // rax
void *v24; // [rsp+0h] [rbp-D8h] BYREF
long long v25; // [rsp+8h] [rbp-D0h]
_BYTE v26[16]; // [rsp+10h] [rbp-C8h] BYREF
int v27[16]; // [rsp+20h] [rbp-B8h] BYREF
int v28[30]; // [rsp+60h] [rbp-78h] BYREF
if ( (int)this < 2 )
{
google::protobuf::compiler::CodeGeneratorRequest::CodeGeneratorRequest(
(google::protobuf::compiler::CodeGeneratorRequest *)v28,
0LL,
0);
if ( !google::protobuf::MessageLite::ParseFromFileDescriptor((google::protobuf::MessageLite *)v28, 0) )
{
v10 = *a2;
if ( *a2 )
{
v11 = strlen(v10);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v10, v11);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
": protoc sent unparseable request to plugin.",
44LL);
v18 = std::ios::widen((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL), 10LL);
v19 = (std::ostream *)std::ostream::put((std::ostream *)&std::cerr, v18);
v7 = 1;
std::ostream::flush(v19);
LABEL_29:
google::protobuf::compiler::CodeGeneratorRequest::~CodeGeneratorRequest((google::protobuf::compiler::CodeGeneratorRequest *)v28);
return v7;
}
v24 = v26;
v25 = 0LL;
v26[0] = 0;
google::protobuf::compiler::CodeGeneratorResponse::CodeGeneratorResponse(
(google::protobuf::compiler::CodeGeneratorResponse *)v27,
0LL,
0);
if ( (unsigned __int8)google::protobuf::compiler::GenerateCode((long long)v28, (long long)a3, (long long)v27, &v24) )
{
v7 = 0;
if ( (unsigned __int8)google::protobuf::MessageLite::SerializeToFileDescriptor(
(google::protobuf::MessageLite *)v27,
1) )
goto LABEL_27;
v8 = *a2;
if ( *a2 )
{
v9 = strlen(v8);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v8, v9);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
v20 = (std::ostream *)&std::cerr;
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, ": Error writing to stdout.", 26LL);
v21 = std::ios::widen((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL), 10LL);
}
else
{
if ( !v25 )
{
v7 = 1;
goto LABEL_27;
}
v16 = *a2;
if ( *a2 )
{
v17 = strlen(v16);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v16, v17);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, ": ", 2LL);
v20 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v24, v25);
v21 = std::ios::widen((char *)v20 + *(_QWORD *)(*(_QWORD *)v20 - 24LL), 10LL);
}
v22 = (std::ostream *)std::ostream::put(v20, v21);
v7 = 1;
std::ostream::flush(v22);
LABEL_27:
google::protobuf::compiler::CodeGeneratorResponse::~CodeGeneratorResponse((google::protobuf::compiler::CodeGeneratorResponse *)v27);
if ( v24 != v26 )
operator delete(v24);
goto LABEL_29;
}
v4 = *a2;
if ( *a2 )
{
v5 = strlen(*a2);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v4, v5);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, ": Unknown option: ", 18LL);
v12 = a2[1];
if ( v12 )
{
v13 = strlen(v12);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, v12, v13);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
v14 = std::ios::widen((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL), 10LL);
v15 = (std::ostream *)std::ostream::put((std::ostream *)&std::cerr, v14);
std::ostream::flush(v15);
return 1;
}
| PluginMain:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xb8
MOV RBX,RSI
CMP EDI,0x2
JL 0x001aca31
MOV R14,qword ptr [RBX]
TEST R14,R14
JZ 0x001acb06
MOV RDI,R14
CALL 0x0010f180
MOV RDI,qword ptr [0x00201fe8]
MOV RSI,R14
MOV RDX,RAX
CALL 0x0010f3a0
JMP 0x001acb24
LAB_001aca31:
MOV R14,RDX
LEA R15,[RSP + 0x60]
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001adab2
LAB_001aca45:
MOV RDI,R15
XOR ESI,ESI
CALL 0x0019dd98
TEST AL,AL
JZ 0x001acadb
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
LAB_001aca6c:
LEA RDI,[RSP + 0x20]
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001aecb6
LAB_001aca7a:
LEA RDI,[RSP + 0x60]
LEA RDX,[RSP + 0x20]
MOV RCX,RSP
MOV RSI,R14
CALL 0x001ac720
TEST AL,AL
JZ 0x001acbad
LEA RDI,[RSP + 0x20]
MOV ESI,0x1
CALL 0x0019e412
XOR EBP,EBP
TEST AL,AL
JNZ 0x001acd25
MOV RBX,qword ptr [RBX]
TEST RBX,RBX
JZ 0x001accc0
MOV RDI,RBX
CALL 0x0010f180
MOV RDI,qword ptr [0x00201fe8]
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0010f3a0
JMP 0x001accde
LAB_001acadb:
MOV RBX,qword ptr [RBX]
TEST RBX,RBX
JZ 0x001acbe4
MOV RDI,RBX
CALL 0x0010f180
LAB_001acaef:
MOV RDI,qword ptr [0x00201fe8]
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0010f3a0
LAB_001acb01:
JMP 0x001acc02
LAB_001acb06:
MOV RAX,qword ptr [0x00201fe8]
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
LEA RDI,[RAX + RCX*0x1]
MOV ESI,dword ptr [RAX + RCX*0x1 + 0x20]
OR ESI,0x1
CALL 0x0010f530
LAB_001acb24:
MOV R14,qword ptr [0x00201fe8]
LEA RSI,[0x1bf8fc]
MOV EDX,0x12
MOV RDI,R14
CALL 0x0010f3a0
MOV RBX,qword ptr [RBX + 0x8]
TEST RBX,RBX
JZ 0x001acb64
MOV RDI,RBX
CALL 0x0010f180
MOV RDI,qword ptr [0x00201fe8]
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0010f3a0
JMP 0x001acb7c
LAB_001acb64:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[R14 + RAX*0x1]
MOV ESI,dword ptr [R14 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x0010f530
LAB_001acb7c:
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R14
MOV ESI,0xa
CALL 0x0010f340
MOVSX ESI,AL
MOV RDI,R14
CALL 0x0010f040
MOV RDI,RAX
CALL 0x0010f260
MOV EBP,0x1
JMP 0x001acd47
LAB_001acbad:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x001acc52
MOV RBX,qword ptr [RBX]
TEST RBX,RBX
JZ 0x001acc5c
MOV RDI,RBX
CALL 0x0010f180
LAB_001acbcd:
MOV RDI,qword ptr [0x00201fe8]
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0010f3a0
JMP 0x001acc7a
LAB_001acbe4:
MOV RAX,qword ptr [0x00201fe8]
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
LEA RDI,[RAX + RCX*0x1]
MOV ESI,dword ptr [RAX + RCX*0x1 + 0x20]
OR ESI,0x1
LAB_001acbfd:
CALL 0x0010f530
LAB_001acc02:
MOV RBX,qword ptr [0x00201fe8]
LEA RSI,[0x1bf90f]
MOV EDX,0x2c
MOV RDI,RBX
CALL 0x0010f3a0
MOV RAX,qword ptr [RBX]
ADD RBX,qword ptr [RAX + -0x18]
MOV RDI,RBX
MOV ESI,0xa
CALL 0x0010f340
MOVSX ESI,AL
MOV RDI,qword ptr [0x00201fe8]
CALL 0x0010f040
MOV EBP,0x1
MOV RDI,RAX
CALL 0x0010f260
JMP 0x001acd3d
LAB_001acc52:
MOV EBP,0x1
JMP 0x001acd25
LAB_001acc5c:
MOV RAX,qword ptr [0x00201fe8]
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
LEA RDI,[RAX + RCX*0x1]
MOV ESI,dword ptr [RAX + RCX*0x1 + 0x20]
OR ESI,0x1
LAB_001acc75:
CALL 0x0010f530
LAB_001acc7a:
MOV RDI,qword ptr [0x00201fe8]
LEA RSI,[0x1ba44a]
MOV EDX,0x2
CALL 0x0010f3a0
MOV RSI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [0x00201fe8]
CALL 0x0010f3a0
MOV RBX,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,RBX
MOV ESI,0xa
CALL 0x0010f340
JMP 0x001acd0d
LAB_001accc0:
MOV RAX,qword ptr [0x00201fe8]
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
LEA RDI,[RAX + RCX*0x1]
MOV ESI,dword ptr [RAX + RCX*0x1 + 0x20]
OR ESI,0x1
CALL 0x0010f530
LAB_001accde:
MOV RBX,qword ptr [0x00201fe8]
LEA RSI,[0x1bf93c]
MOV EDX,0x1a
MOV RDI,RBX
CALL 0x0010f3a0
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,RBX
MOV ESI,0xa
CALL 0x0010f340
LAB_001acd0d:
MOVSX ESI,AL
MOV RDI,RBX
CALL 0x0010f040
MOV EBP,0x1
MOV RDI,RAX
CALL 0x0010f260
LAB_001acd25:
LEA RDI,[RSP + 0x20]
CALL 0x001aedc8
MOV RDI,qword ptr [RSP]
CMP RDI,R15
JZ 0x001acd3d
CALL 0x0010f330
LAB_001acd3d:
LEA RDI,[RSP + 0x60]
CALL 0x001adc3e
LAB_001acd47:
MOV EAX,EBP
ADD RSP,0xb8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::compiler::PluginMain(int, char**, google::protobuf::compiler::CodeGenerator
const*) */
int8 google::protobuf::compiler::PluginMain(int param_1,char **param_2,CodeGenerator *param_3)
{
char *pcVar1;
int *puVar2;
char cVar3;
size_t sVar4;
ostream *poVar5;
int8 uVar6;
char *local_d8;
long local_d0;
char local_c8 [16];
CodeGeneratorResponse local_b8 [64];
CodeGeneratorRequest local_78 [88];
if (1 < param_1) {
pcVar1 = *param_2;
if (pcVar1 == (char *)0x0) {
std::ios::clear(PTR_cerr_00201fe8 + *(long *)(*(long *)PTR_cerr_00201fe8 + -0x18),
*(uint *)(PTR_cerr_00201fe8 +
*(long *)(*(long *)PTR_cerr_00201fe8 + -0x18) + 0x20) | 1);
}
else {
sVar4 = strlen(pcVar1);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00201fe8,pcVar1,sVar4);
}
puVar2 = PTR_cerr_00201fe8;
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00201fe8,": Unknown option: ",0x12);
pcVar1 = param_2[1];
if (pcVar1 == (char *)0x0) {
std::ios::clear(puVar2 + *(long *)(*(long *)puVar2 + -0x18),
*(uint *)(puVar2 + *(long *)(*(long *)puVar2 + -0x18) + 0x20) | 1);
}
else {
sVar4 = strlen(pcVar1);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00201fe8,pcVar1,sVar4);
}
std::ios::widen((char)*(int8 *)(*(long *)puVar2 + -0x18) + (char)puVar2);
std::ostream::put((char)puVar2);
std::ostream::flush();
return 1;
}
CodeGeneratorRequest::CodeGeneratorRequest(local_78,(Arena *)0x0,false);
/* try { // try from 001aca45 to 001aca4e has its CatchHandler @ 001acd79 */
cVar3 = MessageLite::ParseFromFileDescriptor((MessageLite *)local_78,0);
if (cVar3 == '\0') {
pcVar1 = *param_2;
if (pcVar1 == (char *)0x0) {
/* try { // try from 001acbfd to 001acc4c has its CatchHandler @ 001acd79 */
std::ios::clear(PTR_cerr_00201fe8 + *(long *)(*(long *)PTR_cerr_00201fe8 + -0x18),
*(uint *)(PTR_cerr_00201fe8 +
*(long *)(*(long *)PTR_cerr_00201fe8 + -0x18) + 0x20) | 1);
}
else {
sVar4 = strlen(pcVar1);
/* try { // try from 001acaef to 001acb00 has its CatchHandler @ 001acd79 */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00201fe8,pcVar1,sVar4);
}
puVar2 = PTR_cerr_00201fe8;
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00201fe8,": protoc sent unparseable request to plugin.",0x2c);
std::ios::widen((char)puVar2 + (char)*(int8 *)(*(long *)puVar2 + -0x18));
std::ostream::put((char)PTR_cerr_00201fe8);
uVar6 = 1;
std::ostream::flush();
goto LAB_001acd3d;
}
local_d0 = 0;
local_c8[0] = '\0';
/* try { // try from 001aca6c to 001aca79 has its CatchHandler @ 001acd57 */
local_d8 = local_c8;
CodeGeneratorResponse::CodeGeneratorResponse(local_b8,(Arena *)0x0,false);
/* try { // try from 001aca7a to 001acad5 has its CatchHandler @ 001acd5c */
cVar3 = GenerateCode(local_78,param_3,local_b8,(string *)&local_d8);
if (cVar3 == '\0') {
if (local_d0 != 0) {
pcVar1 = *param_2;
if (pcVar1 == (char *)0x0) {
/* try { // try from 001acc75 to 001acd24 has its CatchHandler @ 001acd5c */
std::ios::clear(PTR_cerr_00201fe8 + *(long *)(*(long *)PTR_cerr_00201fe8 + -0x18),
*(uint *)(PTR_cerr_00201fe8 +
*(long *)(*(long *)PTR_cerr_00201fe8 + -0x18) + 0x20) | 1);
}
else {
sVar4 = strlen(pcVar1);
/* try { // try from 001acbcd to 001acbde has its CatchHandler @ 001acd5c */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00201fe8,pcVar1,sVar4);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_00201fe8,": ",2);
poVar5 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00201fe8,local_d8,local_d0);
std::ios::widen((char)*(int8 *)(*(long *)poVar5 + -0x18) + (char)poVar5);
goto LAB_001acd0d;
}
uVar6 = 1;
}
else {
cVar3 = MessageLite::SerializeToFileDescriptor((MessageLite *)local_b8,1);
uVar6 = 0;
if (cVar3 == '\0') {
pcVar1 = *param_2;
if (pcVar1 == (char *)0x0) {
std::ios::clear(PTR_cerr_00201fe8 + *(long *)(*(long *)PTR_cerr_00201fe8 + -0x18),
*(uint *)(PTR_cerr_00201fe8 +
*(long *)(*(long *)PTR_cerr_00201fe8 + -0x18) + 0x20) | 1);
}
else {
sVar4 = strlen(pcVar1);
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00201fe8,pcVar1,sVar4);
}
poVar5 = (ostream *)PTR_cerr_00201fe8;
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00201fe8,": Error writing to stdout.",0x1a);
std::ios::widen((char)*(int8 *)(*(long *)poVar5 + -0x18) + (char)poVar5);
LAB_001acd0d:
std::ostream::put((char)poVar5);
uVar6 = 1;
std::ostream::flush();
}
}
CodeGeneratorResponse::~CodeGeneratorResponse(local_b8);
if (local_d8 != local_c8) {
operator_delete(local_d8);
}
LAB_001acd3d:
CodeGeneratorRequest::~CodeGeneratorRequest(local_78);
return uVar6;
}
| |
34,207 | mthd_my_skip_result | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void mthd_my_skip_result(MYSQL *mysql)
{
ulong pkt_len;
do {
pkt_len= ma_net_safe_read(mysql);
if (pkt_len == packet_error)
break;
} while (pkt_len > 8 || mysql->net.read_pos[0] != 254);
return;
} | O3 | c | mthd_my_skip_result:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x15e47
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %r14, %rax
je 0x16afd
cmpq $0x8, %rax
ja 0x16af3
movq 0x20(%rbx), %rax
cmpb $-0x2, (%rax)
je 0x16afd
movq %rbx, %rdi
callq 0x15e47
jmp 0x16adf
popq %rbx
popq %r14
popq %rbp
retq
| mthd_my_skip_result:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call ma_net_safe_read
mov r14d, 0FFFFFFFFh
loc_16ADF:
cmp rax, r14
jz short loc_16AFD
cmp rax, 8
ja short loc_16AF3
mov rax, [rbx+20h]
cmp byte ptr [rax], 0FEh
jz short loc_16AFD
loc_16AF3:
mov rdi, rbx
call ma_net_safe_read
jmp short loc_16ADF
loc_16AFD:
pop rbx
pop r14
pop rbp
retn
| _BYTE * mthd_my_skip_result(long long a1, long long a2, long long a3, long long a4, unsigned long long a5, int a6)
{
_BYTE *result; // rax
while ( 1 )
{
result = (_BYTE *)ma_net_safe_read(a1, a2, a3, a4, a5, a6);
if ( result == (_BYTE *)0xFFFFFFFFLL )
break;
if ( (unsigned long long)result <= 8 )
{
result = *(_BYTE **)(a1 + 32);
if ( *result == 0xFE )
break;
}
}
return result;
}
| mthd_my_skip_result:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x00115e47
MOV R14D,0xffffffff
LAB_00116adf:
CMP RAX,R14
JZ 0x00116afd
CMP RAX,0x8
JA 0x00116af3
MOV RAX,qword ptr [RBX + 0x20]
CMP byte ptr [RAX],0xfe
JZ 0x00116afd
LAB_00116af3:
MOV RDI,RBX
CALL 0x00115e47
JMP 0x00116adf
LAB_00116afd:
POP RBX
POP R14
POP RBP
RET
|
void mthd_my_skip_result(long param_1)
{
ulong uVar1;
uVar1 = ma_net_safe_read();
while ((uVar1 != 0xffffffff && ((8 < uVar1 || (**(char **)(param_1 + 0x20) != -2))))) {
uVar1 = ma_net_safe_read(param_1);
}
return;
}
| |
34,208 | POINTonE2_mult_w5 | corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/e2.c | POINT_AFFINE_MULT_SCALAR_IMPL(POINTonE2)
DECLARE_PRIVATE_POINTXZ(POINTonE2, 384x)
POINT_LADDER_PRE_IMPL(POINTonE2, 384x, fp2)
POINT_LADDER_STEP_IMPL_A0(POINTonE2, 384x, fp2, onE2)
POINT_LADDER_POST_IMPL_A0(POINTonE2, 384x, fp2, onE2)
POINT_MULT_SCALAR_LADDER_IMPL(POINTonE2)
#endif
static void psi(POINTonE2 *out, const POINTonE2 *in)
{
static const vec384x frobenius_x = { /* 1/(1 + i)^((P-1)/3) */
{ 0 },
{ /* (0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4
897d29650fb85f9b409427eb4f49fffd8bfd00000000aaad << 384) % P */
TO_LIMB_T(0x890dc9e4867545c3), TO_LIMB_T(0x2af322533285a5d5),
TO_LIMB_T(0x50880866309b7e2c), TO_LIMB_T(0xa20d1b8c7e881024),
TO_LIMB_T(0x14e4f04fe2db9068), TO_LIMB_T(0x14e56d3f1564853a) }
};
static const vec384x frobenius_y = { /* 1/(1 + i)^((P-1)/2) */
{ /* (0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60
ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2 << 384) % P */
TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),
TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),
TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },
{ /* (0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e
77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09 << 384) % P */
TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),
TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),
TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) },
};
vec_copy(out, in, sizeof(*out));
cneg_fp(out->X[1], out->X[1], 1); mul_fp2(out->X, out->X, frobenius_x);
cneg_fp(out->Y[1], out->Y[1], 1); mul_fp2(out->Y, out->Y, frobenius_y);
cneg_fp(out->Z[1], out->Z[1], 1);
}
/* Galbraith-Lin-Scott, ~67% faster than POINTonE2_mul_w5 */
static void POINTonE2_mult_gls(POINTonE2 *out, const POINTonE2 *in,
const pow256 SK)
{
union { vec256 l; pow256 s; } val;
/* break down SK to "digits" with |z| as radix [in constant time] */
limbs_from_le_bytes(val.l, SK, 32);
div_by_zz(val.l);
div_by_z(val.l);
div_by_z(val.l + NLIMBS(256)/2);
le_bytes_from_limbs(val.s, val.l, 32);
{
const byte *scalars[2] = { val.s, NULL };
POINTonE2 table[4][1<<(5-1)]; /* 18KB */
size_t i;
POINTonE2_precompute_w5(table[0], in);
for (i = 0; i < 1<<(5-1); i++) {
psi(&table[1][i], &table[0][i]);
psi(&table[2][i], &table[1][i]);
psi(&table[3][i], &table[2][i]);
POINTonE2_cneg(&table[1][i], 1); /* account for z being negative */
POINTonE2_cneg(&table[3][i], 1);
}
POINTonE2s_mult_w5(out, NULL, 4, scalars, 64, table);
}
vec_zero(val.l, sizeof(val)); /* scrub the copy of SK */
} | O1 | c | POINTonE2_mult_w5:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl %r14d, %ebx
andl $0x1f, %ebx
movl $0x120, %edx # imm = 0x120
callq 0x5060
addq $0x120, %r12 # imm = 0x120
movl $0x2, %r13d
movq %r13, %rcx
xorq %rbx, %rcx
decq %rcx
shrq $0x3f, %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x303e0
incq %r13
addq $0x120, %r12 # imm = 0x120
cmpq $0x11, %r13
jne 0x270c0
shrl $0x5, %r14d
andl $0x1, %r14d
leaq 0x60(%r15), %rdi
leaq 0x18a22(%rip), %r12 # 0x3fb20
movq %rdi, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2fa00
addq $0x90, %r15
movq %r15, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2fa00
decq %rbx
shrq $0x3f, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| POINTonE2_gather_booth_w5:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r12, rsi
mov r15, rdi
mov ebx, r14d
and ebx, 1Fh
mov edx, 120h
call _memcpy
add r12, 120h
mov r13d, 2
loc_270C0:
mov rcx, r13
xor rcx, rbx
dec rcx
shr rcx, 3Fh
mov rdi, r15
mov rsi, r12
mov rdx, r15
call vec_select_288
inc r13
add r12, 120h
cmp r13, 11h
jnz short loc_270C0
shr r14d, 5
and r14d, 1
lea rdi, [r15+60h]
lea r12, BLS12_381_P
mov rsi, rdi
mov rdx, r14
mov rcx, r12
call cneg_mod_384
add r15, 90h
mov rdi, r15
mov rsi, r15
mov rdx, r14
mov rcx, r12
call cneg_mod_384
dec rbx
shr rbx, 3Fh
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long POINTonE2_gather_booth_w5(long long a1, long long a2, unsigned int a3)
{
long long v4; // rbx
long long v5; // r12
long long i; // r13
unsigned int v7; // r14d
v4 = a3 & 0x1F;
memcpy(a1, a2, 288LL);
v5 = a2 + 288;
for ( i = 2LL; i != 17; ++i )
{
vec_select_288(a1, v5, a1, ((v4 ^ (unsigned long long)i) - 1) >> 63);
v5 += 288LL;
}
v7 = (a3 >> 5) & 1;
cneg_mod_384(a1 + 96, a1 + 96, v7, &BLS12_381_P);
cneg_mod_384(a1 + 144, a1 + 144, v7, &BLS12_381_P);
return (unsigned long long)(v4 - 1) >> 63;
}
| POINTonE2_gather_booth_w5:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R12,RSI
MOV R15,RDI
MOV EBX,R14D
AND EBX,0x1f
MOV EDX,0x120
CALL 0x00105060
ADD R12,0x120
MOV R13D,0x2
LAB_001270c0:
MOV RCX,R13
XOR RCX,RBX
DEC RCX
SHR RCX,0x3f
MOV RDI,R15
MOV RSI,R12
MOV RDX,R15
CALL 0x001303e0
INC R13
ADD R12,0x120
CMP R13,0x11
JNZ 0x001270c0
SHR R14D,0x5
AND R14D,0x1
LEA RDI,[R15 + 0x60]
LEA R12,[0x13fb20]
MOV RSI,RDI
MOV RDX,R14
MOV RCX,R12
CALL 0x0012fa00
ADD R15,0x90
MOV RDI,R15
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
CALL 0x0012fa00
DEC RBX
SHR RBX,0x3f
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong POINTonE2_gather_booth_w5(void *param_1,void *param_2,uint param_3)
{
long lVar1;
ulong uVar2;
uint uVar3;
memcpy(param_1,param_2,0x120);
lVar1 = (long)param_2 + 0x120;
uVar2 = 2;
do {
vec_select_288(param_1,lVar1,param_1,(uVar2 ^ param_3 & 0x1f) - 1 >> 0x3f);
uVar2 = uVar2 + 1;
lVar1 = lVar1 + 0x120;
} while (uVar2 != 0x11);
uVar3 = param_3 >> 5 & 1;
cneg_mod_384((long)param_1 + 0x60,(long)param_1 + 0x60,uVar3,BLS12_381_P);
cneg_mod_384((long)param_1 + 0x90,(long)param_1 + 0x90,uVar3,BLS12_381_P);
return (ulong)(param_3 & 0x1f) - 1 >> 0x3f;
}
| |
34,209 | translog_buffer_increase_writers | eloqsql/storage/maria/ma_loghandler.c | static inline void
translog_buffer_increase_writers(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_buffer_increase_writers");
translog_buffer_lock_assert_owner(buffer);
buffer->copy_to_buffer_in_progress++;
DBUG_PRINT("info", ("copy_to_buffer_in_progress. Buffer #%u %p progress: %d",
(uint) buffer->buffer_no, buffer,
buffer->copy_to_buffer_in_progress));
DBUG_VOID_RETURN;
} | O0 | c | translog_buffer_increase_writers:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x100078(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x100078(%rax)
jmp 0x5bfad
jmp 0x5bfaf
jmp 0x5bfb1
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_buffer_increase_writers:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov ecx, ds:dword_100078[rax]
add ecx, 1
mov ds:dword_100078[rax], ecx
jmp short $+2
loc_5BFAD:
jmp short $+2
loc_5BFAF:
jmp short $+2
loc_5BFB1:
pop rbp
retn
| long long translog_buffer_increase_writers(long long a1)
{
long long result; // rax
result = a1;
++*(int *)((char *)&dword_100078 + a1);
return result;
}
| translog_buffer_increase_writers:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x100078]
ADD ECX,0x1
MOV dword ptr [RAX + 0x100078],ECX
JMP 0x0015bfad
LAB_0015bfad:
JMP 0x0015bfaf
LAB_0015bfaf:
JMP 0x0015bfb1
LAB_0015bfb1:
POP RBP
RET
|
void translog_buffer_increase_writers(long param_1)
{
*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) =
*(int *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_type + param_1) + 1;
return;
}
| |
34,210 | ma_get_hash_keyval | eloqsql/libmariadb/libmariadb/mariadb_lib.c | uchar *ma_get_hash_keyval(const uchar *hash_entry,
unsigned int *length,
my_bool not_used __attribute__((unused)))
{
/* Hash entry has the following format:
Offset: 0 key (\0 terminated)
key_length + 1 value (\0 terminated)
*/
uchar *p= (uchar *)hash_entry;
size_t len= strlen((char *)p);
*length= (unsigned int)len;
return p;
} | O0 | c | ma_get_hash_keyval:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x131a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
| ma_get_hash_keyval:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
| long long ma_get_hash_keyval(long long a1, _DWORD *a2)
{
*a2 = strlen(a1);
return a1;
}
| ma_get_hash_keyval:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001131a0
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
char * ma_get_hash_keyval(char *param_1,int4 *param_2)
{
size_t sVar1;
sVar1 = strlen(param_1);
*param_2 = (int)sVar1;
return param_1;
}
| |
34,211 | ma_get_hash_keyval | eloqsql/libmariadb/libmariadb/mariadb_lib.c | uchar *ma_get_hash_keyval(const uchar *hash_entry,
unsigned int *length,
my_bool not_used __attribute__((unused)))
{
/* Hash entry has the following format:
Offset: 0 key (\0 terminated)
key_length + 1 value (\0 terminated)
*/
uchar *p= (uchar *)hash_entry;
size_t len= strlen((char *)p);
*length= (unsigned int)len;
return p;
} | O3 | c | ma_get_hash_keyval:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x131c0
movl %eax, (%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
| ma_get_hash_keyval:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _strlen
mov [rbx], eax
mov rax, r14
pop rbx
pop r14
pop rbp
retn
| long long ma_get_hash_keyval(long long a1, _DWORD *a2)
{
*a2 = strlen(a1);
return a1;
}
| ma_get_hash_keyval:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001131c0
MOV dword ptr [RBX],EAX
MOV RAX,R14
POP RBX
POP R14
POP RBP
RET
|
char * ma_get_hash_keyval(char *param_1,int4 *param_2)
{
size_t sVar1;
sVar1 = strlen(param_1);
*param_2 = (int)sVar1;
return param_1;
}
| |
34,212 | OpenSubdiv::v3_6_0::Far::CatmarkLimits<float>::ComputeBoundaryPointWeights(int, int, float*, float*, float*) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/catmarkPatchBuilder.cpp | void
CatmarkLimits<REAL>::ComputeBoundaryPointWeights(int valence, int faceInRing,
Weight* pWeights, Weight* epWeights, Weight* emWeights) {
int numFaces = valence - 1;
double faceAngle = std::numbers::pi / numFaces;
int weightWidth = 2 * valence;
int N = weightWidth - 1;
//
// Position weights are trivial:
//
std::memset(&pWeights[0], 0, weightWidth * sizeof(Weight));
pWeights[0] = (Weight) (4.0 / 6.0);
pWeights[1] = (Weight) (1.0 / 6.0);
pWeights[N] = (Weight) (1.0 / 6.0);
if ((epWeights == 0) && (emWeights == 0)) return;
//
// Ep and Em weights are computed by combining weights for the boundary
// and interior tangents. The boundary tangent is trivially represented
// by two non-zero weights, so allocate and compute weights for the
// interior tangent:
//
double tBoundaryCoeff_1 = ( 1.0 / 6.0);
double tBoundaryCoeff_N = (-1.0 / 6.0);
StackBuffer<Weight, 64, true> tanWeights(weightWidth);
{
double k = (double) numFaces;
double theta = faceAngle;
double c = std::cos(theta);
double s = std::sin(theta);
double div3 = 1.0 / 3.0;
double div3kc = 1.0f / (3.0f * k + c);
double gamma = -4.0f * s * div3kc;
double alpha_0k = -((1.0f + 2.0f * c) * std::sqrt(1.0f + c)) * div3kc
/ std::sqrt(1.0f - c);
double beta_0 = s * div3kc;
tanWeights[0] = (Weight) (gamma * div3);
tanWeights[1] = (Weight) (alpha_0k * div3);
tanWeights[2] = (Weight) (beta_0 * div3);
tanWeights[N] = (Weight) (alpha_0k * div3);
for (int i = 1; i < valence - 1; ++i) {
double sinThetaI = std::sin(theta * i);
double sinThetaIplus1 = std::sin(theta * (i+1));
double alpha = 4.0f * sinThetaI * div3kc;
double beta = (sinThetaI + sinThetaIplus1) * div3kc;
tanWeights[1 + 2*i] = (Weight) (alpha * div3);
tanWeights[1 + 2*i + 1] = (Weight) (beta * div3);
}
}
//
// Compute Ep weights -- trivial case if on the leading face and edge:
//
if (faceInRing == 0) {
// Ep is on boundary edge and has only two weights: w[1] and w[N]
std::memset(&epWeights[0], 0, weightWidth * sizeof(Weight));
epWeights[0] = (Weight) (2.0 / 3.0);
epWeights[1] = (Weight) (1.0 / 3.0);
} else {
// Ep is on interior edge and has all weights
int iEdgeNext = faceInRing;
double faceAngleNext = faceAngle * iEdgeNext;
double cosAngleNext = std::cos(faceAngleNext);
double sinAngleNext = std::sin(faceAngleNext);
for (int i = 0; i < weightWidth; ++i) {
epWeights[i] = (Weight)(tanWeights[i] * sinAngleNext);
}
epWeights[0] += pWeights[0];
epWeights[1] += pWeights[1] + (Weight)(tBoundaryCoeff_1 * cosAngleNext);
epWeights[N] += pWeights[N] + (Weight)(tBoundaryCoeff_N * cosAngleNext);
}
//
// Compute Em weights -- trivial case if on the trailing face and edge:
//
if (faceInRing == (numFaces - 1)) {
// Em is on boundary edge and has only two weights: w[1] and w[N]
std::memset(&emWeights[0], 0, weightWidth * sizeof(Weight));
emWeights[0] = (Weight) (2.0 / 3.0);
emWeights[N] = (Weight) (1.0 / 3.0);
} else {
// Em is on interior edge and has all weights
int iEdgePrev = (faceInRing + 1) % valence;
double faceAnglePrev = faceAngle * iEdgePrev;
double cosAnglePrev = std::cos(faceAnglePrev);
double sinAnglePrev = std::sin(faceAnglePrev);
for (int i = 0; i < weightWidth; ++i) {
emWeights[i] = (Weight)(tanWeights[i] * sinAnglePrev);
}
emWeights[0] += pWeights[0];
emWeights[1] += pWeights[1] + (Weight)(tBoundaryCoeff_1 * cosAnglePrev);
emWeights[N] += pWeights[N] + (Weight)(tBoundaryCoeff_N * cosAnglePrev);
}
} | O2 | cpp | OpenSubdiv::v3_6_0::Far::CatmarkLimits<float>::ComputeBoundaryPointWeights(int, int, float*, float*, float*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movl %esi, 0x3c(%rsp)
movl %edi, %ebp
leal (%rbp,%rbp), %r15d
movslq %r15d, %r14
leaq (,%r14,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
movq %rdx, 0x58(%rsp)
callq 0x50c10
movapd 0x54919(%rip), %xmm0 # 0xbe650
movupd %xmm0, (%r12)
movabsq $0x3fc5555555555555, %rax # imm = 0x3FC5555555555555
movq %rax, -0x8(%r12,%r14,8)
movq %r13, %rax
orq %rbx, %rax
je 0x6a134
movq %r12, 0x48(%rsp)
leal -0x1(%rbp), %r12d
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x547ac(%rip), %xmm1 # 0xbe520
divsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
leaq 0x70(%rsp), %rdi
movl %r15d, %esi
callq 0x547f0
movsd 0x10(%rsp), %xmm0
callq 0x557b0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4f860
movsd 0x20(%rsp), %xmm1
mulsd 0x54773(%rip), %xmm1 # 0xbe528
movsd 0x8(%rsp), %xmm5
addsd %xmm5, %xmm1
movapd %xmm1, %xmm3
movsd 0x5473d(%rip), %xmm2 # 0xbe508
movapd %xmm2, %xmm1
divsd %xmm3, %xmm1
movapd %xmm1, 0x20(%rsp)
movsd 0x5474f(%rip), %xmm4 # 0xbe530
movsd %xmm0, 0x18(%rsp)
mulsd %xmm0, %xmm4
movapd %xmm5, %xmm3
addsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movapd %xmm5, %xmm0
addsd %xmm2, %xmm0
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm0
jb 0x69e0f
sqrtsd %xmm0, %xmm0
jmp 0x69e38
movapd %xmm3, 0x60(%rsp)
movsd %xmm4, 0x30(%rsp)
callq 0x51990
xorpd %xmm5, %xmm5
movsd 0x546dc(%rip), %xmm2 # 0xbe508
movsd 0x30(%rsp), %xmm4
movapd 0x60(%rsp), %xmm3
decq %r14
movapd 0x20(%rsp), %xmm1
mulsd %xmm1, %xmm4
xorpd 0x547c3(%rip), %xmm3 # 0xbe610
mulsd %xmm0, %xmm3
mulsd %xmm1, %xmm3
subsd 0x8(%rsp), %xmm2
ucomisd %xmm5, %xmm2
movq %rbx, 0x50(%rsp)
movq %rbp, 0x40(%rsp)
jb 0x69e71
sqrtsd %xmm2, %xmm0
jmp 0x69e92
movapd %xmm2, %xmm0
movapd %xmm3, 0x60(%rsp)
movsd %xmm4, 0x30(%rsp)
callq 0x51990
movsd 0x30(%rsp), %xmm4
movapd 0x60(%rsp), %xmm3
divsd %xmm0, %xmm3
movapd 0x20(%rsp), %xmm1
movsd 0x18(%rsp), %xmm2
mulsd %xmm1, %xmm2
movsd 0x5468a(%rip), %xmm0 # 0xbe538
mulsd %xmm0, %xmm4
movq 0x70(%rsp), %rax
movsd %xmm4, (%rax)
mulsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rax)
mulsd %xmm0, %xmm2
movsd %xmm2, 0x10(%rax)
movq %r14, 0x18(%rsp)
movsd %xmm3, (%rax,%r14,8)
movslq %r12d, %r12
unpcklpd %xmm1, %xmm1 # xmm1 = xmm1[0,0]
movapd %xmm1, 0x20(%rsp)
pushq $0x1
popq %r14
pushq $0x18
popq %rbp
pushq $0x2
popq %rbx
cmpq %r12, %r14
jge 0x69f56
cvtsi2sd %r14d, %xmm0
mulsd 0x10(%rsp), %xmm0
callq 0x4f860
movsd %xmm0, 0x8(%rsp)
incq %r14
cvtsi2sd %ebx, %xmm0
mulsd 0x10(%rsp), %xmm0
callq 0x4f860
movsd 0x8(%rsp), %xmm2
movapd %xmm2, %xmm1
mulsd 0x545d2(%rip), %xmm1 # 0xbe500
addsd %xmm2, %xmm0
unpcklpd %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
mulpd 0x20(%rsp), %xmm1
movq 0x70(%rsp), %rax
mulpd 0x546d7(%rip), %xmm1 # 0xbe620
movupd %xmm1, (%rax,%rbp)
addq $0x10, %rbp
incl %ebx
jmp 0x69eef
movl 0x3c(%rsp), %ebp
testl %ebp, %ebp
je 0x6a01e
cvtsi2sd %ebp, %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x557b0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4f860
movq 0x70(%rsp), %rax
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
movq 0x50(%rsp), %rbx
movq 0x18(%rsp), %r14
movq 0x48(%rsp), %r12
movq 0x40(%rsp), %rsi
cmpq %rcx, %rdx
je 0x69fc9
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%r13,%rcx,8)
incq %rcx
jmp 0x69faf
movsd (%r12), %xmm0
addsd (%r13), %xmm0
movsd %xmm0, (%r13)
movsd 0x5455d(%rip), %xmm0 # 0xbe540
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%r12), %xmm0
addsd 0x8(%r13), %xmm0
movsd %xmm0, 0x8(%r13)
mulsd 0x54540(%rip), %xmm1 # 0xbe548
addsd (%r12,%r14,8), %xmm1
addsd (%r13,%r14,8), %xmm1
movsd %xmm1, (%r13,%r14,8)
jmp 0x6a04f
movq %r13, %rdi
xorl %esi, %esi
movq 0x58(%rsp), %rdx
callq 0x50c10
movapd 0x5462b(%rip), %xmm0 # 0xbe660
movupd %xmm0, (%r13)
movq 0x50(%rsp), %rbx
movq 0x18(%rsp), %r14
movq 0x48(%rsp), %r12
movq 0x40(%rsp), %rsi
leal -0x2(%rsi), %eax
cmpl %ebp, %eax
jne 0x6a085
movq %rbx, %rdi
xorl %esi, %esi
movq 0x58(%rsp), %rdx
callq 0x50c10
movabsq $0x3fe5555555555555, %rax # imm = 0x3FE5555555555555
movq %rax, (%rbx)
movabsq $0x3fd5555555555555, %rax # imm = 0x3FD5555555555555
movq %rax, (%rbx,%r14,8)
jmp 0x6a127
incl %ebp
movl %ebp, %eax
cltd
idivl %esi
cvtsi2sd %edx, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x557b0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x4f860
movq 0x70(%rsp), %rax
xorl %ecx, %ecx
testl %r15d, %r15d
cmovlel %ecx, %r15d
cmpq %rcx, %r15
je 0x6a0dc
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
jmp 0x6a0c4
movsd (%r12), %xmm0
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x5444e(%rip), %xmm0 # 0xbe540
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%r12), %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rbx)
mulsd 0x54433(%rip), %xmm1 # 0xbe548
addsd (%r12,%r14,8), %xmm1
addsd (%rbx,%r14,8), %xmm1
movsd %xmm1, (%rbx,%r14,8)
movq 0x280(%rsp), %rdi
callq 0x524d0
addq $0x288, %rsp # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN10OpenSubdiv6v3_6_03Far13CatmarkLimitsIdE27ComputeBoundaryPointWeightsEiiPdS4_S4_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 288h
mov rbx, r8
mov r13, rcx
mov r12, rdx
mov [rsp+2B8h+var_27C], esi
mov ebp, edi
lea r15d, [rbp+rbp+0]
movsxd r14, r15d
lea rdx, ds:0[r14*8]
mov rdi, r12
xor esi, esi
mov [rsp+2B8h+var_260], rdx
call _memset
movapd xmm0, cs:xmmword_BE650
movupd xmmword ptr [r12], xmm0
mov rax, 3FC5555555555555h
mov [r12+r14*8-8], rax
mov rax, r13
or rax, rbx
jz loc_6A134
mov [rsp+2B8h+var_270], r12
lea r12d, [rbp-1]
cvtsi2sd xmm0, r12d
movsd qword ptr [rsp+2B8h+var_298], xmm0
movsd xmm1, cs:qword_BE520
divsd xmm1, xmm0
movsd [rsp+2B8h+var_2A8], xmm1
lea rdi, [rsp+2B8h+var_248]
mov esi, r15d
call __ZN10OpenSubdiv6v3_6_03Vtr8internal11StackBufferIdLj64ELb1EEC2Ej; OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<double,64u,true>::StackBuffer(uint)
movsd xmm0, [rsp+2B8h+var_2A8]
call _cos
movsd [rsp+2B8h+var_2B0], xmm0
movsd xmm0, [rsp+2B8h+var_2A8]
call _sin
movsd xmm1, qword ptr [rsp+2B8h+var_298]
mulsd xmm1, cs:qword_BE528
movsd xmm5, [rsp+2B8h+var_2B0]
addsd xmm1, xmm5
movapd xmm3, xmm1
movsd xmm2, cs:qword_BE508
movapd xmm1, xmm2
divsd xmm1, xmm3
movapd [rsp+2B8h+var_298], xmm1
movsd xmm4, cs:qword_BE530
movsd [rsp+2B8h+var_2A0], xmm0
mulsd xmm4, xmm0
movapd xmm3, xmm5
addsd xmm3, xmm5
addsd xmm3, xmm2
movapd xmm0, xmm5
addsd xmm0, xmm2
xorpd xmm5, xmm5
ucomisd xmm0, xmm5
jb short loc_69E0F
sqrtsd xmm0, xmm0
jmp short loc_69E38
loc_69E0F:
movapd [rsp+2B8h+var_258], xmm3
movsd [rsp+2B8h+var_288], xmm4
call _sqrt
xorpd xmm5, xmm5
movsd xmm2, cs:qword_BE508
movsd xmm4, [rsp+2B8h+var_288]
movapd xmm3, [rsp+2B8h+var_258]
loc_69E38:
dec r14
movapd xmm1, [rsp+2B8h+var_298]
mulsd xmm4, xmm1
xorpd xmm3, cs:xmmword_BE610
mulsd xmm3, xmm0
mulsd xmm3, xmm1
subsd xmm2, [rsp+2B8h+var_2B0]
ucomisd xmm2, xmm5
mov [rsp+2B8h+var_268], rbx
mov [rsp+2B8h+var_278], rbp
jb short loc_69E71
sqrtsd xmm0, xmm2
jmp short loc_69E92
loc_69E71:
movapd xmm0, xmm2
movapd [rsp+2B8h+var_258], xmm3
movsd [rsp+2B8h+var_288], xmm4
call _sqrt
movsd xmm4, [rsp+2B8h+var_288]
movapd xmm3, [rsp+2B8h+var_258]
loc_69E92:
divsd xmm3, xmm0
movapd xmm1, [rsp+2B8h+var_298]
movsd xmm2, [rsp+2B8h+var_2A0]
mulsd xmm2, xmm1
movsd xmm0, cs:qword_BE538
mulsd xmm4, xmm0
mov rax, [rsp+2B8h+var_248]
movsd qword ptr [rax], xmm4
mulsd xmm3, xmm0
movsd qword ptr [rax+8], xmm3
mulsd xmm2, xmm0
movsd qword ptr [rax+10h], xmm2
mov [rsp+2B8h+var_2A0], r14
movsd qword ptr [rax+r14*8], xmm3
movsxd r12, r12d
unpcklpd xmm1, xmm1
movapd [rsp+2B8h+var_298], xmm1
push 1
pop r14
push 18h
pop rbp
push 2
pop rbx
loc_69EEF:
cmp r14, r12
jge short loc_69F56
cvtsi2sd xmm0, r14d
mulsd xmm0, [rsp+2B8h+var_2A8]
call _sin
movsd [rsp+2B8h+var_2B0], xmm0
inc r14
cvtsi2sd xmm0, ebx
mulsd xmm0, [rsp+2B8h+var_2A8]
call _sin
movsd xmm2, [rsp+2B8h+var_2B0]
movapd xmm1, xmm2
mulsd xmm1, cs:qword_BE500
addsd xmm0, xmm2
unpcklpd xmm1, xmm0
mulpd xmm1, [rsp+2B8h+var_298]
mov rax, [rsp+2B8h+var_248]
mulpd xmm1, cs:xmmword_BE620
movupd xmmword ptr [rax+rbp], xmm1
add rbp, 10h
inc ebx
jmp short loc_69EEF
loc_69F56:
mov ebp, [rsp+2B8h+var_27C]
test ebp, ebp
jz loc_6A01E
cvtsi2sd xmm0, ebp
mulsd xmm0, [rsp+2B8h+var_2A8]
movsd qword ptr [rsp+2B8h+var_298], xmm0
call _cos
movsd [rsp+2B8h+var_2B0], xmm0
movsd xmm0, qword ptr [rsp+2B8h+var_298]
call _sin
mov rax, [rsp+2B8h+var_248]
xor ecx, ecx
test r15d, r15d
mov edx, 0
cmovg edx, r15d
mov rbx, [rsp+2B8h+var_268]
mov r14, [rsp+2B8h+var_2A0]
mov r12, [rsp+2B8h+var_270]
mov rsi, [rsp+2B8h+var_278]
loc_69FAF:
cmp rdx, rcx
jz short loc_69FC9
movsd xmm1, qword ptr [rax+rcx*8]
mulsd xmm1, xmm0
movsd qword ptr [r13+rcx*8+0], xmm1
inc rcx
jmp short loc_69FAF
loc_69FC9:
movsd xmm0, qword ptr [r12]
addsd xmm0, qword ptr [r13+0]
movsd qword ptr [r13+0], xmm0
movsd xmm0, cs:qword_BE540
movsd xmm1, [rsp+2B8h+var_2B0]
mulsd xmm0, xmm1
addsd xmm0, qword ptr [r12+8]
addsd xmm0, qword ptr [r13+8]
movsd qword ptr [r13+8], xmm0
mulsd xmm1, cs:qword_BE548
addsd xmm1, qword ptr [r12+r14*8]
addsd xmm1, qword ptr [r13+r14*8+0]
movsd qword ptr [r13+r14*8+0], xmm1
jmp short loc_6A04F
loc_6A01E:
mov rdi, r13
xor esi, esi
mov rdx, [rsp+2B8h+var_260]
call _memset
movapd xmm0, cs:xmmword_BE660
movupd xmmword ptr [r13+0], xmm0
mov rbx, [rsp+2B8h+var_268]
mov r14, [rsp+2B8h+var_2A0]
mov r12, [rsp+2B8h+var_270]
mov rsi, [rsp+2B8h+var_278]
loc_6A04F:
lea eax, [rsi-2]
cmp eax, ebp
jnz short loc_6A085
mov rdi, rbx
xor esi, esi
mov rdx, [rsp+2B8h+var_260]
call _memset
mov rax, 3FE5555555555555h
mov [rbx], rax
mov rax, 3FD5555555555555h
mov [rbx+r14*8], rax
jmp loc_6A127
loc_6A085:
inc ebp
mov eax, ebp
cdq
idiv esi
cvtsi2sd xmm1, edx
movsd xmm0, [rsp+2B8h+var_2A8]
mulsd xmm0, xmm1
movsd [rsp+2B8h+var_2A8], xmm0
call _cos
movsd [rsp+2B8h+var_2B0], xmm0
movsd xmm0, [rsp+2B8h+var_2A8]
call _sin
mov rax, [rsp+2B8h+var_248]
xor ecx, ecx
test r15d, r15d
cmovle r15d, ecx
loc_6A0C4:
cmp r15, rcx
jz short loc_6A0DC
movsd xmm1, qword ptr [rax+rcx*8]
mulsd xmm1, xmm0
movsd qword ptr [rbx+rcx*8], xmm1
inc rcx
jmp short loc_6A0C4
loc_6A0DC:
movsd xmm0, qword ptr [r12]
addsd xmm0, qword ptr [rbx]
movsd qword ptr [rbx], xmm0
movsd xmm0, cs:qword_BE540
movsd xmm1, [rsp+2B8h+var_2B0]
mulsd xmm0, xmm1
addsd xmm0, qword ptr [r12+8]
addsd xmm0, qword ptr [rbx+8]
movsd qword ptr [rbx+8], xmm0
mulsd xmm1, cs:qword_BE548
addsd xmm1, qword ptr [r12+r14*8]
addsd xmm1, qword ptr [rbx+r14*8]
movsd qword ptr [rbx+r14*8], xmm1
loc_6A127:
mov rdi, [rsp+2B8h+var_38]; void *
call __ZdlPv; operator delete(void *)
loc_6A134:
add rsp, 288h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void OpenSubdiv::v3_6_0::Far::CatmarkLimits<double>::ComputeBoundaryPointWeights(
int a1,
int a2,
long long a3,
double *a4,
unsigned long long a5)
{
long long v8; // r15
__m128d v9; // xmm1
double v10; // xmm4_8
double v11; // xmm0_8
double v12; // xmm0_8
double v13; // xmm4_8
double v14; // xmm3_8
double v15; // xmm2_8
double v16; // xmm0_8
double v17; // xmm3_8
__m128d v18; // xmm0
long long v19; // rax
double v20; // xmm3_8
long long v21; // r14
long long v22; // rbp
int v23; // ebx
__m128d v24; // xmm1
double v26; // xmm0_8
long long v27; // rax
long long v28; // rcx
long long v29; // rdx
unsigned long long v30; // rbx
long long v31; // r14
int v32; // esi
double v33; // xmm0_8
long long v34; // rax
long long v35; // rcx
double v36; // [rsp+8h] [rbp-2B0h]
double v37; // [rsp+8h] [rbp-2B0h]
double v38; // [rsp+8h] [rbp-2B0h]
double v39; // [rsp+8h] [rbp-2B0h]
double v40; // [rsp+10h] [rbp-2A8h]
double v41; // [rsp+10h] [rbp-2A8h]
double v42; // [rsp+18h] [rbp-2A0h]
__m128d v43; // [rsp+20h] [rbp-298h]
double v44; // [rsp+30h] [rbp-288h]
unsigned long long v45; // [rsp+50h] [rbp-268h]
long long v46; // [rsp+58h] [rbp-260h]
_QWORD v47[73]; // [rsp+70h] [rbp-248h] BYREF
v8 = (unsigned int)(2 * a1);
v46 = 8LL * (int)v8;
memset(a3, 0LL, v46);
*(_OWORD *)a3 = xmmword_BE650;
*(_QWORD *)(a3 + v46 - 8) = 0x3FC5555555555555LL;
if ( __PAIR128__(a5, (unsigned long long)a4) != 0 )
{
v40 = 3.141592653589793 / (double)(a1 - 1);
OpenSubdiv::v3_6_0::Vtr::internal::StackBuffer<double,64u,true>::StackBuffer(v47, (unsigned int)v8);
v36 = cos(v40);
v9 = (__m128d)0x3FF0000000000000uLL;
v9.m128d_f64[0] = 1.0 / ((double)(a1 - 1) * 3.0 + v36);
v42 = sin(v40);
v10 = -4.0 * v42;
v11 = v36 + 1.0;
if ( v36 + 1.0 < 0.0 )
{
v12 = sqrt(v11);
v10 = -4.0 * v42;
}
else
{
v12 = sqrt(v11);
}
v13 = v10 * v9.m128d_f64[0];
v14 = -(v36 + v36 + 1.0) * v12 * v9.m128d_f64[0];
v15 = 1.0 - v36;
v45 = a5;
if ( 1.0 - v36 < 0.0 )
{
v44 = v13;
v16 = sqrt(v15);
v13 = v44;
}
else
{
v16 = sqrt(v15);
}
v17 = v14 / v16;
v18 = (__m128d)0x3FD5555555555555uLL;
v19 = v47[0];
*(double *)v47[0] = v13 * 0.3333333333333333;
v20 = v17 * 0.3333333333333333;
*(double *)(v19 + 8) = v20;
*(double *)(v19 + 16) = v42 * v9.m128d_f64[0] * 0.3333333333333333;
*(double *)(v19 + 8 * ((int)v8 - 1LL)) = v20;
v43 = _mm_unpacklo_pd(v9, v9);
v21 = 1LL;
v22 = 24LL;
v23 = 2;
while ( v21 < a1 - 1 )
{
v37 = sin((double)(int)v21++ * v40);
v24 = (__m128d)*(unsigned long long *)&v37;
v24.m128d_f64[0] = v37 * 4.0;
v18.m128d_f64[0] = sin((double)v23 * v40) + v37;
*(__m128d *)(v47[0] + v22) = _mm_mul_pd(_mm_mul_pd(_mm_unpacklo_pd(v24, v18), v43), (__m128d)xmmword_BE620);
v22 += 16LL;
++v23;
}
if ( a2 )
{
v38 = cos((double)a2 * v40);
v26 = sin((double)a2 * v40);
v27 = v47[0];
v28 = 0LL;
v29 = 0LL;
if ( (int)v8 > 0 )
v29 = (unsigned int)v8;
v30 = v45;
v31 = (int)v8 - 1LL;
v32 = a1;
while ( v29 != v28 )
{
a4[v28] = *(double *)(v27 + 8 * v28) * v26;
++v28;
}
*a4 = *(double *)a3 + *a4;
a4[1] = 0.1666666666666667 * v38 + *(double *)(a3 + 8) + a4[1];
a4[(int)v8 - 1] = v38 * -0.1666666666666667 + *(double *)(a3 + 8 * ((int)v8 - 1LL)) + a4[(int)v8 - 1];
}
else
{
memset(a4, 0LL, v46);
*(_OWORD *)a4 = xmmword_BE660;
v30 = v45;
v31 = (int)v8 - 1LL;
v32 = a1;
}
if ( v32 - 2 == a2 )
{
memset(v30, 0LL, v46);
*(_QWORD *)v30 = 0x3FE5555555555555LL;
*(_QWORD *)(v30 + 8 * v31) = 0x3FD5555555555555LL;
}
else
{
v41 = v40 * (double)((a2 + 1) % v32);
v39 = cos(v41);
v33 = sin(v41);
v34 = v47[0];
v35 = 0LL;
if ( (int)v8 <= 0 )
v8 = 0LL;
while ( v8 != v35 )
{
*(double *)(v30 + 8 * v35) = *(double *)(v34 + 8 * v35) * v33;
++v35;
}
*(double *)v30 = *(double *)a3 + *(double *)v30;
*(double *)(v30 + 8) = 0.1666666666666667 * v39 + *(double *)(a3 + 8) + *(double *)(v30 + 8);
*(double *)(v30 + 8 * v31) = v39 * -0.1666666666666667 + *(double *)(a3 + 8 * v31) + *(double *)(v30 + 8 * v31);
}
operator delete((void *)v47[66]);
}
}
| ComputeBoundaryPointWeights:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x288
MOV RBX,R8
MOV R13,RCX
MOV R12,RDX
MOV dword ptr [RSP + 0x3c],ESI
MOV EBP,EDI
LEA R15D,[RBP + RBP*0x1]
MOVSXD R14,R15D
LEA RDX,[R14*0x8]
MOV RDI,R12
XOR ESI,ESI
MOV qword ptr [RSP + 0x58],RDX
CALL 0x00150c10
MOVAPD XMM0,xmmword ptr [0x001be650]
MOVUPD xmmword ptr [R12],XMM0
MOV RAX,0x3fc5555555555555
MOV qword ptr [R12 + R14*0x8 + -0x8],RAX
MOV RAX,R13
OR RAX,RBX
JZ 0x0016a134
MOV qword ptr [RSP + 0x48],R12
LEA R12D,[RBP + -0x1]
CVTSI2SD XMM0,R12D
MOVSD qword ptr [RSP + 0x20],XMM0
MOVSD XMM1,qword ptr [0x001be520]
DIVSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x10],XMM1
LEA RDI,[RSP + 0x70]
MOV ESI,R15D
CALL 0x001547f0
MOVSD XMM0,qword ptr [RSP + 0x10]
CALL 0x001557b0
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [RSP + 0x10]
CALL 0x0014f860
MOVSD XMM1,qword ptr [RSP + 0x20]
MULSD XMM1,qword ptr [0x001be528]
MOVSD XMM5,qword ptr [RSP + 0x8]
ADDSD XMM1,XMM5
MOVAPD XMM3,XMM1
MOVSD XMM2,qword ptr [0x001be508]
MOVAPD XMM1,XMM2
DIVSD XMM1,XMM3
MOVAPD xmmword ptr [RSP + 0x20],XMM1
MOVSD XMM4,qword ptr [0x001be530]
MOVSD qword ptr [RSP + 0x18],XMM0
MULSD XMM4,XMM0
MOVAPD XMM3,XMM5
ADDSD XMM3,XMM5
ADDSD XMM3,XMM2
MOVAPD XMM0,XMM5
ADDSD XMM0,XMM2
XORPD XMM5,XMM5
UCOMISD XMM0,XMM5
JC 0x00169e0f
SQRTSD XMM0,XMM0
JMP 0x00169e38
LAB_00169e0f:
MOVAPD xmmword ptr [RSP + 0x60],XMM3
MOVSD qword ptr [RSP + 0x30],XMM4
CALL 0x00151990
XORPD XMM5,XMM5
MOVSD XMM2,qword ptr [0x001be508]
MOVSD XMM4,qword ptr [RSP + 0x30]
MOVAPD XMM3,xmmword ptr [RSP + 0x60]
LAB_00169e38:
DEC R14
MOVAPD XMM1,xmmword ptr [RSP + 0x20]
MULSD XMM4,XMM1
XORPD XMM3,xmmword ptr [0x001be610]
MULSD XMM3,XMM0
MULSD XMM3,XMM1
SUBSD XMM2,qword ptr [RSP + 0x8]
UCOMISD XMM2,XMM5
MOV qword ptr [RSP + 0x50],RBX
MOV qword ptr [RSP + 0x40],RBP
JC 0x00169e71
SQRTSD XMM0,XMM2
JMP 0x00169e92
LAB_00169e71:
MOVAPD XMM0,XMM2
MOVAPD xmmword ptr [RSP + 0x60],XMM3
MOVSD qword ptr [RSP + 0x30],XMM4
CALL 0x00151990
MOVSD XMM4,qword ptr [RSP + 0x30]
MOVAPD XMM3,xmmword ptr [RSP + 0x60]
LAB_00169e92:
DIVSD XMM3,XMM0
MOVAPD XMM1,xmmword ptr [RSP + 0x20]
MOVSD XMM2,qword ptr [RSP + 0x18]
MULSD XMM2,XMM1
MOVSD XMM0,qword ptr [0x001be538]
MULSD XMM4,XMM0
MOV RAX,qword ptr [RSP + 0x70]
MOVSD qword ptr [RAX],XMM4
MULSD XMM3,XMM0
MOVSD qword ptr [RAX + 0x8],XMM3
MULSD XMM2,XMM0
MOVSD qword ptr [RAX + 0x10],XMM2
MOV qword ptr [RSP + 0x18],R14
MOVSD qword ptr [RAX + R14*0x8],XMM3
MOVSXD R12,R12D
UNPCKLPD XMM1,XMM1
MOVAPD xmmword ptr [RSP + 0x20],XMM1
PUSH 0x1
POP R14
PUSH 0x18
POP RBP
PUSH 0x2
POP RBX
LAB_00169eef:
CMP R14,R12
JGE 0x00169f56
CVTSI2SD XMM0,R14D
MULSD XMM0,qword ptr [RSP + 0x10]
CALL 0x0014f860
MOVSD qword ptr [RSP + 0x8],XMM0
INC R14
CVTSI2SD XMM0,EBX
MULSD XMM0,qword ptr [RSP + 0x10]
CALL 0x0014f860
MOVSD XMM2,qword ptr [RSP + 0x8]
MOVAPD XMM1,XMM2
MULSD XMM1,qword ptr [0x001be500]
ADDSD XMM0,XMM2
UNPCKLPD XMM1,XMM0
MULPD XMM1,xmmword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x70]
MULPD XMM1,xmmword ptr [0x001be620]
MOVUPD xmmword ptr [RAX + RBP*0x1],XMM1
ADD RBP,0x10
INC EBX
JMP 0x00169eef
LAB_00169f56:
MOV EBP,dword ptr [RSP + 0x3c]
TEST EBP,EBP
JZ 0x0016a01e
CVTSI2SD XMM0,EBP
MULSD XMM0,qword ptr [RSP + 0x10]
MOVSD qword ptr [RSP + 0x20],XMM0
CALL 0x001557b0
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [RSP + 0x20]
CALL 0x0014f860
MOV RAX,qword ptr [RSP + 0x70]
XOR ECX,ECX
TEST R15D,R15D
MOV EDX,0x0
CMOVG EDX,R15D
MOV RBX,qword ptr [RSP + 0x50]
MOV R14,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
LAB_00169faf:
CMP RDX,RCX
JZ 0x00169fc9
MOVSD XMM1,qword ptr [RAX + RCX*0x8]
MULSD XMM1,XMM0
MOVSD qword ptr [R13 + RCX*0x8],XMM1
INC RCX
JMP 0x00169faf
LAB_00169fc9:
MOVSD XMM0,qword ptr [R12]
ADDSD XMM0,qword ptr [R13]
MOVSD qword ptr [R13],XMM0
MOVSD XMM0,qword ptr [0x001be540]
MOVSD XMM1,qword ptr [RSP + 0x8]
MULSD XMM0,XMM1
ADDSD XMM0,qword ptr [R12 + 0x8]
ADDSD XMM0,qword ptr [R13 + 0x8]
MOVSD qword ptr [R13 + 0x8],XMM0
MULSD XMM1,qword ptr [0x001be548]
ADDSD XMM1,qword ptr [R12 + R14*0x8]
ADDSD XMM1,qword ptr [R13 + R14*0x8]
MOVSD qword ptr [R13 + R14*0x8],XMM1
JMP 0x0016a04f
LAB_0016a01e:
MOV RDI,R13
XOR ESI,ESI
MOV RDX,qword ptr [RSP + 0x58]
CALL 0x00150c10
MOVAPD XMM0,xmmword ptr [0x001be660]
MOVUPD xmmword ptr [R13],XMM0
MOV RBX,qword ptr [RSP + 0x50]
MOV R14,qword ptr [RSP + 0x18]
MOV R12,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
LAB_0016a04f:
LEA EAX,[RSI + -0x2]
CMP EAX,EBP
JNZ 0x0016a085
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,qword ptr [RSP + 0x58]
CALL 0x00150c10
MOV RAX,0x3fe5555555555555
MOV qword ptr [RBX],RAX
MOV RAX,0x3fd5555555555555
MOV qword ptr [RBX + R14*0x8],RAX
JMP 0x0016a127
LAB_0016a085:
INC EBP
MOV EAX,EBP
CDQ
IDIV ESI
CVTSI2SD XMM1,EDX
MOVSD XMM0,qword ptr [RSP + 0x10]
MULSD XMM0,XMM1
MOVSD qword ptr [RSP + 0x10],XMM0
CALL 0x001557b0
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSD XMM0,qword ptr [RSP + 0x10]
CALL 0x0014f860
MOV RAX,qword ptr [RSP + 0x70]
XOR ECX,ECX
TEST R15D,R15D
CMOVLE R15D,ECX
LAB_0016a0c4:
CMP R15,RCX
JZ 0x0016a0dc
MOVSD XMM1,qword ptr [RAX + RCX*0x8]
MULSD XMM1,XMM0
MOVSD qword ptr [RBX + RCX*0x8],XMM1
INC RCX
JMP 0x0016a0c4
LAB_0016a0dc:
MOVSD XMM0,qword ptr [R12]
ADDSD XMM0,qword ptr [RBX]
MOVSD qword ptr [RBX],XMM0
MOVSD XMM0,qword ptr [0x001be540]
MOVSD XMM1,qword ptr [RSP + 0x8]
MULSD XMM0,XMM1
ADDSD XMM0,qword ptr [R12 + 0x8]
ADDSD XMM0,qword ptr [RBX + 0x8]
MOVSD qword ptr [RBX + 0x8],XMM0
MULSD XMM1,qword ptr [0x001be548]
ADDSD XMM1,qword ptr [R12 + R14*0x8]
ADDSD XMM1,qword ptr [RBX + R14*0x8]
MOVSD qword ptr [RBX + R14*0x8],XMM1
LAB_0016a127:
MOV RDI,qword ptr [RSP + 0x280]
CALL 0x001524d0
LAB_0016a134:
ADD RSP,0x288
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::Far::CatmarkLimits<double>::ComputeBoundaryPointWeights(int, int, double*,
double*, double*) */
void OpenSubdiv::v3_6_0::Far::CatmarkLimits<double>::ComputeBoundaryPointWeights
(int param_1,int param_2,double *param_3,double *param_4,double *param_5)
{
size_t __n;
uint uVar1;
double dVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
long lVar6;
long lVar7;
long lVar8;
double dVar9;
double dVar10;
double dVar11;
double dVar12;
double dVar13;
double dVar14;
double dVar15;
double *local_248 [66];
void *local_38;
uVar1 = param_1 * 2;
lVar7 = (long)(int)uVar1;
__n = lVar7 * 8;
memset(param_3,0,__n);
dVar9 = _UNK_001be658;
*param_3 = _DAT_001be650;
param_3[1] = dVar9;
param_3[lVar7 + -1] = 0.16666666666666666;
if (param_4 != (double *)0x0 || param_5 != (double *)0x0) {
dVar9 = (double)(param_1 + -1);
dVar12 = DAT_001be520 / dVar9;
Vtr::internal::StackBuffer<double,64u,true>::StackBuffer
((StackBuffer<double,64u,true> *)local_248,uVar1);
dVar10 = cos(dVar12);
dVar11 = sin(dVar12);
dVar13 = DAT_001be508 / (dVar9 * DAT_001be528 + dVar10);
dVar15 = DAT_001be530 * dVar11;
dVar14 = dVar10 + dVar10 + DAT_001be508;
dVar9 = dVar10 + DAT_001be508;
if (dVar9 < 0.0) {
dVar9 = sqrt(dVar9);
}
else {
dVar9 = SQRT(dVar9);
}
lVar7 = lVar7 + -1;
dVar14 = (double)((ulong)dVar14 ^ _DAT_001be610);
dVar10 = DAT_001be508 - dVar10;
if (dVar10 < 0.0) {
dVar10 = sqrt(dVar10);
}
else {
dVar10 = SQRT(dVar10);
}
dVar2 = DAT_001be538;
*local_248[0] = dVar15 * dVar13 * DAT_001be538;
dVar9 = ((dVar14 * dVar9 * dVar13) / dVar10) * dVar2;
local_248[0][1] = dVar9;
local_248[0][2] = dVar11 * dVar13 * dVar2;
local_248[0][lVar7] = dVar9;
lVar6 = 0x18;
iVar5 = 2;
for (lVar8 = 1; lVar8 < param_1 + -1; lVar8 = lVar8 + 1) {
dVar9 = sin((double)(int)lVar8 * dVar12);
dVar11 = sin((double)iVar5 * dVar12);
dVar11 = (dVar11 + dVar9) * dVar13 * _UNK_001be628;
*(double *)((long)local_248[0] + lVar6) = dVar9 * DAT_001be500 * dVar13 * _DAT_001be620;
((double *)((long)local_248[0] + lVar6))[1] = dVar11;
lVar6 = lVar6 + 0x10;
iVar5 = iVar5 + 1;
}
if (param_2 == 0) {
memset(param_4,0,__n);
dVar9 = _UNK_001be668;
*param_4 = _DAT_001be660;
param_4[1] = dVar9;
}
else {
dVar9 = cos((double)param_2 * dVar12);
dVar11 = sin((double)param_2 * dVar12);
uVar3 = 0;
uVar4 = 0;
if (0 < (int)uVar1) {
uVar4 = (ulong)uVar1;
}
for (; uVar4 != uVar3; uVar3 = uVar3 + 1) {
param_4[uVar3] = local_248[0][uVar3] * dVar11;
}
*param_4 = *param_3 + *param_4;
param_4[1] = DAT_001be540 * dVar9 + param_3[1] + param_4[1];
param_4[lVar7] = dVar9 * _DAT_001be548 + param_3[lVar7] + param_4[lVar7];
}
if (param_1 + -2 == param_2) {
memset(param_5,0,__n);
*param_5 = 0.6666666666666666;
param_5[lVar7] = 0.3333333333333333;
}
else {
dVar12 = dVar12 * (double)((param_2 + 1) % param_1);
dVar9 = cos(dVar12);
dVar11 = sin(dVar12);
uVar4 = 0;
uVar3 = (ulong)uVar1;
if ((int)uVar1 < 1) {
uVar3 = uVar4;
}
for (; uVar3 != uVar4; uVar4 = uVar4 + 1) {
param_5[uVar4] = local_248[0][uVar4] * dVar11;
}
*param_5 = *param_3 + *param_5;
param_5[1] = DAT_001be540 * dVar9 + param_3[1] + param_5[1];
param_5[lVar7] = dVar9 * _DAT_001be548 + param_3[lVar7] + param_5[lVar7];
}
operator_delete(local_38);
}
return;
}
| |
34,213 | my_strerror | eloqsql/strings/my_vsnprintf.c | const char* my_strerror(char *buf, size_t len, int nr)
{
char *msg= NULL;
buf[0]= '\0'; /* failsafe */
if (nr <= 0)
{
strmake(buf, (nr == 0 ?
"Internal error/check (Not system error)" :
"Internal error < 0 (Not system error)"),
len-1);
return buf;
}
/*
These (handler-) error messages are shared by perror, as required
by the principle of least surprise.
*/
if ((nr >= HA_ERR_FIRST) && (nr <= HA_ERR_LAST))
{
msg= (char *) handler_error_messages[nr - HA_ERR_FIRST];
strmake(buf, msg, len - 1);
}
else
{
/*
On Windows, do things the Windows way. On a system that supports both
the GNU and the XSI variant, use whichever was configured (GNU); if
this choice is not advertised, use the default (POSIX/XSI). Testing
for __GNUC__ is not sufficient to determine whether this choice exists.
*/
#if defined(_WIN32)
strerror_s(buf, len, nr);
#elif ((defined _POSIX_C_SOURCE && (_POSIX_C_SOURCE >= 200112L)) || \
(defined _XOPEN_SOURCE && (_XOPEN_SOURCE >= 600))) && \
! defined _GNU_SOURCE
strerror_r(nr, buf, len); /* I can build with or without GNU */
#elif defined(__GLIBC__) && defined (_GNU_SOURCE)
char *r= strerror_r(nr, buf, len);
if (r != buf) /* Want to help, GNU? */
strmake(buf, r, len - 1); /* Then don't. */
#else
strerror_r(nr, buf, len);
#endif
}
/*
strerror() return values are implementation-dependent, so let's
be pragmatic.
*/
if (!buf[0])
strmake(buf, "unknown error", len - 1);
return buf;
} | O3 | c | my_strerror:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rdi)
testl %edx, %edx
jle 0x58c62
leal -0x78(%rdx), %eax
cmpl $0x4e, %eax
ja 0x58c76
movl %eax, %eax
leaq 0x27e263(%rip), %rcx # 0x2d6ebc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x58c8b
leaq 0x4da4(%rip), %rax # 0x5da0d
leaq 0x4dc5(%rip), %rsi # 0x5da35
cmoveq %rax, %rsi
jmp 0x58ca3
movl %edx, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x240b0
movq %rax, %rsi
cmpq %rbx, %rax
je 0x58c97
leaq -0x1(%r14), %rdx
movq %rbx, %rdi
callq 0x590a8
cmpb $0x0, (%rbx)
jne 0x58cb1
leaq 0x4db8(%rip), %rsi # 0x5da5b
decq %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x590a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
| my_strerror:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov byte ptr [rdi], 0
test edx, edx
jle short loc_58C62
lea eax, [rdx-78h]
cmp eax, 4Eh ; 'N'
ja short loc_58C76
mov eax, eax
lea rcx, handler_error_messages_rel
movsxd rsi, dword ptr [rcx+rax*4]
add rsi, rcx
jmp short loc_58C8B
loc_58C62:
lea rax, aInternalErrorC; "Internal error/check (Not system error)"
lea rsi, aInternalError0; "Internal error < 0 (Not system error)"
cmovz rsi, rax
jmp short loc_58CA3
loc_58C76:
mov edi, edx
mov rsi, rbx
mov rdx, r14
call _strerror_r
mov rsi, rax
cmp rax, rbx
jz short loc_58C97
loc_58C8B:
lea rdx, [r14-1]
mov rdi, rbx
call strmake
loc_58C97:
cmp byte ptr [rbx], 0
jnz short loc_58CB1
lea rsi, aUnknownError; "unknown error"
loc_58CA3:
dec r14
mov rdi, rbx
mov rdx, r14
call strmake
loc_58CB1:
mov rax, rbx
pop rbx
pop r14
pop rbp
retn
| char * my_strerror(char *a1, long long a2, int a3)
{
char *v4; // rsi
const char *v5; // rsi
*a1 = 0;
if ( a3 <= 0 )
{
v5 = "Internal error < 0 (Not system error)";
if ( !a3 )
v5 = "Internal error/check (Not system error)";
goto LABEL_11;
}
if ( (unsigned int)(a3 - 120) > 0x4E )
{
v4 = (char *)strerror_r((unsigned int)a3, a1, a2);
if ( v4 == a1 )
goto LABEL_9;
}
else
{
v4 = (char *)handler_error_messages_rel + handler_error_messages_rel[a3 - 120];
}
strmake(a1, v4, a2 - 1);
LABEL_9:
if ( !*a1 )
{
v5 = "unknown error";
LABEL_11:
strmake(a1, v5, a2 - 1);
}
return a1;
}
| my_strerror:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV byte ptr [RDI],0x0
TEST EDX,EDX
JLE 0x00158c62
LEA EAX,[RDX + -0x78]
CMP EAX,0x4e
JA 0x00158c76
MOV EAX,EAX
LEA RCX,[0x3d6ebc]
MOVSXD RSI,dword ptr [RCX + RAX*0x4]
ADD RSI,RCX
JMP 0x00158c8b
LAB_00158c62:
LEA RAX,[0x15da0d]
LEA RSI,[0x15da35]
CMOVZ RSI,RAX
JMP 0x00158ca3
LAB_00158c76:
MOV EDI,EDX
MOV RSI,RBX
MOV RDX,R14
CALL 0x001240b0
MOV RSI,RAX
CMP RAX,RBX
JZ 0x00158c97
LAB_00158c8b:
LEA RDX,[R14 + -0x1]
MOV RDI,RBX
CALL 0x001590a8
LAB_00158c97:
CMP byte ptr [RBX],0x0
JNZ 0x00158cb1
LEA RSI,[0x15da5b]
LAB_00158ca3:
DEC R14
MOV RDI,RBX
MOV RDX,R14
CALL 0x001590a8
LAB_00158cb1:
MOV RAX,RBX
POP RBX
POP R14
POP RBP
RET
|
char * my_strerror(char *param_1,size_t param_2,int param_3)
{
char *pcVar1;
*param_1 = '\0';
if (param_3 < 1) {
pcVar1 = "Internal error < 0 (Not system error)";
if (param_3 == 0) {
pcVar1 = "Internal error/check (Not system error)";
}
goto LAB_00158ca3;
}
if (param_3 - 0x78U < 0x4f) {
pcVar1 = handler_error_messages_rel +
*(int *)(handler_error_messages_rel + (ulong)(param_3 - 0x78U) * 4);
LAB_00158c8b:
strmake(param_1,pcVar1,param_2 - 1);
}
else {
pcVar1 = strerror_r(param_3,param_1,param_2);
if (pcVar1 != param_1) goto LAB_00158c8b;
}
if (*param_1 != '\0') {
return param_1;
}
pcVar1 = "unknown error";
LAB_00158ca3:
strmake(param_1,pcVar1,param_2 - 1);
return param_1;
}
| |
34,214 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(unsigned long const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactoryCache.cpp | SurfaceFactoryCache::DataType
SurfaceFactoryCache::find(KeyType const & key) const {
MapType::const_iterator itFound = _map.find(key);
return (itFound != _map.end()) ? itFound->second : DataType(0);
} | O1 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(unsigned long const&) const:
movq %rdi, %rax
movq 0x18(%rsi), %rdi
addq $0x10, %rsi
movq %rsi, %rcx
testq %rdi, %rdi
je 0x9e73c
movq (%rdx), %r8
movq %rsi, %rcx
xorl %r9d, %r9d
cmpq %r8, 0x20(%rdi)
setb %r9b
cmovaeq %rdi, %rcx
movq 0x10(%rdi,%r9,8), %rdi
testq %rdi, %rdi
jne 0x9e723
movq %rsi, %rdi
cmpq %rsi, %rcx
je 0x9e752
movq (%rdx), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %rsi, %rcx
movq %rcx, %rdi
cmpq %rsi, %rdi
je 0x9e77b
movq 0x28(%rdi), %rcx
movq %rcx, (%rax)
movq 0x30(%rdi), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0x9e781
movq 0x3f7be(%rip), %rdx # 0xddf30
cmpb $0x0, (%rdx)
je 0x9e782
incl 0x8(%rcx)
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
lock
incl 0x8(%rcx)
retq
nop
| _ZNK10OpenSubdiv6v3_6_03Bfr19SurfaceFactoryCache4findERKm:
mov rax, rdi
mov rdi, [rsi+18h]
add rsi, 10h
mov rcx, rsi
test rdi, rdi
jz short loc_9E73C
mov r8, [rdx]
mov rcx, rsi
loc_9E723:
xor r9d, r9d
cmp [rdi+20h], r8
setb r9b
cmovnb rcx, rdi
mov rdi, [rdi+r9*8+10h]
test rdi, rdi
jnz short loc_9E723
loc_9E73C:
mov rdi, rsi
cmp rcx, rsi
jz short loc_9E752
mov rdx, [rdx]
cmp rdx, [rcx+20h]
cmovb rcx, rsi
mov rdi, rcx
loc_9E752:
cmp rdi, rsi
jz short loc_9E77B
mov rcx, [rdi+28h]
mov [rax], rcx
mov rcx, [rdi+30h]
mov [rax+8], rcx
test rcx, rcx
jz short locret_9E781
mov rdx, cs:__libc_single_threaded_ptr
cmp byte ptr [rdx], 0
jz short loc_9E782
inc dword ptr [rcx+8]
retn
loc_9E77B:
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
locret_9E781:
retn
loc_9E782:
lock inc dword ptr [rcx+8]
retn
| OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache * OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache *this,
const unsigned long long *a2,
unsigned long long *a3)
{
OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache *result; // rax
unsigned long long v4; // rdi
const unsigned long long *v5; // rsi
unsigned long long v6; // rcx
unsigned long long v7; // r8
const unsigned long long *v8; // rdi
unsigned long long v9; // rcx
result = this;
v4 = a2[3];
v5 = a2 + 2;
v6 = (unsigned long long)v5;
if ( v4 )
{
v7 = *a3;
v6 = (unsigned long long)v5;
do
{
if ( *(_QWORD *)(v4 + 32) >= v7 )
v6 = v4;
v4 = *(_QWORD *)(v4 + 8LL * (*(_QWORD *)(v4 + 32) < v7) + 16);
}
while ( v4 );
}
v8 = v5;
if ( (const unsigned long long *)v6 != v5 )
{
if ( *a3 < *(_QWORD *)(v6 + 32) )
v6 = (unsigned long long)v5;
v8 = (const unsigned long long *)v6;
}
if ( v8 == v5 )
{
*(_OWORD *)result = 0LL;
}
else
{
*(_QWORD *)result = v8[5];
v9 = v8[6];
*((_QWORD *)result + 1) = v9;
if ( v9 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v9 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v9 + 8));
}
}
return result;
}
| find:
MOV RAX,RDI
MOV RDI,qword ptr [RSI + 0x18]
ADD RSI,0x10
MOV RCX,RSI
TEST RDI,RDI
JZ 0x0019e73c
MOV R8,qword ptr [RDX]
MOV RCX,RSI
LAB_0019e723:
XOR R9D,R9D
CMP qword ptr [RDI + 0x20],R8
SETC R9B
CMOVNC RCX,RDI
MOV RDI,qword ptr [RDI + R9*0x8 + 0x10]
TEST RDI,RDI
JNZ 0x0019e723
LAB_0019e73c:
MOV RDI,RSI
CMP RCX,RSI
JZ 0x0019e752
MOV RDX,qword ptr [RDX]
CMP RDX,qword ptr [RCX + 0x20]
CMOVC RCX,RSI
MOV RDI,RCX
LAB_0019e752:
CMP RDI,RSI
JZ 0x0019e77b
MOV RCX,qword ptr [RDI + 0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RDI + 0x30]
MOV qword ptr [RAX + 0x8],RCX
TEST RCX,RCX
JZ 0x0019e781
MOV RDX,qword ptr [0x001ddf30]
CMP byte ptr [RDX],0x0
JZ 0x0019e782
INC dword ptr [RCX + 0x8]
RET
LAB_0019e77b:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
LAB_0019e781:
RET
LAB_0019e782:
INC.LOCK dword ptr [RCX + 0x8]
RET
|
/* OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(unsigned long const&) const */
void OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(ulong *param_1)
{
ulong uVar1;
long lVar2;
ulong *in_RDX;
long in_RSI;
long lVar3;
long lVar4;
bool bVar5;
lVar4 = *(long *)(in_RSI + 0x18);
lVar3 = in_RSI + 0x10;
lVar2 = lVar3;
if (lVar4 != 0) {
do {
bVar5 = *(ulong *)(lVar4 + 0x20) < *in_RDX;
if (!bVar5) {
lVar2 = lVar4;
}
lVar4 = *(long *)(lVar4 + 0x10 + (ulong)bVar5 * 8);
} while (lVar4 != 0);
}
lVar4 = lVar3;
if ((lVar2 != lVar3) && (lVar4 = lVar2, *in_RDX < *(ulong *)(lVar2 + 0x20))) {
lVar4 = lVar3;
}
if (lVar4 == lVar3) {
*param_1 = 0;
param_1[1] = 0;
}
else {
*param_1 = *(ulong *)(lVar4 + 0x28);
uVar1 = *(ulong *)(lVar4 + 0x30);
param_1[1] = uVar1;
if (uVar1 != 0) {
if (*PTR___libc_single_threaded_001ddf30 == '\0') {
LOCK();
*(int *)(uVar1 + 8) = *(int *)(uVar1 + 8) + 1;
UNLOCK();
return;
}
*(int *)(uVar1 + 8) = *(int *)(uVar1 + 8) + 1;
return;
}
}
return;
}
| |
34,215 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(unsigned long const&) const | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactoryCache.cpp | SurfaceFactoryCache::DataType
SurfaceFactoryCache::find(KeyType const & key) const {
MapType::const_iterator itFound = _map.find(key);
return (itFound != _map.end()) ? itFound->second : DataType(0);
} | O3 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(unsigned long const&) const:
movq %rdi, %rax
movq 0x18(%rsi), %rdi
testq %rdi, %rdi
je 0xa124a
addq $0x10, %rsi
movq (%rdx), %rdx
movq %rsi, %rcx
xorl %r8d, %r8d
cmpq %rdx, 0x20(%rdi)
setb %r8b
cmovaeq %rdi, %rcx
movq 0x10(%rdi,%r8,8), %rdi
testq %rdi, %rdi
jne 0xa1226
cmpq %rsi, %rcx
je 0xa124a
cmpq 0x20(%rcx), %rdx
jae 0xa1251
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
retq
movq 0x28(%rcx), %rdx
movq %rdx, (%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x8(%rax)
testq %rcx, %rcx
je 0xa1250
movq 0x40ccc(%rip), %rdx # 0xe1f38
cmpb $0x0, (%rdx)
je 0xa1275
incl 0x8(%rcx)
retq
lock
incl 0x8(%rcx)
retq
| _ZNK10OpenSubdiv6v3_6_03Bfr19SurfaceFactoryCache4findERKm:
mov rax, rdi
mov rdi, [rsi+18h]
test rdi, rdi
jz short loc_A124A
add rsi, 10h
mov rdx, [rdx]
mov rcx, rsi
loc_A1226:
xor r8d, r8d
cmp [rdi+20h], rdx
setb r8b
cmovnb rcx, rdi
mov rdi, [rdi+r8*8+10h]
test rdi, rdi
jnz short loc_A1226
cmp rcx, rsi
jz short loc_A124A
cmp rdx, [rcx+20h]
jnb short loc_A1251
loc_A124A:
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
locret_A1250:
retn
loc_A1251:
mov rdx, [rcx+28h]
mov [rax], rdx
mov rcx, [rcx+30h]
mov [rax+8], rcx
test rcx, rcx
jz short locret_A1250
mov rdx, cs:__libc_single_threaded_ptr
cmp byte ptr [rdx], 0
jz short loc_A1275
inc dword ptr [rcx+8]
retn
loc_A1275:
lock inc dword ptr [rcx+8]
retn
| OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache * OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache *this,
const unsigned long long *a2,
unsigned long long *a3)
{
OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache *result; // rax
unsigned long long v4; // rdi
const unsigned long long *v5; // rsi
unsigned long long v6; // rdx
const unsigned long long *v7; // rcx
unsigned long long v8; // rcx
result = this;
v4 = a2[3];
if ( !v4 )
goto LABEL_8;
v5 = a2 + 2;
v6 = *a3;
v7 = v5;
do
{
if ( *(_QWORD *)(v4 + 32) >= v6 )
v7 = (const unsigned long long *)v4;
v4 = *(_QWORD *)(v4 + 8LL * (*(_QWORD *)(v4 + 32) < v6) + 16);
}
while ( v4 );
if ( v7 != v5 && v6 >= v7[4] )
{
*(_QWORD *)result = v7[5];
v8 = v7[6];
*((_QWORD *)result + 1) = v8;
if ( v8 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v8 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v8 + 8));
}
}
else
{
LABEL_8:
*(_OWORD *)result = 0LL;
}
return result;
}
| find:
MOV RAX,RDI
MOV RDI,qword ptr [RSI + 0x18]
TEST RDI,RDI
JZ 0x001a124a
ADD RSI,0x10
MOV RDX,qword ptr [RDX]
MOV RCX,RSI
LAB_001a1226:
XOR R8D,R8D
CMP qword ptr [RDI + 0x20],RDX
SETC R8B
CMOVNC RCX,RDI
MOV RDI,qword ptr [RDI + R8*0x8 + 0x10]
TEST RDI,RDI
JNZ 0x001a1226
CMP RCX,RSI
JZ 0x001a124a
CMP RDX,qword ptr [RCX + 0x20]
JNC 0x001a1251
LAB_001a124a:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
LAB_001a1250:
RET
LAB_001a1251:
MOV RDX,qword ptr [RCX + 0x28]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x30]
MOV qword ptr [RAX + 0x8],RCX
TEST RCX,RCX
JZ 0x001a1250
MOV RDX,qword ptr [0x001e1f38]
CMP byte ptr [RDX],0x0
JZ 0x001a1275
INC dword ptr [RCX + 0x8]
RET
LAB_001a1275:
INC.LOCK dword ptr [RCX + 0x8]
RET
|
/* OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(unsigned long const&) const */
void OpenSubdiv::v3_6_0::Bfr::SurfaceFactoryCache::find(ulong *param_1)
{
ulong uVar1;
long lVar2;
ulong *in_RDX;
long in_RSI;
long lVar3;
bool bVar4;
lVar3 = *(long *)(in_RSI + 0x18);
if (lVar3 != 0) {
uVar1 = *in_RDX;
lVar2 = in_RSI + 0x10;
do {
bVar4 = *(ulong *)(lVar3 + 0x20) < uVar1;
if (!bVar4) {
lVar2 = lVar3;
}
lVar3 = *(long *)(lVar3 + 0x10 + (ulong)bVar4 * 8);
} while (lVar3 != 0);
if ((lVar2 != in_RSI + 0x10) && (*(ulong *)(lVar2 + 0x20) <= uVar1)) {
*param_1 = *(ulong *)(lVar2 + 0x28);
uVar1 = *(ulong *)(lVar2 + 0x30);
param_1[1] = uVar1;
if (uVar1 == 0) {
return;
}
if (*PTR___libc_single_threaded_001e1f38 == '\0') {
LOCK();
*(int *)(uVar1 + 8) = *(int *)(uVar1 + 8) + 1;
UNLOCK();
return;
}
*(int *)(uVar1 + 8) = *(int *)(uVar1 + 8) + 1;
return;
}
}
*param_1 = 0;
param_1[1] = 0;
return;
}
| |
34,216 | my_strntoull_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static ulonglong
my_strntoull_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative= 0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register ulonglong cutoff;
register unsigned int cutlim;
register ulonglong res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr + l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]= (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+=cnv;
} while (1);
bs:
overflow = 0;
res = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+=cnv;
if ( wc>='0' && wc<='9')
wc -= '0';
else if ( wc>='A' && wc<='Z')
wc = wc - 'A' + 10;
else if ( wc>='a' && wc<='z')
wc = wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow = 1;
else
{
res *= (ulonglong) base;
res += wc;
}
}
else if (cnv==MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*)s;
err[0]= EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]= EDOM;
return 0L;
}
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) res) : (longlong) res);
} | O3 | c | my_strntoull_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, -0x40(%rbp)
movl %ecx, -0x44(%rbp)
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %r12
addq %rsi, %r13
movq %r9, -0x50(%rbp)
movl $0x0, (%r9)
leaq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0x7f81a
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rbx
movq -0x30(%rbp), %rcx
cmpq $0x2a, %rcx
jg 0x7f7ea
cmpq $0x9, %rcx
je 0x7f802
cmpq $0x20, %rcx
je 0x7f802
jmp 0x7f84c
cmpq $0x2b, %rcx
je 0x7f802
cmpq $0x2d, %rcx
jne 0x7f84c
xorl %ecx, %ecx
cmpl $0x0, -0x34(%rbp)
sete %cl
movl %ecx, -0x34(%rbp)
movl %eax, %eax
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jg 0x7f7d2
movq -0x40(%rbp), %rcx
testq %rcx, %rcx
je 0x7f826
movq %r15, (%rcx)
testl %eax, %eax
movl $0x54, %eax
movl $0x21, %ecx
cmovel %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, (%rax)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq -0x44(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
movq %rcx, -0x60(%rbp)
divq %rcx
movq %rdx, %rbx
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r13, %rcx
callq *%r12
testl %eax, %eax
jle 0x7f926
movq %r12, -0x70(%rbp)
movl %ebx, %ecx
movq %rcx, -0x68(%rbp)
xorl %ecx, %ecx
movq %r15, %rbx
xorl %edi, %edi
movq %rbx, %rsi
movl %eax, %ebx
addq %rsi, %rbx
movq -0x30(%rbp), %rsi
leaq -0x30(%rsi), %rax
cmpq $0x9, %rax
ja 0x7f8ac
movq %rax, -0x30(%rbp)
jmp 0x7f8d1
leaq -0x41(%rsi), %rax
cmpq $0x19, %rax
ja 0x7f8bc
addq $-0x37, %rsi
jmp 0x7f8ca
leaq -0x61(%rsi), %rax
cmpq $0x19, %rax
ja 0x7f937
addq $-0x57, %rsi
movq %rsi, -0x30(%rbp)
movq %rsi, %rax
cmpl -0x44(%rbp), %eax
jge 0x7f937
movl $0x1, %esi
cmpq -0x58(%rbp), %rcx
jbe 0x7f8e6
movq %rcx, %r12
jmp 0x7f8ff
jne 0x7f8f2
movq -0x58(%rbp), %r12
cmpq -0x68(%rbp), %rax
ja 0x7f8ff
imulq -0x60(%rbp), %rcx
addq %rcx, %rax
movl %edi, %esi
movq %rax, %r12
movq %rsi, -0x78(%rbp)
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq *-0x70(%rbp)
movq -0x78(%rbp), %rsi
movq %r12, %rcx
movl %esi, %edi
testl %eax, %eax
jg 0x7f890
jmp 0x7f92e
xorl %r12d, %r12d
movq %r15, %rbx
xorl %esi, %esi
testl %eax, %eax
je 0x7f971
movl %esi, %edi
movq %r12, %rcx
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x7f943
movq %rbx, (%rax)
cmpq %r15, %rbx
je 0x7f962
testl %edi, %edi
je 0x7f98c
movq -0x50(%rbp), %rax
movl $0x22, (%rax)
movq $-0x1, %rax
jmp 0x7f83d
movq -0x50(%rbp), %rax
movl $0x21, (%rax)
jmp 0x7f83b
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0x7f97d
movq %rbx, (%rax)
movq -0x50(%rbp), %rax
movl $0x54, (%rax)
jmp 0x7f83b
movq %rcx, %rax
negq %rax
cmpl $0x0, -0x34(%rbp)
cmoveq %rcx, %rax
jmp 0x7f83d
| my_strntoull_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_40], r8
mov [rbp+var_44], ecx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, [rdi+0B8h]
mov r12, [rax+28h]
add r13, rsi
mov [rbp+var_50], r9
mov dword ptr [r9], 0
lea rsi, [rbp+var_30]
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle short loc_7F81A
mov [rbp+var_34], 0
lea rbx, [rbp+var_30]
loc_7F7D2:
mov rcx, [rbp+var_30]
cmp rcx, 2Ah ; '*'
jg short loc_7F7EA
cmp rcx, 9
jz short loc_7F802
cmp rcx, 20h ; ' '
jz short loc_7F802
jmp short loc_7F84C
loc_7F7EA:
cmp rcx, 2Bh ; '+'
jz short loc_7F802
cmp rcx, 2Dh ; '-'
jnz short loc_7F84C
xor ecx, ecx
cmp [rbp+var_34], 0
setz cl
mov [rbp+var_34], ecx
loc_7F802:
mov eax, eax
add r15, rax
mov rdi, r14
mov rsi, rbx
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jg short loc_7F7D2
loc_7F81A:
mov rcx, [rbp+var_40]
test rcx, rcx
jz short loc_7F826
mov [rcx], r15
loc_7F826:
test eax, eax
mov eax, 54h ; 'T'
mov ecx, 21h ; '!'
cmovz ecx, eax
mov rax, [rbp+var_50]
mov [rax], ecx
loc_7F83B:
xor eax, eax
loc_7F83D:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7F84C:
movsxd rcx, [rbp+var_44]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_60], rcx
div rcx
mov rbx, rdx
mov [rbp+var_58], rax
lea rsi, [rbp+var_30]
mov rdi, r14
mov rdx, r15
mov rcx, r13
call r12
test eax, eax
jle loc_7F926
mov [rbp+var_70], r12
mov ecx, ebx
mov [rbp+var_68], rcx
xor ecx, ecx
mov rbx, r15
xor edi, edi
loc_7F890:
mov rsi, rbx
mov ebx, eax
add rbx, rsi
mov rsi, [rbp+var_30]
lea rax, [rsi-30h]
cmp rax, 9
ja short loc_7F8AC
mov [rbp+var_30], rax
jmp short loc_7F8D1
loc_7F8AC:
lea rax, [rsi-41h]
cmp rax, 19h
ja short loc_7F8BC
add rsi, 0FFFFFFFFFFFFFFC9h
jmp short loc_7F8CA
loc_7F8BC:
lea rax, [rsi-61h]
cmp rax, 19h
ja short loc_7F937
add rsi, 0FFFFFFFFFFFFFFA9h
loc_7F8CA:
mov [rbp+var_30], rsi
mov rax, rsi
loc_7F8D1:
cmp eax, [rbp+var_44]
jge short loc_7F937
mov esi, 1
cmp rcx, [rbp+var_58]
jbe short loc_7F8E6
mov r12, rcx
jmp short loc_7F8FF
loc_7F8E6:
jnz short loc_7F8F2
mov r12, [rbp+var_58]
cmp rax, [rbp+var_68]
ja short loc_7F8FF
loc_7F8F2:
imul rcx, [rbp+var_60]
add rax, rcx
mov esi, edi
mov r12, rax
loc_7F8FF:
mov [rbp+var_78], rsi
mov rdi, r14
lea rsi, [rbp+var_30]
mov rdx, rbx
mov rcx, r13
call [rbp+var_70]
mov rsi, [rbp+var_78]
mov rcx, r12
mov edi, esi
test eax, eax
jg loc_7F890
jmp short loc_7F92E
loc_7F926:
xor r12d, r12d
mov rbx, r15
xor esi, esi
loc_7F92E:
test eax, eax
jz short loc_7F971
mov edi, esi
mov rcx, r12
loc_7F937:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_7F943
mov [rax], rbx
loc_7F943:
cmp rbx, r15
jz short loc_7F962
test edi, edi
jz short loc_7F98C
mov rax, [rbp+var_50]
mov dword ptr [rax], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
jmp loc_7F83D
loc_7F962:
mov rax, [rbp+var_50]
mov dword ptr [rax], 21h ; '!'
jmp loc_7F83B
loc_7F971:
mov rax, [rbp+var_40]
test rax, rax
jz short loc_7F97D
mov [rax], rbx
loc_7F97D:
mov rax, [rbp+var_50]
mov dword ptr [rax], 54h ; 'T'
jmp loc_7F83B
loc_7F98C:
mov rax, rcx
neg rax
cmp [rbp+var_34], 0
cmovz rax, rcx
jmp loc_7F83D
| long long my_strntoull_mb2_or_mb4(long long a1, long long a2, long long a3, int a4, _QWORD *a5, int *a6)
{
long long v6; // r15
long long ( *v8)(long long, _QWORD *, long long, long long); // r12
long long v9; // r13
int v10; // eax
int v11; // ecx
long long result; // rax
int v13; // eax
unsigned long long v14; // rcx
long long v15; // rbx
int v16; // edi
unsigned long long v17; // rax
long long v18; // rsi
int v19; // esi
unsigned long long v20; // r12
long long ( *v21)(long long, _QWORD *, long long, long long); // [rsp+10h] [rbp-70h]
unsigned long long v22; // [rsp+28h] [rbp-58h]
BOOL v26; // [rsp+4Ch] [rbp-34h]
_QWORD v27[6]; // [rsp+50h] [rbp-30h] BYREF
v6 = a2;
v8 = *(long long ( **)(long long, _QWORD *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v9 = a2 + a3;
*a6 = 0;
v10 = v8(a1, v27, a2, a2 + a3);
if ( v10 <= 0 )
{
LABEL_11:
if ( a5 )
*a5 = v6;
v11 = 33;
if ( !v10 )
v11 = 84;
*a6 = v11;
return 0LL;
}
v26 = 0;
while ( v27[0] > 42LL )
{
if ( v27[0] != 43LL )
{
if ( v27[0] != 45LL )
goto LABEL_17;
v26 = !v26;
}
LABEL_10:
v6 += (unsigned int)v10;
v10 = v8(a1, v27, v6, v9);
if ( v10 <= 0 )
goto LABEL_11;
}
if ( v27[0] == 9LL || v27[0] == 32LL )
goto LABEL_10;
LABEL_17:
v22 = 0xFFFFFFFFFFFFFFFFLL / a4;
v13 = v8(a1, v27, v6, v9);
if ( v13 <= 0 )
{
v20 = 0LL;
v15 = v6;
v19 = 0;
LABEL_35:
if ( v13 )
{
v16 = v19;
v14 = v20;
goto LABEL_37;
}
if ( a5 )
*a5 = v15;
*a6 = 84;
return 0LL;
}
v21 = v8;
v14 = 0LL;
v15 = v6;
v16 = 0;
while ( 1 )
{
v15 += (unsigned int)v13;
v17 = v27[0] - 48LL;
if ( (unsigned long long)(v27[0] - 48LL) > 9 )
{
if ( (unsigned long long)(v27[0] - 65LL) > 0x19 )
{
if ( (unsigned long long)(v27[0] - 97LL) > 0x19 )
break;
v18 = v27[0] - 87LL;
}
else
{
v18 = v27[0] - 55LL;
}
v27[0] = v18;
v17 = v18;
}
else
{
v27[0] -= 48LL;
}
if ( (int)v17 >= a4 )
break;
v19 = 1;
if ( v14 <= v22 )
{
if ( v14 != v22 || (v20 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v19 = v16;
v20 = a4 * v14 + v17;
}
}
else
{
v20 = v14;
}
v13 = v21(a1, v27, v15, v9);
v14 = v20;
v16 = v19;
if ( v13 <= 0 )
goto LABEL_35;
}
LABEL_37:
if ( a5 )
*a5 = v15;
if ( v15 == v6 )
{
*a6 = 33;
return 0LL;
}
if ( v16 )
{
*a6 = 34;
return -1LL;
}
else
{
result = -(long long)v14;
if ( !v26 )
return v14;
}
return result;
}
| my_strntoull_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x40],R8
MOV dword ptr [RBP + -0x44],ECX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0xb8]
MOV R12,qword ptr [RAX + 0x28]
ADD R13,RSI
MOV qword ptr [RBP + -0x50],R9
MOV dword ptr [R9],0x0
LEA RSI,[RBP + -0x30]
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x0017f81a
MOV dword ptr [RBP + -0x34],0x0
LEA RBX,[RBP + -0x30]
LAB_0017f7d2:
MOV RCX,qword ptr [RBP + -0x30]
CMP RCX,0x2a
JG 0x0017f7ea
CMP RCX,0x9
JZ 0x0017f802
CMP RCX,0x20
JZ 0x0017f802
JMP 0x0017f84c
LAB_0017f7ea:
CMP RCX,0x2b
JZ 0x0017f802
CMP RCX,0x2d
JNZ 0x0017f84c
XOR ECX,ECX
CMP dword ptr [RBP + -0x34],0x0
SETZ CL
MOV dword ptr [RBP + -0x34],ECX
LAB_0017f802:
MOV EAX,EAX
ADD R15,RAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JG 0x0017f7d2
LAB_0017f81a:
MOV RCX,qword ptr [RBP + -0x40]
TEST RCX,RCX
JZ 0x0017f826
MOV qword ptr [RCX],R15
LAB_0017f826:
TEST EAX,EAX
MOV EAX,0x54
MOV ECX,0x21
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],ECX
LAB_0017f83b:
XOR EAX,EAX
LAB_0017f83d:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017f84c:
MOVSXD RCX,dword ptr [RBP + -0x44]
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x60],RCX
DIV RCX
MOV RBX,RDX
MOV qword ptr [RBP + -0x58],RAX
LEA RSI,[RBP + -0x30]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R13
CALL R12
TEST EAX,EAX
JLE 0x0017f926
MOV qword ptr [RBP + -0x70],R12
MOV ECX,EBX
MOV qword ptr [RBP + -0x68],RCX
XOR ECX,ECX
MOV RBX,R15
XOR EDI,EDI
LAB_0017f890:
MOV RSI,RBX
MOV EBX,EAX
ADD RBX,RSI
MOV RSI,qword ptr [RBP + -0x30]
LEA RAX,[RSI + -0x30]
CMP RAX,0x9
JA 0x0017f8ac
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0017f8d1
LAB_0017f8ac:
LEA RAX,[RSI + -0x41]
CMP RAX,0x19
JA 0x0017f8bc
ADD RSI,-0x37
JMP 0x0017f8ca
LAB_0017f8bc:
LEA RAX,[RSI + -0x61]
CMP RAX,0x19
JA 0x0017f937
ADD RSI,-0x57
LAB_0017f8ca:
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,RSI
LAB_0017f8d1:
CMP EAX,dword ptr [RBP + -0x44]
JGE 0x0017f937
MOV ESI,0x1
CMP RCX,qword ptr [RBP + -0x58]
JBE 0x0017f8e6
MOV R12,RCX
JMP 0x0017f8ff
LAB_0017f8e6:
JNZ 0x0017f8f2
MOV R12,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x68]
JA 0x0017f8ff
LAB_0017f8f2:
IMUL RCX,qword ptr [RBP + -0x60]
ADD RAX,RCX
MOV ESI,EDI
MOV R12,RAX
LAB_0017f8ff:
MOV qword ptr [RBP + -0x78],RSI
MOV RDI,R14
LEA RSI,[RBP + -0x30]
MOV RDX,RBX
MOV RCX,R13
CALL qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
MOV RCX,R12
MOV EDI,ESI
TEST EAX,EAX
JG 0x0017f890
JMP 0x0017f92e
LAB_0017f926:
XOR R12D,R12D
MOV RBX,R15
XOR ESI,ESI
LAB_0017f92e:
TEST EAX,EAX
JZ 0x0017f971
MOV EDI,ESI
MOV RCX,R12
LAB_0017f937:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x0017f943
MOV qword ptr [RAX],RBX
LAB_0017f943:
CMP RBX,R15
JZ 0x0017f962
TEST EDI,EDI
JZ 0x0017f98c
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x22
MOV RAX,-0x1
JMP 0x0017f83d
LAB_0017f962:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x21
JMP 0x0017f83b
LAB_0017f971:
MOV RAX,qword ptr [RBP + -0x40]
TEST RAX,RAX
JZ 0x0017f97d
MOV qword ptr [RAX],RBX
LAB_0017f97d:
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX],0x54
JMP 0x0017f83b
LAB_0017f98c:
MOV RAX,RCX
NEG RAX
CMP dword ptr [RBP + -0x34],0x0
CMOVZ RAX,RCX
JMP 0x0017f83d
|
ulong my_strntoull_mb2_or_mb4
(long param_1,long param_2,long param_3,int param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
int1 auVar2 [16];
int1 auVar3 [16];
bool bVar4;
bool bVar5;
ulong uVar6;
bool bVar7;
uint uVar8;
ulong uVar9;
int4 uVar10;
ulong uVar11;
long lVar12;
ulong uVar13;
ulong local_38;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
param_3 = param_3 + param_2;
*param_6 = 0;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
if (0 < (int)uVar8) {
bVar4 = false;
do {
if ((long)local_38 < 0x2b) {
if ((local_38 != 9) && (local_38 != 0x20)) {
LAB_0017f84c:
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
auVar3 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar9 = SUB168(auVar3 / auVar2,0);
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
lVar12 = param_2;
if ((int)uVar8 < 1) {
uVar11 = 0;
bVar5 = false;
goto LAB_0017f92e;
}
uVar11 = 0;
bVar5 = false;
goto LAB_0017f890;
}
}
else if (local_38 != 0x2b) {
if (local_38 != 0x2d) goto LAB_0017f84c;
bVar4 = !bVar4;
}
param_2 = param_2 + (ulong)uVar8;
uVar8 = (*pcVar1)(param_1,&local_38,param_2,param_3);
} while (0 < (int)uVar8);
}
if (param_5 != (long *)0x0) {
*param_5 = param_2;
}
uVar10 = 0x21;
if (uVar8 == 0) {
uVar10 = 0x54;
}
*param_6 = uVar10;
return 0;
while( true ) {
if (param_4 <= (int)uVar13) goto LAB_0017f937;
uVar6 = uVar11;
bVar7 = true;
if ((uVar11 <= uVar9) &&
((uVar11 != uVar9 || (uVar6 = uVar9, uVar13 <= (SUB168(auVar3 % auVar2,0) & 0xffffffff))))) {
uVar6 = uVar13 + uVar11 * (long)param_4;
bVar7 = bVar5;
}
bVar5 = bVar7;
uVar11 = uVar6;
local_38 = uVar13;
uVar8 = (*pcVar1)(param_1,&local_38,lVar12,param_3);
if ((int)uVar8 < 1) break;
LAB_0017f890:
lVar12 = (ulong)uVar8 + lVar12;
uVar13 = local_38 - 0x30;
if (9 < uVar13) {
if (local_38 - 0x41 < 0x1a) {
uVar13 = local_38 - 0x37;
}
else {
if (0x19 < local_38 - 0x61) goto LAB_0017f937;
uVar13 = local_38 - 0x57;
}
}
}
LAB_0017f92e:
if (uVar8 == 0) {
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
*param_6 = 0x54;
}
else {
LAB_0017f937:
if (param_5 != (long *)0x0) {
*param_5 = lVar12;
}
if (lVar12 != param_2) {
if (bVar5) {
*param_6 = 0x22;
return 0xffffffffffffffff;
}
if (!bVar4) {
return uVar11;
}
return -uVar11;
}
*param_6 = 0x21;
}
return 0;
}
| |
34,217 | post_add_n_dbl | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/pairing.c | static void post_add_n_dbl(vec384fp12 ret, const vec384fp6 lines[],
const POINTonE1_affine *Px2, size_t n)
{
vec384fp6 line;
post_line_by_Px2(line, lines++[0], Px2);
mul_by_xy00z0_fp12(ret, ret, line);
while (n--) {
sqr_fp12(ret, ret);
post_line_by_Px2(line, lines++[0], Px2);
mul_by_xy00z0_fp12(ret, ret, line);
}
} | O2 | c | post_add_n_dbl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x150(%rbp), %r13
movq %r13, %rdi
callq 0x5da2a
addq $0x120, %r15 # imm = 0x120
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5605e
subq $0x1, %rbx
jb 0x5db04
movq %r12, %rdi
movq %r12, %rsi
callq 0x55bce
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
jmp 0x5dace
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| post_add_n_dbl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
lea r13, [rbp+var_150]
mov rdi, r13
loc_5DACE:
call post_line_by_Px2
add r15, 120h
mov rdi, r12
mov rsi, r12
mov rdx, r13
call mul_by_xy00z0_fp12
sub rbx, 1
jb short loc_5DB04
mov rdi, r12
mov rsi, r12
call sqr_fp12
mov rdi, r13
mov rsi, r15
mov rdx, r14
jmp short loc_5DACE
loc_5DB04:
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long post_add_n_dbl(long long a1, long long a2, long long a3, long long a4)
{
long long v5; // r14
long long v6; // r15
long long result; // rax
_BYTE v9[336]; // [rsp+0h] [rbp-150h] BYREF
v5 = a3;
v6 = a2;
while ( 1 )
{
post_line_by_Px2((long long)v9, a2, a3);
v6 += 288LL;
result = mul_by_xy00z0_fp12(a1, a1, (long long)v9);
if ( a4-- == 0 )
break;
sqr_fp12(a1, a1);
a2 = v6;
a3 = v5;
}
return result;
}
| post_add_n_dbl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LEA R13,[RBP + -0x150]
MOV RDI,R13
LAB_0015dace:
CALL 0x0015da2a
ADD R15,0x120
MOV RDI,R12
MOV RSI,R12
MOV RDX,R13
CALL 0x0015605e
SUB RBX,0x1
JC 0x0015db04
MOV RDI,R12
MOV RSI,R12
CALL 0x00155bce
MOV RDI,R13
MOV RSI,R15
MOV RDX,R14
JMP 0x0015dace
LAB_0015db04:
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void post_add_n_dbl(int8 param_1,long param_2,int8 param_3,long param_4)
{
bool bVar1;
int1 local_158 [296];
while( true ) {
post_line_by_Px2(local_158,param_2,param_3);
param_2 = param_2 + 0x120;
mul_by_xy00z0_fp12(param_1,param_1,local_158);
bVar1 = param_4 == 0;
param_4 = param_4 + -1;
if (bVar1) break;
sqr_fp12(param_1,param_1);
}
return;
}
| |
34,218 | get_internal_charset | eloqsql/mysys/charset.c | static CHARSET_INFO *
get_internal_charset(MY_CHARSET_LOADER *loader, uint cs_number, myf flags)
{
char buf[FN_REFLEN];
struct charset_info_st *cs;
DBUG_ASSERT(cs_number < array_elements(all_charsets));
if ((cs= (struct charset_info_st*) all_charsets[cs_number]))
{
if (cs->state & MY_CS_READY) /* if CS is already initialized */
{
my_collation_statistics_inc_use_count(cs_number);
return cs;
}
/*
To make things thread safe we are not allowing other threads to interfere
while we may changing the cs_info_table
*/
mysql_mutex_lock(&THR_LOCK_charset);
if (!(cs->state & (MY_CS_COMPILED|MY_CS_LOADED))) /* if CS is not in memory */
{
MY_CHARSET_LOADER loader;
strxmov(get_charsets_dir(buf), cs->cs_name.str, ".xml", NullS);
my_charset_loader_init_mysys(&loader);
my_read_charset_file(&loader, buf, flags);
}
if (cs->state & MY_CS_AVAILABLE)
{
if (!(cs->state & MY_CS_READY))
{
if (!simple_8bit_charset_data_is_full(cs))
{
CHARSET_INFO *refcs= find_charset_data_inheritance_source(cs);
if (refcs)
inherit_charset_data(cs, refcs);
}
if (!simple_8bit_collation_data_is_full(cs))
{
CHARSET_INFO *refcl= find_collation_data_inheritance_source(cs, flags);
if (refcl)
inherit_collation_data(cs, refcl);
}
if (my_ci_init_charset(cs, loader) ||
my_ci_init_collation(cs, loader))
{
cs= NULL;
}
else
cs->state|= MY_CS_READY;
}
my_collation_statistics_inc_use_count(cs_number);
}
else
cs= NULL;
mysql_mutex_unlock(&THR_LOCK_charset);
}
return cs;
} | O3 | c | get_internal_charset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp # imm = 0x2C8
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl %esi, %r13d
leaq 0xb6e23f(%rip), %r12 # 0xc01d70
movq (%r12,%r13,8), %rbx
testq %rbx, %rbx
je 0x93c1a
testb $0x1, 0xd(%rbx)
jne 0x93c21
movq %rdx, %r15
movq %rdi, %r14
leaq 0xb7703b(%rip), %rax # 0xc0ab90
cmpq $0x0, 0x40(%rax)
jne 0x93e03
leaq 0xb77029(%rip), %rdi # 0xc0ab90
callq 0x29220
movl 0xc(%rbx), %eax
testb $0x9, %al
jne 0x93c0d
leaq -0x230(%rbp), %rdi
callq 0x93437
movq 0x10(%rbx), %rsi
leaq 0x497b9(%rip), %rdx # 0xdd347
movq %rax, %rdi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xd815c
leaq -0x2e0(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0xd01(%rip), %rax # 0x92eaa
movq %rax, 0x80(%rdi)
leaq -0xd00(%rip), %rax # 0x92eb9
movq %rax, 0x88(%rdi)
leaq -0xcf3(%rip), %rax # 0x92ed4
movq %rax, 0x90(%rdi)
leaq 0xd335(%rip), %rax # 0xa0f0a
movq %rax, 0x98(%rdi)
leaq 0x2f3bbd(%rip), %rax # 0x3877a0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0xd02(%rip), %rax # 0x92ef2
movq %rax, 0xa8(%rdi)
leaq -0x230(%rbp), %rsi
movq %r15, %rdx
callq 0x947e0
movl 0xc(%rbx), %eax
btl $0x9, %eax
jb 0x93c31
xorl %ebx, %ebx
jmp 0x93dc3
xorl %ebx, %ebx
jmp 0x93ddf
leaq 0xb721b8(%rip), %rax # 0xc05de0
incq (%rax,%r13,8)
jmp 0x93ddf
btl $0x8, %eax
jb 0x93db8
cmpq $0x0, 0x40(%rbx)
je 0x93c57
cmpq $0x0, 0x50(%rbx)
je 0x93c57
cmpq $0x0, 0x48(%rbx)
je 0x93c57
cmpq $0x0, 0x68(%rbx)
jne 0x93c86
movq 0x10(%rbx), %rdi
movl $0x20, %esi
callq 0x938e8
testl %eax, %eax
je 0x93c86
cmpl %eax, (%rbx)
je 0x93c86
movl %eax, %eax
movq (%r12,%rax,8), %rsi
testq %rsi, %rsi
je 0x93c86
testb $0x2, 0xd(%rsi)
je 0x93c86
movq %rbx, %rdi
callq 0x94a29
cmpq $0x0, 0x58(%rbx)
jne 0x93d7a
testb $0x10, 0xc(%rbx)
jne 0x93d7a
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x93d7a
leaq 0x4971e(%rip), %rsi # 0xdd3cd
movl $0x8, %edx
movq %rax, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rdi
callq 0x291d0
movq -0x2e8(%rbp), %rcx
testl %eax, %eax
jne 0x93d7a
leaq 0x8(%rcx), %rdi
movq %rdi, -0x2f0(%rbp)
movl $0x5d, %esi
callq 0x29440
testq %rax, %rax
setne %dl
movq -0x2e8(%rbp), %rcx
addq $0x28, %rcx
cmpq %rax, %rcx
seta %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x93d7a
movq -0x2f0(%rbp), %rsi
subq %rsi, %rax
leaq -0x2e0(%rbp), %rdi
movl $0x21, %ecx
movq %rax, %rdx
movq %rax, -0x2e8(%rbp)
callq 0x29420
movq -0x2e8(%rbp), %rax
movb $0x0, -0x2e0(%rbp,%rax)
leaq -0x2e0(%rbp), %rdi
movq %r15, %rsi
callq 0x935cb
testl %eax, %eax
je 0x93d7a
cmpl %eax, (%rbx)
je 0x93d7a
movl %eax, %eax
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0x93d7a
testb $0x2, 0xd(%rax)
je 0x93d7a
cmpq $0x0, 0x58(%rbx)
jne 0x93d7a
testb $0x10, 0xc(%rbx)
jne 0x93d7a
movq 0x58(%rax), %rax
movq %rax, 0x58(%rbx)
movq 0xb8(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x93d95
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testb %al, %al
jne 0x93db0
movq 0xc0(%rbx), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x93db4
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
testb %al, %al
je 0x93db4
xorl %ebx, %ebx
jmp 0x93db8
orb $0x1, 0xd(%rbx)
leaq 0xb72021(%rip), %rax # 0xc05de0
incq (%rax,%r13,8)
leaq 0xb76dc6(%rip), %rax # 0xc0ab90
movq 0x40(%rax), %rdi
testq %rdi, %rdi
jne 0x93e0d
leaq 0xb76db6(%rip), %rdi # 0xc0ab90
callq 0x291e0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x93e1f
movq %rbx, %rax
addq $0x2c8, %rsp # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2e8a7
jmp 0x93b6c
leaq 0x2f42ac(%rip), %rax # 0x3880c0
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x93dd3
callq 0x29270
| get_internal_charset:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2C8h
mov rax, fs:28h
mov [rbp+var_30], rax
mov r13d, esi
lea r12, all_charsets
mov rbx, [r12+r13*8]
test rbx, rbx
jz loc_93C1A
test byte ptr [rbx+0Dh], 1
jnz loc_93C21
mov r15, rdx
mov r14, rdi
lea rax, THR_LOCK_charset
cmp qword ptr [rax+40h], 0
jnz loc_93E03
lea rdi, THR_LOCK_charset
call _pthread_mutex_lock
loc_93B6C:
mov eax, [rbx+0Ch]
test al, 9
jnz loc_93C0D
lea rdi, [rbp+var_230]
call get_charsets_dir
mov rsi, [rbx+10h]
lea rdx, aIndexXml+5; ".xml"
mov rdi, rax
xor ecx, ecx
xor eax, eax
call strxmov
lea rdi, [rbp+var_2E0]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
lea rsi, [rbp+var_230]
mov rdx, r15
call my_read_charset_file
mov eax, [rbx+0Ch]
loc_93C0D:
bt eax, 9
jb short loc_93C31
xor ebx, ebx
jmp loc_93DC3
loc_93C1A:
xor ebx, ebx
jmp loc_93DDF
loc_93C21:
lea rax, my_collation_statistics
inc qword ptr [rax+r13*8]
jmp loc_93DDF
loc_93C31:
bt eax, 8
jb loc_93DB8
cmp qword ptr [rbx+40h], 0
jz short loc_93C57
cmp qword ptr [rbx+50h], 0
jz short loc_93C57
cmp qword ptr [rbx+48h], 0
jz short loc_93C57
cmp qword ptr [rbx+68h], 0
jnz short loc_93C86
loc_93C57:
mov rdi, [rbx+10h]
mov esi, 20h ; ' '
call get_charset_number_internal
test eax, eax
jz short loc_93C86
cmp [rbx], eax
jz short loc_93C86
mov eax, eax
mov rsi, [r12+rax*8]
test rsi, rsi
jz short loc_93C86
test byte ptr [rsi+0Dh], 2
jz short loc_93C86
mov rdi, rbx
call inherit_charset_data
loc_93C86:
cmp qword ptr [rbx+58h], 0
jnz loc_93D7A
test byte ptr [rbx+0Ch], 10h
jnz loc_93D7A
mov rax, [rbx+38h]
test rax, rax
jz loc_93D7A
lea rsi, aImport; "[import "
mov edx, 8
mov [rbp+var_2E8], rax
mov rdi, [rbp+var_2E8]
call _strncmp
mov rcx, [rbp+var_2E8]
test eax, eax
jnz loc_93D7A
lea rdi, [rcx+8]
mov [rbp+var_2F0], rdi
mov esi, 5Dh ; ']'
call _strchr
test rax, rax
setnz dl
mov rcx, [rbp+var_2E8]
add rcx, 28h ; '('
cmp rcx, rax
setnbe cl
and cl, dl
cmp cl, 1
jnz short loc_93D7A
mov rsi, [rbp+var_2F0]
sub rax, rsi
lea rdi, [rbp+var_2E0]
mov ecx, 21h ; '!'
mov rdx, rax
mov [rbp+var_2E8], rax
call ___memcpy_chk
mov rax, [rbp+var_2E8]
mov [rbp+rax+var_2E0], 0
lea rdi, [rbp+var_2E0]
mov rsi, r15
call get_collation_number
test eax, eax
jz short loc_93D7A
cmp [rbx], eax
jz short loc_93D7A
mov eax, eax
mov rax, [r12+rax*8]
test rax, rax
jz short loc_93D7A
test byte ptr [rax+0Dh], 2
jz short loc_93D7A
cmp qword ptr [rbx+58h], 0
jnz short loc_93D7A
test byte ptr [rbx+0Ch], 10h
jnz short loc_93D7A
mov rax, [rax+58h]
mov [rbx+58h], rax
loc_93D7A:
mov rax, [rbx+0B8h]
mov rax, [rax]
test rax, rax
jz short loc_93D95
mov rdi, rbx
mov rsi, r14
call rax
test al, al
jnz short loc_93DB0
loc_93D95:
mov rax, [rbx+0C0h]
mov rax, [rax]
test rax, rax
jz short loc_93DB4
mov rdi, rbx
mov rsi, r14
call rax
test al, al
jz short loc_93DB4
loc_93DB0:
xor ebx, ebx
jmp short loc_93DB8
loc_93DB4:
or byte ptr [rbx+0Dh], 1
loc_93DB8:
lea rax, my_collation_statistics
inc qword ptr [rax+r13*8]
loc_93DC3:
lea rax, THR_LOCK_charset
mov rdi, [rax+40h]
test rdi, rdi
jnz short loc_93E0D
loc_93DD3:
lea rdi, THR_LOCK_charset
call _pthread_mutex_unlock
loc_93DDF:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_93E1F
mov rax, rbx
add rsp, 2C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_93E03:
call get_internal_charset_cold_1
jmp loc_93B6C
loc_93E0D:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_93DD3
loc_93E1F:
call ___stack_chk_fail
| long long get_internal_charset(long long a1, unsigned int a2, long long a3)
{
long long v3; // r13
long long v4; // rbx
long long v6; // rdx
long long v7; // rcx
int v8; // eax
int charsets_dir; // eax
int v10; // r8d
int v11; // r9d
int charset_number_internal; // eax
long long v13; // rsi
long long v14; // rax
int v15; // eax
unsigned long long v16; // rax
int collation_number; // eax
long long v18; // rax
unsigned __int8 ( *v19)(long long, long long, long long, long long); // rax
unsigned __int8 ( *v20)(long long, long long, long long, long long); // rax
long long v22; // [rsp+0h] [rbp-2F0h]
long long v23; // [rsp+8h] [rbp-2E8h]
_BYTE v24[128]; // [rsp+10h] [rbp-2E0h] BYREF
long long ( *v25)(long long); // [rsp+90h] [rbp-260h]
long long ( *v26)(long long); // [rsp+98h] [rbp-258h]
long long ( *v27)(long long, long long, long long, long long, long long, long long); // [rsp+A0h] [rbp-250h]
long long ( *v28)(_QWORD); // [rsp+A8h] [rbp-248h]
long long ( *v29)(); // [rsp+B0h] [rbp-240h]
long long ( *v30)(unsigned int *); // [rsp+B8h] [rbp-238h]
_BYTE v31[512]; // [rsp+C0h] [rbp-230h] BYREF
unsigned long long v32; // [rsp+2C0h] [rbp-30h]
v32 = __readfsqword(0x28u);
v3 = a2;
v4 = all_charsets[a2];
if ( !v4 )
return 0LL;
if ( (*(_BYTE *)(v4 + 13) & 1) != 0 )
{
++my_collation_statistics[a2];
}
else
{
if ( THR_LOCK_charset[8] )
get_internal_charset_cold_1();
else
pthread_mutex_lock(THR_LOCK_charset);
v8 = *(_DWORD *)(v4 + 12);
if ( (v8 & 9) == 0 )
{
charsets_dir = get_charsets_dir((long long)v31);
strxmov(charsets_dir, *(_QWORD *)(v4 + 16), (unsigned int)".xml", 0, v10, v11);
v24[0] = 0;
v25 = my_once_alloc_c;
v26 = my_malloc_c;
v27 = my_realloc_c;
v28 = my_free;
v29 = my_charset_error_reporter;
v30 = add_collation;
my_read_charset_file(v24, v31, a3);
v8 = *(_DWORD *)(v4 + 12);
}
if ( (v8 & 0x200) != 0 )
{
if ( (v8 & 0x100) == 0 )
{
if ( !*(_QWORD *)(v4 + 64) || !*(_QWORD *)(v4 + 80) || !*(_QWORD *)(v4 + 72) || !*(_QWORD *)(v4 + 104) )
{
charset_number_internal = get_charset_number_internal(*(_QWORD *)(v4 + 16), 32);
if ( charset_number_internal )
{
if ( *(_DWORD *)v4 != charset_number_internal )
{
v13 = all_charsets[charset_number_internal];
if ( v13 )
{
if ( (*(_BYTE *)(v13 + 13) & 2) != 0 )
inherit_charset_data(v4);
}
}
}
}
if ( !*(_QWORD *)(v4 + 88) && (*(_BYTE *)(v4 + 12) & 0x10) == 0 )
{
v14 = *(_QWORD *)(v4 + 56);
if ( v14 )
{
v23 = *(_QWORD *)(v4 + 56);
v15 = strncmp(v14, "[import ", 8LL);
v7 = v23;
if ( !v15 )
{
v22 = v23 + 8;
v16 = strchr(v23 + 8, 93LL);
LOBYTE(v6) = v16 != 0;
v7 = v23 + 40;
LOBYTE(v7) = v16 != 0 && v23 + 40 > v16;
if ( (_BYTE)v7 == 1 )
{
v23 = v16 - v22;
__memcpy_chk(v24, v22, v16 - v22, 33LL);
v24[v23] = 0;
collation_number = get_collation_number((long long)v24, a3);
if ( collation_number )
{
if ( *(_DWORD *)v4 != collation_number )
{
v18 = all_charsets[collation_number];
if ( v18 )
{
if ( (*(_BYTE *)(v18 + 13) & 2) != 0 && !*(_QWORD *)(v4 + 88) && (*(_BYTE *)(v4 + 12) & 0x10) == 0 )
*(_QWORD *)(v4 + 88) = *(_QWORD *)(v18 + 88);
}
}
}
}
}
}
}
v19 = **(unsigned __int8 ( ***)(long long, long long, long long, long long))(v4 + 184);
if ( v19 && v19(v4, a1, v6, v7)
|| (v20 = **(unsigned __int8 ( ***)(long long, long long, long long, long long))(v4 + 192)) != 0LL
&& v20(v4, a1, v6, v7) )
{
v4 = 0LL;
}
else
{
*(_BYTE *)(v4 + 13) |= 1u;
}
}
++my_collation_statistics[v3];
}
else
{
v4 = 0LL;
}
if ( THR_LOCK_charset[8] )
PSI_server[44]();
pthread_mutex_unlock(THR_LOCK_charset);
}
return v4;
}
| get_internal_charset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2c8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R13D,ESI
LEA R12,[0xd01d70]
MOV RBX,qword ptr [R12 + R13*0x8]
TEST RBX,RBX
JZ 0x00193c1a
TEST byte ptr [RBX + 0xd],0x1
JNZ 0x00193c21
MOV R15,RDX
MOV R14,RDI
LEA RAX,[0xd0ab90]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x00193e03
LEA RDI,[0xd0ab90]
CALL 0x00129220
LAB_00193b6c:
MOV EAX,dword ptr [RBX + 0xc]
TEST AL,0x9
JNZ 0x00193c0d
LEA RDI,[RBP + -0x230]
CALL 0x00193437
MOV RSI,qword ptr [RBX + 0x10]
LEA RDX,[0x1dd347]
MOV RDI,RAX
XOR ECX,ECX
XOR EAX,EAX
CALL 0x001d815c
LEA RDI,[RBP + -0x2e0]
MOV byte ptr [RDI],0x0
LEA RAX,[0x192eaa]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x192eb9]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x192ed4]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x1a0f0a]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x4877a0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x192ef2]
MOV qword ptr [RDI + 0xa8],RAX
LEA RSI,[RBP + -0x230]
MOV RDX,R15
CALL 0x001947e0
MOV EAX,dword ptr [RBX + 0xc]
LAB_00193c0d:
BT EAX,0x9
JC 0x00193c31
XOR EBX,EBX
JMP 0x00193dc3
LAB_00193c1a:
XOR EBX,EBX
JMP 0x00193ddf
LAB_00193c21:
LEA RAX,[0xd05de0]
INC qword ptr [RAX + R13*0x8]
JMP 0x00193ddf
LAB_00193c31:
BT EAX,0x8
JC 0x00193db8
CMP qword ptr [RBX + 0x40],0x0
JZ 0x00193c57
CMP qword ptr [RBX + 0x50],0x0
JZ 0x00193c57
CMP qword ptr [RBX + 0x48],0x0
JZ 0x00193c57
CMP qword ptr [RBX + 0x68],0x0
JNZ 0x00193c86
LAB_00193c57:
MOV RDI,qword ptr [RBX + 0x10]
MOV ESI,0x20
CALL 0x001938e8
TEST EAX,EAX
JZ 0x00193c86
CMP dword ptr [RBX],EAX
JZ 0x00193c86
MOV EAX,EAX
MOV RSI,qword ptr [R12 + RAX*0x8]
TEST RSI,RSI
JZ 0x00193c86
TEST byte ptr [RSI + 0xd],0x2
JZ 0x00193c86
MOV RDI,RBX
CALL 0x00194a29
LAB_00193c86:
CMP qword ptr [RBX + 0x58],0x0
JNZ 0x00193d7a
TEST byte ptr [RBX + 0xc],0x10
JNZ 0x00193d7a
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x00193d7a
LEA RSI,[0x1dd3cd]
MOV EDX,0x8
MOV qword ptr [RBP + -0x2e8],RAX
MOV RDI,qword ptr [RBP + -0x2e8]
CALL 0x001291d0
MOV RCX,qword ptr [RBP + -0x2e8]
TEST EAX,EAX
JNZ 0x00193d7a
LEA RDI,[RCX + 0x8]
MOV qword ptr [RBP + -0x2f0],RDI
MOV ESI,0x5d
CALL 0x00129440
TEST RAX,RAX
SETNZ DL
MOV RCX,qword ptr [RBP + -0x2e8]
ADD RCX,0x28
CMP RCX,RAX
SETA CL
AND CL,DL
CMP CL,0x1
JNZ 0x00193d7a
MOV RSI,qword ptr [RBP + -0x2f0]
SUB RAX,RSI
LEA RDI,[RBP + -0x2e0]
MOV ECX,0x21
MOV RDX,RAX
MOV qword ptr [RBP + -0x2e8],RAX
CALL 0x00129420
MOV RAX,qword ptr [RBP + -0x2e8]
MOV byte ptr [RBP + RAX*0x1 + -0x2e0],0x0
LEA RDI,[RBP + -0x2e0]
MOV RSI,R15
CALL 0x001935cb
TEST EAX,EAX
JZ 0x00193d7a
CMP dword ptr [RBX],EAX
JZ 0x00193d7a
MOV EAX,EAX
MOV RAX,qword ptr [R12 + RAX*0x8]
TEST RAX,RAX
JZ 0x00193d7a
TEST byte ptr [RAX + 0xd],0x2
JZ 0x00193d7a
CMP qword ptr [RBX + 0x58],0x0
JNZ 0x00193d7a
TEST byte ptr [RBX + 0xc],0x10
JNZ 0x00193d7a
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBX + 0x58],RAX
LAB_00193d7a:
MOV RAX,qword ptr [RBX + 0xb8]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00193d95
MOV RDI,RBX
MOV RSI,R14
CALL RAX
TEST AL,AL
JNZ 0x00193db0
LAB_00193d95:
MOV RAX,qword ptr [RBX + 0xc0]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00193db4
MOV RDI,RBX
MOV RSI,R14
CALL RAX
TEST AL,AL
JZ 0x00193db4
LAB_00193db0:
XOR EBX,EBX
JMP 0x00193db8
LAB_00193db4:
OR byte ptr [RBX + 0xd],0x1
LAB_00193db8:
LEA RAX,[0xd05de0]
INC qword ptr [RAX + R13*0x8]
LAB_00193dc3:
LEA RAX,[0xd0ab90]
MOV RDI,qword ptr [RAX + 0x40]
TEST RDI,RDI
JNZ 0x00193e0d
LAB_00193dd3:
LEA RDI,[0xd0ab90]
CALL 0x001291e0
LAB_00193ddf:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00193e1f
MOV RAX,RBX
ADD RSP,0x2c8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00193e03:
CALL 0x0012e8a7
JMP 0x00193b6c
LAB_00193e0d:
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00193dd3
LAB_00193e1f:
CALL 0x00129270
|
uint * get_internal_charset(int8 param_1,ulong param_2,int8 param_3)
{
char *__s;
char *__s1;
long lVar1;
char cVar2;
uint uVar3;
int iVar4;
int8 uVar5;
char *pcVar6;
uint *puVar7;
long in_FS_OFFSET;
int1 local_2e8 [128];
code *local_268;
code *local_260;
code *local_258;
code *local_250;
int *local_248;
code *local_240;
int1 local_238 [512];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
param_2 = param_2 & 0xffffffff;
puVar7 = (uint *)(&all_charsets)[param_2];
if (puVar7 == (uint *)0x0) {
puVar7 = (uint *)0x0;
goto LAB_00193ddf;
}
if ((*(byte *)((long)puVar7 + 0xd) & 1) != 0) {
*(long *)(my_collation_statistics + param_2 * 8) =
*(long *)(my_collation_statistics + param_2 * 8) + 1;
goto LAB_00193ddf;
}
if (THR_LOCK_charset._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_charset);
}
else {
get_internal_charset_cold_1();
}
uVar3 = puVar7[3];
if ((uVar3 & 9) == 0) {
uVar5 = get_charsets_dir(local_238);
strxmov(uVar5,*(int8 *)(puVar7 + 4),".xml",0);
local_2e8[0] = 0;
local_268 = my_once_alloc_c;
local_260 = my_malloc_c;
local_258 = my_realloc_c;
local_250 = my_free;
local_248 = my_charset_error_reporter;
local_240 = add_collation;
my_read_charset_file(local_2e8,local_238,param_3);
uVar3 = puVar7[3];
}
if ((uVar3 >> 9 & 1) == 0) {
puVar7 = (uint *)0x0;
}
else {
if ((uVar3 >> 8 & 1) == 0) {
if ((((*(long *)(puVar7 + 0x10) == 0) || (*(long *)(puVar7 + 0x14) == 0)) ||
(*(long *)(puVar7 + 0x12) == 0)) || (*(long *)(puVar7 + 0x1a) == 0)) {
uVar3 = get_charset_number_internal(*(int8 *)(puVar7 + 4),0x20);
if (((uVar3 != 0) && (*puVar7 != uVar3)) &&
(((&all_charsets)[uVar3] != 0 && ((*(byte *)((&all_charsets)[uVar3] + 0xd) & 2) != 0))))
{
inherit_charset_data(puVar7);
}
}
if (((*(long *)(puVar7 + 0x16) == 0) && ((puVar7[3] & 0x10) == 0)) &&
(__s1 = *(char **)(puVar7 + 0xe), __s1 != (char *)0x0)) {
iVar4 = strncmp(__s1,"[import ",8);
if (iVar4 == 0) {
__s = __s1 + 8;
pcVar6 = strchr(__s,0x5d);
if (pcVar6 < __s1 + 0x28 && pcVar6 != (char *)0x0) {
__memcpy_chk(local_2e8,__s,(long)pcVar6 - (long)__s,0x21);
local_2e8[(long)pcVar6 - (long)__s] = 0;
uVar3 = get_collation_number(local_2e8,param_3);
if (((((uVar3 != 0) && (*puVar7 != uVar3)) &&
(lVar1 = (&all_charsets)[uVar3], lVar1 != 0)) &&
(((*(byte *)(lVar1 + 0xd) & 2) != 0 && (*(long *)(puVar7 + 0x16) == 0)))) &&
((puVar7[3] & 0x10) == 0)) {
*(int8 *)(puVar7 + 0x16) = *(int8 *)(lVar1 + 0x58);
}
}
}
}
if ((code *)**(int8 **)(puVar7 + 0x2e) == (code *)0x0) {
LAB_00193d95:
if ((code *)**(int8 **)(puVar7 + 0x30) != (code *)0x0) {
cVar2 = (*(code *)**(int8 **)(puVar7 + 0x30))(puVar7,param_1);
if (cVar2 != '\0') goto LAB_00193db0;
}
*(byte *)((long)puVar7 + 0xd) = *(byte *)((long)puVar7 + 0xd) | 1;
}
else {
cVar2 = (*(code *)**(int8 **)(puVar7 + 0x2e))(puVar7,param_1);
if (cVar2 == '\0') goto LAB_00193d95;
LAB_00193db0:
puVar7 = (uint *)0x0;
}
}
*(long *)(my_collation_statistics + param_2 * 8) =
*(long *)(my_collation_statistics + param_2 * 8) + 1;
}
if (THR_LOCK_charset._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_charset);
LAB_00193ddf:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return puVar7;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,219 | my_realloc | eloqsql/mysys/my_malloc.c | void *my_realloc(PSI_memory_key key, void *old_point, size_t size, myf my_flags)
{
my_memory_header *old_mh, *mh;
void *point;
size_t old_size;
my_bool old_flags;
DBUG_ENTER("my_realloc");
DBUG_PRINT("my",("ptr: %p size: %zu flags: %lu", old_point, size, my_flags));
DBUG_ASSERT(size > 0);
if (!old_point && (my_flags & MY_ALLOW_ZERO_PTR))
DBUG_RETURN(my_malloc(key, size, my_flags));
old_mh= USER_TO_HEADER(old_point);
old_size= old_mh->m_size & ~1;
old_flags= old_mh->m_size & 1;
DBUG_ASSERT(old_mh->m_key == key || old_mh->m_key == PSI_NOT_INSTRUMENTED);
DBUG_ASSERT(old_flags == MY_TEST(my_flags & MY_THREAD_SPECIFIC));
size= ALIGN_SIZE(size);
mh= sf_realloc(old_mh, size + HEADER_SIZE, my_flags);
if (mh == NULL)
{
if (size < old_size)
DBUG_RETURN(old_point);
my_errno=errno;
if (my_flags & MY_FREE_ON_ERROR)
{
/* my_free will take care of size accounting */
my_free(old_point);
old_point= 0;
}
if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL + ME_FATAL), size);
point= NULL;
}
else
{
mh->m_size= size | old_flags;
mh->m_key= PSI_CALL_memory_realloc(key, old_size, size, & mh->m_owner);
update_malloc_size((longlong)size - (longlong)old_size, old_flags);
point= HEADER_TO_USER(mh);
}
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN(point);
} | O3 | c | my_realloc:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
testq %rsi, %rsi
setne %al
testb $0x40, %cl
sete %dl
orb %al, %dl
je 0x28448
movq %rsi, %r15
movl %edi, -0x2c(%rbp)
movq %rcx, -0x38(%rbp)
leaq -0x18(%rsi), %rdi
movq -0x10(%rsi), %r12
movq %r12, %r13
andq $-0x2, %r13
addq $0x7, %rbx
andq $-0x8, %rbx
leaq 0x18(%rbx), %rsi
callq 0x245e0
testq %rax, %rax
je 0x28461
movq %rax, %r14
andl $0x1, %r12d
movq %r12, %rax
orq %rbx, %rax
movq %rax, 0x8(%r14)
leaq 0x2cb6b1(%rip), %rax # 0x2f3ac8
movq (%rax), %rax
movl -0x2c(%rbp), %edi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x3e8(%rax)
movl %eax, 0x10(%r14)
subq %r13, %rbx
movq %rbx, %rdi
movl %r12d, %esi
callq *0x2cb151(%rip) # 0x2f3590
addq $0x18, %r14
movq %r14, %r15
jmp 0x284a4
movq %rbx, %rsi
movq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x28289
cmpq %r13, %rbx
jb 0x284a4
callq 0x24050
movl (%rax), %r14d
callq 0x28ca6
movl %r14d, (%rax)
movq -0x38(%rbp), %r14
testb %r14b, %r14b
jns 0x28487
movq %r15, %rdi
callq 0x284b6
xorl %r15d, %r15d
testb $0x18, %r14b
je 0x284a4
movl $0x1004, %esi # imm = 0x1004
movl $0x5, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2e7bf
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_realloc:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
test rsi, rsi
setnz al
test cl, 40h
setz dl
or dl, al
jz short loc_28448
mov r15, rsi
mov [rbp+var_2C], edi
mov [rbp+var_38], rcx
lea rdi, [rsi-18h]
mov r12, [rsi-10h]
mov r13, r12
and r13, 0FFFFFFFFFFFFFFFEh
add rbx, 7
and rbx, 0FFFFFFFFFFFFFFF8h
lea rsi, [rbx+18h]
call _realloc
test rax, rax
jz short loc_28461
mov r14, rax
and r12d, 1
mov rax, r12
or rax, rbx
mov [r14+8], rax
lea rax, PSI_server
mov rax, [rax]
mov edi, [rbp+var_2C]
mov rsi, r13
mov rdx, rbx
mov rcx, r14
call qword ptr [rax+3E8h]
mov [r14+10h], eax
sub rbx, r13
mov rdi, rbx
mov esi, r12d
call cs:update_malloc_size
add r14, 18h
mov r15, r14
jmp short loc_284A4
loc_28448:
mov rsi, rbx
mov rdx, rcx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp my_malloc
loc_28461:
cmp rbx, r13
jb short loc_284A4
call ___errno_location
mov r14d, [rax]
call _my_thread_var
mov [rax], r14d
mov r14, [rbp+var_38]
test r14b, r14b
jns short loc_28487
mov rdi, r15
call my_free
loc_28487:
xor r15d, r15d
test r14b, 18h
jz short loc_284A4
mov esi, 1004h
mov edi, 5
mov rdx, rbx
xor eax, eax
call my_error
loc_284A4:
mov rax, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_realloc(unsigned int a1, long long a2, unsigned long long a3, char a4)
{
long long v4; // r15
long long v5; // r12
unsigned long long v6; // r13
unsigned long long v7; // rbx
long long v8; // rax
long long v9; // r14
int v11; // r14d
int v12; // ecx
int v13; // r8d
int v14; // r9d
if ( a2 == 0 && (a4 & 0x40) != 0 )
return my_malloc(a1, a3, a4);
v4 = a2;
v5 = *(_QWORD *)(a2 - 16);
v6 = v5 & 0xFFFFFFFFFFFFFFFELL;
v7 = (a3 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v8 = realloc(a2 - 24, v7 + 24);
if ( v8 )
{
v9 = v8;
*(_QWORD *)(v8 + 8) = v7 | v5 & 1;
*(_DWORD *)(v8 + 16) = (*((long long ( **)(_QWORD, unsigned long long, unsigned long long, long long))PSI_server[0]
+ 125))(
a1,
v6,
v7,
v8);
update_malloc_size();
return v9 + 24;
}
else if ( v7 >= v6 )
{
v11 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var() = v11;
if ( a4 < 0 )
my_free(a2);
v4 = 0LL;
if ( (a4 & 0x18) != 0 )
my_error(5, 4100, v7, v12, v13, v14);
}
return v4;
}
| my_realloc:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
TEST RSI,RSI
SETNZ AL
TEST CL,0x40
SETZ DL
OR DL,AL
JZ 0x00128448
MOV R15,RSI
MOV dword ptr [RBP + -0x2c],EDI
MOV qword ptr [RBP + -0x38],RCX
LEA RDI,[RSI + -0x18]
MOV R12,qword ptr [RSI + -0x10]
MOV R13,R12
AND R13,-0x2
ADD RBX,0x7
AND RBX,-0x8
LEA RSI,[RBX + 0x18]
CALL 0x001245e0
TEST RAX,RAX
JZ 0x00128461
MOV R14,RAX
AND R12D,0x1
MOV RAX,R12
OR RAX,RBX
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x3f3ac8]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x2c]
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R14
CALL qword ptr [RAX + 0x3e8]
MOV dword ptr [R14 + 0x10],EAX
SUB RBX,R13
MOV RDI,RBX
MOV ESI,R12D
CALL qword ptr [0x003f3590]
ADD R14,0x18
MOV R15,R14
JMP 0x001284a4
LAB_00128448:
MOV RSI,RBX
MOV RDX,RCX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00128289
LAB_00128461:
CMP RBX,R13
JC 0x001284a4
CALL 0x00124050
MOV R14D,dword ptr [RAX]
CALL 0x00128ca6
MOV dword ptr [RAX],R14D
MOV R14,qword ptr [RBP + -0x38]
TEST R14B,R14B
JNS 0x00128487
MOV RDI,R15
CALL 0x001284b6
LAB_00128487:
XOR R15D,R15D
TEST R14B,0x18
JZ 0x001284a4
MOV ESI,0x1004
MOV EDI,0x5
MOV RDX,RBX
XOR EAX,EAX
CALL 0x0012e7bf
LAB_001284a4:
MOV RAX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_realloc(ulong param_1,long param_2,long param_3,ulong param_4)
{
int iVar1;
int4 uVar2;
void *pvVar3;
long lVar4;
int *piVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
if ((param_4 & 0x40) == 0 || param_2 != 0) {
uVar7 = *(ulong *)(param_2 + -0x10);
uVar8 = uVar7 & 0xfffffffffffffffe;
uVar6 = param_3 + 7U & 0xfffffffffffffff8;
pvVar3 = realloc((void *)(param_2 + -0x18),uVar6 + 0x18);
if (pvVar3 == (void *)0x0) {
if (uVar8 <= uVar6) {
piVar5 = __errno_location();
iVar1 = *piVar5;
piVar5 = (int *)_my_thread_var();
*piVar5 = iVar1;
if ((char)param_4 < '\0') {
my_free(param_2);
}
param_2 = 0;
if ((param_4 & 0x18) != 0) {
my_error(5,0x1004,uVar6);
param_2 = 0;
}
}
}
else {
uVar7 = (ulong)((uint)uVar7 & 1);
*(ulong *)((long)pvVar3 + 8) = uVar7 | uVar6;
uVar2 = (**(code **)(PSI_server + 1000))(param_1 & 0xffffffff,uVar8,uVar6,pvVar3);
*(int4 *)((long)pvVar3 + 0x10) = uVar2;
(*(code *)update_malloc_size)(uVar6 - uVar8,uVar7);
param_2 = (long)pvVar3 + 0x18;
}
return param_2;
}
lVar4 = my_malloc(param_1,param_3,param_4);
return lVar4;
}
| |
34,220 | mi_recinfo_write | eloqsql/storage/myisam/mi_open.c | uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
{
uchar buff[MI_COLUMNDEF_SIZE];
uchar *ptr=buff;
mi_int2store(ptr,recinfo->type); ptr +=2;
mi_int2store(ptr,recinfo->length); ptr +=2;
*ptr++ = recinfo->null_bit;
mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
} | O0 | c | mi_recinfo_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0xf(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movb -0x2c(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x2b(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movb -0x30(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x2f(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0xc(%rax), %dl
movq -0x28(%rbp), %rax
movq %rax, %rsi
incq %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax)
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %eax
movl %eax, -0x34(%rbp)
movb -0x34(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x33(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %r8
subq %rcx, %r8
leaq 0xa0413(%rip), %rdi # 0x159afb
movl $0x4e3, %esi # imm = 0x4E3
movl $0x4, %r9d
callq 0xb8400
testq %rax, %rax
setne %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb971f
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| mi_recinfo_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
lea rcx, [rbp+var_F]
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_2C], eax
mov dl, byte ptr [rbp+var_2C]
mov rax, [rbp+var_28]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_2C+1]
mov rax, [rbp+var_28]
mov [rax], dl
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+4]
mov [rbp+var_30], eax
mov dl, byte ptr [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_30+1]
mov rax, [rbp+var_28]
mov [rax], dl
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov dl, [rax+0Ch]
mov rax, [rbp+var_28]
mov rsi, rax
inc rsi
mov [rbp+var_28], rsi
mov [rax], dl
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+0Eh]
mov [rbp+var_34], eax
mov dl, byte ptr [rbp+var_34]
mov rax, [rbp+var_28]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_34+1]
mov rax, [rbp+var_28]
mov [rax], dl
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov edx, [rbp+var_14]
mov r8, [rbp+var_28]
sub r8, rcx
lea rdi, aWorkspaceLlm4b_29; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4E3h
mov r9d, 4
call inline_mysql_file_write_2
test rax, rax
setnz al
movzx eax, al
mov [rbp+var_38], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B971F
mov eax, [rbp+var_38]
add rsp, 40h
pop rbp
retn
loc_B971F:
call ___stack_chk_fail
| _BOOL8 mi_recinfo_write(unsigned int a1, long long a2)
{
__int16 v2; // kr00_2
__int16 v3; // kr02_2
__int16 v4; // kr04_2
_BYTE v6[7]; // [rsp+31h] [rbp-Fh] BYREF
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
v2 = *(_DWORD *)a2;
v6[0] = HIBYTE(v2);
v6[1] = v2;
v3 = *(_WORD *)(a2 + 4);
v6[2] = HIBYTE(v3);
v6[3] = v3;
v6[4] = *(_BYTE *)(a2 + 12);
v4 = *(_WORD *)(a2 + 14);
v6[5] = HIBYTE(v4);
v6[6] = v4;
return inline_mysql_file_write_2(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
0x4E3u,
a1,
(long long)v6,
7LL,
4LL) != 0;
}
| mi_recinfo_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
LEA RCX,[RBP + -0xf]
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
MOV DL,byte ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x2b]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x30],EAX
MOV DL,byte ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x2f]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV DL,byte ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RAX
INC RSI
MOV qword ptr [RBP + -0x28],RSI
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0xe]
MOV dword ptr [RBP + -0x34],EAX
MOV DL,byte ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x33]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
MOV EDX,dword ptr [RBP + -0x14]
MOV R8,qword ptr [RBP + -0x28]
SUB R8,RCX
LEA RDI,[0x259afb]
MOV ESI,0x4e3
MOV R9D,0x4
CALL 0x001b8400
TEST RAX,RAX
SETNZ AL
MOVZX EAX,AL
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b971f
MOV EAX,dword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBP
RET
LAB_001b971f:
CALL 0x0012a250
|
bool mi_recinfo_write(int4 param_1,int4 *param_2)
{
long lVar1;
long in_FS_OFFSET;
int1 local_3c;
int1 uStack_3b;
int1 local_38;
int1 uStack_37;
int1 local_34;
int1 uStack_33;
int1 local_17;
int1 local_16;
int1 local_15;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_34 = (int1)*param_2;
local_16 = local_34;
uStack_33 = (int1)((uint)*param_2 >> 8);
local_17 = uStack_33;
local_38 = (int1)*(int2 *)(param_2 + 1);
local_14 = local_38;
uStack_37 = (int1)((ushort)*(int2 *)(param_2 + 1) >> 8);
local_15 = uStack_37;
local_13 = *(int1 *)(param_2 + 3);
local_3c = (int1)*(int2 *)((long)param_2 + 0xe);
local_11 = local_3c;
uStack_3b = (int1)((ushort)*(int2 *)((long)param_2 + 0xe) >> 8);
local_12 = uStack_3b;
lVar1 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x4e3,
param_1,&local_17,(long)&local_10 - (long)&local_17,4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return lVar1 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,221 | my_error | eloqsql/mysys/my_error.c | void my_error(uint nr, myf MyFlags, ...)
{
const char *format;
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d", nr, MyFlags, errno));
if (!(format = my_get_err_msg(nr)))
(void) my_snprintf(ebuff, sizeof(ebuff), "Unknown error %d", nr);
else
{
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
}
(*error_handler_hook)(nr, ebuff, MyFlags);
DBUG_VOID_RETURN;
} | O0 | c | my_error:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
testb %al, %al
je 0xefb87
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %r9, -0x2c8(%rbp)
movq %r8, -0x2d0(%rbp)
movq %rcx, -0x2d8(%rbp)
movq %rdx, -0x2e0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
jmp 0xefbbf
movl -0x214(%rbp), %edi
callq 0xefa90
movq %rax, -0x228(%rbp)
cmpq $0x0, %rax
jne 0xefbf9
leaq -0x210(%rbp), %rdi
movl -0x214(%rbp), %ecx
movl $0x200, %esi # imm = 0x200
leaq 0x6466c(%rip), %rdx # 0x15425c
movb $0x0, %al
callq 0x14d300
jmp 0xefc4d
leaq -0x240(%rbp), %rax
leaq -0x2f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rcx
leaq -0x240(%rbp), %r8
leaq 0x3835e4(%rip), %rdi # 0x473220
movl $0x200, %edx # imm = 0x200
callq 0x14ace0
leaq -0x240(%rbp), %rax
leaq 0x1cff8c(%rip), %rax # 0x2bfbe0
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x220(%rbp), %rdx
callq *%rax
jmp 0xefc6f
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xefc8a
addq $0x2f0, %rsp # imm = 0x2F0
popq %rbp
retq
callq 0x2a270
nop
| my_error:
push rbp
mov rbp, rsp
sub rsp, 2F0h
test al, al
jz short loc_EFB87
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_EFB87:
mov [rbp+var_2C8], r9
mov [rbp+var_2D0], r8
mov [rbp+var_2D8], rcx
mov [rbp+var_2E0], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
jmp short $+2
loc_EFBBF:
mov edi, [rbp+var_214]
call my_get_err_msg
mov [rbp+var_228], rax
cmp rax, 0
jnz short loc_EFBF9
lea rdi, [rbp+var_210]
mov ecx, [rbp+var_214]
mov esi, 200h
lea rdx, aUnknownErrorD; "Unknown error %d"
mov al, 0
call my_snprintf
jmp short loc_EFC4D
loc_EFBF9:
lea rax, [rbp+var_240]
lea rcx, [rbp+var_2F0]
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
lea rsi, [rbp+var_210]
mov rcx, [rbp+var_228]
lea r8, [rbp+var_240]
lea rdi, my_charset_utf8mb3_general_ci
mov edx, 200h
call my_vsnprintf_ex
lea rax, [rbp+var_240]
loc_EFC4D:
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_220]
call rax
jmp short $+2
loc_EFC6F:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_EFC8A
add rsp, 2F0h
pop rbp
retn
loc_EFC8A:
call ___stack_chk_fail
| unsigned long long my_error(unsigned int a1, long long a2, ...)
{
int v2; // r8d
int v3; // r9d
va_list va; // [rsp+B0h] [rbp-240h] BYREF
_BYTE *err_msg; // [rsp+C8h] [rbp-228h]
long long v7; // [rsp+D0h] [rbp-220h]
unsigned int v8; // [rsp+DCh] [rbp-214h]
_BYTE v9[520]; // [rsp+E0h] [rbp-210h] BYREF
unsigned long long v10; // [rsp+2E8h] [rbp-8h]
va_start(va, a2);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_end(va);
v10 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
err_msg = my_get_err_msg(a1);
if ( err_msg )
{
va_start(va, a2);
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v9, 512LL, err_msg, va);
}
else
{
my_snprintf((unsigned int)v9, 512, (unsigned int)"Unknown error %d", v8, v2, v3);
}
error_handler_hook();
return __readfsqword(0x28u);
}
| my_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2f0
TEST AL,AL
JZ 0x001efb87
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_001efb87:
MOV qword ptr [RBP + -0x2c8],R9
MOV qword ptr [RBP + -0x2d0],R8
MOV qword ptr [RBP + -0x2d8],RCX
MOV qword ptr [RBP + -0x2e0],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
JMP 0x001efbbf
LAB_001efbbf:
MOV EDI,dword ptr [RBP + -0x214]
CALL 0x001efa90
MOV qword ptr [RBP + -0x228],RAX
CMP RAX,0x0
JNZ 0x001efbf9
LEA RDI,[RBP + -0x210]
MOV ECX,dword ptr [RBP + -0x214]
MOV ESI,0x200
LEA RDX,[0x25425c]
MOV AL,0x0
CALL 0x0024d300
JMP 0x001efc4d
LAB_001efbf9:
LEA RAX,[RBP + -0x240]
LEA RCX,[RBP + -0x2f0]
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
LEA RSI,[RBP + -0x210]
MOV RCX,qword ptr [RBP + -0x228]
LEA R8,[RBP + -0x240]
LEA RDI,[0x573220]
MOV EDX,0x200
CALL 0x0024ace0
LEA RAX,[RBP + -0x240]
LAB_001efc4d:
LEA RAX,[0x3bfbe0]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
CALL RAX
JMP 0x001efc6f
LAB_001efc6f:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001efc8a
ADD RSP,0x2f0
POP RBP
RET
LAB_001efc8a:
CALL 0x0012a270
|
void my_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,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [16];
int8 local_2e8;
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int4 local_248;
int4 local_244;
int1 *local_240;
int1 *local_238;
long local_230;
int8 local_228;
int4 local_21c;
int1 local_218 [520];
long local_10;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2e8 = param_11;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
local_228 = param_10;
local_21c = param_9;
local_230 = my_get_err_msg(param_9);
if (local_230 == 0) {
my_snprintf(local_218,0x200,"Unknown error %d",local_21c);
}
else {
local_238 = local_2f8;
local_240 = &stack0x00000008;
local_244 = 0x30;
local_248 = 0x10;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_218,0x200,local_230,&local_248);
}
(*(code *)error_handler_hook)(local_21c,local_218,local_228);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,222 | string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::string string_join(const std::vector<std::string> & values, const std::string & separator) {
std::ostringstream result;
for (size_t i = 0; i < values.size(); ++i) {
if (i > 0) {
result << separator;
}
result << values[i];
}
return result.str();
} | O2 | cpp | string_join(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x24d90
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %rbp
jae 0x5676a
testq %rbp, %rbp
je 0x56756
movq %r12, %rdi
movq %r14, %rsi
callq 0x248f0
movq (%r15), %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0x248f0
incq %rbp
addq $0x20, %r13
jmp 0x56730
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x24fe0
movq %rsp, %rdi
callq 0x24230
movq %rbx, %rax
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56796
movq %rax, %rbx
movq %rsp, %rdi
callq 0x24230
movq %rbx, %rdi
callq 0x251e0
| _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 178h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov r12, rsp
mov rdi, r12
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
xor r13d, r13d
xor ebp, ebp
loc_56730:
mov rsi, [r15]
mov rax, [r15+8]
sub rax, rsi
sar rax, 5
cmp rbp, rax
jnb short loc_5676A
test rbp, rbp
jz short loc_56756
mov rdi, r12
mov rsi, r14
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov rsi, [r15]
loc_56756:
add rsi, r13
mov rdi, r12
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
inc rbp
add r13, 20h ; ' '
jmp short loc_56730
loc_5676A:
lea rsi, [rsp+1A8h+var_1A0]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, rbx
add rsp, 178h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_56796:
mov rbx, rax
mov rdi, rsp
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rdi, rbx
call __Unwind_Resume
| long long string_join(long long a1, long long *a2, long long a3)
{
long long v5; // r13
unsigned long long i; // rbp
long long v7; // rsi
long long v9; // [rsp+0h] [rbp-1A8h] BYREF
_BYTE v10[416]; // [rsp+8h] [rbp-1A0h] BYREF
std::ostringstream::basic_ostringstream(&v9);
v5 = 0LL;
for ( i = 0LL; ; ++i )
{
v7 = *a2;
if ( i >= (a2[1] - *a2) >> 5 )
break;
if ( i )
{
std::operator<<<char>(&v9, a3);
v7 = *a2;
}
std::operator<<<char>(&v9, v5 + v7);
v5 += 32LL;
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(&v9);
return a1;
}
| string_join:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x178
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV R12,RSP
MOV RDI,R12
CALL 0x00124d90
XOR R13D,R13D
XOR EBP,EBP
LAB_00156730:
MOV RSI,qword ptr [R15]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,RSI
SAR RAX,0x5
CMP RBP,RAX
JNC 0x0015676a
TEST RBP,RBP
JZ 0x00156756
LAB_00156748:
MOV RDI,R12
MOV RSI,R14
CALL 0x001248f0
MOV RSI,qword ptr [R15]
LAB_00156756:
ADD RSI,R13
MOV RDI,R12
CALL 0x001248f0
INC RBP
ADD R13,0x20
JMP 0x00156730
LAB_0015676a:
LEA RSI,[RSP + 0x8]
LAB_0015676f:
MOV RDI,RBX
CALL 0x00124fe0
LAB_00156777:
MOV RDI,RSP
CALL 0x00124230
MOV RAX,RBX
ADD RSP,0x178
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_join(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&,
std::__cxx11::string const&) */
vector * string_join(vector *param_1,string *param_2)
{
string *in_RDX;
ulong uVar1;
long lVar2;
long lVar3;
ostringstream aoStack_1a8 [376];
std::__cxx11::ostringstream::ostringstream(aoStack_1a8);
lVar3 = 0;
for (uVar1 = 0; lVar2 = *(long *)param_2, uVar1 < (ulong)(*(long *)(param_2 + 8) - lVar2 >> 5);
uVar1 = uVar1 + 1) {
if (uVar1 != 0) {
/* try { // try from 00156748 to 00156760 has its CatchHandler @ 00156796 */
std::operator<<((ostream *)aoStack_1a8,in_RDX);
lVar2 = *(long *)param_2;
}
std::operator<<((ostream *)aoStack_1a8,(string *)(lVar2 + lVar3));
lVar3 = lVar3 + 0x20;
}
/* try { // try from 0015676f to 00156776 has its CatchHandler @ 00156794 */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(aoStack_1a8);
return param_1;
}
| |
34,223 | mi_cmp_static_unique | eloqsql/storage/myisam/mi_statrec.c | int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
const uchar *record, my_off_t pos)
{
DBUG_ENTER("_mi_cmp_static_unique");
info->rec_cache.seek_not_done=1; /* We have done a seek */
if (info->s->file_read(info, info->rec_buff, info->s->base.reclength,
pos, MYF(MY_NABP)))
DBUG_RETURN(-1);
DBUG_RETURN(mi_unique_comp(def, record, info->rec_buff,
def->null_are_equal));
} | O0 | c | mi_cmp_static_unique:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x300(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x2e0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x120(%rcx), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x140(%rcx), %rdx
movq -0x28(%rbp), %rcx
movl $0x4, %r8d
callq *%rax
cmpq $0x0, %rax
je 0x5019e
jmp 0x50195
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x501c3
jmp 0x501a0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdx
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %ecx
callq 0x50d10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _mi_cmp_static_unique:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+300h], 1
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+2E0h]
mov rdi, [rbp+var_10]
mov rcx, [rbp+var_10]
mov rsi, [rcx+120h]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov rdx, [rcx+140h]
mov rcx, [rbp+var_28]
mov r8d, 4
call rax
cmp rax, 0
jz short loc_5019E
jmp short $+2
loc_50195:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_501C3
loc_5019E:
jmp short $+2
loc_501A0:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rdx, [rax+120h]
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax+3]
call mi_unique_comp
mov [rbp+var_4], eax
loc_501C3:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mi_cmp_static_unique(long long a1, long long a2, long long a3, long long a4)
{
*(_DWORD *)(a1 + 768) = 1;
if ( (*(long long ( **)(long long, _QWORD, _QWORD, long long, long long))(*(_QWORD *)a1 + 736LL))(
a1,
*(_QWORD *)(a1 + 288),
*(_QWORD *)(*(_QWORD *)a1 + 320LL),
a4,
4LL) )
{
return (unsigned int)-1;
}
else
{
return (unsigned int)mi_unique_comp(a2, a3, *(_QWORD *)(a1 + 288), (unsigned int)*(char *)(a2 + 3));
}
}
| _mi_cmp_static_unique:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x300],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x2e0]
MOV RDI,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RCX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x140]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8D,0x4
CALL RAX
CMP RAX,0x0
JZ 0x0015019e
JMP 0x00150195
LAB_00150195:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001501c3
LAB_0015019e:
JMP 0x001501a0
LAB_001501a0:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x120]
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX + 0x3]
CALL 0x00150d10
MOV dword ptr [RBP + -0x4],EAX
LAB_001501c3:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 _mi_cmp_static_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
int4 local_c;
*(int4 *)(param_1 + 0x60) = 1;
lVar1 = (**(code **)(*param_1 + 0x2e0))
(param_1,param_1[0x24],*(int8 *)(*param_1 + 0x140),param_4,4);
if (lVar1 == 0) {
local_c = mi_unique_comp(param_2,param_3,param_1[0x24],(int)*(char *)(param_2 + 3));
}
else {
local_c = 0xffffffff;
}
return local_c;
}
| |
34,224 | rw_pr_init | eloqsql/mysys/thr_rwlock.c | int rw_pr_init(rw_pr_lock_t *rwlock)
{
pthread_mutex_init(&rwlock->lock, NULL);
pthread_cond_init(&rwlock->no_active_readers, NULL);
rwlock->active_readers= 0;
rwlock->writers_waiting_readers= 0;
rwlock->active_writer= FALSE;
#ifdef SAFE_MUTEX
rwlock->writer_thread= 0;
#endif
return 0;
} | O0 | c | rw_pr_init:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x373f0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x37420
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x60(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
| rw_pr_init:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
xor eax, eax
mov esi, eax
call _pthread_mutex_init
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
xor eax, eax
mov esi, eax
call _pthread_cond_init
mov rax, [rbp+var_8]
mov dword ptr [rax+58h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+5Ch], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+60h], 0
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long rw_pr_init(long long a1)
{
pthread_mutex_init(a1, 0LL);
pthread_cond_init(a1 + 40, 0LL);
*(_DWORD *)(a1 + 88) = 0;
*(_DWORD *)(a1 + 92) = 0;
*(_BYTE *)(a1 + 96) = 0;
return 0LL;
}
| rw_pr_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001373f0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00137420
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x5c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x60],0x0
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 rw_pr_init(pthread_mutex_t *param_1)
{
pthread_mutex_init(param_1,(pthread_mutexattr_t *)0x0);
pthread_cond_init((pthread_cond_t *)(param_1 + 1),(pthread_condattr_t *)0x0);
*(int4 *)((long)param_1 + 0x58) = 0;
*(int4 *)((long)param_1 + 0x5c) = 0;
*(int1 *)((long)param_1 + 0x60) = 0;
return 0;
}
| |
34,225 | lf_alloc_new | eloqsql/mysys/lf_alloc-pin.c | void *lf_alloc_new(LF_PINS *pins)
{
LF_ALLOCATOR *allocator= (LF_ALLOCATOR *)(pins->pinbox->free_func_arg);
uchar *node;
for (;;)
{
do
{
node= allocator->top;
lf_pin(pins, 0, node);
} while (node != allocator->top && LF_BACKOFF());
if (!node)
{
node= (void *)my_malloc(key_memory_lf_node, allocator->element_size,
MYF(MY_WME));
if (allocator->constructor)
allocator->constructor(node);
#ifdef MY_LF_EXTRA_DEBUG
if (likely(node != 0))
my_atomic_add32(&allocator->mallocs, 1);
#endif
break;
}
if (my_atomic_casptr((void **)(char *)&allocator->top,
(void *)&node, anext_node(node)))
break;
}
lf_unpin(pins, 0);
return node;
} | O0 | c | lf_alloc_new:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5e08e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5e09c
jmp 0x5e09e
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0x5e0b3
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
je 0x5e0d7
callq 0x5e1a0
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5e08e
cmpq $0x0, -0x18(%rbp)
jne 0x5e120
leaq 0x3b3b54(%rip), %rax # 0x411c40
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x5b130
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x5e11e
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x5e16f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movl 0x38(%rcx), %edx
movq (%rax,%rdx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rdx
lock
cmpxchgq %rdx, 0x48(%rcx)
movq %rax, %rcx
sete %al
movb %al, -0x49(%rbp)
movq %rcx, -0x48(%rbp)
testb $0x1, %al
jne 0x5e15a
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x5e16a
jmp 0x5e16f
jmp 0x5e08c
jmp 0x5e171
jmp 0x5e173
jmp 0x5e175
movq -0x8(%rbp), %rcx
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
xchgq %rax, (%rcx)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| lf_alloc_new:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax+20h]
mov rax, [rax+30h]
mov [rbp+var_10], rax
loc_5E08C:
jmp short $+2
loc_5E08E:
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov [rbp+var_18], rax
jmp short $+2
loc_5E09C:
jmp short $+2
loc_5E09E:
mov rcx, [rbp+var_8]
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
xchg rax, [rcx]
jmp short $+2
loc_5E0B3:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov rdx, [rax+48h]
xor eax, eax
cmp rcx, rdx
mov [rbp+var_39], al
jz short loc_5E0D7
call LF_BACKOFF
cmp eax, 0
setnz al
mov [rbp+var_39], al
loc_5E0D7:
mov al, [rbp+var_39]
test al, 1
jnz short loc_5E08E
cmp [rbp+var_18], 0
jnz short loc_5E120
lea rax, key_memory_lf_node
mov edi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+50h]
mov esi, eax
mov edx, 10h
call my_malloc
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+58h], 0
jz short loc_5E11E
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rdi, [rbp+var_18]
call rax
loc_5E11E:
jmp short loc_5E16F
loc_5E120:
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov edx, [rcx+38h]
mov rax, [rax+rdx]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdx, [rbp+var_28]
lock cmpxchg [rcx+48h], rdx
mov rcx, rax
setz al
mov [rbp+var_49], al
mov [rbp+var_48], rcx
test al, 1
jnz short loc_5E15A
mov rax, [rbp+var_48]
mov [rbp+var_18], rax
loc_5E15A:
mov al, [rbp+var_49]
and al, 1
mov [rbp+var_29], al
test [rbp+var_29], 1
jz short loc_5E16A
jmp short loc_5E16F
loc_5E16A:
jmp loc_5E08C
loc_5E16F:
jmp short $+2
loc_5E171:
jmp short $+2
loc_5E173:
jmp short $+2
loc_5E175:
mov rcx, [rbp+var_8]
mov [rbp+var_38], 0
mov rax, [rbp+var_38]
xchg rax, [rcx]
mov rax, [rbp+var_18]
add rsp, 50h
pop rbp
retn
| long long lf_alloc_new(long long a1)
{
signed long long v1; // rcx
bool v3; // [rsp+7h] [rbp-49h]
bool v4; // [rsp+17h] [rbp-39h]
long long v5; // [rsp+38h] [rbp-18h]
long long v6; // [rsp+40h] [rbp-10h]
v6 = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 48LL);
while ( 1 )
{
do
{
v5 = *(_QWORD *)(v6 + 72);
_InterlockedExchange64((volatile long long *)a1, v5);
v4 = 0;
if ( v5 != *(_QWORD *)(v6 + 72) )
v4 = (unsigned int)LF_BACKOFF() != 0;
}
while ( v4 );
if ( !v5 )
break;
v1 = _InterlockedCompareExchange64(
(volatile signed long long *)(v6 + 72),
*(_QWORD *)(v5 + *(unsigned int *)(v6 + 56)),
v5);
v3 = v5 == v1;
if ( v5 != v1 )
v5 = v1;
if ( v3 )
goto LABEL_12;
}
v5 = my_malloc(key_memory_lf_node, *(unsigned int *)(v6 + 80), 16);
if ( *(_QWORD *)(v6 + 88) )
(*(void ( **)(long long))(v6 + 88))(v5);
LABEL_12:
_InterlockedExchange64((volatile long long *)a1, 0LL);
return v5;
}
| lf_alloc_new:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x10],RAX
LAB_0015e08c:
JMP 0x0015e08e
LAB_0015e08e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0015e09c
LAB_0015e09c:
JMP 0x0015e09e
LAB_0015e09e:
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
XCHG qword ptr [RCX],RAX
JMP 0x0015e0b3
LAB_0015e0b3:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x48]
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x39],AL
JZ 0x0015e0d7
CALL 0x0015e1a0
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x39],AL
LAB_0015e0d7:
MOV AL,byte ptr [RBP + -0x39]
TEST AL,0x1
JNZ 0x0015e08e
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x0015e120
LEA RAX,[0x511c40]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x50]
MOV ESI,EAX
MOV EDX,0x10
CALL 0x0015b130
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x58],0x0
JZ 0x0015e11e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RDI,qword ptr [RBP + -0x18]
CALL RAX
LAB_0015e11e:
JMP 0x0015e16f
LAB_0015e120:
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RCX + 0x38]
MOV RAX,qword ptr [RAX + RDX*0x1]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CMPXCHG.LOCK qword ptr [RCX + 0x48],RDX
MOV RCX,RAX
SETZ AL
MOV byte ptr [RBP + -0x49],AL
MOV qword ptr [RBP + -0x48],RCX
TEST AL,0x1
JNZ 0x0015e15a
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x18],RAX
LAB_0015e15a:
MOV AL,byte ptr [RBP + -0x49]
AND AL,0x1
MOV byte ptr [RBP + -0x29],AL
TEST byte ptr [RBP + -0x29],0x1
JZ 0x0015e16a
JMP 0x0015e16f
LAB_0015e16a:
JMP 0x0015e08c
LAB_0015e16f:
JMP 0x0015e171
LAB_0015e171:
JMP 0x0015e173
LAB_0015e173:
JMP 0x0015e175
LAB_0015e175:
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x38]
XCHG qword ptr [RCX],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x50
POP RBP
RET
|
long lf_alloc_new(long *param_1)
{
long lVar1;
int iVar2;
bool bVar3;
long local_20;
lVar1 = *(long *)(param_1[4] + 0x30);
do {
do {
local_20 = *(long *)(lVar1 + 0x48);
LOCK();
*param_1 = local_20;
UNLOCK();
bVar3 = false;
if (local_20 != *(long *)(lVar1 + 0x48)) {
iVar2 = LF_BACKOFF();
bVar3 = iVar2 != 0;
}
} while (bVar3);
if (local_20 == 0) {
local_20 = my_malloc(key_memory_lf_node,*(int4 *)(lVar1 + 0x50),0x10);
if (*(long *)(lVar1 + 0x58) != 0) {
(**(code **)(lVar1 + 0x58))(local_20);
}
break;
}
LOCK();
bVar3 = local_20 == *(long *)(lVar1 + 0x48);
if (bVar3) {
*(long *)(lVar1 + 0x48) = *(long *)(local_20 + (ulong)*(uint *)(lVar1 + 0x38));
}
UNLOCK();
} while (!bVar3);
LOCK();
*param_1 = 0;
UNLOCK();
return local_20;
}
| |
34,226 | my_os_charset_to_mysql_charset | eloqsql/mysys/charset.c | static const char*
my_os_charset_to_mysql_charset(const char* csname)
{
const MY_CSET_OS_NAME* csp;
for (csp = charsets; csp->os_name; csp++)
{
if (!strcasecmp(csp->os_name, csname))
{
switch (csp->param)
{
case my_cs_exact:
return csp->my_name;
case my_cs_approx:
/*
Maybe we should print a warning eventually:
character set correspondence is not exact.
*/
return csp->my_name;
default:
return NULL;
}
}
}
return NULL;
} | O0 | c | my_os_charset_to_mysql_charset:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1aa73d(%rip), %rax # 0x20d870
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x631a6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x26360
cmpl $0x0, %eax
jne 0x63196
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x63170
jmp 0x63166
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x6317e
jmp 0x6318c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x631ae
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x631ae
movq $0x0, -0x8(%rbp)
jmp 0x631ae
jmp 0x63198
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x63137
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_os_charset_to_mysql_charset:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
lea rax, charsets
mov [rbp+var_18], rax
loc_63137:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_631A6
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_10]
call _strcasecmp
cmp eax, 0
jnz short loc_63196
mov rax, [rbp+var_18]
mov eax, [rax+10h]
mov [rbp+var_1C], eax
test eax, eax
jz short loc_63170
jmp short $+2
loc_63166:
mov eax, [rbp+var_1C]
sub eax, 1
jz short loc_6317E
jmp short loc_6318C
loc_63170:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_631AE
loc_6317E:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_631AE
loc_6318C:
mov [rbp+var_8], 0
jmp short loc_631AE
loc_63196:
jmp short $+2
loc_63198:
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_18], rax
jmp short loc_63137
loc_631A6:
mov [rbp+var_8], 0
loc_631AE:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| char * my_os_charset_to_mysql_charset(long long a1)
{
int v2; // [rsp+4h] [rbp-1Ch]
char **i; // [rsp+8h] [rbp-18h]
for ( i = charsets; ; i += 3 )
{
if ( !*i )
return 0LL;
if ( !(unsigned int)strcasecmp(*i, a1) )
break;
}
v2 = *((_DWORD *)i + 4);
if ( !v2 )
return i[1];
if ( v2 == 1 )
return i[1];
return 0LL;
}
| my_os_charset_to_mysql_charset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x30d870]
MOV qword ptr [RBP + -0x18],RAX
LAB_00163137:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX],0x0
JZ 0x001631a6
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00126360
CMP EAX,0x0
JNZ 0x00163196
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x1c],EAX
TEST EAX,EAX
JZ 0x00163170
JMP 0x00163166
LAB_00163166:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
JZ 0x0016317e
JMP 0x0016318c
LAB_00163170:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001631ae
LAB_0016317e:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001631ae
LAB_0016318c:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001631ae
LAB_00163196:
JMP 0x00163198
LAB_00163198:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00163137
LAB_001631a6:
MOV qword ptr [RBP + -0x8],0x0
LAB_001631ae:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int * my_os_charset_to_mysql_charset(char *param_1)
{
int iVar1;
int **local_20;
local_20 = &charsets;
while( true ) {
if (*local_20 == (int *)0x0) {
return (int *)0x0;
}
iVar1 = strcasecmp(*local_20,param_1);
if (iVar1 == 0) break;
local_20 = local_20 + 3;
}
if (*(int *)(local_20 + 2) != 0) {
if (*(int *)(local_20 + 2) != 1) {
return (int *)0x0;
}
return local_20[1];
}
return local_20[1];
}
| |
34,227 | test_mul_mat_id::build_graph(ggml_context*) | monkey531[P]llama/tests/test-backend-ops.cpp | ggml_tensor * build_graph(ggml_context * ctx) override {
// C^T = A * B^T: (k, m) * (k, n) => (m, n)
ggml_tensor * as = ggml_new_tensor_3d(ctx, type_a, k, m, n_mats);
ggml_set_name(as, "as");
ggml_tensor * ids = ggml_new_tensor_2d(ctx, GGML_TYPE_I32, n_mats, n);
ggml_set_name(ids, "ids");
if (n_used != n_mats) {
ids = ggml_view_2d(ctx, ids, n_used, n, ids->nb[1], 0);
ggml_set_name(ids, "view_of_ids");
}
ggml_tensor * b = ggml_new_tensor_3d(ctx, type_b, k, this->b ? 1 : n_used, n);
ggml_set_name(b, "b");
ggml_tensor * out = ggml_mul_mat_id(ctx, as, b, ids);
ggml_set_name(out, "out");
return out;
} | O0 | cpp | test_mul_mat_id::build_graph(ggml_context*):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x48(%rsp), %rsi
movl 0x38(%rdi), %edx
movq 0x60(%rdi), %rcx
movq 0x50(%rdi), %r8
movslq 0x40(%rdi), %r9
callq 0x43c80
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x165e7(%rip), %rsi # 0x6c079
callq 0x19c10
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movslq 0x40(%rdi), %rcx
movq 0x58(%rdi), %r8
movl $0x1a, %edx
callq 0x43cf0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x165c0(%rip), %rsi # 0x6c084
callq 0x19c10
movq 0x20(%rsp), %rcx
movl 0x44(%rcx), %eax
cmpl 0x40(%rcx), %eax
je 0x55b16
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movslq 0x44(%rax), %rdx
movq 0x58(%rax), %rcx
movq 0x38(%rsp), %rax
movq 0x38(%rax), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x19880
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1656b(%rip), %rsi # 0x6c07c
callq 0x19c10
movq 0x20(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl 0x3c(%rax), %ecx
movl %ecx, 0x14(%rsp)
movq 0x60(%rax), %rcx
movq %rcx, 0x18(%rsp)
testb $0x1, 0x48(%rax)
je 0x55b46
movl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x55b52
movq 0x20(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rcx
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %eax
movslq %eax, %r8
movq 0x58(%rdi), %r9
callq 0x43c80
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x15e55(%rip), %rsi # 0x6b9db
callq 0x19c10
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x19850
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x167cf(%rip), %rsi # 0x6c384
callq 0x19c10
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN15test_mul_mat_id11build_graphEP12ggml_context:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rdi, [rsp+58h+var_8]
mov [rsp+58h+var_38], rdi
mov rsi, [rsp+58h+var_10]
mov edx, [rdi+38h]
mov rcx, [rdi+60h]
mov r8, [rdi+50h]
movsxd r9, dword ptr [rdi+40h]
call _ZN9test_case18ggml_new_tensor_3dEP12ggml_context9ggml_typelll; test_case::ggml_new_tensor_3d(ggml_context *,ggml_type,long,long,long)
mov [rsp+58h+var_18], rax
mov rdi, [rsp+58h+var_18]
lea rsi, aAs; "as"
call _ggml_set_name
mov rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_10]
movsxd rcx, dword ptr [rdi+40h]
mov r8, [rdi+58h]
mov edx, 1Ah
call _ZN9test_case18ggml_new_tensor_2dEP12ggml_context9ggml_typell; test_case::ggml_new_tensor_2d(ggml_context *,ggml_type,long,long)
mov [rsp+58h+var_20], rax
mov rdi, [rsp+58h+var_20]
lea rsi, aViewOfIds+8; "ids"
call _ggml_set_name
mov rcx, [rsp+58h+var_38]
mov eax, [rcx+44h]
cmp eax, [rcx+40h]
jz short loc_55B16
mov rax, [rsp+58h+var_38]
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_20]
movsxd rdx, dword ptr [rax+44h]
mov rcx, [rax+58h]
mov rax, [rsp+58h+var_20]
mov r8, [rax+38h]
xor eax, eax
mov r9d, eax
call _ggml_view_2d
mov [rsp+58h+var_20], rax
mov rdi, [rsp+58h+var_20]
lea rsi, aViewOfIds; "view_of_ids"
call _ggml_set_name
loc_55B16:
mov rax, [rsp+58h+var_38]
mov rcx, [rsp+58h+var_10]
mov [rsp+58h+var_50], rcx
mov ecx, [rax+3Ch]
mov [rsp+58h+var_44], ecx
mov rcx, [rax+60h]
mov [rsp+58h+var_40], rcx
test byte ptr [rax+48h], 1
jz short loc_55B46
mov eax, 1
mov [rsp+58h+var_54], eax
jmp short loc_55B52
loc_55B46:
mov rax, [rsp+58h+var_38]
mov eax, [rax+44h]
mov [rsp+58h+var_54], eax
loc_55B52:
mov rcx, [rsp+58h+var_40]
mov edx, [rsp+58h+var_44]
mov rsi, [rsp+58h+var_50]
mov rdi, [rsp+58h+var_38]
mov eax, [rsp+58h+var_54]
movsxd r8, eax
mov r9, [rdi+58h]
call _ZN9test_case18ggml_new_tensor_3dEP12ggml_context9ggml_typelll; test_case::ggml_new_tensor_3d(ggml_context *,ggml_type,long,long,long)
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_28]
lea rsi, aB+1; "b"
call _ggml_set_name
mov rdi, [rsp+58h+var_10]
mov rsi, [rsp+58h+var_18]
mov rdx, [rsp+58h+var_28]
mov rcx, [rsp+58h+var_20]
call _ggml_mul_mat_id
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_30]
lea rsi, aSumOfOut+7; "out"
call _ggml_set_name
mov rax, [rsp+58h+var_30]
add rsp, 58h
retn
| long long test_mul_mat_id::build_graph(long long a1, long long a2)
{
int v3; // [rsp+4h] [rbp-54h]
long long v5; // [rsp+28h] [rbp-30h]
long long v6; // [rsp+30h] [rbp-28h]
long long v7; // [rsp+38h] [rbp-20h]
long long v8; // [rsp+40h] [rbp-18h]
v8 = test_case::ggml_new_tensor_3d(
a1,
a2,
*(_DWORD *)(a1 + 56),
*(_QWORD *)(a1 + 96),
*(_QWORD *)(a1 + 80),
*(int *)(a1 + 64));
ggml_set_name(v8, "as");
v7 = test_case::ggml_new_tensor_2d(a1, a2, 0x1Au, *(int *)(a1 + 64), *(_QWORD *)(a1 + 88));
ggml_set_name(v7, "ids");
if ( *(_DWORD *)(a1 + 68) != *(_DWORD *)(a1 + 64) )
{
v7 = ggml_view_2d(a2, v7, *(int *)(a1 + 68), *(_QWORD *)(a1 + 88), *(_QWORD *)(v7 + 56), 0LL);
ggml_set_name(v7, "view_of_ids");
}
if ( (*(_BYTE *)(a1 + 72) & 1) != 0 )
v3 = 1;
else
v3 = *(_DWORD *)(a1 + 68);
v6 = test_case::ggml_new_tensor_3d(a1, a2, *(_DWORD *)(a1 + 60), *(_QWORD *)(a1 + 96), v3, *(_QWORD *)(a1 + 88));
ggml_set_name(v6, "b");
v5 = ggml_mul_mat_id(a2, v8, v6, v7);
ggml_set_name(v5, "out");
return v5;
}
| build_graph:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RDI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x20],RDI
MOV RSI,qword ptr [RSP + 0x48]
MOV EDX,dword ptr [RDI + 0x38]
MOV RCX,qword ptr [RDI + 0x60]
MOV R8,qword ptr [RDI + 0x50]
MOVSXD R9,dword ptr [RDI + 0x40]
CALL 0x00143c80
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[0x16c079]
CALL 0x00119c10
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x48]
MOVSXD RCX,dword ptr [RDI + 0x40]
MOV R8,qword ptr [RDI + 0x58]
MOV EDX,0x1a
CALL 0x00143cf0
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[0x16c084]
CALL 0x00119c10
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RCX + 0x44]
CMP EAX,dword ptr [RCX + 0x40]
JZ 0x00155b16
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x38]
MOVSXD RDX,dword ptr [RAX + 0x44]
MOV RCX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RSP + 0x38]
MOV R8,qword ptr [RAX + 0x38]
XOR EAX,EAX
MOV R9D,EAX
CALL 0x00119880
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[0x16c07c]
CALL 0x00119c10
LAB_00155b16:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x8],RCX
MOV ECX,dword ptr [RAX + 0x3c]
MOV dword ptr [RSP + 0x14],ECX
MOV RCX,qword ptr [RAX + 0x60]
MOV qword ptr [RSP + 0x18],RCX
TEST byte ptr [RAX + 0x48],0x1
JZ 0x00155b46
MOV EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x00155b52
LAB_00155b46:
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX + 0x44]
MOV dword ptr [RSP + 0x4],EAX
LAB_00155b52:
MOV RCX,qword ptr [RSP + 0x18]
MOV EDX,dword ptr [RSP + 0x14]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x4]
MOVSXD R8,EAX
MOV R9,qword ptr [RDI + 0x58]
CALL 0x00143c80
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x16b9db]
CALL 0x00119c10
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
CALL 0x00119850
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x16c384]
CALL 0x00119c10
MOV RAX,qword ptr [RSP + 0x28]
ADD RSP,0x58
RET
|
/* test_mul_mat_id::build_graph(ggml_context*) */
int8 __thiscall test_mul_mat_id::build_graph(test_mul_mat_id *this,ggml_context *param_1)
{
int8 uVar1;
int8 uVar2;
int local_54;
long local_20;
uVar1 = test_case::ggml_new_tensor_3d
((test_case *)this,param_1,*(int4 *)(this + 0x38),
*(int8 *)(this + 0x60),*(int8 *)(this + 0x50),
(long)*(int *)(this + 0x40));
ggml_set_name(uVar1,&DAT_0016c079);
local_20 = test_case::ggml_new_tensor_2d
((test_case *)this,param_1,0x1a,(long)*(int *)(this + 0x40),
*(int8 *)(this + 0x58));
ggml_set_name(local_20,"ids");
if (*(int *)(this + 0x44) != *(int *)(this + 0x40)) {
local_20 = ggml_view_2d(param_1,local_20,(long)*(int *)(this + 0x44),
*(int8 *)(this + 0x58),*(int8 *)(local_20 + 0x38),0);
ggml_set_name(local_20,"view_of_ids");
}
if (((byte)this[0x48] & 1) == 0) {
local_54 = *(int *)(this + 0x44);
}
else {
local_54 = 1;
}
uVar2 = test_case::ggml_new_tensor_3d
((test_case *)this,param_1,*(int4 *)(this + 0x3c),
*(int8 *)(this + 0x60),(long)local_54,*(int8 *)(this + 0x58));
ggml_set_name(uVar2,&DAT_0016b9db);
uVar1 = ggml_mul_mat_id(param_1,uVar1,uVar2,local_20);
ggml_set_name(uVar1,"out");
return uVar1;
}
| |
34,228 | mysql_next_result | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int STDCALL mysql_next_result(MYSQL *mysql)
{
/* make sure communication is not blocking */
if (mysql->status != MYSQL_STATUS_READY)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* clear error, and mysql status variables */
CLEAR_CLIENT_ERROR(mysql);
mysql->affected_rows = (ulonglong) ~0;
if (mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
return(mysql->methods->db_read_query_result(mysql));
}
return(-1);
} | O3 | c | mysql_next_result:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x297, %rdi # imm = 0x297
cmpl $0x0, 0x488(%rbx)
je 0x1a421
movl $0x7de, 0x90(%rbx) # imm = 0x7DE
leaq 0x316e0(%rip), %rax # 0x4bac0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x29c(%rbx)
leaq 0x97(%rbx), %rdi
leaq 0x316cb(%rip), %rax # 0x4bad0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r14b, 0x296(%rbx)
movl $0x1, %eax
jmp 0x1a46a
movl $0x0, 0x90(%rbx)
movw $0x30, 0x4(%rdi)
movl $0x30303030, (%rdi) # imm = 0x30303030
movb $0x0, 0x97(%rbx)
movq 0x2a0(%rbx), %rax
testq %rax, %rax
je 0x1a451
movl $0x0, 0x4(%rax)
movq $-0x1, 0x338(%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb $0x8, 0x380(%rbx)
jne 0x1a46f
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4d0(%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmpq *0x20(%rax)
| mysql_next_result:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
add rdi, 297h
cmp dword ptr [rbx+488h], 0
jz short loc_1A421
mov dword ptr [rbx+90h], 7DEh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+29Ch], r14b
lea rdi, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov [rbx+296h], r14b
mov eax, 1
jmp short loc_1A46A
loc_1A421:
mov dword ptr [rbx+90h], 0
mov word ptr [rdi+4], 30h ; '0'
mov dword ptr [rdi], 30303030h
mov byte ptr [rbx+97h], 0
mov rax, [rbx+2A0h]
test rax, rax
jz short loc_1A451
mov dword ptr [rax+4], 0
loc_1A451:
mov qword ptr [rbx+338h], 0FFFFFFFFFFFFFFFFh
mov eax, 0FFFFFFFFh
test byte ptr [rbx+380h], 8
jnz short loc_1A46F
loc_1A46A:
pop rbx
pop r14
pop rbp
retn
loc_1A46F:
mov rax, [rbx+4D0h]
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp qword ptr [rax+20h]
| long long mysql_next_result(long long a1)
{
char *v2; // rdi
long long result; // rax
long long v4; // rax
v2 = (char *)(a1 + 663);
if ( *(_DWORD *)(a1 + 1160) )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(v2, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[14], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return 1LL;
}
else
{
*(_DWORD *)(a1 + 144) = 0;
strcpy(v2, "00000");
*(_BYTE *)(a1 + 151) = 0;
v4 = *(_QWORD *)(a1 + 672);
if ( v4 )
*(_DWORD *)(v4 + 4) = 0;
*(_QWORD *)(a1 + 824) = -1LL;
result = 0xFFFFFFFFLL;
if ( (*(_BYTE *)(a1 + 896) & 8) != 0 )
return (*(long long ( **)(long long))(*(_QWORD *)(a1 + 1232) + 32LL))(a1);
}
return result;
}
| mysql_next_result:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
ADD RDI,0x297
CMP dword ptr [RBX + 0x488],0x0
JZ 0x0011a421
MOV dword ptr [RBX + 0x90],0x7de
LEA RAX,[0x14bac0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x29c],R14B
LEA RDI,[RBX + 0x97]
LEA RAX,[0x14bad0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [RBX + 0x296],R14B
MOV EAX,0x1
JMP 0x0011a46a
LAB_0011a421:
MOV dword ptr [RBX + 0x90],0x0
MOV word ptr [RDI + 0x4],0x30
MOV dword ptr [RDI],0x30303030
MOV byte ptr [RBX + 0x97],0x0
MOV RAX,qword ptr [RBX + 0x2a0]
TEST RAX,RAX
JZ 0x0011a451
MOV dword ptr [RAX + 0x4],0x0
LAB_0011a451:
MOV qword ptr [RBX + 0x338],-0x1
MOV EAX,0xffffffff
TEST byte ptr [RBX + 0x380],0x8
JNZ 0x0011a46f
LAB_0011a46a:
POP RBX
POP R14
POP RBP
RET
LAB_0011a46f:
MOV RAX,qword ptr [RBX + 0x4d0]
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP qword ptr [RAX + 0x20]
|
int8 mysql_next_result(long param_1)
{
int8 uVar1;
if (*(int *)(param_1 + 0x488) == 0) {
*(int4 *)(param_1 + 0x90) = 0;
*(int2 *)(param_1 + 0x29b) = 0x30;
builtin_strncpy((char *)(param_1 + 0x297),"0000",4);
*(int1 *)(param_1 + 0x97) = 0;
if (*(long *)(param_1 + 0x2a0) != 0) {
*(int4 *)(*(long *)(param_1 + 0x2a0) + 4) = 0;
}
*(int8 *)(param_1 + 0x338) = 0xffffffffffffffff;
uVar1 = 0xffffffff;
if ((*(byte *)(param_1 + 0x380) & 8) != 0) {
/* WARNING: Could not recover jumptable at 0x0011a47d. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar1 = (**(code **)(*(long *)(param_1 + 0x4d0) + 0x20))(param_1);
return uVar1;
}
}
else {
*(int4 *)(param_1 + 0x90) = 0x7de;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
strncpy((char *)(param_1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_0014bb40,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
uVar1 = 1;
}
return uVar1;
}
| |
34,229 | ssz_verify_multi_merkle_proof | corpus-core[P]colibri-stateless/src/util/ssz_merkle.c | bool ssz_verify_multi_merkle_proof(bytes_t proof_data, bytes_t leafes, gindex_t* gindex, bytes32_t out) {
buffer_t witnesses_gindex = {0};
buffer_t calculated_gindex = {0};
for (uint32_t i = 0; i < leafes.len / 32; i++)
ssz_add_multi_merkle_proof(gindex[i], &witnesses_gindex, &calculated_gindex);
/*
fprintf(stderr, "_______\nwitnesses_gindex:\n");
for (uint32_t i = 0; i < witnesses_gindex.data.len / sizeof(gindex_t); i++) {
fprintf(stderr, "witness gindex: %llu\n", ((gindex_t*) witnesses_gindex.data.data)[i]);
}
fprintf(stderr, "_______\ncalculated_gindex:\n");
for (uint32_t i = 0; i < calculated_gindex.data.len / sizeof(gindex_t); i++) {
fprintf(stderr, "path gindex: %llu\n", ((gindex_t*) calculated_gindex.data.data)[i]);
}
fprintf(stderr, "_______\nvalues:\n");
*/
buffer_free(&calculated_gindex);
merkle_proof_data_t data = {
.leafes_gindex = gindex,
.leafes_data = leafes,
.leafes_len = leafes.len / 32,
.witnesses_data = proof_data,
.witnesses_gindex = (gindex_t*) witnesses_gindex.data.data,
.witnesses_len = witnesses_gindex.data.len / sizeof(gindex_t),
};
if (data.witnesses_len != proof_data.len / 32) {
buffer_free(&witnesses_gindex);
return false;
}
// find the highest gindex since we want to start with that.
gindex_t start = 0;
for (uint32_t i = 0; i < data.leafes_len; i++) {
if (data.leafes_gindex[i] > start) start = data.leafes_gindex[i];
}
bool result = merkle_proof(&data, start, 1, out);
buffer_free(&witnesses_gindex);
return result;
} | O1 | c | ssz_verify_multi_merkle_proof:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x28(%rsp)
movq %r8, %r14
movq %rcx, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edi, %r15d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movl %edx, %eax
shrl $0x5, %eax
movl %eax, 0x8(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x20, %edx
jb 0x59e44
movl 0x8(%rsp), %r13d
xorl %ebp, %ebp
leaq 0x10(%rsp), %rbx
leaq 0x40(%rsp), %r12
movq (%r14,%rbp,8), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x59ba8
incq %rbp
cmpq %rbp, %r13
jne 0x59e2d
leaq 0x40(%rsp), %rdi
callq 0x57107
movl %r15d, 0x58(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
movl 0x10(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x70(%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, 0x78(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, 0x80(%rsp)
movq %r14, 0x88(%rsp)
movl 0x8(%rsp), %edx
movl %edx, 0x90(%rsp)
shrl $0x5, %r15d
cmpl %r15d, %eax
jne 0x59eac
cmpl $0x20, %ecx
jae 0x59eb0
xorl %esi, %esi
jmp 0x59ecb
xorl %ebx, %ebx
jmp 0x59ee1
movl 0x8(%rsp), %eax
xorl %ecx, %ecx
xorl %esi, %esi
movq (%r14,%rcx,8), %rdx
cmpq %rsi, %rdx
cmovaq %rdx, %rsi
incq %rcx
cmpq %rcx, %rax
jne 0x59eb8
leaq 0x58(%rsp), %rdi
movl $0x1, %edx
movq 0x28(%rsp), %rcx
callq 0x59eff
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x57107
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ssz_verify_multi_merkle_proof:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_A0], r9
mov r14, r8
mov [rsp+0C8h+var_90], rcx
mov [rsp+0C8h+var_98], rsi
mov r15d, edi
xorps xmm0, xmm0
movaps [rsp+0C8h+var_B8], xmm0
xor eax, eax
mov [rsp+0C8h+var_A8], rax
mov [rsp+0C8h+var_78], rax
movaps [rsp+0C8h+var_88], xmm0
mov eax, edx
shr eax, 5
mov [rsp+0C8h+var_C0], eax
mov [rsp+0C8h+var_BC], edx
cmp edx, 20h ; ' '
jb short loc_59E44
mov r13d, [rsp+0C8h+var_C0]
xor ebp, ebp
lea rbx, [rsp+0C8h+var_B8]
lea r12, [rsp+0C8h+var_88]
loc_59E2D:
mov rdi, [r14+rbp*8]
mov rsi, rbx
mov rdx, r12
call ssz_add_multi_merkle_proof
inc rbp
cmp r13, rbp
jnz short loc_59E2D
loc_59E44:
lea rdi, [rsp+0C8h+var_88]
call buffer_free
mov [rsp+0C8h+var_70], r15d
mov rax, [rsp+0C8h+var_98]
mov [rsp+0C8h+var_68], rax
mov rax, qword ptr [rsp+0C8h+var_B8+8]
mov [rsp+0C8h+var_60], rax
mov eax, dword ptr [rsp+0C8h+var_B8]
shr eax, 3
mov [rsp+0C8h+var_58], eax
mov ecx, [rsp+0C8h+var_BC]
mov [rsp+0C8h+var_50], ecx
mov rdx, [rsp+0C8h+var_90]
mov [rsp+0C8h+var_48], rdx
mov [rsp+0C8h+var_40], r14
mov edx, [rsp+0C8h+var_C0]
mov [rsp+0C8h+var_38], edx
shr r15d, 5
cmp eax, r15d
jnz short loc_59EAC
cmp ecx, 20h ; ' '
jnb short loc_59EB0
xor esi, esi
jmp short loc_59ECB
loc_59EAC:
xor ebx, ebx
jmp short loc_59EE1
loc_59EB0:
mov eax, [rsp+0C8h+var_C0]
xor ecx, ecx
xor esi, esi
loc_59EB8:
mov rdx, [r14+rcx*8]
cmp rdx, rsi
cmova rsi, rdx
inc rcx
cmp rax, rcx
jnz short loc_59EB8
loc_59ECB:
lea rdi, [rsp+0C8h+var_70]
mov edx, 1
mov rcx, [rsp+0C8h+var_A0]
call merkle_proof
mov ebx, eax
loc_59EE1:
lea rdi, [rsp+0C8h+var_B8]
call buffer_free
mov eax, ebx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ssz_verify_multi_merkle_proof(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
long long v7; // rbp
unsigned long long v8; // rsi
unsigned int v9; // ebx
long long v10; // rcx
unsigned int v12; // [rsp+8h] [rbp-C0h]
__int128 v14; // [rsp+10h] [rbp-B8h] BYREF
long long v15; // [rsp+20h] [rbp-A8h]
long long v16; // [rsp+28h] [rbp-A0h]
long long v17; // [rsp+30h] [rbp-98h]
long long v18; // [rsp+38h] [rbp-90h]
__int128 v19; // [rsp+40h] [rbp-88h] BYREF
long long v20; // [rsp+50h] [rbp-78h]
unsigned int v21; // [rsp+58h] [rbp-70h] BYREF
long long v22; // [rsp+60h] [rbp-68h]
long long v23; // [rsp+68h] [rbp-60h]
unsigned int v24; // [rsp+70h] [rbp-58h]
unsigned int v25; // [rsp+78h] [rbp-50h]
long long v26; // [rsp+80h] [rbp-48h]
long long v27; // [rsp+88h] [rbp-40h]
unsigned int v28; // [rsp+90h] [rbp-38h]
v16 = a6;
v18 = a4;
v17 = a2;
v14 = 0LL;
v15 = 0LL;
v20 = 0LL;
v19 = 0LL;
v12 = a3 >> 5;
if ( a3 >= 0x20 )
{
v7 = 0LL;
do
ssz_add_multi_merkle_proof(*(_QWORD *)(a5 + 8 * v7++), (unsigned int *)&v14, (unsigned int *)&v19);
while ( v12 != v7 );
}
buffer_free((long long)&v19);
v21 = a1;
v22 = v17;
v23 = *((_QWORD *)&v14 + 1);
v24 = (unsigned int)v14 >> 3;
v25 = a3;
v26 = v18;
v27 = a5;
v28 = v12;
if ( (unsigned int)v14 >> 3 == a1 >> 5 )
{
if ( a3 >= 0x20 )
{
v10 = 0LL;
v8 = 0LL;
do
{
if ( *(_QWORD *)(a5 + 8 * v10) > v8 )
v8 = *(_QWORD *)(a5 + 8 * v10);
++v10;
}
while ( v12 != v10 );
}
else
{
v8 = 0LL;
}
v9 = merkle_proof(&v21, v8, 1LL, v16);
}
else
{
v9 = 0;
}
buffer_free((long long)&v14);
return v9;
}
| ssz_verify_multi_merkle_proof:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x28],R9
MOV R14,R8
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x30],RSI
MOV R15D,EDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
XOR EAX,EAX
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x50],RAX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV EAX,EDX
SHR EAX,0x5
MOV dword ptr [RSP + 0x8],EAX
MOV dword ptr [RSP + 0xc],EDX
CMP EDX,0x20
JC 0x00159e44
MOV R13D,dword ptr [RSP + 0x8]
XOR EBP,EBP
LEA RBX,[RSP + 0x10]
LEA R12,[RSP + 0x40]
LAB_00159e2d:
MOV RDI,qword ptr [R14 + RBP*0x8]
MOV RSI,RBX
MOV RDX,R12
CALL 0x00159ba8
INC RBP
CMP R13,RBP
JNZ 0x00159e2d
LAB_00159e44:
LEA RDI,[RSP + 0x40]
CALL 0x00157107
MOV dword ptr [RSP + 0x58],R15D
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x60],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x68],RAX
MOV EAX,dword ptr [RSP + 0x10]
SHR EAX,0x3
MOV dword ptr [RSP + 0x70],EAX
MOV ECX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP + 0x78],ECX
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x80],RDX
MOV qword ptr [RSP + 0x88],R14
MOV EDX,dword ptr [RSP + 0x8]
MOV dword ptr [RSP + 0x90],EDX
SHR R15D,0x5
CMP EAX,R15D
JNZ 0x00159eac
CMP ECX,0x20
JNC 0x00159eb0
XOR ESI,ESI
JMP 0x00159ecb
LAB_00159eac:
XOR EBX,EBX
JMP 0x00159ee1
LAB_00159eb0:
MOV EAX,dword ptr [RSP + 0x8]
XOR ECX,ECX
XOR ESI,ESI
LAB_00159eb8:
MOV RDX,qword ptr [R14 + RCX*0x8]
CMP RDX,RSI
CMOVA RSI,RDX
INC RCX
CMP RAX,RCX
JNZ 0x00159eb8
LAB_00159ecb:
LEA RDI,[RSP + 0x58]
MOV EDX,0x1
MOV RCX,qword ptr [RSP + 0x28]
CALL 0x00159eff
MOV EBX,EAX
LAB_00159ee1:
LEA RDI,[RSP + 0x10]
CALL 0x00157107
MOV EAX,EBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
ssz_verify_multi_merkle_proof
(uint param_1,int8 param_2,ulong param_3,int8 param_4,long param_5,
int8 param_6)
{
ulong uVar1;
uint uVar2;
int4 uVar3;
ulong uVar4;
uint uVar5;
ulong uVar6;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
uint local_70 [2];
int8 local_68;
int8 local_60;
uint local_58;
uint local_50;
int8 local_48;
long local_40;
uint local_38;
local_b8 = 0;
uStack_b0 = 0;
local_a8 = 0;
local_78 = 0;
local_88 = 0;
uStack_80 = 0;
uVar5 = (uint)param_3;
uVar2 = (uint)(param_3 >> 5) & 0x7ffffff;
local_a0 = param_6;
local_98 = param_2;
local_90 = param_4;
if (0x1f < uVar5) {
uVar6 = 0;
do {
ssz_add_multi_merkle_proof(*(int8 *)(param_5 + uVar6 * 8),&local_b8,&local_88);
uVar6 = uVar6 + 1;
} while (uVar2 != uVar6);
}
buffer_free(&local_88);
local_68 = local_98;
local_60 = uStack_b0;
local_58 = (uint)local_b8 >> 3;
local_48 = local_90;
local_70[0] = param_1;
local_50 = uVar5;
local_40 = param_5;
local_38 = uVar2;
if (local_58 == param_1 >> 5) {
if (uVar5 < 0x20) {
uVar6 = 0;
}
else {
uVar4 = 0;
uVar6 = 0;
do {
uVar1 = *(ulong *)(param_5 + uVar4 * 8);
if (uVar6 < uVar1) {
uVar6 = uVar1;
}
uVar4 = uVar4 + 1;
} while (uVar2 != uVar4);
}
uVar3 = merkle_proof(local_70,uVar6,1,local_a0);
}
else {
uVar3 = 0;
}
buffer_free(&local_b8);
return uVar3;
}
| |
34,230 | ssz_verify_multi_merkle_proof | corpus-core[P]colibri-stateless/src/util/ssz_merkle.c | bool ssz_verify_multi_merkle_proof(bytes_t proof_data, bytes_t leafes, gindex_t* gindex, bytes32_t out) {
buffer_t witnesses_gindex = {0};
buffer_t calculated_gindex = {0};
for (uint32_t i = 0; i < leafes.len / 32; i++)
ssz_add_multi_merkle_proof(gindex[i], &witnesses_gindex, &calculated_gindex);
/*
fprintf(stderr, "_______\nwitnesses_gindex:\n");
for (uint32_t i = 0; i < witnesses_gindex.data.len / sizeof(gindex_t); i++) {
fprintf(stderr, "witness gindex: %llu\n", ((gindex_t*) witnesses_gindex.data.data)[i]);
}
fprintf(stderr, "_______\ncalculated_gindex:\n");
for (uint32_t i = 0; i < calculated_gindex.data.len / sizeof(gindex_t); i++) {
fprintf(stderr, "path gindex: %llu\n", ((gindex_t*) calculated_gindex.data.data)[i]);
}
fprintf(stderr, "_______\nvalues:\n");
*/
buffer_free(&calculated_gindex);
merkle_proof_data_t data = {
.leafes_gindex = gindex,
.leafes_data = leafes,
.leafes_len = leafes.len / 32,
.witnesses_data = proof_data,
.witnesses_gindex = (gindex_t*) witnesses_gindex.data.data,
.witnesses_len = witnesses_gindex.data.len / sizeof(gindex_t),
};
if (data.witnesses_len != proof_data.len / 32) {
buffer_free(&witnesses_gindex);
return false;
}
// find the highest gindex since we want to start with that.
gindex_t start = 0;
for (uint32_t i = 0; i < data.leafes_len; i++) {
if (data.leafes_gindex[i] > start) start = data.leafes_gindex[i];
}
bool result = merkle_proof(&data, start, 1, out);
buffer_free(&witnesses_gindex);
return result;
} | O2 | c | ssz_verify_multi_merkle_proof:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edi, %ebp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rbx
movaps %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x80(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
movl %edx, 0x4(%rsp)
movl %edx, %r13d
shrl $0x5, %r13d
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x4d90d
movq (%r14,%r12,8), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4d693
incq %r12
jmp 0x4d8f4
leaq 0x80(%rsp), %rdi
callq 0x4b16d
movl %ebp, 0x40(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x20(%rsp), %eax
shrl $0x3, %eax
movl %eax, 0x58(%rsp)
movl 0x4(%rsp), %ecx
movl %ecx, 0x60(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x68(%rsp)
movq %r14, 0x70(%rsp)
movl %r13d, 0x78(%rsp)
shrl $0x5, %ebp
cmpl %ebp, %eax
jne 0x4d979
xorl %eax, %eax
xorl %esi, %esi
cmpq %rax, %r13
je 0x4d97d
movq (%r14,%rax,8), %rcx
cmpq %rsi, %rcx
cmovaq %rcx, %rsi
incq %rax
jmp 0x4d964
xorl %ebx, %ebx
jmp 0x4d991
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rdx
movq 0x8(%rsp), %rcx
callq 0x4d9af
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x4b16d
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ssz_verify_multi_merkle_proof:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_C0], r9
mov r14, r8
mov [rsp+0C8h+var_B0], rcx
mov [rsp+0C8h+var_B8], rsi
mov ebp, edi
xorps xmm0, xmm0
lea rbx, [rsp+0C8h+var_A8]
movaps xmmword ptr [rbx], xmm0
and qword ptr [rbx+10h], 0
lea r15, [rsp+0C8h+var_48]
and qword ptr [r15+10h], 0
movaps xmmword ptr [r15], xmm0
mov [rsp+0C8h+var_C4], edx
mov r13d, edx
shr r13d, 5
xor r12d, r12d
loc_4D8F4:
cmp r13, r12
jz short loc_4D90D
mov rdi, [r14+r12*8]
mov rsi, rbx
mov rdx, r15
call ssz_add_multi_merkle_proof
inc r12
jmp short loc_4D8F4
loc_4D90D:
lea rdi, [rsp+0C8h+var_48]
call buffer_free
mov [rsp+0C8h+var_88], ebp
mov rax, [rsp+0C8h+var_B8]
mov [rsp+0C8h+var_80], rax
mov rax, [rsp+0C8h+var_A0]
mov [rsp+0C8h+var_78], rax
mov eax, [rsp+0C8h+var_A8]
shr eax, 3
mov [rsp+0C8h+var_70], eax
mov ecx, [rsp+0C8h+var_C4]
mov [rsp+0C8h+var_68], ecx
mov rcx, [rsp+0C8h+var_B0]
mov [rsp+0C8h+var_60], rcx
mov [rsp+0C8h+var_58], r14
mov [rsp+0C8h+var_50], r13d
shr ebp, 5
cmp eax, ebp
jnz short loc_4D979
xor eax, eax
xor esi, esi
loc_4D964:
cmp r13, rax
jz short loc_4D97D
mov rcx, [r14+rax*8]
cmp rcx, rsi
cmova rsi, rcx
inc rax
jmp short loc_4D964
loc_4D979:
xor ebx, ebx
jmp short loc_4D991
loc_4D97D:
lea rdi, [rsp+0C8h+var_88]
push 1
pop rdx
mov rcx, [rsp+0C8h+var_C0]
call merkle_proof
mov ebx, eax
loc_4D991:
lea rdi, [rsp+0C8h+var_A8]
call buffer_free
mov eax, ebx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ssz_verify_multi_merkle_proof(
unsigned int a1,
long long a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
long long v7; // r13
long long i; // r12
long long v9; // rax
unsigned long long v10; // rsi
unsigned int v11; // ebx
__int128 v16; // [rsp+20h] [rbp-A8h] BYREF
long long v17; // [rsp+30h] [rbp-98h]
unsigned int v18; // [rsp+40h] [rbp-88h] BYREF
long long v19; // [rsp+48h] [rbp-80h]
long long v20; // [rsp+50h] [rbp-78h]
unsigned int v21; // [rsp+58h] [rbp-70h]
unsigned int v22; // [rsp+60h] [rbp-68h]
long long v23; // [rsp+68h] [rbp-60h]
long long v24; // [rsp+70h] [rbp-58h]
int v25; // [rsp+78h] [rbp-50h]
__int128 v26; // [rsp+80h] [rbp-48h] BYREF
long long v27; // [rsp+90h] [rbp-38h]
v16 = 0LL;
v17 = 0LL;
v27 = 0LL;
v26 = 0LL;
v7 = a3 >> 5;
for ( i = 0LL; v7 != i; ++i )
ssz_add_multi_merkle_proof(*(_QWORD *)(a5 + 8 * i), (long long)&v16, (long long)&v26);
buffer_free((long long)&v26);
v18 = a1;
v19 = a2;
v20 = *((_QWORD *)&v16 + 1);
v21 = (unsigned int)v16 >> 3;
v22 = a3;
v23 = a4;
v24 = a5;
v25 = v7;
if ( (unsigned int)v16 >> 3 == a1 >> 5 )
{
v9 = 0LL;
v10 = 0LL;
while ( v7 != v9 )
{
if ( *(_QWORD *)(a5 + 8 * v9) > v10 )
v10 = *(_QWORD *)(a5 + 8 * v9);
++v9;
}
v11 = merkle_proof(&v18, v10, 1LL, a6);
}
else
{
v11 = 0;
}
buffer_free((long long)&v16);
return v11;
}
| ssz_verify_multi_merkle_proof:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x8],R9
MOV R14,R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],RSI
MOV EBP,EDI
XORPS XMM0,XMM0
LEA RBX,[RSP + 0x20]
MOVAPS xmmword ptr [RBX],XMM0
AND qword ptr [RBX + 0x10],0x0
LEA R15,[RSP + 0x80]
AND qword ptr [R15 + 0x10],0x0
MOVAPS xmmword ptr [R15],XMM0
MOV dword ptr [RSP + 0x4],EDX
MOV R13D,EDX
SHR R13D,0x5
XOR R12D,R12D
LAB_0014d8f4:
CMP R13,R12
JZ 0x0014d90d
MOV RDI,qword ptr [R14 + R12*0x8]
MOV RSI,RBX
MOV RDX,R15
CALL 0x0014d693
INC R12
JMP 0x0014d8f4
LAB_0014d90d:
LEA RDI,[RSP + 0x80]
CALL 0x0014b16d
MOV dword ptr [RSP + 0x40],EBP
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x50],RAX
MOV EAX,dword ptr [RSP + 0x20]
SHR EAX,0x3
MOV dword ptr [RSP + 0x58],EAX
MOV ECX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x60],ECX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x68],RCX
MOV qword ptr [RSP + 0x70],R14
MOV dword ptr [RSP + 0x78],R13D
SHR EBP,0x5
CMP EAX,EBP
JNZ 0x0014d979
XOR EAX,EAX
XOR ESI,ESI
LAB_0014d964:
CMP R13,RAX
JZ 0x0014d97d
MOV RCX,qword ptr [R14 + RAX*0x8]
CMP RCX,RSI
CMOVA RSI,RCX
INC RAX
JMP 0x0014d964
LAB_0014d979:
XOR EBX,EBX
JMP 0x0014d991
LAB_0014d97d:
LEA RDI,[RSP + 0x40]
PUSH 0x1
POP RDX
MOV RCX,qword ptr [RSP + 0x8]
CALL 0x0014d9af
MOV EBX,EAX
LAB_0014d991:
LEA RDI,[RSP + 0x20]
CALL 0x0014b16d
MOV EAX,EBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
ssz_verify_multi_merkle_proof
(uint param_1,int8 param_2,ulong param_3,int8 param_4,long param_5,
int8 param_6)
{
ulong uVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
uint local_88 [2];
int8 local_80;
int8 local_78;
uint local_70;
int4 local_68;
int8 local_60;
long local_58;
int4 local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
local_a8 = 0;
uStack_a0 = 0;
local_98 = 0;
local_38 = 0;
local_48 = 0;
uStack_40 = 0;
uVar5 = param_3 >> 5 & 0x7ffffff;
for (uVar4 = 0; uVar5 != uVar4; uVar4 = uVar4 + 1) {
ssz_add_multi_merkle_proof(*(int8 *)(param_5 + uVar4 * 8),&local_a8,&local_48);
}
buffer_free(&local_48);
local_78 = uStack_a0;
local_70 = (uint)local_a8 >> 3;
local_50 = (int4)uVar5;
local_88[0] = param_1;
local_80 = param_2;
local_68 = (int)param_3;
local_60 = param_4;
local_58 = param_5;
if (local_70 == param_1 >> 5) {
uVar4 = 0;
for (uVar3 = 0; uVar5 != uVar3; uVar3 = uVar3 + 1) {
uVar1 = *(ulong *)(param_5 + uVar3 * 8);
if (uVar4 < uVar1) {
uVar4 = uVar1;
}
}
uVar2 = merkle_proof(local_88,uVar4,1,param_6);
}
else {
uVar2 = 0;
}
buffer_free(&local_a8);
return uVar2;
}
| |
34,231 | 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>>>>>::scan_number() | monkey531[P]llama/common/json.hpp | token_type scan_number() // lgtm [cpp/use-of-goto]
{
// reset token_buffer to store the number's bytes
reset();
// the type of the parsed number; initially set to unsigned; will be
// changed if minus sign, decimal point or exponent is read
token_type number_type = token_type::value_unsigned;
// state (init): we just found out we need to scan a number
switch (current)
{
case '-':
{
add(current);
goto scan_number_minus;
}
case '0':
{
add(current);
goto scan_number_zero;
}
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
// all other characters are rejected outside scan_number()
default: // LCOV_EXCL_LINE
JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert) LCOV_EXCL_LINE
}
scan_number_minus:
// state: we just parsed a leading minus sign
number_type = token_type::value_integer;
switch (get())
{
case '0':
{
add(current);
goto scan_number_zero;
}
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
default:
{
error_message = "invalid number; expected digit after '-'";
return token_type::parse_error;
}
}
scan_number_zero:
// state: we just parse a zero (maybe with a leading minus sign)
switch (get())
{
case '.':
{
add(decimal_point_char);
goto scan_number_decimal1;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_any1:
// state: we just parsed a number 0-9 (maybe with a leading minus sign)
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any1;
}
case '.':
{
add(decimal_point_char);
goto scan_number_decimal1;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_decimal1:
// state: we just parsed a decimal point
number_type = token_type::value_float;
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_decimal2;
}
default:
{
error_message = "invalid number; expected digit after '.'";
return token_type::parse_error;
}
}
scan_number_decimal2:
// we just parsed at least one number after a decimal point
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_decimal2;
}
case 'e':
case 'E':
{
add(current);
goto scan_number_exponent;
}
default:
goto scan_number_done;
}
scan_number_exponent:
// we just parsed an exponent
number_type = token_type::value_float;
switch (get())
{
case '+':
case '-':
{
add(current);
goto scan_number_sign;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
{
error_message =
"invalid number; expected '+', '-', or digit after exponent";
return token_type::parse_error;
}
}
scan_number_sign:
// we just parsed an exponent sign
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
{
error_message = "invalid number; expected digit after exponent sign";
return token_type::parse_error;
}
}
scan_number_any2:
// we just parsed a number after the exponent or exponent sign
switch (get())
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
add(current);
goto scan_number_any2;
}
default:
goto scan_number_done;
}
scan_number_done:
// unget the character after the number (we only read it to know that
// we are done scanning a number)
unget();
char* endptr = nullptr; // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
errno = 0;
// try to parse integers first and fall back to floats
if (number_type == token_type::value_unsigned)
{
const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
value_unsigned = static_cast<number_unsigned_t>(x);
if (value_unsigned == x)
{
return token_type::value_unsigned;
}
}
}
else if (number_type == token_type::value_integer)
{
const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
if (errno == 0)
{
value_integer = static_cast<number_integer_t>(x);
if (value_integer == x)
{
return token_type::value_integer;
}
}
}
// this code is reached if we parse a floating-point number or if an
// integer conversion above failed
strtof(value_float, token_buffer.data(), &endptr);
// we checked the number format before
JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
return token_type::value_float;
} | 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>>>>>::scan_number():
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x46c62
movl 0x14(%rbx), %eax
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x469dc
leaq 0x50(%rbx), %r14
movl $0x5, %ebp
movsbl %al, %esi
movq %r14, %rdi
callq 0x18590
leaq 0x50(%rbx), %r14
movq %rbx, %rdi
callq 0x18fee
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x468ec
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x18590
jmp 0x468ce
cmpl $0x2e, %eax
je 0x46a4e
cmpl $0x45, %eax
je 0x46aaa
cmpl $0x65, %eax
je 0x46aaa
movq %rbx, %rdi
callq 0x46bfe
movq $0x0, (%rsp)
callq 0x18060
movq %rax, %r14
movl $0x0, (%rax)
movq 0x50(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
movl $0xa, %edx
cmpl $0x5, %ebp
jne 0x46961
callq 0x18890
movq 0x50(%rbx), %rcx
addq 0x58(%rbx), %rcx
cmpq %rcx, (%r15)
jne 0x46ba4
cmpl $0x0, (%r14)
jne 0x4697d
movl $0x5, %ecx
movl $0x80, %edx
jmp 0x469d3
callq 0x18100
movq 0x50(%rbx), %rcx
addq 0x58(%rbx), %rcx
cmpq %rcx, (%r15)
jne 0x46bc0
cmpl $0x0, (%r14)
je 0x469c9
movq 0x50(%rbx), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0x18540
movsd %xmm0, 0x88(%rbx)
movq 0x50(%rbx), %rax
addq 0x58(%rbx), %rax
movl $0x7, %ecx
cmpq %rax, (%r14)
je 0x46ae4
leaq 0x63dec(%rip), %rdi # 0xaa79d
leaq 0x625b9(%rip), %rdx # 0xa8f71
leaq 0x65156(%rip), %rcx # 0xabb15
movl $0x21d6, %esi # imm = 0x21D6
jmp 0x46bf6
movl $0x6, %ecx
movl $0x78, %edx
movq %rax, (%rbx,%rdx)
jmp 0x46ae4
cmpl $0x30, %eax
je 0x46a1c
cmpl $0x2d, %eax
jne 0x46bdc
leaq 0x50(%rbx), %r14
movq %r14, %rdi
movl $0x2d, %esi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x46b7d
movl 0x14(%rbx), %eax
movl $0x6, %ebp
jmp 0x468bf
leaq 0x50(%rbx), %rdi
movl $0x30, %esi
callq 0x18590
movl $0x5, %ebp
movq %rbx, %rdi
callq 0x18fee
cmpl $0x65, %eax
je 0x46aa6
cmpl $0x45, %eax
je 0x46aa6
cmpl $0x2e, %eax
jne 0x46907
leaq 0x50(%rbx), %r14
movsbl 0x90(%rbx), %esi
movq %r14, %rdi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x46a9d
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x46a71
cmpl $0x65, %eax
je 0x46aaa
cmpl $0x45, %eax
jne 0x46b31
jmp 0x46aaa
leaq 0x64fda(%rip), %rax # 0xaba7e
jmp 0x46adb
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jb 0x46af1
cmpl $0x2d, %eax
je 0x46b51
cmpl $0x2b, %eax
je 0x46b51
leaq 0x64fcc(%rip), %rax # 0xabaa7
movq %rax, 0x70(%rbx)
movl $0xe, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x46b31
leaq 0x50(%rbx), %r14
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x46b15
movq %rbx, %rdi
callq 0x46bfe
movq $0x0, (%rsp)
callq 0x18060
movl $0x0, (%rax)
jmp 0x4697d
movsbl 0x14(%rbx), %esi
leaq 0x50(%rbx), %r14
movq %r14, %rdi
callq 0x18590
movq %rbx, %rdi
callq 0x18fee
addl $-0x30, %eax
cmpl $0xa, %eax
jb 0x46af5
leaq 0x64f6a(%rip), %rax # 0xabae2
jmp 0x46adb
cmpl $0x30, %eax
je 0x46b8e
leaq 0x64ecc(%rip), %rax # 0xaba55
jmp 0x46adb
movsbl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x18590
movl $0x6, %ebp
jmp 0x46a2f
leaq 0x63bf2(%rip), %rdi # 0xaa79d
leaq 0x623bf(%rip), %rdx # 0xa8f71
leaq 0x64f5c(%rip), %rcx # 0xabb15
movl $0x21b5, %esi # imm = 0x21B5
jmp 0x46bf6
leaq 0x63bd6(%rip), %rdi # 0xaa79d
leaq 0x623a3(%rip), %rdx # 0xa8f71
leaq 0x64f40(%rip), %rcx # 0xabb15
movl $0x21c5, %esi # imm = 0x21C5
jmp 0x46bf6
leaq 0x63bba(%rip), %rdi # 0xaa79d
leaq 0x62387(%rip), %rdx # 0xa8f71
leaq 0x623de(%rip), %rcx # 0xa8fcf
movl $0x20be, %esi # imm = 0x20BE
xorl %eax, %eax
callq 0x18af0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE11scan_numberEv:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5resetEv; 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>>>::reset(void)
mov eax, [rbx+14h]
lea ecx, [rax-31h]
cmp ecx, 9
jnb loc_469DC
lea r14, [rbx+50h]
mov ebp, 5
loc_468BF:
movsx esi, al
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
lea r14, [rbx+50h]
loc_468CE:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
lea ecx, [rax-30h]
cmp ecx, 0Ah
jnb short loc_468EC
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
jmp short loc_468CE
loc_468EC:
cmp eax, 2Eh ; '.'
jz loc_46A4E
cmp eax, 45h ; 'E'
jz loc_46AAA
cmp eax, 65h ; 'e'
jz loc_46AAA
loc_46907:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; 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>>>::unget(void)
mov [rsp+28h+var_28], 0
call ___errno_location
mov r14, rax
mov dword ptr [rax], 0
mov rdi, [rbx+50h]
mov r15, rsp
mov rsi, r15
mov edx, 0Ah
cmp ebp, 5
jnz short loc_46961
call _strtoull
mov rcx, [rbx+50h]
add rcx, [rbx+58h]
cmp [r15], rcx
jnz loc_46BA4
cmp dword ptr [r14], 0
jnz short loc_4697D
mov ecx, 5
mov edx, 80h
jmp short loc_469D3
loc_46961:
call _strtoll
mov rcx, [rbx+50h]
add rcx, [rbx+58h]
cmp [r15], rcx
jnz loc_46BC0
cmp dword ptr [r14], 0
jz short loc_469C9
loc_4697D:
mov rdi, [rbx+50h]
mov r14, rsp
mov rsi, r14
call _strtod
movsd qword ptr [rbx+88h], xmm0
mov rax, [rbx+50h]
add rax, [rbx+58h]
mov ecx, 7
cmp [r14], rax
jz loc_46AE4
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aEndptrTokenBuf; "endptr == token_buffer.data() + token_b"...
mov esi, 21D6h
jmp loc_46BF6
loc_469C9:
mov ecx, 6
mov edx, 78h ; 'x'
loc_469D3:
mov [rbx+rdx], rax
jmp loc_46AE4
loc_469DC:
cmp eax, 30h ; '0'
jz short loc_46A1C
cmp eax, 2Dh ; '-'
jnz loc_46BDC
lea r14, [rbx+50h]
mov rdi, r14
mov esi, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
lea ecx, [rax-31h]
cmp ecx, 9
jnb loc_46B7D
mov eax, [rbx+14h]
mov ebp, 6
jmp loc_468BF
loc_46A1C:
lea rdi, [rbx+50h]
mov esi, 30h ; '0'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov ebp, 5
loc_46A2F:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
cmp eax, 65h ; 'e'
jz short loc_46AA6
cmp eax, 45h ; 'E'
jz short loc_46AA6
cmp eax, 2Eh ; '.'
jnz loc_46907
lea r14, [rbx+50h]
loc_46A4E:
movsx esi, byte ptr [rbx+90h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
add eax, 0FFFFFFD0h
cmp eax, 9
ja short loc_46A9D
lea r14, [rbx+50h]
loc_46A71:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
lea ecx, [rax-30h]
cmp ecx, 0Ah
jb short loc_46A71
cmp eax, 65h ; 'e'
jz short loc_46AAA
cmp eax, 45h ; 'E'
jnz loc_46B31
jmp short loc_46AAA
loc_46A9D:
lea rax, aInvalidNumberE; "invalid number; expected digit after '."...
jmp short loc_46ADB
loc_46AA6:
lea r14, [rbx+50h]
loc_46AAA:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
lea ecx, [rax-30h]
cmp ecx, 0Ah
jb short loc_46AF1
cmp eax, 2Dh ; '-'
jz loc_46B51
cmp eax, 2Bh ; '+'
jz short loc_46B51
lea rax, aInvalidNumberE_0; "invalid number; expected '+', '-', or d"...
loc_46ADB:
mov [rbx+70h], rax
mov ecx, 0Eh
loc_46AE4:
mov eax, ecx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_46AF1:
lea r14, [rbx+50h]
loc_46AF5:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
add eax, 0FFFFFFD0h
cmp eax, 9
ja short loc_46B31
lea r14, [rbx+50h]
loc_46B15:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
add eax, 0FFFFFFD0h
cmp eax, 0Ah
jb short loc_46B15
loc_46B31:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; 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>>>::unget(void)
mov [rsp+28h+var_28], 0
call ___errno_location
mov dword ptr [rax], 0
jmp loc_4697D
loc_46B51:
movsx esi, byte ptr [rbx+14h]
lea r14, [rbx+50h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; 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>>>::get(void)
add eax, 0FFFFFFD0h
cmp eax, 0Ah
jb short loc_46AF5
lea rax, aInvalidNumberE_1; "invalid number; expected digit after ex"...
jmp loc_46ADB
loc_46B7D:
cmp eax, 30h ; '0'
jz short loc_46B8E
lea rax, aInvalidNumberE_2; "invalid number; expected digit after '-"...
jmp loc_46ADB
loc_46B8E:
movsx esi, byte ptr [rbx+14h]
mov rdi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov ebp, 6
jmp loc_46A2F
loc_46BA4:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aEndptrTokenBuf; "endptr == token_buffer.data() + token_b"...
mov esi, 21B5h
jmp short loc_46BF6
loc_46BC0:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aEndptrTokenBuf; "endptr == token_buffer.data() + token_b"...
mov esi, 21C5h
jmp short loc_46BF6
loc_46BDC:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalse; "false"
mov esi, 20BEh
loc_46BF6:
xor eax, eax
call _ggml_abort
nop
| long long 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_number(
long long a1)
{
long long v1; // rax
int v3; // eax
long long v4; // r14
int v5; // ebp
long long v6; // r14
int v7; // eax
_DWORD *v8; // r14
long long v9; // rdi
long long v10; // rax
unsigned int v11; // ecx
long long v12; // rdx
int v13; // eax
int v14; // eax
int v15; // eax
const char *v16; // rax
int v17; // eax
long long v19; // r14
_QWORD v20[5]; // [rsp+0h] [rbp-28h] BYREF
v20[0] = v1;
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(a1);
v3 = *(_DWORD *)(a1 + 20);
if ( (unsigned int)(v3 - 49) >= 9 )
{
if ( v3 == 48 )
{
std::string::push_back(a1 + 80, 48LL);
v5 = 5;
}
else
{
if ( v3 != 45 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8382LL,
"GGML_ASSERT(%s) failed",
"false");
return 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>>>::unget("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
v4 = a1 + 80;
std::string::push_back(a1 + 80, 45LL);
v13 = 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>>>::get((__m128i *)a1);
if ( (unsigned int)(v13 - 49) < 9 )
{
v3 = *(_DWORD *)(a1 + 20);
v5 = 6;
goto LABEL_3;
}
if ( v13 != 48 )
{
v16 = "invalid number; expected digit after '-'";
goto LABEL_40;
}
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
v5 = 6;
}
v14 = 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>>>::get((__m128i *)a1);
if ( v14 == 101 || v14 == 69 )
{
v6 = a1 + 80;
goto LABEL_36;
}
if ( v14 != 46 )
goto LABEL_9;
v6 = a1 + 80;
LABEL_28:
std::string::push_back(v6, (unsigned int)*(char *)(a1 + 144));
if ( (unsigned int)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>>>::get((__m128i *)a1)
- 48 > 9 )
{
v16 = "invalid number; expected digit after '.'";
LABEL_40:
*(_QWORD *)(a1 + 112) = v16;
return 14;
}
v6 = a1 + 80;
do
{
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
v15 = 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>>>::get((__m128i *)a1);
}
while ( (unsigned int)(v15 - 48) < 0xA );
if ( v15 != 101 && v15 != 69 )
{
LABEL_45:
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>>>::unget(a1);
v20[0] = 0LL;
*(_DWORD *)__errno_location() = 0;
goto LABEL_15;
}
LABEL_36:
std::string::push_back(v6, (unsigned int)*(char *)(a1 + 20));
v17 = 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>>>::get((__m128i *)a1);
if ( (unsigned int)(v17 - 48) < 0xA )
{
v19 = a1 + 80;
}
else
{
if ( v17 != 45 && v17 != 43 )
{
v16 = "invalid number; expected '+', '-', or digit after exponent";
goto LABEL_40;
}
v19 = a1 + 80;
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
if ( (unsigned int)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>>>::get((__m128i *)a1)
- 48 >= 0xA )
{
v16 = "invalid number; expected digit after exponent sign";
goto LABEL_40;
}
}
std::string::push_back(v19, (unsigned int)*(char *)(a1 + 20));
if ( (unsigned int)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>>>::get((__m128i *)a1)
- 48 <= 9 )
{
do
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
while ( (unsigned int)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>>>::get((__m128i *)a1)
- 48 < 0xA );
}
goto LABEL_45;
}
v4 = a1 + 80;
v5 = 5;
LABEL_3:
std::string::push_back(v4, (unsigned int)(char)v3);
v6 = a1 + 80;
while ( 1 )
{
v7 = 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>>>::get((__m128i *)a1);
if ( (unsigned int)(v7 - 48) >= 0xA )
break;
std::string::push_back(a1 + 80, (unsigned int)*(char *)(a1 + 20));
}
if ( v7 == 46 )
goto LABEL_28;
if ( v7 == 69 || v7 == 101 )
goto LABEL_36;
LABEL_9:
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>>>::unget(a1);
v20[0] = 0LL;
v8 = (_DWORD *)__errno_location();
*v8 = 0;
v9 = *(_QWORD *)(a1 + 80);
if ( v5 == 5 )
{
v10 = strtoull(v9, v20, 10LL);
if ( v20[0] != *(_QWORD *)(a1 + 88) + *(_QWORD *)(a1 + 80) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8629LL,
"GGML_ASSERT(%s) failed",
"endptr == token_buffer.data() + token_buffer.size()");
return 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>>>::unget("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
if ( !*v8 )
{
v11 = 5;
v12 = 128LL;
LABEL_18:
*(_QWORD *)(a1 + v12) = v10;
return v11;
}
}
else
{
v10 = strtoll(v9, v20, 10LL);
if ( v20[0] != *(_QWORD *)(a1 + 88) + *(_QWORD *)(a1 + 80) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8645LL,
"GGML_ASSERT(%s) failed",
"endptr == token_buffer.data() + token_buffer.size()");
return 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>>>::unget("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
if ( !*v8 )
{
v11 = 6;
v12 = 120LL;
goto LABEL_18;
}
}
LABEL_15:
*(double *)(a1 + 136) = strtod(*(_QWORD *)(a1 + 80), v20);
v11 = 7;
if ( v20[0] == *(_QWORD *)(a1 + 88) + *(_QWORD *)(a1 + 80) )
return v11;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
8662LL,
"GGML_ASSERT(%s) failed",
"endptr == token_buffer.data() + token_buffer.size()");
return 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>>>::unget("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
| scan_number:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00146c62
MOV EAX,dword ptr [RBX + 0x14]
LEA ECX,[RAX + -0x31]
CMP ECX,0x9
JNC 0x001469dc
LEA R14,[RBX + 0x50]
MOV EBP,0x5
LAB_001468bf:
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00118590
LEA R14,[RBX + 0x50]
LAB_001468ce:
MOV RDI,RBX
CALL 0x00118fee
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JNC 0x001468ec
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00118590
JMP 0x001468ce
LAB_001468ec:
CMP EAX,0x2e
JZ 0x00146a4e
CMP EAX,0x45
JZ 0x00146aaa
CMP EAX,0x65
JZ 0x00146aaa
LAB_00146907:
MOV RDI,RBX
CALL 0x00146bfe
MOV qword ptr [RSP],0x0
CALL 0x00118060
MOV R14,RAX
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RBX + 0x50]
MOV R15,RSP
MOV RSI,R15
MOV EDX,0xa
CMP EBP,0x5
JNZ 0x00146961
CALL 0x00118890
MOV RCX,qword ptr [RBX + 0x50]
ADD RCX,qword ptr [RBX + 0x58]
CMP qword ptr [R15],RCX
JNZ 0x00146ba4
CMP dword ptr [R14],0x0
JNZ 0x0014697d
MOV ECX,0x5
MOV EDX,0x80
JMP 0x001469d3
LAB_00146961:
CALL 0x00118100
MOV RCX,qword ptr [RBX + 0x50]
ADD RCX,qword ptr [RBX + 0x58]
CMP qword ptr [R15],RCX
JNZ 0x00146bc0
CMP dword ptr [R14],0x0
JZ 0x001469c9
LAB_0014697d:
MOV RDI,qword ptr [RBX + 0x50]
MOV R14,RSP
MOV RSI,R14
CALL 0x00118540
MOVSD qword ptr [RBX + 0x88],XMM0
MOV RAX,qword ptr [RBX + 0x50]
ADD RAX,qword ptr [RBX + 0x58]
MOV ECX,0x7
CMP qword ptr [R14],RAX
JZ 0x00146ae4
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1abb15]
MOV ESI,0x21d6
JMP 0x00146bf6
LAB_001469c9:
MOV ECX,0x6
MOV EDX,0x78
LAB_001469d3:
MOV qword ptr [RBX + RDX*0x1],RAX
JMP 0x00146ae4
LAB_001469dc:
CMP EAX,0x30
JZ 0x00146a1c
CMP EAX,0x2d
JNZ 0x00146bdc
LEA R14,[RBX + 0x50]
MOV RDI,R14
MOV ESI,0x2d
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
LEA ECX,[RAX + -0x31]
CMP ECX,0x9
JNC 0x00146b7d
MOV EAX,dword ptr [RBX + 0x14]
MOV EBP,0x6
JMP 0x001468bf
LAB_00146a1c:
LEA RDI,[RBX + 0x50]
MOV ESI,0x30
CALL 0x00118590
MOV EBP,0x5
LAB_00146a2f:
MOV RDI,RBX
CALL 0x00118fee
CMP EAX,0x65
JZ 0x00146aa6
CMP EAX,0x45
JZ 0x00146aa6
CMP EAX,0x2e
JNZ 0x00146907
LEA R14,[RBX + 0x50]
LAB_00146a4e:
MOVSX ESI,byte ptr [RBX + 0x90]
MOV RDI,R14
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
ADD EAX,-0x30
CMP EAX,0x9
JA 0x00146a9d
LEA R14,[RBX + 0x50]
LAB_00146a71:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JC 0x00146a71
CMP EAX,0x65
JZ 0x00146aaa
CMP EAX,0x45
JNZ 0x00146b31
JMP 0x00146aaa
LAB_00146a9d:
LEA RAX,[0x1aba7e]
JMP 0x00146adb
LAB_00146aa6:
LEA R14,[RBX + 0x50]
LAB_00146aaa:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
LEA ECX,[RAX + -0x30]
CMP ECX,0xa
JC 0x00146af1
CMP EAX,0x2d
JZ 0x00146b51
CMP EAX,0x2b
JZ 0x00146b51
LEA RAX,[0x1abaa7]
LAB_00146adb:
MOV qword ptr [RBX + 0x70],RAX
MOV ECX,0xe
LAB_00146ae4:
MOV EAX,ECX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00146af1:
LEA R14,[RBX + 0x50]
LAB_00146af5:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
ADD EAX,-0x30
CMP EAX,0x9
JA 0x00146b31
LEA R14,[RBX + 0x50]
LAB_00146b15:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
ADD EAX,-0x30
CMP EAX,0xa
JC 0x00146b15
LAB_00146b31:
MOV RDI,RBX
CALL 0x00146bfe
MOV qword ptr [RSP],0x0
CALL 0x00118060
MOV dword ptr [RAX],0x0
JMP 0x0014697d
LAB_00146b51:
MOVSX ESI,byte ptr [RBX + 0x14]
LEA R14,[RBX + 0x50]
MOV RDI,R14
CALL 0x00118590
MOV RDI,RBX
CALL 0x00118fee
ADD EAX,-0x30
CMP EAX,0xa
JC 0x00146af5
LEA RAX,[0x1abae2]
JMP 0x00146adb
LAB_00146b7d:
CMP EAX,0x30
JZ 0x00146b8e
LEA RAX,[0x1aba55]
JMP 0x00146adb
LAB_00146b8e:
MOVSX ESI,byte ptr [RBX + 0x14]
MOV RDI,R14
CALL 0x00118590
MOV EBP,0x6
JMP 0x00146a2f
LAB_00146ba4:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1abb15]
MOV ESI,0x21b5
JMP 0x00146bf6
LAB_00146bc0:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1abb15]
MOV ESI,0x21c5
JMP 0x00146bf6
LAB_00146bdc:
LEA RDI,[0x1aa79d]
LEA RDX,[0x1a8f71]
LEA RCX,[0x1a8fcf]
MOV ESI,0x20be
LAB_00146bf6:
XOR EAX,EAX
CALL 0x00118af0
|
/* 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 > > >::scan_number() */
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>>>
::scan_number(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)
{
char cVar1;
int iVar2;
int iVar3;
char *in_RAX;
int *piVar4;
ulonglong uVar5;
int8 uVar6;
char *pcVar7;
long lVar8;
double dVar9;
char *local_28;
local_28 = in_RAX;
reset(this);
iVar3 = *(int *)(this + 0x14);
cVar1 = (char)this;
if (iVar3 - 0x31U < 9) {
iVar3 = 5;
LAB_001468bf:
std::__cxx11::string::push_back(cVar1 + 'P');
while (iVar2 = get(this), iVar2 - 0x30U < 10) {
std::__cxx11::string::push_back(cVar1 + 'P');
}
if (iVar2 == 0x2e) {
LAB_00146a4e:
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (9 < iVar3 - 0x30U) {
pcVar7 = "invalid number; expected digit after \'.\'";
goto LAB_00146adb;
}
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
} while (iVar3 - 0x30U < 10);
if ((iVar3 == 0x65) || (iVar3 == 0x45)) goto LAB_00146aaa;
goto LAB_00146b31;
}
if ((iVar2 == 0x45) || (iVar2 == 0x65)) goto LAB_00146aaa;
LAB_00146907:
unget(this);
local_28 = (char *)0x0;
piVar4 = __errno_location();
*piVar4 = 0;
if (iVar3 == 5) {
uVar5 = strtoull(*(char **)(this + 0x50),&local_28,10);
if (local_28 != (char *)(*(long *)(this + 0x50) + *(long *)(this + 0x58))) {
pcVar7 = "endptr == token_buffer.data() + token_buffer.size()";
uVar6 = 0x21b5;
goto LAB_00146bf6;
}
if (*piVar4 == 0) {
uVar6 = 5;
lVar8 = 0x80;
LAB_001469d3:
*(ulonglong *)(this + lVar8) = uVar5;
return uVar6;
}
}
else {
uVar5 = strtoll(*(char **)(this + 0x50),&local_28,10);
if (local_28 != (char *)(*(long *)(this + 0x50) + *(long *)(this + 0x58))) {
pcVar7 = "endptr == token_buffer.data() + token_buffer.size()";
uVar6 = 0x21c5;
goto LAB_00146bf6;
}
if (*piVar4 == 0) {
uVar6 = 6;
lVar8 = 0x78;
goto LAB_001469d3;
}
}
}
else {
if (iVar3 == 0x30) {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = 5;
}
else {
if (iVar3 != 0x2d) {
pcVar7 = "false";
uVar6 = 0x20be;
goto LAB_00146bf6;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (iVar3 - 0x31U < 9) {
iVar3 = 6;
goto LAB_001468bf;
}
if (iVar3 != 0x30) {
pcVar7 = "invalid number; expected digit after \'-\'";
goto LAB_00146adb;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = 6;
}
iVar2 = get(this);
if ((iVar2 != 0x65) && (iVar2 != 0x45)) {
if (iVar2 != 0x2e) goto LAB_00146907;
goto LAB_00146a4e;
}
LAB_00146aaa:
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (9 < iVar3 - 0x30U) {
if ((iVar3 != 0x2d) && (iVar3 != 0x2b)) {
pcVar7 = "invalid number; expected \'+\', \'-\', or digit after exponent";
LAB_00146adb:
*(char **)(this + 0x70) = pcVar7;
return 0xe;
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (9 < iVar3 - 0x30U) {
pcVar7 = "invalid number; expected digit after exponent sign";
goto LAB_00146adb;
}
}
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
if (iVar3 - 0x30U < 10) {
do {
std::__cxx11::string::push_back(cVar1 + 'P');
iVar3 = get(this);
} while (iVar3 - 0x30U < 10);
}
LAB_00146b31:
unget(this);
local_28 = (char *)0x0;
piVar4 = __errno_location();
*piVar4 = 0;
}
dVar9 = strtod(*(char **)(this + 0x50),&local_28);
*(double *)(this + 0x88) = dVar9;
if (local_28 == (char *)(*(long *)(this + 0x50) + *(long *)(this + 0x58))) {
return 7;
}
pcVar7 = "endptr == token_buffer.data() + token_buffer.size()";
uVar6 = 0x21d6;
LAB_00146bf6:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar7);
}
| |
34,232 | 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>::type_name() const | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
case value_t::string:
return "string";
case value_t::boolean:
return "boolean";
case value_t::binary:
return "binary";
case value_t::discarded:
return "discarded";
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
default:
return "number";
}
} | O0 | 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>::type_name() const:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x67a6a
movq -0x18(%rbp), %rax
leaq 0x2469c(%rip), %rcx # 0x8c0a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x25447(%rip), %rax # 0x8ce5b
movq %rax, -0x8(%rbp)
jmp 0x67a75
leaq 0x2543f(%rip), %rax # 0x8ce60
movq %rax, -0x8(%rbp)
jmp 0x67a75
leaq 0x25439(%rip), %rax # 0x8ce67
movq %rax, -0x8(%rbp)
jmp 0x67a75
leaq 0x25432(%rip), %rax # 0x8ce6d
movq %rax, -0x8(%rbp)
jmp 0x67a75
leaq 0x2542c(%rip), %rax # 0x8ce74
movq %rax, -0x8(%rbp)
jmp 0x67a75
leaq 0x25427(%rip), %rax # 0x8ce7c
movq %rax, -0x8(%rbp)
jmp 0x67a75
leaq 0x25421(%rip), %rax # 0x8ce83
movq %rax, -0x8(%rbp)
jmp 0x67a75
jmp 0x67a6a
leaq 0x2541c(%rip), %rax # 0x8ce8d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov [rbp+var_18], rax
sub rax, 9; switch 10 cases
ja short def_67A0B; jumptable 0000000000067A0B default case
mov rax, [rbp+var_18]
lea rcx, jpt_67A0B
movsxd rax, ds:(jpt_67A0B - 8C0A0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_67A0D:
lea rax, aNull; jumptable 0000000000067A0B case 0
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A1A:
lea rax, aObject; jumptable 0000000000067A0B case 1
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A27:
lea rax, aArray; jumptable 0000000000067A0B case 2
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A34:
lea rax, aString; jumptable 0000000000067A0B case 3
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A41:
lea rax, aBoolean; jumptable 0000000000067A0B case 4
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A4E:
lea rax, aBinary; jumptable 0000000000067A0B case 8
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A5B:
lea rax, aDiscarded; jumptable 0000000000067A0B case 9
mov [rbp+var_8], rax
jmp short loc_67A75
loc_67A68:
jmp short $+2; jumptable 0000000000067A0B cases 5-7
def_67A0B:
lea rax, aNumber; jumptable 0000000000067A0B default case
mov [rbp+var_8], rax
loc_67A75:
mov rax, [rbp+var_8]
pop rbp
retn
| const char * 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>::type_name(
_BYTE *a1)
{
const char *v2; // [rsp+10h] [rbp-8h]
switch ( *a1 )
{
case 0:
v2 = "null";
break;
case 1:
v2 = "object";
break;
case 2:
v2 = "array";
break;
case 3:
v2 = "string";
break;
case 4:
v2 = "boolean";
break;
case 8:
v2 = "binary";
break;
case 9:
v2 = "discarded";
break;
default:
v2 = "number";
break;
}
return v2;
}
| type_name:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x9
JA 0x00167a6a
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x18c0a0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RAX,[0x18ce5b]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_1:
LEA RAX,[0x18ce60]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_2:
LEA RAX,[0x18ce67]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_3:
LEA RAX,[0x18ce6d]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_4:
LEA RAX,[0x18ce74]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_8:
LEA RAX,[0x18ce7c]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_9:
LEA RAX,[0x18ce83]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167a75
caseD_5:
JMP 0x00167a6a
default:
LEA RAX,[0x18ce8d]
MOV qword ptr [RBP + -0x8],RAX
LAB_00167a75:
MOV RAX,qword ptr [RBP + -0x8]
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>::type_name() const */
char * __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>
::type_name(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)
{
char *local_10;
switch(*this) {
case (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>
)0x0:
local_10 = "null";
break;
case (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>
)0x1:
local_10 = "object";
break;
case (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>
)0x2:
local_10 = "array";
break;
case (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>
)0x3:
local_10 = "string";
break;
case (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>
)0x4:
local_10 = "boolean";
break;
case (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>
)0x5:
case (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>
)0x6:
case (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>
)0x7:
default:
local_10 = "number";
break;
case (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>
)0x8:
local_10 = "binary";
break;
case (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>
)0x9:
local_10 = "discarded";
}
return local_10;
}
| |
34,233 | 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>::type_name() const | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
case value_t::string:
return "string";
case value_t::boolean:
return "boolean";
case value_t::binary:
return "binary";
case value_t::discarded:
return "discarded";
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
default:
return "number";
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::basic_json<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>::type_name() const:
movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x15b6e
leaq 0x1161a(%rip), %rcx # 0x27180
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0xcc8c(%rip), %rax # 0x22801
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv:
movzx eax, byte ptr [rdi]
cmp rax, 9
ja short loc_15B6E
lea rcx, unk_27180
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_15B6E:
lea rax, aNumber; "number"
retn
| const char * 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>::type_name(
unsigned __int8 *a1)
{
unsigned long long v1; // rax
v1 = *a1;
if ( v1 > 9 )
return "number";
else
return (char *)dword_27180 + dword_27180[v1];
}
| type_name:
MOVZX EAX,byte ptr [RDI]
CMP RAX,0x9
JA 0x00115b6e
LEA RCX,[0x127180]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00115b6e:
LEA RAX,[0x122801]
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>::type_name() const */
char * __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>
::type_name(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)
{
if ((ulong)(byte)*this < 10) {
return &DAT_00127180 + *(int *)(&DAT_00127180 + (ulong)(byte)*this * 4);
}
return "number";
}
| |
34,234 | 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>::type_name() const | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | JSON_HEDLEY_RETURNS_NON_NULL
const char* type_name() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
return "null";
case value_t::object:
return "object";
case value_t::array:
return "array";
case value_t::string:
return "string";
case value_t::boolean:
return "boolean";
case value_t::binary:
return "binary";
case value_t::discarded:
return "discarded";
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
default:
return "number";
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::type_name() const:
movzbl (%rdi), %eax
cmpq $0x9, %rax
ja 0x15a90
leaq 0x106f8(%rip), %rcx # 0x26180
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0xbd6a(%rip), %rax # 0x21801
retq
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv:
movzx eax, byte ptr [rdi]
cmp rax, 9
ja short loc_15A90
lea rcx, unk_26180
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_15A90:
lea rax, aNumber; "number"
retn
| const char * 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>::type_name(
unsigned __int8 *a1)
{
unsigned long long v1; // rax
v1 = *a1;
if ( v1 > 9 )
return "number";
else
return (char *)dword_26180 + dword_26180[v1];
}
| type_name:
MOVZX EAX,byte ptr [RDI]
CMP RAX,0x9
JA 0x00115a90
LEA RCX,[0x126180]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00115a90:
LEA RAX,[0x121801]
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>::type_name() const */
char * __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>
::type_name(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)
{
if ((ulong)(byte)*this < 10) {
return &DAT_00126180 + *(int *)(&DAT_00126180 + (ulong)(byte)*this * 4);
}
return "number";
}
| |
34,235 | ma_SHA1Final | eloqsql/libmariadb/libmariadb/ma_sha1.c | void ma_SHA1Final(unsigned char digest[20], _MA_SHA1_CTX * context)
{
unsigned char bits[8];
unsigned int index, padLen;
/* Save number of bits */
bits[7] = context->count[0] & 0xFF;
bits[6] = (context->count[0] >> 8) & 0xFF;
bits[5] = (context->count[0] >> 16) & 0xFF;
bits[4] = (context->count[0] >> 24) & 0xFF;
bits[3] = context->count[1] & 0xFF;
bits[2] = (context->count[1] >> 8) & 0xFF;
bits[1] = (context->count[1] >> 16) & 0xFF;
bits[0] = (context->count[1] >> 24) & 0xFF;
/* Pad out to 56 mod 64.
*/
index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
ma_SHA1Update(context, PADDING, padLen);
/* Append length (before padding) */
ma_SHA1Update(context, bits, 8);
/* Store state in digest */
ma_SHA1Encode(digest, context->state, 20);
/* Zeroize sensitive information.
*/
memset((unsigned char*) context, 0, sizeof(*context));
} | O0 | c | ma_SHA1Final:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xa(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xb(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0xe(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0xf(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x24(%rbp)
cmpl $0x38, -0x24(%rbp)
jae 0x64c2a
movl $0x38, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x64c35
movl $0x78, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %edx
leaq 0x1c525(%rip), %rsi # 0x81170
callq 0x62df0
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x62df0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x14, %edx
callq 0x64cb0
movq -0x20(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x4c(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x64caa
addq $0x30, %rsp
popq %rbp
retq
callq 0x144c0
nop
| ma_SHA1Final:
push rbp
mov rbp, rsp
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov eax, [rax+14h]
and eax, 0FFh
mov [rbp+var_9], al
mov rax, [rbp+var_20]
mov eax, [rax+14h]
shr eax, 8
and eax, 0FFh
mov [rbp+var_A], al
mov rax, [rbp+var_20]
mov eax, [rax+14h]
shr eax, 10h
and eax, 0FFh
mov [rbp+var_B], al
mov rax, [rbp+var_20]
mov eax, [rax+14h]
shr eax, 18h
and eax, 0FFh
mov [rbp+var_C], al
mov rax, [rbp+var_20]
mov eax, [rax+18h]
and eax, 0FFh
mov [rbp+var_D], al
mov rax, [rbp+var_20]
mov eax, [rax+18h]
shr eax, 8
and eax, 0FFh
mov [rbp+var_E], al
mov rax, [rbp+var_20]
mov eax, [rax+18h]
shr eax, 10h
and eax, 0FFh
mov [rbp+var_F], al
mov rax, [rbp+var_20]
mov eax, [rax+18h]
shr eax, 18h
and eax, 0FFh
mov [rbp+var_10], al
mov rax, [rbp+var_20]
mov eax, [rax+14h]
shr eax, 3
and eax, 3Fh
mov [rbp+var_24], eax
cmp [rbp+var_24], 38h ; '8'
jnb short loc_64C2A
mov eax, 38h ; '8'
sub eax, [rbp+var_24]
mov [rbp+var_2C], eax
jmp short loc_64C35
loc_64C2A:
mov eax, 78h ; 'x'
sub eax, [rbp+var_24]
mov [rbp+var_2C], eax
loc_64C35:
mov eax, [rbp+var_2C]
mov [rbp+var_28], eax
mov rdi, [rbp+var_20]
mov eax, [rbp+var_28]
mov edx, eax
lea rsi, PADDING
call ma_SHA1Update
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_10]
mov edx, 8
call ma_SHA1Update
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, 14h
call ma_SHA1Encode
mov rax, [rbp+var_20]
xorps xmm0, xmm0
movups xmmword ptr [rax+4Ch], xmm0
movups xmmword ptr [rax+40h], xmm0
movups xmmword ptr [rax+30h], xmm0
movups xmmword ptr [rax+20h], xmm0
movups xmmword ptr [rax+10h], xmm0
movups xmmword ptr [rax], xmm0
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_64CAA
add rsp, 30h
pop rbp
retn
loc_64CAA:
call ___stack_chk_fail
| unsigned long long ma_SHA1Final(long long a1, long long a2)
{
unsigned int v3; // [rsp+4h] [rbp-2Ch]
unsigned int v4; // [rsp+Ch] [rbp-24h]
_BYTE v5[8]; // [rsp+20h] [rbp-10h] BYREF
unsigned long long v6; // [rsp+28h] [rbp-8h]
v6 = __readfsqword(0x28u);
v5[7] = *(_DWORD *)(a2 + 20);
v5[6] = BYTE1(*(_DWORD *)(a2 + 20));
v5[5] = BYTE2(*(_DWORD *)(a2 + 20));
v5[4] = HIBYTE(*(_DWORD *)(a2 + 20));
v5[3] = *(_DWORD *)(a2 + 24);
v5[2] = BYTE1(*(_DWORD *)(a2 + 24));
v5[1] = BYTE2(*(_DWORD *)(a2 + 24));
v5[0] = HIBYTE(*(_DWORD *)(a2 + 24));
v4 = (*(_DWORD *)(a2 + 20) >> 3) & 0x3F;
if ( v4 >= 0x38 )
v3 = 120 - v4;
else
v3 = 56 - v4;
ma_SHA1Update(a2, (long long)&PADDING, v3);
ma_SHA1Update(a2, (long long)v5, 8uLL);
ma_SHA1Encode(a1, a2, 20LL);
*(_OWORD *)(a2 + 76) = 0LL;
*(_OWORD *)(a2 + 64) = 0LL;
*(_OWORD *)(a2 + 48) = 0LL;
*(_OWORD *)(a2 + 32) = 0LL;
*(_OWORD *)(a2 + 16) = 0LL;
*(_OWORD *)a2 = 0LL;
return __readfsqword(0x28u);
}
| ma_SHA1Final:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x14]
AND EAX,0xff
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x14]
SHR EAX,0x8
AND EAX,0xff
MOV byte ptr [RBP + -0xa],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x14]
SHR EAX,0x10
AND EAX,0xff
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x14]
SHR EAX,0x18
AND EAX,0xff
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
AND EAX,0xff
MOV byte ptr [RBP + -0xd],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
SHR EAX,0x8
AND EAX,0xff
MOV byte ptr [RBP + -0xe],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
SHR EAX,0x10
AND EAX,0xff
MOV byte ptr [RBP + -0xf],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
SHR EAX,0x18
AND EAX,0xff
MOV byte ptr [RBP + -0x10],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x14]
SHR EAX,0x3
AND EAX,0x3f
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x38
JNC 0x00164c2a
MOV EAX,0x38
SUB EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00164c35
LAB_00164c2a:
MOV EAX,0x78
SUB EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x2c],EAX
LAB_00164c35:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x28],EAX
MOV RDI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x28]
MOV EDX,EAX
LEA RSI,[0x181170]
CALL 0x00162df0
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x10]
MOV EDX,0x8
CALL 0x00162df0
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,0x14
CALL 0x00164cb0
MOV RAX,qword ptr [RBP + -0x20]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x4c],XMM0
MOVUPS xmmword ptr [RAX + 0x40],XMM0
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00164caa
ADD RSP,0x30
POP RBP
RET
LAB_00164caa:
CALL 0x001144c0
|
void ma_SHA1Final(int8 param_1,int8 *param_2)
{
uint uVar1;
long in_FS_OFFSET;
int local_34;
int1 local_18;
int1 local_17;
int1 local_16;
int1 local_15;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_11 = (int1)*(int4 *)((long)param_2 + 0x14);
local_12 = (int1)((uint)*(int4 *)((long)param_2 + 0x14) >> 8);
local_13 = (int1)((uint)*(int4 *)((long)param_2 + 0x14) >> 0x10);
local_14 = (int1)((uint)*(int4 *)((long)param_2 + 0x14) >> 0x18);
local_15 = (int1)*(int4 *)(param_2 + 3);
local_16 = (int1)((uint)*(int4 *)(param_2 + 3) >> 8);
local_17 = (int1)((uint)*(int4 *)(param_2 + 3) >> 0x10);
local_18 = (int1)((uint)*(int4 *)(param_2 + 3) >> 0x18);
uVar1 = *(uint *)((long)param_2 + 0x14) >> 3 & 0x3f;
if (uVar1 < 0x38) {
local_34 = 0x38 - uVar1;
}
else {
local_34 = 0x78 - uVar1;
}
ma_SHA1Update(param_2,PADDING,local_34);
ma_SHA1Update(param_2,&local_18,8);
ma_SHA1Encode(param_1,param_2,0x14);
*(int8 *)((long)param_2 + 0x4c) = 0;
*(int8 *)((long)param_2 + 0x54) = 0;
param_2[8] = 0;
param_2[9] = 0;
param_2[6] = 0;
param_2[7] = 0;
param_2[4] = 0;
param_2[5] = 0;
param_2[2] = 0;
param_2[3] = 0;
*param_2 = 0;
param_2[1] = 0;
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,236 | bf_set | bluesky950520[P]quickjs/libbf.c | int bf_set(bf_t *r, const bf_t *a)
{
if (r == a)
return 0;
if (bf_resize(r, a->len)) {
bf_set_nan(r);
return BF_ST_MEM_ERROR;
}
r->sign = a->sign;
r->expn = a->expn;
if (a->len > 0)
memcpy(r->tab, a->tab, a->len * sizeof(limb_t));
return 0;
} | O2 | c | bf_set:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
cmpq %rsi, %rdi
je 0x6f6bc
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x6f50f
testl %eax, %eax
je 0x6f692
movq %r14, %rdi
callq 0x6f5cd
pushq $0x20
popq %rbx
jmp 0x6f6bc
movl 0x8(%r15), %eax
movl %eax, 0x8(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r14)
movq 0x18(%r15), %rdx
testq %rdx, %rdx
je 0x6f6bc
movq 0x20(%r14), %rdi
movq 0x20(%r15), %rsi
shlq $0x3, %rdx
callq 0xe5c0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| bf_set:
push r15
push r14
push rbx
xor ebx, ebx
cmp rdi, rsi
jz short loc_6F6BC
mov r15, rsi
mov r14, rdi
mov rsi, [rsi+18h]
call bf_resize
test eax, eax
jz short loc_6F692
mov rdi, r14
call bf_set_nan
push 20h ; ' '
pop rbx
jmp short loc_6F6BC
loc_6F692:
mov eax, [r15+8]
mov [r14+8], eax
mov rax, [r15+10h]
mov [r14+10h], rax
mov rdx, [r15+18h]
test rdx, rdx
jz short loc_6F6BC
mov rdi, [r14+20h]
mov rsi, [r15+20h]
shl rdx, 3
call _memcpy
loc_6F6BC:
mov eax, ebx
pop rbx
pop r14
pop r15
retn
| long long bf_set(long long a1, long long a2)
{
unsigned int v2; // ebx
long long v3; // rdx
v2 = 0;
if ( a1 != a2 )
{
if ( (unsigned int)bf_resize(a1, *(_QWORD *)(a2 + 24)) )
{
bf_set_nan(a1);
return 32;
}
else
{
*(_DWORD *)(a1 + 8) = *(_DWORD *)(a2 + 8);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16);
v3 = *(_QWORD *)(a2 + 24);
if ( v3 )
memcpy(*(_QWORD *)(a1 + 32), *(_QWORD *)(a2 + 32), 8 * v3);
}
}
return v2;
}
| bf_set:
PUSH R15
PUSH R14
PUSH RBX
XOR EBX,EBX
CMP RDI,RSI
JZ 0x0016f6bc
MOV R15,RSI
MOV R14,RDI
MOV RSI,qword ptr [RSI + 0x18]
CALL 0x0016f50f
TEST EAX,EAX
JZ 0x0016f692
MOV RDI,R14
CALL 0x0016f5cd
PUSH 0x20
POP RBX
JMP 0x0016f6bc
LAB_0016f692:
MOV EAX,dword ptr [R15 + 0x8]
MOV dword ptr [R14 + 0x8],EAX
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [R14 + 0x10],RAX
MOV RDX,qword ptr [R15 + 0x18]
TEST RDX,RDX
JZ 0x0016f6bc
MOV RDI,qword ptr [R14 + 0x20]
MOV RSI,qword ptr [R15 + 0x20]
SHL RDX,0x3
CALL 0x0010e5c0
LAB_0016f6bc:
MOV EAX,EBX
POP RBX
POP R14
POP R15
RET
|
int8 bf_set(long param_1,long param_2)
{
int iVar1;
int8 uVar2;
uVar2 = 0;
if (param_1 != param_2) {
iVar1 = bf_resize(param_1,*(int8 *)(param_2 + 0x18));
if (iVar1 == 0) {
*(int4 *)(param_1 + 8) = *(int4 *)(param_2 + 8);
*(int8 *)(param_1 + 0x10) = *(int8 *)(param_2 + 0x10);
if (*(long *)(param_2 + 0x18) != 0) {
memcpy(*(void **)(param_1 + 0x20),*(void **)(param_2 + 0x20),*(long *)(param_2 + 0x18) << 3)
;
uVar2 = 0;
}
}
else {
bf_set_nan(param_1);
uVar2 = 0x20;
}
}
return uVar2;
}
| |
34,237 | bf_set | bluesky950520[P]quickjs/libbf.c | int bf_set(bf_t *r, const bf_t *a)
{
if (r == a)
return 0;
if (bf_resize(r, a->len)) {
bf_set_nan(r);
return BF_ST_MEM_ERROR;
}
r->sign = a->sign;
r->expn = a->expn;
if (a->len > 0)
memcpy(r->tab, a->tab, a->len * sizeof(limb_t));
return 0;
} | O3 | c | bf_set:
pushq %rbp
pushq %r14
pushq %rbx
xorl %ebp, %ebp
cmpq %rsi, %rdi
je 0x8775b
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
callq 0x874b9
testl %eax, %eax
je 0x87732
cmpq $0x0, 0x18(%rbx)
je 0x87716
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
movl $0x20, %ebp
jmp 0x8775b
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdx
testq %rdx, %rdx
je 0x8775b
movq 0x20(%rbx), %rdi
movq 0x20(%r14), %rsi
shlq $0x3, %rdx
callq 0xe5b0
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| bf_set:
push rbp
push r14
push rbx
xor ebp, ebp
cmp rdi, rsi
jz short loc_8775B
mov r14, rsi
mov rbx, rdi
mov rsi, [rsi+18h]
call bf_resize
test eax, eax
jz short loc_87732
cmp qword ptr [rbx+18h], 0
jz short loc_87716
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_87716:
mov rax, 7FFFFFFFFFFFFFFFh
mov [rbx+10h], rax
mov dword ptr [rbx+8], 0
mov ebp, 20h ; ' '
jmp short loc_8775B
loc_87732:
mov eax, [r14+8]
mov [rbx+8], eax
mov rax, [r14+10h]
mov [rbx+10h], rax
mov rdx, [r14+18h]
test rdx, rdx
jz short loc_8775B
mov rdi, [rbx+20h]
mov rsi, [r14+20h]
shl rdx, 3
call _memcpy
loc_8775B:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
| long long bf_set(_QWORD *a1, long long a2)
{
unsigned int v2; // ebp
long long v3; // rdx
v2 = 0;
if ( a1 != (_QWORD *)a2 )
{
if ( (unsigned int)bf_resize((long long)a1, *(_QWORD *)(a2 + 24)) )
{
if ( a1[3] )
{
a1[4] = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*a1 + 8LL))(*(_QWORD *)*a1, a1[4], 0LL);
a1[3] = 0LL;
}
a1[2] = 0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
return 32;
}
else
{
*((_DWORD *)a1 + 2) = *(_DWORD *)(a2 + 8);
a1[2] = *(_QWORD *)(a2 + 16);
v3 = *(_QWORD *)(a2 + 24);
if ( v3 )
memcpy(a1[4], *(_QWORD *)(a2 + 32), 8 * v3);
}
}
return v2;
}
| bf_set:
PUSH RBP
PUSH R14
PUSH RBX
XOR EBP,EBP
CMP RDI,RSI
JZ 0x0018775b
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x18]
CALL 0x001874b9
TEST EAX,EAX
JZ 0x00187732
CMP qword ptr [RBX + 0x18],0x0
JZ 0x00187716
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_00187716:
MOV RAX,0x7fffffffffffffff
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],0x0
MOV EBP,0x20
JMP 0x0018775b
LAB_00187732:
MOV EAX,dword ptr [R14 + 0x8]
MOV dword ptr [RBX + 0x8],EAX
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x10],RAX
MOV RDX,qword ptr [R14 + 0x18]
TEST RDX,RDX
JZ 0x0018775b
MOV RDI,qword ptr [RBX + 0x20]
MOV RSI,qword ptr [R14 + 0x20]
SHL RDX,0x3
CALL 0x0010e5b0
LAB_0018775b:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
|
int8 bf_set(long *param_1,long *param_2)
{
int iVar1;
long lVar2;
int8 uVar3;
uVar3 = 0;
if (param_1 != param_2) {
iVar1 = bf_resize(param_1,param_2[3]);
if (iVar1 == 0) {
*(int *)(param_1 + 1) = (int)param_2[1];
param_1[2] = param_2[2];
if (param_2[3] != 0) {
memcpy((void *)param_1[4],(void *)param_2[4],param_2[3] << 3);
}
}
else {
if (param_1[3] != 0) {
lVar2 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar2;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
uVar3 = 0x20;
}
}
return uVar3;
}
| |
34,238 | bitmap_union | eloqsql/mysys/my_bitmap.c | void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits == map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ |= *from++;
} | O0 | c | bitmap_union:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf0e44
jmp 0xf0e46
jmp 0xf0e48
jmp 0xf0e4a
jmp 0xf0e4c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xf0e88
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xf0e58
popq %rbp
retq
nopw (%rax,%rax)
| bitmap_union:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short $+2
loc_F0E44:
jmp short $+2
loc_F0E46:
jmp short $+2
loc_F0E48:
jmp short $+2
loc_F0E4A:
jmp short $+2
loc_F0E4C:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_F0E58:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
ja short loc_F0E88
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 4
mov [rbp+var_20], rcx
mov ecx, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 4
mov [rbp+var_18], rdx
or ecx, [rax]
mov [rax], ecx
jmp short loc_F0E58
loc_F0E88:
pop rbp
retn
| _DWORD * bitmap_union(_QWORD *a1, int **a2)
{
_DWORD *result; // rax
int *v3; // rax
int v4; // ecx
_DWORD *v5; // rax
unsigned long long v6; // [rsp+0h] [rbp-28h]
int *v7; // [rsp+8h] [rbp-20h]
_DWORD *v8; // [rsp+10h] [rbp-18h]
v8 = (_DWORD *)*a1;
v7 = *a2;
v6 = a1[1];
while ( 1 )
{
result = v8;
if ( (unsigned long long)v8 > v6 )
break;
v3 = v7++;
v4 = *v3;
v5 = v8++;
*v5 |= v4;
}
return result;
}
| bitmap_union:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001f0e44
LAB_001f0e44:
JMP 0x001f0e46
LAB_001f0e46:
JMP 0x001f0e48
LAB_001f0e48:
JMP 0x001f0e4a
LAB_001f0e4a:
JMP 0x001f0e4c
LAB_001f0e4c:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001f0e58:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x001f0e88
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x20],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x18],RDX
OR ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
JMP 0x001f0e58
LAB_001f0e88:
POP RBP
RET
|
void bitmap_union(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *local_28;
uint *local_20;
puVar1 = (uint *)param_1[1];
local_28 = (uint *)*param_2;
local_20 = (uint *)*param_1;
while (local_20 <= puVar1) {
*local_20 = *local_28 | *local_20;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
return;
}
| |
34,239 | common_log_main() | monkey531[P]llama/common/log.cpp | struct common_log * common_log_main() {
static struct common_log log;
return &log;
} | O3 | cpp | common_log_main():
pushq %rbx
movb 0x6397a(%rip), %al # 0x12f508
testb %al, %al
je 0xcbb9b
leaq 0x6389f(%rip), %rax # 0x12f438
popq %rbx
retq
leaq 0x63966(%rip), %rdi # 0x12f508
callq 0x1bfd0
testl %eax, %eax
je 0xcbb92
leaq 0x63886(%rip), %rdi # 0x12f438
movl $0x100, %esi # imm = 0x100
callq 0xcc286
leaq 0x10d(%rip), %rdi # 0xcbcd0
leaq 0x6386e(%rip), %rsi # 0x12f438
leaq 0x62cf7(%rip), %rdx # 0x12e8c8
callq 0x1b790
leaq 0x6392b(%rip), %rdi # 0x12f508
callq 0x1b5a0
jmp 0xcbb92
movq %rax, %rbx
leaq 0x6391a(%rip), %rdi # 0x12f508
callq 0x1b590
movq %rbx, %rdi
callq 0x1bf70
| _Z15common_log_mainv:
push rbx
mov al, cs:_ZGVZ15common_log_mainvE3log; `guard variable for'common_log_main(void)::log
test al, al
jz short loc_CBB9B
loc_CBB92:
lea rax, _ZZ15common_log_mainvE3log; common_log_main(void)::log
pop rbx
retn
loc_CBB9B:
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_acquire
test eax, eax
jz short loc_CBB92
lea rdi, _ZZ15common_log_mainvE3log; this
mov esi, 100h; unsigned __int64
call _ZN10common_logC2Em; common_log::common_log(ulong)
lea rdi, _ZN10common_logD2Ev; lpfunc
lea rsi, _ZZ15common_log_mainvE3log; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_release
jmp short loc_CBB92
mov rbx, rax
lea rdi, _ZGVZ15common_log_mainvE3log; __guard *
call ___cxa_guard_abort
mov rdi, rbx
call __Unwind_Resume
| void *common_log_main(void)
{
if ( !(_BYTE)`guard variable for'common_log_main(void)::log
&& __cxa_guard_acquire(&`guard variable for'common_log_main(void)::log) )
{
common_log::common_log((common_log *)&common_log_main(void)::log, 0x100uLL);
__cxa_atexit(common_log::~common_log, &common_log_main(void)::log, &_dso_handle);
__cxa_guard_release(&`guard variable for'common_log_main(void)::log);
}
return &common_log_main(void)::log;
}
| common_log_main:
PUSH RBX
MOV AL,byte ptr [0x0022f508]
TEST AL,AL
JZ 0x001cbb9b
LAB_001cbb92:
LEA RAX,[0x22f438]
POP RBX
RET
LAB_001cbb9b:
LEA RDI,[0x22f508]
CALL 0x0011bfd0
TEST EAX,EAX
JZ 0x001cbb92
LAB_001cbbab:
LEA RDI,[0x22f438]
MOV ESI,0x100
CALL 0x001cc286
LAB_001cbbbc:
LEA RDI,[0x1cbcd0]
LEA RSI,[0x22f438]
LEA RDX,[0x22e8c8]
CALL 0x0011b790
LEA RDI,[0x22f508]
CALL 0x0011b5a0
JMP 0x001cbb92
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_log_main() */
int1 * common_log_main(void)
{
int iVar1;
if (common_log_main()::log == '\0') {
iVar1 = __cxa_guard_acquire(&common_log_main()::log);
if (iVar1 != 0) {
/* try { // try from 001cbbab to 001cbbbb has its CatchHandler @ 001cbbe4 */
common_log::common_log((common_log *)common_log_main()::log,0x100);
__cxa_atexit(common_log::~common_log,common_log_main()::log,&__dso_handle);
__cxa_guard_release(&common_log_main()::log);
}
}
return common_log_main()::log;
}
| |
34,240 | 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>>>>>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/./json.hpp | std::string exception_message(const token_type expected, const std::string& context)
{
std::string error_msg = "syntax error ";
if (!context.empty())
{
error_msg += concat("while parsing ", context, ' ');
}
error_msg += "- ";
if (last_token == token_type::parse_error)
{
error_msg += concat(m_lexer.get_error_message(), "; last read: '",
m_lexer.get_token_string(), '\'');
}
else
{
error_msg += concat("unexpected ", lexer_t::token_type_name(last_token));
}
if (expected != token_type::uninitialized)
{
error_msg += concat("; expected ", lexer_t::token_type_name(expected));
}
return error_msg;
} | O3 | 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>>>>>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
leaq 0x8fbb3(%rip), %rsi # 0xc6f82
leaq 0x8fbb9(%rip), %rdx # 0xc6f8f
callq 0x3fe82
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x37462
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
addq $0xf, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1ca10
leaq 0x8fb81(%rip), %rsi # 0xc6f90
leaq 0x8(%rsp), %rdi
callq 0x1c810
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1c3a0
leaq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0x1cd90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1c3a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x37462
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
leaq 0x8fb36(%rip), %rsi # 0xc6f9f
movq %rbx, %rdi
callq 0x1c810
movl 0x20(%r14), %edi
cmpl $0xe, %edi
jne 0x37505
movq 0x98(%r14), %rax
addq $0x28, %r14
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x372ee
leaq 0x2f(%rsp), %r8
movb $0x27, (%r8)
leaq 0x8faf7(%rip), %rdx # 0xc6fa2
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rcx
callq 0x32a20
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1c3a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x374ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3757f
movq 0x48(%rsp), %rsi
jmp 0x37577
callq 0x32ae2
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rax, %rdi
callq 0x1c490
leaq 0xb(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1ca10
leaq 0x8fa72(%rip), %rsi # 0xc6fb1
leaq 0x8(%rsp), %rdi
callq 0x1c810
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1c810
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1c3a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3757f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
testl %ebp, %ebp
je 0x375ff
movl %ebp, %edi
callq 0x32ae2
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rax, %rdi
callq 0x1c490
leaq 0xb(%rax), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1ca10
leaq 0x8f9fe(%rip), %rsi # 0xc6fbd
leaq 0x8(%rsp), %rdi
callq 0x1c810
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1c810
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x1c3a0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x375ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37658
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37636
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x37636
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37681
movq 0x48(%rsp), %rsi
jmp 0x37679
jmp 0x37651
jmp 0x37658
jmp 0x37667
movq %rax, %r14
jmp 0x37681
jmp 0x37658
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x37674
jmp 0x37681
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x37681
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1c110
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x37695
movq (%r12), %rsi
incq %rsi
callq 0x1c110
movq %r14, %rdi
callq 0x1c7d0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIPKcEEE17exception_messageENS1_10lexer_baseISF_E10token_typeERKSB_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rcx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
lea rsi, aSyntaxError; "syntax error "
lea rdx, aSyntaxError+0Dh; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rsi, [r15+8]
test rsi, rsi
jz short loc_37462
lea r13, [rsp+88h+var_70]
mov [r13-10h], r13
mov qword ptr [r13-8], 0
mov byte ptr [r13+0], 0
add rsi, 0Fh
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aWhileParsing; "while parsing "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
lea rdi, [rsp+88h+var_80]
mov esi, 20h ; ' '
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r13
jz short loc_37462
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_37462:
lea rsi, asc_C6F9F; "- "
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov edi, [r14+20h]
cmp edi, 0Eh
jnz loc_37505
mov rax, [r14+98h]
add r14, 28h ; '('
mov [rsp+88h+var_58], rax
lea rdi, [rsp+88h+var_50]
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIPKcEEE16get_token_stringEv; 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<char const*>>::get_token_string(void)
lea r8, [rsp+88h+var_59]
mov byte ptr [r8], 27h ; '''
lea rdx, aLastRead; "; last read: '"
lea rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_58]
lea rcx, [rsp+88h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJPKcRA15_S9_S8_cEEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const*,char const(&)[15],std::string,char>(char const*,char const(&)[15],std::string,char &&)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_374EC
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_374EC:
lea rax, [rsp+88h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jz loc_3757F
mov rsi, [rsp+88h+var_40]
jmp short loc_37577
loc_37505:
call _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type)
mov r14, rax
lea r15, [rsp+88h+var_70]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rax
call _strlen
lea rsi, [rax+0Bh]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aUnexpected; "unexpected "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r15
jz short loc_3757F
mov rsi, [rsp+88h+var_70]
loc_37577:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3757F:
test ebp, ebp
jz short loc_375FF
mov edi, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE; nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type)
mov r14, rax
lea r15, [rsp+88h+var_70]
mov [r15-10h], r15
mov qword ptr [r15-8], 0
mov byte ptr [r15], 0
mov rdi, rax
call _strlen
lea rsi, [rax+0Bh]
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
lea rsi, aExpected_0; "; expected "
lea rdi, [rsp+88h+var_80]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rdi, [rsp+88h+var_80]
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [rsp+88h+var_80]
mov rdx, [rsp+88h+var_78]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm; std::string::append(char const*,ulong)
mov rdi, [rsp+88h+var_80]; void *
cmp rdi, r15
jz short loc_375FF
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_375FF:
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_37658
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_37636
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_37636
mov r14, rax
loc_37636:
lea rax, [rsp+arg_40]
mov rdi, [rax-10h]
cmp rdi, rax
jz short loc_37681
mov rsi, [rsp+arg_40]
jmp short loc_37679
jmp short loc_37651
jmp short loc_37658
jmp short loc_37667
loc_37651:
mov r14, rax
jmp short loc_37681
jmp short $+2
loc_37658:
mov r14, rax
mov rdi, [rsp+arg_0]
cmp rdi, r15
jnz short loc_37674
jmp short loc_37681
loc_37667:
mov r14, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_37681
loc_37674:
mov rsi, [rsp+arg_10]
loc_37679:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_37681:
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_37695
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_37695:
mov rdi, r14
call __Unwind_Resume
| _QWORD * 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<char const*>>::exception_message(
_QWORD *a1,
long long a2,
unsigned int a3,
_QWORD *a4)
{
long long v8; // rsi
unsigned int v9; // edi
void *v10; // rdi
long long v11; // rsi
const char *v12; // r14
long long v13; // rax
const char *v14; // r14
long long v15; // rax
void *v17; // [rsp+8h] [rbp-80h] BYREF
long long v18; // [rsp+10h] [rbp-78h]
_QWORD v19[2]; // [rsp+18h] [rbp-70h] BYREF
char v20; // [rsp+2Fh] [rbp-59h] BYREF
long long v21; // [rsp+30h] [rbp-58h] BYREF
_QWORD v22[2]; // [rsp+38h] [rbp-50h] BYREF
long long v23; // [rsp+48h] [rbp-40h] BYREF
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "syntax error ", "");
v8 = a4[1];
if ( v8 )
{
v17 = v19;
v18 = 0LL;
LOBYTE(v19[0]) = 0;
std::string::reserve(&v17, v8 + 15);
std::string::append(&v17, "while parsing ");
std::string::append(&v17, *a4, a4[1]);
std::string::push_back(&v17, 32LL);
std::string::append(a1, v17, v18);
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
}
std::string::append(a1, "- ");
v9 = *(_DWORD *)(a2 + 32);
if ( v9 == 14 )
{
v21 = *(_QWORD *)(a2 + 152);
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<char const*>>::get_token_string(
(long long)v22,
a2 + 40);
v20 = 39;
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const*,char const(&)[15],std::string,char>(
(long long)&v17,
&v21,
(long long)"; last read: '",
v22,
&v20);
std::string::append(a1, v17, v18);
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
v10 = (void *)v22[0];
if ( (long long *)v22[0] != &v23 )
{
v11 = v23;
LABEL_11:
operator delete(v10, v11 + 1);
}
}
else
{
v12 = nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(v9);
v17 = v19;
v18 = 0LL;
LOBYTE(v19[0]) = 0;
v13 = strlen(v12);
std::string::reserve(&v17, v13 + 11);
std::string::append(&v17, "unexpected ");
std::string::append(&v17, v12);
std::string::append(a1, v17, v18);
v10 = v17;
if ( v17 != v19 )
{
v11 = v19[0];
goto LABEL_11;
}
}
if ( a3 )
{
v14 = nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(a3);
v17 = v19;
v18 = 0LL;
LOBYTE(v19[0]) = 0;
v15 = strlen(v14);
std::string::reserve(&v17, v15 + 11);
std::string::append(&v17, "; expected ");
std::string::append(&v17, v14);
std::string::append(a1, v17, v18);
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
}
return a1;
}
| exception_message:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RCX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
LEA RSI,[0x1c6f82]
LEA RDX,[0x1c6f8f]
CALL 0x0013fe82
MOV RSI,qword ptr [R15 + 0x8]
TEST RSI,RSI
JZ 0x00137462
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
MOV qword ptr [R13 + -0x8],0x0
MOV byte ptr [R13],0x0
ADD RSI,0xf
LAB_001373fe:
LEA RDI,[RSP + 0x8]
CALL 0x0011ca10
LEA RSI,[0x1c6f90]
LEA RDI,[RSP + 0x8]
CALL 0x0011c810
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x0011c3a0
LEA RDI,[RSP + 0x8]
MOV ESI,0x20
CALL 0x0011cd90
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00137443:
MOV RDI,RBX
CALL 0x0011c3a0
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x00137462
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c110
LAB_00137462:
LEA RSI,[0x1c6f9f]
MOV RDI,RBX
CALL 0x0011c810
MOV EDI,dword ptr [R14 + 0x20]
CMP EDI,0xe
JNZ 0x00137505
MOV RAX,qword ptr [R14 + 0x98]
ADD R14,0x28
MOV qword ptr [RSP + 0x30],RAX
LAB_0013748e:
LEA RDI,[RSP + 0x38]
MOV RSI,R14
CALL 0x001372ee
LEA R8,[RSP + 0x2f]
MOV byte ptr [R8],0x27
LAB_001374a4:
LEA RDX,[0x1c6fa2]
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x30]
LEA RCX,[RSP + 0x38]
CALL 0x00132a20
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001374c9:
MOV RDI,RBX
CALL 0x0011c3a0
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001374ec
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c110
LAB_001374ec:
LEA RAX,[RSP + 0x48]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0013757f
MOV RSI,qword ptr [RSP + 0x48]
JMP 0x00137577
LAB_00137505:
CALL 0x00132ae2
MOV R14,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
MOV RDI,RAX
CALL 0x0011c490
LEA RSI,[RAX + 0xb]
LAB_0013752e:
LEA RDI,[RSP + 0x8]
CALL 0x0011ca10
LEA RSI,[0x1c6fb1]
LEA RDI,[RSP + 0x8]
CALL 0x0011c810
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0011c810
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00137560:
MOV RDI,RBX
CALL 0x0011c3a0
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x0013757f
MOV RSI,qword ptr [RSP + 0x18]
LAB_00137577:
INC RSI
CALL 0x0011c110
LAB_0013757f:
TEST EBP,EBP
JZ 0x001375ff
MOV EDI,EBP
CALL 0x00132ae2
MOV R14,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV qword ptr [R15 + -0x8],0x0
MOV byte ptr [R15],0x0
MOV RDI,RAX
CALL 0x0011c490
LEA RSI,[RAX + 0xb]
LAB_001375ae:
LEA RDI,[RSP + 0x8]
CALL 0x0011ca10
LEA RSI,[0x1c6fbd]
LEA RDI,[RSP + 0x8]
CALL 0x0011c810
LEA RDI,[RSP + 0x8]
MOV RSI,R14
CALL 0x0011c810
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001375e0:
MOV RDI,RBX
CALL 0x0011c3a0
LAB_001375e8:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001375ff
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011c110
LAB_001375ff:
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
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<char const*>
>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::token_type, std::__cxx11::string const&) */
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::__cxx11::string,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<char_const*>>
::exception_message(long *param_1,long param_2,int param_3,ulong *param_4)
{
char *pcVar1;
long *local_80;
int8 local_78;
int1 local_70;
int7 uStack_6f;
int1 local_59;
int8 local_58;
long *local_50 [2];
long local_40 [2];
*param_1 = (long)(param_1 + 2);
std::__cxx11::string::_M_construct<char_const*>(param_1,"syntax error ","");
if (param_4[1] != 0) {
local_78 = 0;
local_70 = 0;
/* try { // try from 001373fe to 00137438 has its CatchHandler @ 00137667 */
local_80 = (long *)&local_70;
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80,*param_4);
std::__cxx11::string::push_back((char)&local_80);
/* try { // try from 00137443 to 0013744a has its CatchHandler @ 0013764f */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
}
/* try { // try from 00137462 to 00137470 has its CatchHandler @ 00137651 */
std::__cxx11::string::append((char *)param_1);
if (*(int *)(param_2 + 0x20) == 0xe) {
local_58 = *(int8 *)(param_2 + 0x98);
/* try { // try from 0013748e to 0013749a has its CatchHandler @ 0013764b */
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<char_const*>>
::get_token_string();
local_59 = 0x27;
/* try { // try from 001374a4 to 001374be has its CatchHandler @ 00137633 */
concat<std::__cxx11::string,char_const*,char_const(&)[15],std::__cxx11::string,char>
((char **)&local_80,(char *)&local_58,(string *)"; last read: \'",(char *)local_50);
/* try { // try from 001374c9 to 001374d0 has its CatchHandler @ 00137613 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
if (local_50[0] == local_40) goto LAB_0013757f;
}
else {
pcVar1 = (char *)lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name();
local_78 = 0;
local_70 = 0;
local_80 = (long *)&local_70;
strlen(pcVar1);
/* try { // try from 0013752e to 00137555 has its CatchHandler @ 00137656 */
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80);
/* try { // try from 00137560 to 00137567 has its CatchHandler @ 00137611 */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 == (long *)&local_70) goto LAB_0013757f;
local_40[0] = CONCAT71(uStack_6f,local_70);
local_50[0] = local_80;
}
operator_delete(local_50[0],local_40[0] + 1);
LAB_0013757f:
if (param_3 != 0) {
pcVar1 = (char *)lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::token_type_name(param_3);
local_78 = 0;
local_70 = 0;
local_80 = (long *)&local_70;
strlen(pcVar1);
/* try { // try from 001375ae to 001375d5 has its CatchHandler @ 00137658 */
std::__cxx11::string::reserve((ulong)&local_80);
std::__cxx11::string::append((char *)&local_80);
std::__cxx11::string::append((char *)&local_80);
/* try { // try from 001375e0 to 001375e7 has its CatchHandler @ 0013764d */
std::__cxx11::string::append((char *)param_1,(ulong)local_80);
if (local_80 != (long *)&local_70) {
operator_delete(local_80,CONCAT71(uStack_6f,local_70) + 1);
}
}
return param_1;
}
| |
34,241 | string_buffer_concat_value | bluesky950520[P]quickjs/quickjs.c | static int string_buffer_concat_value(StringBuffer *s, JSValue v)
{
JSString *p;
JSValue v1;
int res;
if (s->error_status) {
/* prevent exception overload */
return -1;
}
if (unlikely(JS_VALUE_GET_TAG(v) != JS_TAG_STRING)) {
v1 = JS_ToString(s->ctx, v);
if (JS_IsException(v1))
return string_buffer_set_error(s);
p = JS_VALUE_GET_STRING(v1);
res = string_buffer_concat(s, p, 0, p->len);
JS_FreeValue(s->ctx, v1);
return res;
}
p = JS_VALUE_GET_STRING(v);
return string_buffer_concat(s, p, 0, p->len);
} | O0 | c | string_buffer_concat_value:
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x859bb
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x85ab8
movq 0x48(%rsp), %rax
cmpl $-0x7, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x85a88
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x29d40
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x85a37
movq 0x38(%rsp), %rdi
callq 0x6fe50
movl %eax, 0x54(%rsp)
jmp 0x85ab8
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x6fc30
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x23c90
movl 0x1c(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x85ab8
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x30(%rsp), %rax
movq 0x4(%rax), %rax
andq $0x7fffffff, %rax # imm = 0x7FFFFFFF
movl %eax, %ecx
xorl %edx, %edx
callq 0x6fc30
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| string_buffer_concat_value:
sub rsp, 58h
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_10], rdx
mov [rsp+58h+var_20], rdi
mov rax, [rsp+58h+var_20]
cmp dword ptr [rax+1Ch], 0
jz short loc_859BB
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp loc_85AB8
loc_859BB:
mov rax, [rsp+58h+var_10]
cmp eax, 0FFFFFFF9h
setnz al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_85A88
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
mov rsi, [rsp+58h+var_18]
mov rdx, [rsp+58h+var_10]
call JS_ToString
mov [rsp+58h+var_50], rax
mov [rsp+58h+var_48], rdx
mov rax, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
mov rax, [rsp+58h+var_48]
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_85A37
mov rdi, [rsp+58h+var_20]
call string_buffer_set_error
mov [rsp+58h+var_4], eax
jmp loc_85AB8
loc_85A37:
mov rax, [rsp+58h+var_38]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call string_buffer_concat
mov [rsp+58h+var_3C], eax
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
mov rsi, [rsp+58h+var_38]
mov rdx, [rsp+58h+var_30]
call JS_FreeValue
mov eax, [rsp+58h+var_3C]
mov [rsp+58h+var_4], eax
jmp short loc_85AB8
loc_85A88:
mov rax, [rsp+58h+var_18]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_28]
mov rax, [rax+4]
and rax, 7FFFFFFFh
mov ecx, eax
xor edx, edx
call string_buffer_concat
mov [rsp+58h+var_4], eax
loc_85AB8:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long string_buffer_concat_value(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
long long v6; // rdx
long long v8; // [rsp+8h] [rbp-50h]
unsigned int v9; // [rsp+1Ch] [rbp-3Ch]
long long v10; // [rsp+28h] [rbp-30h]
if ( *(_DWORD *)(a1 + 28) )
{
return (unsigned int)-1;
}
else if ( (_DWORD)a3 == -7 )
{
return (unsigned int)string_buffer_concat(a1, a2, 0, *(_DWORD *)(a2 + 4) & 0x7FFFFFFF);
}
else
{
v8 = JS_ToString(*(_QWORD *)a1, a2, a3, a4, a5, a6);
v10 = v6;
if ( JS_IsException_1(v8, v6) )
{
return (unsigned int)string_buffer_set_error(a1);
}
else
{
v9 = string_buffer_concat(a1, v8, 0, *(_DWORD *)(v8 + 4) & 0x7FFFFFFF);
JS_FreeValue(*(_QWORD *)a1, v8, v10);
return v9;
}
}
}
| string_buffer_concat_value:
SUB RSP,0x58
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x1c],0x0
JZ 0x001859bb
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x00185ab8
LAB_001859bb:
MOV RAX,qword ptr [RSP + 0x48]
CMP EAX,-0x7
SETNZ AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00185a88
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x00129d40
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00185a37
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0016fe50
MOV dword ptr [RSP + 0x54],EAX
JMP 0x00185ab8
LAB_00185a37:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x0016fc30
MOV dword ptr [RSP + 0x1c],EAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00123c90
MOV EAX,dword ptr [RSP + 0x1c]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x00185ab8
LAB_00185a88:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x4]
AND RAX,0x7fffffff
MOV ECX,EAX
XOR EDX,EDX
CALL 0x0016fc30
MOV dword ptr [RSP + 0x54],EAX
LAB_00185ab8:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 string_buffer_concat_value(int8 *param_1,long param_2,int8 param_3)
{
int iVar1;
long lVar2;
int1 auVar3 [16];
int4 local_4;
if (*(int *)((long)param_1 + 0x1c) == 0) {
if ((int)param_3 == -7) {
local_4 = string_buffer_concat
(param_1,param_2,0,(uint)*(int8 *)(param_2 + 4) & 0x7fffffff);
}
else {
auVar3 = JS_ToString(*param_1,param_2,param_3);
lVar2 = auVar3._0_8_;
iVar1 = JS_IsException(lVar2,auVar3._8_8_);
if (iVar1 == 0) {
local_4 = string_buffer_concat
(param_1,lVar2,0,(uint)*(int8 *)(lVar2 + 4) & 0x7fffffff);
JS_FreeValue(*param_1,lVar2,auVar3._8_8_);
}
else {
local_4 = string_buffer_set_error(param_1);
}
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
| |
34,242 | string_buffer_concat_value | bluesky950520[P]quickjs/quickjs.c | static int string_buffer_concat_value(StringBuffer *s, JSValue v)
{
JSString *p;
JSValue v1;
int res;
if (s->error_status) {
/* prevent exception overload */
return -1;
}
if (unlikely(JS_VALUE_GET_TAG(v) != JS_TAG_STRING)) {
v1 = JS_ToString(s->ctx, v);
if (JS_IsException(v1))
return string_buffer_set_error(s);
p = JS_VALUE_GET_STRING(v1);
res = string_buffer_concat(s, p, 0, p->len);
JS_FreeValue(s->ctx, v1);
return res;
}
p = JS_VALUE_GET_STRING(v);
return string_buffer_concat(s, p, 0, p->len);
} | O2 | c | string_buffer_concat_value:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x1c(%rdi)
je 0x41967
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
cmpl $-0x7, %edx
jne 0x4198b
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl 0x4(%rsi), %ecx
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x39dad
movq (%rbx), %rdi
callq 0x1b03c
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x419a6
movq %rbx, %rdi
callq 0x39f6d
jmp 0x41959
movq %rax, %r14
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl 0x4(%rax), %ecx
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x39dad
movl %eax, %ebp
movq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1801e
movl %ebp, %eax
jmp 0x4195c
| string_buffer_concat_value:
push rbp
push r15
push r14
push rbx
push rax
cmp dword ptr [rdi+1Ch], 0
jz short loc_41967
loc_41959:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_4195C:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_41967:
mov rbx, rdi
cmp edx, 0FFFFFFF9h
jnz short loc_4198B
mov ecx, 7FFFFFFFh
and ecx, [rsi+4]
mov rdi, rbx
xor edx, edx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp string_buffer_concat
loc_4198B:
mov rdi, [rbx]
call JS_ToString
mov r15, rdx
cmp r15d, 6
jnz short loc_419A6
mov rdi, rbx
call string_buffer_set_error
jmp short loc_41959
loc_419A6:
mov r14, rax
mov ecx, 7FFFFFFFh
and ecx, [rax+4]
mov rdi, rbx
mov rsi, rax
xor edx, edx
call string_buffer_concat
mov ebp, eax
mov rdi, [rbx]
mov rsi, r14
mov rdx, r15
call JS_FreeValue
mov eax, ebp
jmp short loc_4195C
| long long string_buffer_concat_value(long long a1, long long a2, long long a3)
{
long long v4; // rax
long long v5; // rdx
long long v6; // r15
long long v7; // r14
unsigned int v8; // ebp
if ( !*(_DWORD *)(a1 + 28) )
{
if ( (_DWORD)a3 == -7 )
return string_buffer_concat(a1, a2, 0, *(_DWORD *)(a2 + 4) & 0x7FFFFFFF);
v4 = JS_ToString(*(_QWORD *)a1, a2, a3);
v6 = v5;
if ( (_DWORD)v5 != 6 )
{
v7 = v4;
v8 = string_buffer_concat(a1, v4, 0, *(_DWORD *)(v4 + 4) & 0x7FFFFFFF);
JS_FreeValue(*(_QWORD *)a1, v7, v6);
return v8;
}
string_buffer_set_error(a1);
}
return -1LL;
}
| string_buffer_concat_value:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP dword ptr [RDI + 0x1c],0x0
JZ 0x00141967
LAB_00141959:
PUSH -0x1
POP RAX
LAB_0014195c:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00141967:
MOV RBX,RDI
CMP EDX,-0x7
JNZ 0x0014198b
MOV ECX,0x7fffffff
AND ECX,dword ptr [RSI + 0x4]
MOV RDI,RBX
XOR EDX,EDX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00139dad
LAB_0014198b:
MOV RDI,qword ptr [RBX]
CALL 0x0011b03c
MOV R15,RDX
CMP R15D,0x6
JNZ 0x001419a6
MOV RDI,RBX
CALL 0x00139f6d
JMP 0x00141959
LAB_001419a6:
MOV R14,RAX
MOV ECX,0x7fffffff
AND ECX,dword ptr [RAX + 0x4]
MOV RDI,RBX
MOV RSI,RAX
XOR EDX,EDX
CALL 0x00139dad
MOV EBP,EAX
MOV RDI,qword ptr [RBX]
MOV RSI,R14
MOV RDX,R15
CALL 0x0011801e
MOV EAX,EBP
JMP 0x0014195c
|
ulong string_buffer_concat_value(int8 *param_1,long param_2,int param_3)
{
uint uVar1;
ulong uVar2;
long lVar3;
int1 auVar4 [16];
if (*(int *)((long)param_1 + 0x1c) == 0) {
if (param_3 == -7) {
uVar2 = string_buffer_concat(param_1,param_2,0,*(uint *)(param_2 + 4) & 0x7fffffff);
return uVar2;
}
auVar4 = JS_ToString(*param_1);
lVar3 = auVar4._0_8_;
if (auVar4._8_4_ != 6) {
uVar1 = string_buffer_concat(param_1,lVar3,0,*(uint *)(lVar3 + 4) & 0x7fffffff);
JS_FreeValue(*param_1,lVar3,auVar4._8_8_);
return (ulong)uVar1;
}
string_buffer_set_error(param_1);
}
return 0xffffffffffffffff;
}
| |
34,243 | string_buffer_concat_value | bluesky950520[P]quickjs/quickjs.c | static int string_buffer_concat_value(StringBuffer *s, JSValue v)
{
JSString *p;
JSValue v1;
int res;
if (s->error_status) {
/* prevent exception overload */
return -1;
}
if (unlikely(JS_VALUE_GET_TAG(v) != JS_TAG_STRING)) {
v1 = JS_ToString(s->ctx, v);
if (JS_IsException(v1))
return string_buffer_set_error(s);
p = JS_VALUE_GET_STRING(v1);
res = string_buffer_concat(s, p, 0, p->len);
JS_FreeValue(s->ctx, v1);
return res;
}
p = JS_VALUE_GET_STRING(v);
return string_buffer_concat(s, p, 0, p->len);
} | O3 | c | string_buffer_concat_value:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0x0, 0x1c(%rdi)
je 0x4e324
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdi, %r14
cmpl $-0x7, %edx
jne 0x4e349
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl 0x4(%rsi), %ecx
movq %r14, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x43bad
movq (%r14), %rdi
xorl %ecx, %ecx
callq 0x28154
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x4e37a
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq 0x1d481
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movl $0xffffffff, 0x1c(%r14) # imm = 0xFFFFFFFF
jmp 0x4e316
movq %rax, %r15
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
andl 0x4(%rax), %ecx
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x43bad
movl %eax, %ebx
cmpl $-0x9, %r12d
jb 0x4e316
movq (%r14), %rax
movq 0x18(%rax), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x4e316
movq %r15, %rsi
movq %r12, %rdx
callq 0x219cc
jmp 0x4e316
| string_buffer_concat_value:
push r15
push r14
push r12
push rbx
push rax
mov ebx, 0FFFFFFFFh
cmp dword ptr [rdi+1Ch], 0
jz short loc_4E324
loc_4E316:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_4E324:
mov r14, rdi
cmp edx, 0FFFFFFF9h
jnz short loc_4E349
mov ecx, 7FFFFFFFh
and ecx, [rsi+4]
mov rdi, r14
xor edx, edx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp string_buffer_concat
loc_4E349:
mov rdi, [r14]
xor ecx, ecx
call JS_ToStringInternal
mov r12, rdx
cmp r12d, 6
jnz short loc_4E37A
mov rdi, [r14]
mov rsi, [r14+8]
call js_free
xorps xmm0, xmm0
movups xmmword ptr [r14+8], xmm0
mov dword ptr [r14+1Ch], 0FFFFFFFFh
jmp short loc_4E316
loc_4E37A:
mov r15, rax
mov ecx, 7FFFFFFFh
and ecx, [rax+4]
mov rdi, r14
mov rsi, rax
xor edx, edx
call string_buffer_concat
mov ebx, eax
cmp r12d, 0FFFFFFF7h
jb loc_4E316
mov rax, [r14]
mov rdi, [rax+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg loc_4E316
mov rsi, r15
mov rdx, r12
call js_free_value_rt
jmp loc_4E316
| long long string_buffer_concat_value(
long long a1,
_DWORD *a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
unsigned int v14; // ebx
unsigned long long v16; // rax
unsigned int v17; // edx
unsigned int v18; // r12d
_QWORD *v19; // r15
long long v20; // rdi
int v21; // eax
v14 = -1;
if ( *(_DWORD *)(a1 + 28) )
return v14;
if ( (_DWORD)a3 != -7 )
{
v16 = JS_ToStringInternal(*(_QWORD *)a1, a2, a3, 0LL, a13, a14, a4, a5, a6, a7, a8, a9, a10, a11);
v18 = v17;
if ( v17 == 6 )
{
js_free(*(_QWORD *)a1, *(_QWORD *)(a1 + 8));
*(_OWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 28) = -1;
}
else
{
v19 = (_QWORD *)v16;
v14 = string_buffer_concat(a1, v16, 0, *(_DWORD *)(v16 + 4) & 0x7FFFFFFF);
if ( v18 >= 0xFFFFFFF7 )
{
v20 = *(_QWORD *)(*(_QWORD *)a1 + 24LL);
v21 = (*(_DWORD *)v19)--;
if ( v21 <= 1 )
js_free_value_rt(v20, v19, v18);
}
}
return v14;
}
return string_buffer_concat(a1, (long long)a2, 0, a2[1] & 0x7FFFFFFF);
}
| string_buffer_concat_value:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,0xffffffff
CMP dword ptr [RDI + 0x1c],0x0
JZ 0x0014e324
LAB_0014e316:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0014e324:
MOV R14,RDI
CMP EDX,-0x7
JNZ 0x0014e349
MOV ECX,0x7fffffff
AND ECX,dword ptr [RSI + 0x4]
MOV RDI,R14
XOR EDX,EDX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00143bad
LAB_0014e349:
MOV RDI,qword ptr [R14]
XOR ECX,ECX
CALL 0x00128154
MOV R12,RDX
CMP R12D,0x6
JNZ 0x0014e37a
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x8]
CALL 0x0011d481
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x8],XMM0
MOV dword ptr [R14 + 0x1c],0xffffffff
JMP 0x0014e316
LAB_0014e37a:
MOV R15,RAX
MOV ECX,0x7fffffff
AND ECX,dword ptr [RAX + 0x4]
MOV RDI,R14
MOV RSI,RAX
XOR EDX,EDX
CALL 0x00143bad
MOV EBX,EAX
CMP R12D,-0x9
JC 0x0014e316
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x0014e316
MOV RSI,R15
MOV RDX,R12
CALL 0x001219cc
JMP 0x0014e316
|
ulong string_buffer_concat_value(long *param_1,long param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
uint uVar3;
int *piVar4;
ulong uVar5;
int1 auVar6 [16];
uVar5 = 0xffffffff;
if (*(int *)((long)param_1 + 0x1c) == 0) {
if ((int)param_3 == -7) {
uVar5 = string_buffer_concat(param_1,param_2,0,*(uint *)(param_2 + 4) & 0x7fffffff);
return uVar5;
}
auVar6 = JS_ToStringInternal(*param_1,param_2,param_3,0);
piVar4 = auVar6._0_8_;
if (auVar6._8_4_ == 6) {
js_free(*param_1,param_1[1]);
param_1[1] = 0;
param_1[2] = 0;
*(int4 *)((long)param_1 + 0x1c) = 0xffffffff;
}
else {
uVar3 = string_buffer_concat(param_1,piVar4,0,piVar4[1] & 0x7fffffff);
uVar5 = (ulong)uVar3;
if (0xfffffff6 < auVar6._8_4_) {
uVar2 = *(int8 *)(*param_1 + 0x18);
iVar1 = *piVar4;
*piVar4 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,piVar4,auVar6._8_8_);
}
}
}
}
return uVar5;
}
| |
34,244 | js_math_min_max | bluesky950520[P]quickjs/quickjs.c | static JSValue js_math_min_max(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
BOOL is_max = magic;
double r, a;
int i;
uint32_t tag;
if (unlikely(argc == 0)) {
return js_float64(is_max ? NEG_INF : INF);
}
tag = JS_VALUE_GET_TAG(argv[0]);
if (tag == JS_TAG_INT) {
int a1, r1 = JS_VALUE_GET_INT(argv[0]);
for(i = 1; i < argc; i++) {
tag = JS_VALUE_GET_TAG(argv[i]);
if (tag != JS_TAG_INT) {
r = r1;
goto generic_case;
}
a1 = JS_VALUE_GET_INT(argv[i]);
if (is_max)
r1 = max_int(r1, a1);
else
r1 = min_int(r1, a1);
}
return js_int32(r1);
} else {
if (JS_ToFloat64(ctx, &r, argv[0]))
return JS_EXCEPTION;
i = 1;
generic_case:
while (i < argc) {
if (JS_ToFloat64(ctx, &a, argv[i]))
return JS_EXCEPTION;
if (!isnan(r)) {
if (isnan(a)) {
r = a;
} else {
if (is_max)
r = js_fmax(r, a);
else
r = js_fmin(r, a);
}
}
i++;
}
return js_number(r);
}
} | O1 | c | js_math_min_max:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
testl %ecx, %ecx
je 0x7dd71
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %r14
movq 0x8(%r8), %rcx
testl %ecx, %ecx
je 0x7db6e
movq (%r15), %rdx
movq %rsp, %rsi
movq %r14, %rdi
callq 0x27681
testl %eax, %eax
jne 0x7dd54
movl $0x1, %eax
jmp 0x7dbf0
movl (%r15), %ecx
movl $0x1, %eax
cmpl $0x2, %ebp
setge %dl
jl 0x7dbe6
movl $0x1, %eax
cmpl $0x0, 0x18(%r15)
jne 0x7dbd1
movl %ebp, %edx
leaq 0x10(%r15), %rdi
movl $0x2, %esi
subq %rdx, %rsi
movl $0x1, %eax
movl (%rdi), %r8d
testl %ebx, %ebx
je 0x7dbad
cmpl %r8d, %ecx
cmovlel %r8d, %ecx
jmp 0x7dbb4
cmpl %r8d, %ecx
cmovgel %r8d, %ecx
leaq (%rsi,%rax), %r8
incq %rax
cmpq $0x1, %r8
je 0x7dbde
cmpl $0x0, 0x18(%rdi)
leaq 0x10(%rdi), %rdi
je 0x7db9d
cmpq %rdx, %rax
setb %dl
cvtsi2sd %ecx, %xmm0
movsd %xmm0, (%rsp)
xorl %esi, %esi
jmp 0x7dbe8
cmpq %rdx, %rax
setb %dl
movl %ebp, %eax
movl %ecx, %esi
testb %dl, %dl
je 0x7dd10
movsd (%rsp), %xmm3
cmpl %ebp, %eax
jge 0x7dcd2
movl %eax, %eax
movl %ebp, %r12d
subq %rax, %r12
shlq $0x4, %rax
leaq (%rax,%r15), %r13
addq $0x8, %r13
leaq 0x8(%rsp), %r15
movapd %xmm3, 0x10(%rsp)
movq -0x8(%r13), %rdx
movq (%r13), %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0x27681
testl %eax, %eax
jne 0x7dd4a
movapd 0x10(%rsp), %xmm3
ucomisd %xmm3, %xmm3
jp 0x7dcbd
movsd 0x8(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x7dccc
movapd %xmm0, %xmm1
xorpd %xmm4, %xmm4
cmpeqpd %xmm4, %xmm1
movapd %xmm3, %xmm2
cmpeqpd %xmm4, %xmm2
andpd %xmm1, %xmm2
movd %xmm2, %eax
testl %ebx, %ebx
je 0x7dc7b
testb $0x1, %al
je 0x7dc85
andpd %xmm0, %xmm3
jmp 0x7dcbd
testb $0x1, %al
je 0x7dc9c
orpd %xmm0, %xmm3
jmp 0x7dcbd
movapd %xmm3, %xmm1
cmpunordsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
maxsd %xmm3, %xmm0
jmp 0x7dcb1
movapd %xmm3, %xmm1
cmpunordsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm0, %xmm2
minsd %xmm3, %xmm0
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm3
addq $0x10, %r13
decq %r12
jne 0x7dc16
jmp 0x7dcd2
movapd %xmm0, %xmm3
jmp 0x7dcbd
movsd %xmm3, (%rsp)
movq %xmm3, %rsi
movq %rsi, %rcx
shrq $0x34, %rcx
andl $0x7ff, %ecx # imm = 0x7FF
addq $-0x3ff, %rcx # imm = 0xFC01
cmpq $0x1f, %rcx
jb 0x7dd16
testq %rsi, %rsi
sete %cl
movabsq $-0x3e20000000000000, %rax # imm = 0xC1E0000000000000
cmpq %rax, %rsi
sete %al
orb %cl, %al
jmp 0x7dd26
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x7dd5d
movq %rsi, %rax
shlq $0xc, %rax
shlq %cl, %rax
testq %rax, %rax
sete %al
cvttsd2si %xmm3, %ecx
xorl %edi, %edi
testb %al, %al
cmovneq %rcx, %rsi
movl $0x7, %edx
cmovneq %rdi, %rdx
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rsi, %rcx
jmp 0x7dd5d
movaps 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movl $0x6, %edx
xorl %esi, %esi
xorl %ecx, %ecx
movl %esi, %eax
orq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebx, %ebx
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
movabsq $-0x10000000000000, %rsi # imm = 0xFFF0000000000000
cmoveq %rax, %rsi
movl $0x7, %edx
movq %rsi, %rcx
jmp 0x7dd5d
| js_math_min_max:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebx, r9d
test ecx, ecx
jz loc_7DD71
mov r15, r8
mov ebp, ecx
mov r14, rdi
mov rcx, [r8+8]
test ecx, ecx
jz short loc_7DB6E
mov rdx, [r15]
mov rsi, rsp
mov rdi, r14
call JS_ToFloat64
test eax, eax
jnz loc_7DD54
mov eax, 1
jmp loc_7DBF0
loc_7DB6E:
mov ecx, [r15]
mov eax, 1
cmp ebp, 2
setnl dl
jl short loc_7DBE6
mov eax, 1
cmp dword ptr [r15+18h], 0
jnz short loc_7DBD1
mov edx, ebp
lea rdi, [r15+10h]
mov esi, 2
sub rsi, rdx
mov eax, 1
loc_7DB9D:
mov r8d, [rdi]
test ebx, ebx
jz short loc_7DBAD
cmp ecx, r8d
cmovle ecx, r8d
jmp short loc_7DBB4
loc_7DBAD:
cmp ecx, r8d
cmovge ecx, r8d
loc_7DBB4:
lea r8, [rsi+rax]
inc rax
cmp r8, 1
jz short loc_7DBDE
cmp dword ptr [rdi+18h], 0
lea rdi, [rdi+10h]
jz short loc_7DB9D
cmp rax, rdx
setb dl
loc_7DBD1:
cvtsi2sd xmm0, ecx
movsd [rsp+58h+var_58], xmm0
xor esi, esi
jmp short loc_7DBE8
loc_7DBDE:
cmp rax, rdx
setb dl
mov eax, ebp
loc_7DBE6:
mov esi, ecx
loc_7DBE8:
test dl, dl
jz loc_7DD10
loc_7DBF0:
movsd xmm3, [rsp+58h+var_58]
cmp eax, ebp
jge loc_7DCD2
mov eax, eax
mov r12d, ebp
sub r12, rax
shl rax, 4
lea r13, [rax+r15]
add r13, 8
lea r15, [rsp+58h+var_50]
loc_7DC16:
movapd [rsp+58h+var_48], xmm3
mov rdx, [r13-8]
mov rcx, [r13+0]
mov rdi, r14
mov rsi, r15
call JS_ToFloat64
test eax, eax
jnz loc_7DD4A
movapd xmm3, [rsp+58h+var_48]
ucomisd xmm3, xmm3
jp short loc_7DCBD
movsd xmm0, [rsp+58h+var_50]
ucomisd xmm0, xmm0
jp short loc_7DCCC
movapd xmm1, xmm0
xorpd xmm4, xmm4
cmpeqpd xmm1, xmm4
movapd xmm2, xmm3
cmpeqpd xmm2, xmm4
andpd xmm2, xmm1
movd eax, xmm2
test ebx, ebx
jz short loc_7DC7B
test al, 1
jz short loc_7DC85
andpd xmm3, xmm0
jmp short loc_7DCBD
loc_7DC7B:
test al, 1
jz short loc_7DC9C
orpd xmm3, xmm0
jmp short loc_7DCBD
loc_7DC85:
movapd xmm1, xmm3
cmpunordsd xmm1, xmm3
movapd xmm2, xmm1
andpd xmm2, xmm0
maxsd xmm0, xmm3
jmp short loc_7DCB1
loc_7DC9C:
movapd xmm1, xmm3
cmpunordsd xmm1, xmm3
movapd xmm2, xmm1
andpd xmm2, xmm0
minsd xmm0, xmm3
loc_7DCB1:
andnpd xmm1, xmm0
orpd xmm1, xmm2
movapd xmm3, xmm1
loc_7DCBD:
add r13, 10h
dec r12
jnz loc_7DC16
jmp short loc_7DCD2
loc_7DCCC:
movapd xmm3, xmm0
jmp short loc_7DCBD
loc_7DCD2:
movsd [rsp+58h+var_58], xmm3
movq rsi, xmm3
mov rcx, rsi
shr rcx, 34h
and ecx, 7FFh
add rcx, 0FFFFFFFFFFFFFC01h
cmp rcx, 1Fh
jb short loc_7DD16
test rsi, rsi
setz cl
mov rax, 0C1E0000000000000h
cmp rsi, rax
setz al
or al, cl
jmp short loc_7DD26
loc_7DD10:
xor ecx, ecx
xor edx, edx
jmp short loc_7DD5D
loc_7DD16:
mov rax, rsi
shl rax, 0Ch
shl rax, cl
test rax, rax
setz al
loc_7DD26:
cvttsd2si ecx, xmm3
xor edi, edi
test al, al
cmovnz rsi, rcx
mov edx, 7
cmovnz rdx, rdi
mov rcx, 0FFFFFFFF00000000h
and rcx, rsi
jmp short loc_7DD5D
loc_7DD4A:
movaps xmm0, [rsp+58h+var_48]
movsd [rsp+58h+var_58], xmm0
loc_7DD54:
mov edx, 6
xor esi, esi
xor ecx, ecx
loc_7DD5D:
mov eax, esi
or rax, rcx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7DD71:
test ebx, ebx
mov rax, 7FF0000000000000h
mov rsi, 0FFF0000000000000h
cmovz rsi, rax
mov edx, 7
mov rcx, rsi
jmp short loc_7DD5D
| unsigned long long js_math_min_max(long long a1, long long a2, long long a3, int a4, _DWORD **a5, int a6)
{
_DWORD *v10; // rcx
unsigned long long v11; // rax
int v12; // ecx
bool v13; // dl
int *v14; // rdi
int v15; // r8d
long long v16; // r8
bool v17; // zf
unsigned long long v18; // rsi
__m128d v19; // xmm3
unsigned long long v20; // r12
_QWORD *v21; // r13
__m128d v22; // xmm0
char v23; // al
__m128d v24; // xmm1
__m128d v25; // xmm2
bool v26; // al
unsigned long long v27; // rcx
double v29; // [rsp+0h] [rbp-58h] BYREF
double v30; // [rsp+8h] [rbp-50h] BYREF
__m128d v31; // [rsp+10h] [rbp-48h]
if ( !a4 )
{
v18 = 0xFFF0000000000000LL;
if ( !a6 )
v18 = 0x7FF0000000000000LL;
v27 = v18;
return v27 | (unsigned int)v18;
}
v10 = a5[1];
if ( !(_DWORD)v10 )
{
v12 = *(_DWORD *)a5;
LODWORD(v11) = 1;
v13 = a4 >= 2;
if ( a4 >= 2 )
{
LODWORD(v11) = 1;
if ( *((_DWORD *)a5 + 6) )
{
LABEL_17:
v29 = (double)v12;
LODWORD(v18) = 0;
goto LABEL_20;
}
v14 = (int *)(a5 + 2);
v11 = 1LL;
while ( 1 )
{
v15 = *v14;
if ( a6 )
{
if ( v12 <= v15 )
v12 = *v14;
}
else if ( v12 >= v15 )
{
v12 = *v14;
}
v16 = 2LL - (unsigned int)a4 + v11++;
if ( v16 == 1 )
break;
v17 = v14[6] == 0;
v14 += 4;
if ( !v17 )
{
v13 = v11 < (unsigned int)a4;
goto LABEL_17;
}
}
v13 = v11 < (unsigned int)a4;
LODWORD(v11) = a4;
}
LODWORD(v18) = v12;
LABEL_20:
if ( !v13 )
{
v27 = 0LL;
return v27 | (unsigned int)v18;
}
goto LABEL_21;
}
if ( (unsigned int)JS_ToFloat64(a1, &v29, *a5, (unsigned int)v10) )
goto LABEL_41;
LODWORD(v11) = 1;
LABEL_21:
v19 = (__m128d)*(unsigned long long *)&v29;
if ( (int)v11 >= a4 )
{
LABEL_33:
v29 = v19.m128d_f64[0];
v18 = *(_QWORD *)&v19.m128d_f64[0];
if ( ((*(_QWORD *)&v19.m128d_f64[0] >> 52) & 0x7FFuLL) - 1023 < 0x1F )
v26 = *(_QWORD *)&v19.m128d_f64[0] << 12 << ((unsigned __int8)(*(_QWORD *)&v19.m128d_f64[0] >> 52) + 1) == 0LL;
else
v26 = *(_QWORD *)&v19.m128d_f64[0] == 0LL || *(_QWORD *)&v19.m128d_f64[0] == 0xC1E0000000000000LL;
if ( v26 )
v18 = (unsigned int)(int)v19.m128d_f64[0];
v27 = v18 & 0xFFFFFFFF00000000LL;
return v27 | (unsigned int)v18;
}
v20 = (unsigned int)a4 - (unsigned long long)(unsigned int)v11;
v21 = &a5[2 * (unsigned int)v11 + 1];
while ( 1 )
{
v31 = v19;
if ( (unsigned int)JS_ToFloat64(a1, &v30, (_DWORD *)*(v21 - 1), *v21) )
break;
v22 = (__m128d)*(unsigned long long *)&v30;
v23 = _mm_cvtsi128_si32((__m128i)_mm_and_pd(
_mm_cmpeq_pd(v31, (__m128d)0LL),
_mm_cmpeq_pd((__m128d)*(unsigned long long *)&v30, (__m128d)0LL)));
if ( a6 )
{
if ( (v23 & 1) == 0 )
{
v24 = _mm_cmpunord_sd(v31, v31);
v25 = _mm_and_pd(v24, (__m128d)*(unsigned long long *)&v30);
v22.m128d_f64[0] = fmax(v30, v31.m128d_f64[0]);
LABEL_31:
v19 = _mm_or_pd(_mm_andn_pd(v24, v22), v25);
goto LABEL_32;
}
v19 = _mm_and_pd(v31, (__m128d)*(unsigned long long *)&v30);
}
else
{
if ( (v23 & 1) == 0 )
{
v24 = _mm_cmpunord_sd(v31, v31);
v25 = _mm_and_pd(v24, (__m128d)*(unsigned long long *)&v30);
v22.m128d_f64[0] = fmin(v30, v31.m128d_f64[0]);
goto LABEL_31;
}
v19 = _mm_or_pd(v31, (__m128d)*(unsigned long long *)&v30);
}
LABEL_32:
v21 += 2;
if ( !--v20 )
goto LABEL_33;
}
v29 = v31.m128d_f64[0];
LABEL_41:
LODWORD(v18) = 0;
v27 = 0LL;
return v27 | (unsigned int)v18;
}
| js_math_min_max:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBX,R9D
TEST ECX,ECX
JZ 0x0017dd71
MOV R15,R8
MOV EBP,ECX
MOV R14,RDI
MOV RCX,qword ptr [R8 + 0x8]
TEST ECX,ECX
JZ 0x0017db6e
MOV RDX,qword ptr [R15]
MOV RSI,RSP
MOV RDI,R14
CALL 0x00127681
TEST EAX,EAX
JNZ 0x0017dd54
MOV EAX,0x1
JMP 0x0017dbf0
LAB_0017db6e:
MOV ECX,dword ptr [R15]
MOV EAX,0x1
CMP EBP,0x2
SETGE DL
JL 0x0017dbe6
MOV EAX,0x1
CMP dword ptr [R15 + 0x18],0x0
JNZ 0x0017dbd1
MOV EDX,EBP
LEA RDI,[R15 + 0x10]
MOV ESI,0x2
SUB RSI,RDX
MOV EAX,0x1
LAB_0017db9d:
MOV R8D,dword ptr [RDI]
TEST EBX,EBX
JZ 0x0017dbad
CMP ECX,R8D
CMOVLE ECX,R8D
JMP 0x0017dbb4
LAB_0017dbad:
CMP ECX,R8D
CMOVGE ECX,R8D
LAB_0017dbb4:
LEA R8,[RSI + RAX*0x1]
INC RAX
CMP R8,0x1
JZ 0x0017dbde
CMP dword ptr [RDI + 0x18],0x0
LEA RDI,[RDI + 0x10]
JZ 0x0017db9d
CMP RAX,RDX
SETC DL
LAB_0017dbd1:
CVTSI2SD XMM0,ECX
MOVSD qword ptr [RSP],XMM0
XOR ESI,ESI
JMP 0x0017dbe8
LAB_0017dbde:
CMP RAX,RDX
SETC DL
MOV EAX,EBP
LAB_0017dbe6:
MOV ESI,ECX
LAB_0017dbe8:
TEST DL,DL
JZ 0x0017dd10
LAB_0017dbf0:
MOVSD XMM3,qword ptr [RSP]
CMP EAX,EBP
JGE 0x0017dcd2
MOV EAX,EAX
MOV R12D,EBP
SUB R12,RAX
SHL RAX,0x4
LEA R13,[RAX + R15*0x1]
ADD R13,0x8
LEA R15,[RSP + 0x8]
LAB_0017dc16:
MOVAPD xmmword ptr [RSP + 0x10],XMM3
MOV RDX,qword ptr [R13 + -0x8]
MOV RCX,qword ptr [R13]
MOV RDI,R14
MOV RSI,R15
CALL 0x00127681
TEST EAX,EAX
JNZ 0x0017dd4a
MOVAPD XMM3,xmmword ptr [RSP + 0x10]
UCOMISD XMM3,XMM3
JP 0x0017dcbd
MOVSD XMM0,qword ptr [RSP + 0x8]
UCOMISD XMM0,XMM0
JP 0x0017dccc
MOVAPD XMM1,XMM0
XORPD XMM4,XMM4
CMPEQPD XMM1,XMM4
MOVAPD XMM2,XMM3
CMPEQPD XMM2,XMM4
ANDPD XMM2,XMM1
MOVD EAX,XMM2
TEST EBX,EBX
JZ 0x0017dc7b
TEST AL,0x1
JZ 0x0017dc85
ANDPD XMM3,XMM0
JMP 0x0017dcbd
LAB_0017dc7b:
TEST AL,0x1
JZ 0x0017dc9c
ORPD XMM3,XMM0
JMP 0x0017dcbd
LAB_0017dc85:
MOVAPD XMM1,XMM3
CMPUNORDSD XMM1,XMM3
MOVAPD XMM2,XMM1
ANDPD XMM2,XMM0
MAXSD XMM0,XMM3
JMP 0x0017dcb1
LAB_0017dc9c:
MOVAPD XMM1,XMM3
CMPUNORDSD XMM1,XMM3
MOVAPD XMM2,XMM1
ANDPD XMM2,XMM0
MINSD XMM0,XMM3
LAB_0017dcb1:
ANDNPD XMM1,XMM0
ORPD XMM1,XMM2
MOVAPD XMM3,XMM1
LAB_0017dcbd:
ADD R13,0x10
DEC R12
JNZ 0x0017dc16
JMP 0x0017dcd2
LAB_0017dccc:
MOVAPD XMM3,XMM0
JMP 0x0017dcbd
LAB_0017dcd2:
MOVSD qword ptr [RSP],XMM3
MOVQ RSI,XMM3
MOV RCX,RSI
SHR RCX,0x34
AND ECX,0x7ff
ADD RCX,-0x3ff
CMP RCX,0x1f
JC 0x0017dd16
TEST RSI,RSI
SETZ CL
MOV RAX,-0x3e20000000000000
CMP RSI,RAX
SETZ AL
OR AL,CL
JMP 0x0017dd26
LAB_0017dd10:
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0017dd5d
LAB_0017dd16:
MOV RAX,RSI
SHL RAX,0xc
SHL RAX,CL
TEST RAX,RAX
SETZ AL
LAB_0017dd26:
CVTTSD2SI ECX,XMM3
XOR EDI,EDI
TEST AL,AL
CMOVNZ RSI,RCX
MOV EDX,0x7
CMOVNZ RDX,RDI
MOV RCX,-0x100000000
AND RCX,RSI
JMP 0x0017dd5d
LAB_0017dd4a:
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
MOVSD qword ptr [RSP],XMM0
LAB_0017dd54:
MOV EDX,0x6
XOR ESI,ESI
XOR ECX,ECX
LAB_0017dd5d:
MOV EAX,ESI
OR RAX,RCX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017dd71:
TEST EBX,EBX
MOV RAX,0x7ff0000000000000
MOV RSI,-0x10000000000000
CMOVZ RSI,RAX
MOV EDX,0x7
MOV RCX,RSI
JMP 0x0017dd5d
|
int1 [16]
js_math_min_max(int8 param_1,int8 param_2,int8 param_3,uint param_4,uint *param_5,
int param_6)
{
uint *puVar1;
int1 auVar2 [16];
bool bVar3;
int iVar4;
uint uVar5;
uint uVar6;
ulong uVar7;
int8 uVar8;
double dVar9;
uint *puVar10;
long lVar11;
int4 uVar12;
int4 uVar13;
ulong uVar14;
double dVar15;
int1 auVar16 [16];
double local_58;
double local_50;
int1 local_48 [16];
if (param_4 == 0) {
dVar15 = -INFINITY;
if (param_6 == 0) {
dVar15 = INFINITY;
}
uVar8 = 7;
dVar9 = dVar15;
}
else {
if ((int)*(int8 *)(param_5 + 2) == 0) {
uVar6 = *param_5;
bVar3 = 1 < (int)param_4;
uVar5 = 1;
if ((int)param_4 < 2) {
LAB_0017dbe6:
dVar9 = (double)(ulong)uVar6;
}
else {
uVar7 = 1;
if (param_5[6] == 0) {
uVar14 = (ulong)param_4;
puVar10 = param_5 + 4;
uVar7 = 1;
do {
uVar5 = *puVar10;
if (param_6 == 0) {
if ((int)uVar5 <= (int)uVar6) {
uVar6 = uVar5;
}
}
else if ((int)uVar6 <= (int)uVar5) {
uVar6 = uVar5;
}
lVar11 = (2 - uVar14) + uVar7;
uVar7 = uVar7 + 1;
if (lVar11 == 1) {
bVar3 = uVar7 < uVar14;
uVar5 = param_4;
goto LAB_0017dbe6;
}
puVar1 = puVar10 + 6;
puVar10 = puVar10 + 4;
} while (*puVar1 == 0);
bVar3 = uVar7 < uVar14;
}
uVar5 = (uint)uVar7;
local_58 = (double)(int)uVar6;
dVar9 = 0.0;
}
if (!bVar3) {
dVar15 = 0.0;
uVar8 = 0;
goto LAB_0017dd5d;
}
}
else {
iVar4 = JS_ToFloat64(param_1,&local_58,*(int8 *)param_5);
if (iVar4 != 0) {
LAB_0017dd54:
uVar8 = 6;
dVar15 = 0.0;
dVar9 = 0.0;
goto LAB_0017dd5d;
}
uVar5 = 1;
}
local_48._8_8_ = 0;
local_48._0_8_ = (ulong)local_58;
dVar9 = local_58;
if ((int)uVar5 < (int)param_4) {
lVar11 = (ulong)param_4 - (ulong)uVar5;
param_5 = param_5 + (ulong)uVar5 * 4 + 2;
do {
iVar4 = JS_ToFloat64(param_1,&local_50,*(int8 *)(param_5 + -2),*(int8 *)param_5)
;
if (iVar4 != 0) goto LAB_0017dd54;
dVar15 = local_48._0_8_;
if (!NAN(dVar15)) {
uVar13 = (int4)((ulong)local_50 >> 0x20);
if (NAN(local_50)) {
local_48._8_8_ = 0;
local_48._0_8_ = (ulong)local_50;
}
else {
uVar12 = SUB84(local_50,0);
if (param_6 == 0) {
if (dVar15 != 0.0 || local_50 != 0.0) {
uVar7 = -(ulong)NAN(dVar15);
uVar14 = uVar7 & (ulong)local_50;
if (dVar15 <= local_50) {
uVar12 = local_48._0_4_;
uVar13 = local_48._4_4_;
}
goto LAB_0017dcb1;
}
auVar2._8_8_ = 0;
auVar2._0_8_ = local_50;
local_48 = local_48 | auVar2;
}
else if (dVar15 != 0.0 || local_50 != 0.0) {
uVar7 = -(ulong)NAN(dVar15);
uVar14 = uVar7 & (ulong)local_50;
if (local_50 <= dVar15) {
uVar12 = local_48._0_4_;
uVar13 = local_48._4_4_;
}
LAB_0017dcb1:
local_48._8_8_ = 0;
local_48._0_8_ = ~uVar7 & CONCAT44(uVar13,uVar12) | uVar14;
}
else {
local_48._0_8_ = (ulong)dVar15 & (ulong)local_50;
local_48._8_8_ = 0;
}
}
}
dVar9 = local_48._0_8_;
param_5 = param_5 + 4;
lVar11 = lVar11 + -1;
} while (lVar11 != 0);
}
uVar7 = (ulong)((uint)((ulong)dVar9 >> 0x34) & 0x7ff) - 0x3ff;
if (uVar7 < 0x1f) {
bVar3 = ((long)dVar9 << 0xc) << ((byte)uVar7 & 0x3f) == 0;
}
else {
uVar7 = CONCAT71((int7)(uVar7 >> 8),dVar9 == 0.0);
bVar3 = dVar9 == -2147483648.0 || dVar9 == 0.0;
}
if (bVar3) {
dVar9 = (double)CONCAT44((int)(uVar7 >> 0x20),(int)dVar9);
}
uVar8 = 7;
if (bVar3) {
uVar8 = 0;
}
dVar15 = (double)((ulong)dVar9 & 0xffffffff00000000);
}
LAB_0017dd5d:
auVar16._0_8_ = (ulong)dVar9 & 0xffffffff | (ulong)dVar15;
auVar16._8_8_ = uVar8;
return auVar16;
}
| |
34,245 | js_math_min_max | bluesky950520[P]quickjs/quickjs.c | static JSValue js_math_min_max(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
BOOL is_max = magic;
double r, a;
int i;
uint32_t tag;
if (unlikely(argc == 0)) {
return js_float64(is_max ? NEG_INF : INF);
}
tag = JS_VALUE_GET_TAG(argv[0]);
if (tag == JS_TAG_INT) {
int a1, r1 = JS_VALUE_GET_INT(argv[0]);
for(i = 1; i < argc; i++) {
tag = JS_VALUE_GET_TAG(argv[i]);
if (tag != JS_TAG_INT) {
r = r1;
goto generic_case;
}
a1 = JS_VALUE_GET_INT(argv[i]);
if (is_max)
r1 = max_int(r1, a1);
else
r1 = min_int(r1, a1);
}
return js_int32(r1);
} else {
if (JS_ToFloat64(ctx, &r, argv[0]))
return JS_EXCEPTION;
i = 1;
generic_case:
while (i < argc) {
if (JS_ToFloat64(ctx, &a, argv[i]))
return JS_EXCEPTION;
if (!isnan(r)) {
if (isnan(a)) {
r = a;
} else {
if (is_max)
r = js_fmax(r, a);
else
r = js_fmin(r, a);
}
}
i++;
}
return js_number(r);
}
} | O2 | c | js_math_min_max:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
testl %ecx, %ecx
je 0x69ad8
movq %r8, %r15
movl %ecx, %r12d
movq %rdi, %r14
movq 0x8(%r8), %rcx
pushq $0x6
popq %rbx
testl %ecx, %ecx
je 0x699ae
movq (%r15), %rdx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2127f
testl %eax, %eax
je 0x699e1
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x69ac1
movl (%r15), %eax
movslq %r12d, %r13
leaq 0x18(%r15), %rcx
pushq $0x1
popq %rbx
cmpq %r13, %rbx
jge 0x699ef
cmpl $0x0, (%rcx)
jne 0x699fa
movl -0x8(%rcx), %edx
testl %ebp, %ebp
je 0x699d3
cmpl %edx, %eax
cmovlel %edx, %eax
jmp 0x699d8
cmpl %edx, %eax
cmovgel %edx, %eax
incq %rbx
addq $0x10, %rcx
jmp 0x699bb
movsd 0x8(%rsp), %xmm0
movslq %r12d, %r13
pushq $0x1
popq %rbx
jmp 0x699fe
movl %eax, %eax
xorl %ecx, %ecx
xorl %ebx, %ebx
jmp 0x69ac1
cvtsi2sd %eax, %xmm0
movq %rbx, %rax
shlq $0x4, %rax
addq %rax, %r15
addq $0x8, %r15
movq %rsp, %r12
cmpq %r13, %rbx
jge 0x69aa3
movapd %xmm0, 0x10(%rsp)
movq -0x8(%r15), %rdx
movq (%r15), %rcx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2127f
testl %eax, %eax
jne 0x69aba
movapd 0x10(%rsp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x69a91
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm1
jp 0x69a9d
movapd %xmm1, %xmm3
xorpd %xmm4, %xmm4
cmpeqpd %xmm4, %xmm3
movapd %xmm0, %xmm2
cmpeqpd %xmm4, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
testl %ebp, %ebp
je 0x69a7b
testb $0x1, %al
je 0x69a85
andpd %xmm1, %xmm0
jmp 0x69a91
testb $0x1, %al
je 0x69a8c
orpd %xmm1, %xmm0
jmp 0x69a91
callq 0xe0e0
jmp 0x69a91
callq 0xe5e0
incq %rbx
addq $0x10, %r15
jmp 0x69a0f
movapd %xmm1, %xmm0
jmp 0x69a91
callq 0x16f9e
movq %rdx, %rbx
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
jmp 0x69ac1
xorl %ecx, %ecx
pushq $0x6
popq %rbx
xorl %eax, %eax
movl %eax, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
cmoveq %rcx, %rax
pushq $0x7
popq %rbx
movq %rax, %rcx
jmp 0x69ac1
| js_math_min_max:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, r9d
test ecx, ecx
jz loc_69AD8
mov r15, r8
mov r12d, ecx
mov r14, rdi
mov rcx, [r8+8]
push 6
pop rbx
test ecx, ecx
jz short loc_699AE
mov rdx, [r15]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call JS_ToFloat64
test eax, eax
jz short loc_699E1
xor eax, eax
xor ecx, ecx
jmp loc_69AC1
loc_699AE:
mov eax, [r15]
movsxd r13, r12d
lea rcx, [r15+18h]
push 1
pop rbx
loc_699BB:
cmp rbx, r13
jge short loc_699EF
cmp dword ptr [rcx], 0
jnz short loc_699FA
mov edx, [rcx-8]
test ebp, ebp
jz short loc_699D3
cmp eax, edx
cmovle eax, edx
jmp short loc_699D8
loc_699D3:
cmp eax, edx
cmovge eax, edx
loc_699D8:
inc rbx
add rcx, 10h
jmp short loc_699BB
loc_699E1:
movsd xmm0, [rsp+58h+var_50]
movsxd r13, r12d
push 1
pop rbx
jmp short loc_699FE
loc_699EF:
mov eax, eax
xor ecx, ecx
xor ebx, ebx
jmp loc_69AC1
loc_699FA:
cvtsi2sd xmm0, eax
loc_699FE:
mov rax, rbx
shl rax, 4
add r15, rax
add r15, 8
mov r12, rsp
loc_69A0F:
cmp rbx, r13
jge loc_69AA3
movapd [rsp+58h+var_48], xmm0
mov rdx, [r15-8]
mov rcx, [r15]
mov rdi, r14
mov rsi, r12
call JS_ToFloat64
test eax, eax
jnz loc_69ABA
movapd xmm0, [rsp+58h+var_48]
ucomisd xmm0, xmm0
jp short loc_69A91
movsd xmm1, [rsp+58h+var_58]
ucomisd xmm1, xmm1
jp short loc_69A9D
movapd xmm3, xmm1
xorpd xmm4, xmm4
cmpeqpd xmm3, xmm4
movapd xmm2, xmm0
cmpeqpd xmm2, xmm4
andpd xmm2, xmm3
movd eax, xmm2
test ebp, ebp
jz short loc_69A7B
test al, 1
jz short loc_69A85
andpd xmm0, xmm1
jmp short loc_69A91
loc_69A7B:
test al, 1
jz short loc_69A8C
orpd xmm0, xmm1
jmp short loc_69A91
loc_69A85:
call _fmax
jmp short loc_69A91
loc_69A8C:
call _fmin
loc_69A91:
inc rbx
add r15, 10h
jmp loc_69A0F
loc_69A9D:
movapd xmm0, xmm1
jmp short loc_69A91
loc_69AA3:
call js_number
mov rbx, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
jmp short loc_69AC1
loc_69ABA:
xor ecx, ecx
push 6
pop rbx
xor eax, eax
loc_69AC1:
mov eax, eax
or rax, rcx
mov rdx, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_69AD8:
test ebp, ebp
mov rcx, 7FF0000000000000h
mov rax, 0FFF0000000000000h
cmovz rax, rcx
push 7
pop rbx
mov rcx, rax
jmp short loc_69AC1
| unsigned long long js_math_min_max(long long a1, __m128d a2, long long a3, long long a4, int a5, long long a6, int a7)
{
long long v10; // rcx
long long v11; // rax
unsigned long long v12; // rcx
long long v13; // r13
_DWORD *v14; // rcx
long long i; // rbx
int v16; // edx
long long *j; // r15
char v18; // al
double v20; // [rsp+0h] [rbp-58h] BYREF
unsigned long long v21; // [rsp+8h] [rbp-50h] BYREF
__m128d v22; // [rsp+10h] [rbp-48h]
if ( a5 )
{
v10 = *(_QWORD *)(a6 + 8);
if ( (_DWORD)v10 )
{
if ( (unsigned int)JS_ToFloat64(a1, (long long)&v21, *(_DWORD **)a6, v10) )
{
LODWORD(v11) = 0;
v12 = 0LL;
return v12 | (unsigned int)v11;
}
a2 = (__m128d)v21;
v13 = a5;
i = 1LL;
}
else
{
LODWORD(v11) = *(_DWORD *)a6;
v13 = a5;
v14 = (_DWORD *)(a6 + 24);
for ( i = 1LL; ; ++i )
{
if ( i >= a5 )
{
v12 = 0LL;
return v12 | (unsigned int)v11;
}
if ( *v14 )
break;
v16 = *(v14 - 2);
if ( a7 )
{
if ( (int)v11 <= v16 )
LODWORD(v11) = *(v14 - 2);
}
else if ( (int)v11 >= v16 )
{
LODWORD(v11) = *(v14 - 2);
}
v14 += 4;
}
a2.m128d_f64[0] = (double)(int)v11;
}
for ( j = (long long *)(16 * i + a6 + 8); ; j += 2 )
{
if ( i >= v13 )
{
v11 = js_number(a2.m128d_f64[0]);
v12 = v11 & 0xFFFFFFFF00000000LL;
return v12 | (unsigned int)v11;
}
v22 = a2;
if ( (unsigned int)JS_ToFloat64(a1, (long long)&v20, (_DWORD *)*(j - 1), *j) )
break;
a2 = v22;
v18 = _mm_cvtsi128_si32((__m128i)_mm_and_pd(
_mm_cmpeq_pd(v22, (__m128d)0LL),
_mm_cmpeq_pd((__m128d)*(unsigned long long *)&v20, (__m128d)0LL)));
if ( a7 )
{
if ( (v18 & 1) != 0 )
a2 = _mm_and_pd(v22, (__m128d)*(unsigned long long *)&v20);
else
fmax(v22.m128d_f64[0], v20);
}
else if ( (v18 & 1) != 0 )
{
a2 = _mm_or_pd(v22, (__m128d)*(unsigned long long *)&v20);
}
else
{
fmin(v22.m128d_f64[0], v20);
}
++i;
}
v12 = 0LL;
LODWORD(v11) = 0;
}
else
{
v11 = 0xFFF0000000000000LL;
if ( !a7 )
v11 = 0x7FF0000000000000LL;
v12 = v11;
}
return v12 | (unsigned int)v11;
}
| js_math_min_max:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R9D
TEST ECX,ECX
JZ 0x00169ad8
MOV R15,R8
MOV R12D,ECX
MOV R14,RDI
MOV RCX,qword ptr [R8 + 0x8]
PUSH 0x6
POP RBX
TEST ECX,ECX
JZ 0x001699ae
MOV RDX,qword ptr [R15]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x0012127f
TEST EAX,EAX
JZ 0x001699e1
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00169ac1
LAB_001699ae:
MOV EAX,dword ptr [R15]
MOVSXD R13,R12D
LEA RCX,[R15 + 0x18]
PUSH 0x1
POP RBX
LAB_001699bb:
CMP RBX,R13
JGE 0x001699ef
CMP dword ptr [RCX],0x0
JNZ 0x001699fa
MOV EDX,dword ptr [RCX + -0x8]
TEST EBP,EBP
JZ 0x001699d3
CMP EAX,EDX
CMOVLE EAX,EDX
JMP 0x001699d8
LAB_001699d3:
CMP EAX,EDX
CMOVGE EAX,EDX
LAB_001699d8:
INC RBX
ADD RCX,0x10
JMP 0x001699bb
LAB_001699e1:
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSXD R13,R12D
PUSH 0x1
POP RBX
JMP 0x001699fe
LAB_001699ef:
MOV EAX,EAX
XOR ECX,ECX
XOR EBX,EBX
JMP 0x00169ac1
LAB_001699fa:
CVTSI2SD XMM0,EAX
LAB_001699fe:
MOV RAX,RBX
SHL RAX,0x4
ADD R15,RAX
ADD R15,0x8
MOV R12,RSP
LAB_00169a0f:
CMP RBX,R13
JGE 0x00169aa3
MOVAPD xmmword ptr [RSP + 0x10],XMM0
MOV RDX,qword ptr [R15 + -0x8]
MOV RCX,qword ptr [R15]
MOV RDI,R14
MOV RSI,R12
CALL 0x0012127f
TEST EAX,EAX
JNZ 0x00169aba
MOVAPD XMM0,xmmword ptr [RSP + 0x10]
UCOMISD XMM0,XMM0
JP 0x00169a91
MOVSD XMM1,qword ptr [RSP]
UCOMISD XMM1,XMM1
JP 0x00169a9d
MOVAPD XMM3,XMM1
XORPD XMM4,XMM4
CMPEQPD XMM3,XMM4
MOVAPD XMM2,XMM0
CMPEQPD XMM2,XMM4
ANDPD XMM2,XMM3
MOVD EAX,XMM2
TEST EBP,EBP
JZ 0x00169a7b
TEST AL,0x1
JZ 0x00169a85
ANDPD XMM0,XMM1
JMP 0x00169a91
LAB_00169a7b:
TEST AL,0x1
JZ 0x00169a8c
ORPD XMM0,XMM1
JMP 0x00169a91
LAB_00169a85:
CALL 0x0010e0e0
JMP 0x00169a91
LAB_00169a8c:
CALL 0x0010e5e0
LAB_00169a91:
INC RBX
ADD R15,0x10
JMP 0x00169a0f
LAB_00169a9d:
MOVAPD XMM0,XMM1
JMP 0x00169a91
LAB_00169aa3:
CALL 0x00116f9e
MOV RBX,RDX
MOV RCX,-0x100000000
AND RCX,RAX
JMP 0x00169ac1
LAB_00169aba:
XOR ECX,ECX
PUSH 0x6
POP RBX
XOR EAX,EAX
LAB_00169ac1:
MOV EAX,EAX
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00169ad8:
TEST EBP,EBP
MOV RCX,0x7ff0000000000000
MOV RAX,-0x10000000000000
CMOVZ RAX,RCX
PUSH 0x7
POP RBX
MOV RCX,RAX
JMP 0x00169ac1
|
int1 [16]
js_math_min_max(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int param_5,uint *param_6,int param_7)
{
uint uVar1;
int iVar2;
uint uVar3;
uint *puVar4;
ulong uVar5;
long lVar6;
int8 extraout_XMM0_Qb;
int8 extraout_XMM0_Qb_00;
int1 auVar7 [16];
int1 auVar8 [16];
double local_58;
double local_50;
double local_48;
int8 uStack_40;
if (param_5 == 0) {
uVar5 = 0xfff0000000000000;
if (param_7 == 0) {
uVar5 = 0x7ff0000000000000;
}
auVar7._8_8_ = 7;
auVar7._0_8_ = uVar5;
}
else if ((int)*(int8 *)(param_6 + 2) == 0) {
uVar3 = *param_6;
puVar4 = param_6 + 6;
for (lVar6 = 1; lVar6 < param_5; lVar6 = lVar6 + 1) {
if (*puVar4 != 0) {
local_50 = (double)(int)uVar3;
goto LAB_001699fe;
}
uVar1 = puVar4[-2];
if (param_7 == 0) {
if ((int)uVar1 <= (int)uVar3) {
uVar3 = uVar1;
}
}
else if ((int)uVar3 <= (int)uVar1) {
uVar3 = uVar1;
}
puVar4 = puVar4 + 4;
}
uVar5 = 0;
auVar7 = ZEXT416(uVar3);
}
else {
iVar2 = JS_ToFloat64(param_2,&local_50,*(int8 *)param_6);
if (iVar2 == 0) {
param_1 = 0;
lVar6 = 1;
LAB_001699fe:
param_6 = param_6 + lVar6 * 4 + 2;
for (; lVar6 < param_5; lVar6 = lVar6 + 1) {
local_48 = local_50;
uStack_40 = param_1;
iVar2 = JS_ToFloat64(param_2,&local_58,*(int8 *)(param_6 + -2),*(int8 *)param_6)
;
if (iVar2 != 0) {
uVar5 = 0;
auVar7 = ZEXT816(6) << 0x40;
goto LAB_00169ac1;
}
local_50 = local_48;
param_1 = uStack_40;
if (!NAN(local_48)) {
if (NAN(local_58)) {
param_1 = 0;
local_50 = local_58;
}
else if (param_7 == 0) {
if (local_48 != 0.0 || local_58 != 0.0) {
local_50 = fmin(local_48,local_58);
param_1 = extraout_XMM0_Qb_00;
}
else {
local_50 = (double)((ulong)local_48 | (ulong)local_58);
}
}
else if (local_48 != 0.0 || local_58 != 0.0) {
local_50 = fmax(local_48,local_58);
param_1 = extraout_XMM0_Qb;
}
else {
local_50 = (double)((ulong)local_48 & (ulong)local_58);
param_1 = 0;
}
}
param_6 = param_6 + 4;
}
auVar7 = js_number();
uVar5 = auVar7._0_8_ & 0xffffffff00000000;
}
else {
auVar7 = ZEXT816(6) << 0x40;
uVar5 = 0;
}
}
LAB_00169ac1:
auVar8._0_8_ = auVar7._0_8_ & 0xffffffff | uVar5;
auVar8._8_8_ = auVar7._8_8_;
return auVar8;
}
| |
34,246 | bf_sin | bluesky950520[P]quickjs/libbf.c | int bf_sin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
{
if (a->len == 0) {
if (a->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else {
bf_set_zero(r, a->sign);
return 0;
}
}
/* small argument case: result = x+r(x) with r(x) = -x^3/6 +
O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
if (a->expn < 0) {
slimb_t e;
e = sat_add(2 * a->expn, a->expn - 2);
if (e < a->expn - bf_max(prec + 2, a->len * LIMB_BITS + 2)) {
bf_set(r, a);
return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
}
}
return bf_ziv_rounding(r, a, prec, flags, bf_sin_internal, NULL);
} | O1 | c | bf_sin:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rbp
movq 0x18(%rsi), %rax
testq %rax, %rax
je 0x8c79f
movl %ecx, %r12d
movq %rdx, %r14
testq %rbp, %rbp
jns 0x8c77b
leaq -0x2(,%rbp,2), %r13
addq %rbp, %r13
leaq 0x2(%r14), %rcx
shlq $0x6, %rax
orq $0x2, %rax
cmpq %rax, %rcx
cmovgq %rcx, %rax
subq %rax, %rbp
cmpq %rbp, %r13
jge 0x8c76f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x84c8d
movl $0x1, %ecx
subl 0x8(%r15), %ecx
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %r8
movl %r12d, %r9d
callq 0x8ac4a
cmpq %rbp, %r13
movq %rax, %rbp
jl 0x8c8ff
movl %r12d, %r13d
andl $0x7, %r13d
cmpl $0x6, %r13d
jne 0x8c7f3
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x924c4
jmp 0x8c8d7
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
movabsq $0x7fffffffffffffff, %r14 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %rbp
je 0x8c830
cmpq %r14, %rbp
jne 0x8c867
cmpq $0x0, 0x18(%rbx)
je 0x8c7e3
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r14, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x8c897
movl %r12d, 0x4(%rsp)
leaq 0x20(%r14), %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x924c4
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movq %r12, %rcx
callq 0x851e7
movl $0x10, %ebp
testl %eax, %eax
je 0x8c89b
movl 0x4(%rsp), %r12d
jmp 0x8c8d7
cmpq $0x0, 0x18(%rbx)
je 0x8c852
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %r14, 0x10(%rbx)
movl $0x0, 0x8(%rbx)
movl $0x1, %ebp
jmp 0x8c8ff
movl 0x8(%r15), %ebp
cmpq $0x0, 0x18(%rbx)
je 0x8c88d
movq (%rbx), %rax
movq 0x20(%rbx), %rsi
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movq %rax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
incq %r14
movq %r14, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0x8c8ff
movl $0x20, %r12d
leaq (%r14,%r12,2), %rbp
addq %r12, %r12
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x924c4
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
movq %rbp, %rcx
callq 0x851e7
testl %eax, %eax
je 0x8c8a1
movl 0x4(%rsp), %r12d
movl $0x10, %ebp
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x8c8ff
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x84e26
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| bf_sin:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov rbx, rdi
mov rbp, [rsi+10h]
mov rax, [rsi+18h]
test rax, rax
jz loc_8C79F
mov r12d, ecx
mov r14, rdx
test rbp, rbp
jns short loc_8C77B
lea r13, ds:0FFFFFFFFFFFFFFFEh[rbp*2]
add r13, rbp
lea rcx, [r14+2]
shl rax, 6
or rax, 2
cmp rcx, rax
cmovg rax, rcx
sub rbp, rax
cmp r13, rbp
jge short loc_8C76F
mov rdi, rbx
mov rsi, r15
call bf_set
mov ecx, 1
sub ecx, [r15+8]
mov rdi, rbx
mov rsi, rbx
mov rdx, r13
mov r8, r14
mov r9d, r12d
call bf_add_epsilon
loc_8C76F:
cmp r13, rbp
mov rbp, rax
jl loc_8C8FF
loc_8C77B:
mov r13d, r12d
and r13d, 7
cmp r13d, 6
jnz short loc_8C7F3
xor ebp, ebp
mov rdi, rbx
xor esi, esi
mov rdx, r15
mov rcx, r14
call bf_sincos
jmp loc_8C8D7
loc_8C79F:
mov rax, 7FFFFFFFFFFFFFFEh
mov r14, 7FFFFFFFFFFFFFFFh
cmp rbp, rax
jz short loc_8C830
cmp rbp, r14
jnz loc_8C867
cmp qword ptr [rbx+18h], 0
jz short loc_8C7E3
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8C7E3:
mov [rbx+10h], r14
mov dword ptr [rbx+8], 0
jmp loc_8C897
loc_8C7F3:
mov [rsp+38h+var_34], r12d
lea r12, [r14+20h]
mov rdi, rbx
xor esi, esi
mov rdx, r15
mov rcx, r12
call bf_sincos
mov rdi, rbx
mov rsi, r14
mov edx, r13d
mov rcx, r12
call bf_can_round
mov ebp, 10h
test eax, eax
jz short loc_8C89B
mov r12d, [rsp+38h+var_34]
jmp loc_8C8D7
loc_8C830:
cmp qword ptr [rbx+18h], 0
jz short loc_8C852
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8C852:
mov [rbx+10h], r14
mov dword ptr [rbx+8], 0
mov ebp, 1
jmp loc_8C8FF
loc_8C867:
mov ebp, [r15+8]
cmp qword ptr [rbx+18h], 0
jz short loc_8C88D
mov rax, [rbx]
mov rsi, [rbx+20h]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
mov [rbx+20h], rax
mov qword ptr [rbx+18h], 0
loc_8C88D:
inc r14
mov [rbx+10h], r14
mov [rbx+8], ebp
loc_8C897:
xor ebp, ebp
jmp short loc_8C8FF
loc_8C89B:
mov r12d, 20h ; ' '
loc_8C8A1:
lea rbp, [r14+r12*2]
add r12, r12
mov rdi, rbx
xor esi, esi
mov rdx, r15
mov rcx, rbp
call bf_sincos
mov rdi, rbx
mov rsi, r14
mov edx, r13d
mov rcx, rbp
call bf_can_round
test eax, eax
jz short loc_8C8A1
mov r12d, [rsp+38h+var_34]
mov ebp, 10h
loc_8C8D7:
mov rcx, [rbx+18h]
test rcx, rcx
jz short loc_8C8FF
mov rdi, rbx
mov rsi, r14
mov edx, r12d
mov r8d, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp __bf_round
loc_8C8FF:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long bf_sin(__int128 *a1, long long a2, long long a3, unsigned int a4)
{
long long v4; // rbp
long long v5; // rax
long long v8; // r13
long long v9; // rax
long long v10; // rbp
bool v11; // cc
unsigned int v12; // ebp
int v13; // r13d
int v14; // ebp
long long v15; // r12
long long v16; // rbp
unsigned long long v17; // rcx
unsigned int v19; // [rsp+0h] [rbp-34h]
v4 = *(_QWORD *)(a2 + 16);
v5 = *(_QWORD *)(a2 + 24);
if ( v5 )
{
if ( v4 >= 0 )
goto LABEL_32;
v8 = v4 + 2 * v4 - 2;
v9 = (v5 << 6) | 2;
if ( a3 + 2 > v9 )
v9 = a3 + 2;
v10 = v4 - v9;
if ( v8 < v10 )
{
bf_set(a1, a2);
LODWORD(v9) = bf_add_epsilon(a1, a1, v8, 1 - *(_DWORD *)(a2 + 8), a3, a4);
}
v11 = v8 < v10;
v12 = v9;
if ( !v11 )
{
LABEL_32:
v13 = a4 & 7;
if ( v13 == 6 )
{
v12 = 0;
bf_sincos(a1, 0LL, a2, a3);
}
else
{
v19 = a4;
bf_sincos(a1, 0LL, a2, a3 + 32);
v12 = 16;
if ( !bf_can_round(a1, a3, v13, a3 + 32) )
{
v15 = 32LL;
do
{
v16 = a3 + 2 * v15;
v15 *= 2LL;
bf_sincos(a1, 0LL, a2, v16);
}
while ( !bf_can_round(a1, a3, v13, v16) );
a4 = v19;
v12 = 16;
}
}
v17 = *((_QWORD *)a1 + 3);
if ( v17 )
return _bf_round((long long)a1, a3, a4, v17, v12);
}
}
else if ( v4 == 0x7FFFFFFFFFFFFFFELL )
{
if ( *((_QWORD *)a1 + 3) )
{
*((_QWORD *)a1 + 4) = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)a1 + 8LL))(
**(_QWORD **)a1,
*((_QWORD *)a1 + 4),
0LL);
*((_QWORD *)a1 + 3) = 0LL;
}
*((_QWORD *)a1 + 2) = 0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
return 1;
}
else
{
if ( v4 == 0x7FFFFFFFFFFFFFFFLL )
{
if ( *((_QWORD *)a1 + 3) )
{
*((_QWORD *)a1 + 4) = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)a1 + 8LL))(
**(_QWORD **)a1,
*((_QWORD *)a1 + 4),
0LL);
*((_QWORD *)a1 + 3) = 0LL;
}
*((_QWORD *)a1 + 2) = 0x7FFFFFFFFFFFFFFFLL;
*((_DWORD *)a1 + 2) = 0;
}
else
{
v14 = *(_DWORD *)(a2 + 8);
if ( *((_QWORD *)a1 + 3) )
{
*((_QWORD *)a1 + 4) = (*(long long ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)a1 + 8LL))(
**(_QWORD **)a1,
*((_QWORD *)a1 + 4),
0LL);
*((_QWORD *)a1 + 3) = 0LL;
}
*((_QWORD *)a1 + 2) = 0x8000000000000000LL;
*((_DWORD *)a1 + 2) = v14;
}
return 0;
}
return v12;
}
| bf_sin:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV RBX,RDI
MOV RBP,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RSI + 0x18]
TEST RAX,RAX
JZ 0x0018c79f
MOV R12D,ECX
MOV R14,RDX
TEST RBP,RBP
JNS 0x0018c77b
LEA R13,[-0x2 + RBP*0x2]
ADD R13,RBP
LEA RCX,[R14 + 0x2]
SHL RAX,0x6
OR RAX,0x2
CMP RCX,RAX
CMOVG RAX,RCX
SUB RBP,RAX
CMP R13,RBP
JGE 0x0018c76f
MOV RDI,RBX
MOV RSI,R15
CALL 0x00184c8d
MOV ECX,0x1
SUB ECX,dword ptr [R15 + 0x8]
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R13
MOV R8,R14
MOV R9D,R12D
CALL 0x0018ac4a
LAB_0018c76f:
CMP R13,RBP
MOV RBP,RAX
JL 0x0018c8ff
LAB_0018c77b:
MOV R13D,R12D
AND R13D,0x7
CMP R13D,0x6
JNZ 0x0018c7f3
XOR EBP,EBP
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R15
MOV RCX,R14
CALL 0x001924c4
JMP 0x0018c8d7
LAB_0018c79f:
MOV RAX,0x7ffffffffffffffe
MOV R14,0x7fffffffffffffff
CMP RBP,RAX
JZ 0x0018c830
CMP RBP,R14
JNZ 0x0018c867
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018c7e3
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018c7e3:
MOV qword ptr [RBX + 0x10],R14
MOV dword ptr [RBX + 0x8],0x0
JMP 0x0018c897
LAB_0018c7f3:
MOV dword ptr [RSP + 0x4],R12D
LEA R12,[R14 + 0x20]
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R15
MOV RCX,R12
CALL 0x001924c4
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R13D
MOV RCX,R12
CALL 0x001851e7
MOV EBP,0x10
TEST EAX,EAX
JZ 0x0018c89b
MOV R12D,dword ptr [RSP + 0x4]
JMP 0x0018c8d7
LAB_0018c830:
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018c852
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018c852:
MOV qword ptr [RBX + 0x10],R14
MOV dword ptr [RBX + 0x8],0x0
MOV EBP,0x1
JMP 0x0018c8ff
LAB_0018c867:
MOV EBP,dword ptr [R15 + 0x8]
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0018c88d
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x18],0x0
LAB_0018c88d:
INC R14
MOV qword ptr [RBX + 0x10],R14
MOV dword ptr [RBX + 0x8],EBP
LAB_0018c897:
XOR EBP,EBP
JMP 0x0018c8ff
LAB_0018c89b:
MOV R12D,0x20
LAB_0018c8a1:
LEA RBP,[R14 + R12*0x2]
ADD R12,R12
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R15
MOV RCX,RBP
CALL 0x001924c4
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R13D
MOV RCX,RBP
CALL 0x001851e7
TEST EAX,EAX
JZ 0x0018c8a1
MOV R12D,dword ptr [RSP + 0x4]
MOV EBP,0x10
LAB_0018c8d7:
MOV RCX,qword ptr [RBX + 0x18]
TEST RCX,RCX
JZ 0x0018c8ff
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R12D
MOV R8D,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00184e26
LAB_0018c8ff:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong bf_sin(long *param_1,long param_2,long param_3,uint param_4)
{
long lVar1;
int4 uVar2;
int iVar3;
ulong uVar4;
long lVar5;
uint uVar6;
lVar5 = *(long *)(param_2 + 0x10);
if (*(long *)(param_2 + 0x18) == 0) {
if (lVar5 == 0x7ffffffffffffffe) {
if (param_1[3] != 0) {
lVar5 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
uVar4 = 1;
}
else {
if (lVar5 == 0x7fffffffffffffff) {
if (param_1[3] != 0) {
lVar5 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = 0x7fffffffffffffff;
*(int4 *)(param_1 + 1) = 0;
}
else {
uVar2 = *(int4 *)(param_2 + 8);
if (param_1[3] != 0) {
lVar5 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,param_1[4],0);
param_1[4] = lVar5;
param_1[3] = 0;
}
param_1[2] = -0x8000000000000000;
*(int4 *)(param_1 + 1) = uVar2;
}
uVar4 = 0;
}
}
else {
if (lVar5 < 0) {
lVar1 = lVar5 * 3 + -2;
uVar4 = *(long *)(param_2 + 0x18) << 6 | 2;
if ((long)uVar4 < (long)(param_3 + 2U)) {
uVar4 = param_3 + 2U;
}
if (lVar1 < (long)(lVar5 - uVar4)) {
bf_set(param_1,param_2);
uVar4 = bf_add_epsilon(param_1,param_1,lVar1,1 - *(int *)(param_2 + 8),param_3,param_4);
goto LAB_0018c8ff;
}
}
uVar6 = param_4 & 7;
if (uVar6 == 6) {
uVar4 = 0;
bf_sincos(param_1,0,param_2,param_3);
}
else {
bf_sincos(param_1,0,param_2,param_3 + 0x20);
iVar3 = bf_can_round(param_1,param_3,uVar6,param_3 + 0x20);
uVar4 = 0x10;
if (iVar3 == 0) {
lVar5 = 0x20;
do {
lVar1 = param_3 + lVar5 * 2;
lVar5 = lVar5 * 2;
bf_sincos(param_1,0,param_2,lVar1);
iVar3 = bf_can_round(param_1,param_3,uVar6,lVar1);
} while (iVar3 == 0);
uVar4 = 0x10;
}
}
if (param_1[3] != 0) {
uVar4 = __bf_round(param_1,param_3,param_4,param_1[3],uVar4);
return uVar4;
}
}
LAB_0018c8ff:
return uVar4 & 0xffffffff;
}
| |
34,247 | ggml_backend_cpu_buffer_type | 7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c | ggml_backend_buffer_type_t ggml_backend_cpu_buffer_type(void) {
static struct ggml_backend_buffer_type ggml_backend_cpu_buffer_type = {
/* .iface = */ {
/* .alloc_buffer = */ ggml_backend_cpu_buffer_type_alloc_buffer,
/* .get_alignment = */ ggml_backend_cpu_buffer_type_get_alignment,
/* .get_alloc_size = */ NULL, // defaults to ggml_nbytes
/* .supports_backend = */ ggml_backend_cpu_buffer_type_supports_backend,
/* .is_host = */ ggml_backend_cpu_buffer_type_is_host,
},
/* .context = */ NULL,
};
return &ggml_backend_cpu_buffer_type;
} | O0 | c | ggml_backend_cpu_buffer_type:
leaq 0xf2061(%rip), %rax # 0x259a58
retq
nopl (%rax,%rax)
| ggml_backend_cpu_buffer_type:
lea rax, ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type
retn
| long long ( **ggml_backend_cpu_buffer_type())()
{
return ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type;
}
| |||
34,248 | ggml_backend_cpu_buffer_type | 7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c | ggml_backend_buffer_type_t ggml_backend_cpu_buffer_type(void) {
static struct ggml_backend_buffer_type ggml_backend_cpu_buffer_type = {
/* .iface = */ {
/* .alloc_buffer = */ ggml_backend_cpu_buffer_type_alloc_buffer,
/* .get_alignment = */ ggml_backend_cpu_buffer_type_get_alignment,
/* .get_alloc_size = */ NULL, // defaults to ggml_nbytes
/* .supports_backend = */ ggml_backend_cpu_buffer_type_supports_backend,
/* .is_host = */ ggml_backend_cpu_buffer_type_is_host,
},
/* .context = */ NULL,
};
return &ggml_backend_cpu_buffer_type;
} | O1 | c | ggml_backend_cpu_buffer_type:
leaq 0xc380e(%rip), %rax # 0x177d88
retq
| ggml_backend_cpu_buffer_type:
lea rax, ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type
retn
| long long ( **ggml_backend_cpu_buffer_type())()
{
return ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type;
}
| |||
34,249 | ggml_backend_cpu_buffer_type | 7CodeWizard[P]stablediffusion/ggml/src/ggml-backend.c | ggml_backend_buffer_type_t ggml_backend_cpu_buffer_type(void) {
static struct ggml_backend_buffer_type ggml_backend_cpu_buffer_type = {
/* .iface = */ {
/* .alloc_buffer = */ ggml_backend_cpu_buffer_type_alloc_buffer,
/* .get_alignment = */ ggml_backend_cpu_buffer_type_get_alignment,
/* .get_alloc_size = */ NULL, // defaults to ggml_nbytes
/* .supports_backend = */ ggml_backend_cpu_buffer_type_supports_backend,
/* .is_host = */ ggml_backend_cpu_buffer_type_is_host,
},
/* .context = */ NULL,
};
return &ggml_backend_cpu_buffer_type;
} | O2 | c | ggml_backend_cpu_buffer_type:
leaq 0xc6773(%rip), %rax # 0x156d98
retq
| ggml_backend_cpu_buffer_type:
lea rax, ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type
retn
| long long ( **ggml_backend_cpu_buffer_type())()
{
return ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type;
}
| ggml_backend_cpu_buffer_type:
LEA RAX,[0x256d98]
RET
|
int1 * ggml_backend_cpu_buffer_type(void)
{
return ggml_backend_cpu_buffer_type_ggml_backend_cpu_buffer_type;
}
| |
34,250 | GraphicsState::DrawFrame(unsigned char*, bool) | sp1187[P]veesem/src/ui/graphics_state.cc | void GraphicsState::DrawFrame(uint8_t* fb, bool bilinear) {
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, texture_id_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 320, 240, 0, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, fb);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, bilinear ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, bilinear ? GL_LINEAR : GL_NEAREST);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(margin_width_, margin_height_);
glTexCoord2f(1, 0);
glVertex2f(window_width_ - margin_width_, margin_height_);
glTexCoord2f(1, 1);
glVertex2f(window_width_ - margin_width_, window_height_ - margin_height_);
glTexCoord2f(0, 1);
glVertex2f(margin_width_, window_height_ - margin_height_);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
} | O0 | cpp | GraphicsState::DrawFrame(unsigned char*, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm2, %xmm2
movss 0xe3266(%rip), %xmm3 # 0xf25f0
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x7150
movl $0x4000, %edi # imm = 0x4000
callq 0x7550
movq -0x20(%rbp), %rax
movl (%rax), %esi
movl $0xde1, %edi # imm = 0xDE1
callq 0x7af0
movq -0x10(%rbp), %rax
movl $0xde1, %edi # imm = 0xDE1
xorl %r9d, %r9d
movl $0x8050, %edx # imm = 0x8050
movl $0x140, %ecx # imm = 0x140
movl $0xf0, %r8d
movl %r9d, %esi
movl $0x80e1, (%rsp) # imm = 0x80E1
movl $0x8366, 0x8(%rsp) # imm = 0x8366
movq %rax, 0x10(%rsp)
callq 0x7a60
movb -0x11(%rbp), %cl
movl $0x2600, %edx # imm = 0x2600
movl $0x2601, %eax # imm = 0x2601
testb $0x1, %cl
cmovnel %eax, %edx
movl $0xde1, %edi # imm = 0xDE1
movl $0x2800, %esi # imm = 0x2800
callq 0x76d0
movb -0x11(%rbp), %cl
movl $0x2600, %edx # imm = 0x2600
movl $0x2601, %eax # imm = 0x2601
testb $0x1, %cl
cmovnel %eax, %edx
movl $0xde1, %edi # imm = 0xDE1
movl $0x2801, %esi # imm = 0x2801
callq 0x76d0
movl $0x7, %edi
callq 0x79a0
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x75c0
movq -0x20(%rbp), %rax
cvtsi2ssl 0x20(%rax), %xmm0
cvtsi2ssl 0x24(%rax), %xmm1
callq 0x74d0
movss 0xe3195(%rip), %xmm0 # 0xf25f0
xorps %xmm1, %xmm1
callq 0x75c0
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
subl 0x20(%rax), %ecx
cvtsi2ss %ecx, %xmm0
cvtsi2ssl 0x24(%rax), %xmm1
callq 0x74d0
movss 0xe316d(%rip), %xmm1 # 0xf25f0
movaps %xmm1, %xmm0
callq 0x75c0
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
subl 0x20(%rcx), %eax
cvtsi2ss %eax, %xmm0
movl 0x1c(%rcx), %eax
subl 0x24(%rcx), %eax
cvtsi2ss %eax, %xmm1
callq 0x74d0
xorps %xmm0, %xmm0
movss 0xe313d(%rip), %xmm1 # 0xf25f0
callq 0x75c0
movq -0x20(%rbp), %rcx
cvtsi2ssl 0x20(%rcx), %xmm0
movl 0x1c(%rcx), %eax
subl 0x24(%rcx), %eax
cvtsi2ss %eax, %xmm1
callq 0x74d0
callq 0x7820
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
callq 0x7af0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN13GraphicsState9DrawFrameEPhb:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
and al, 1
mov [rbp+var_11], al
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
xorps xmm2, xmm2
movss xmm3, cs:flt_F25F0
movaps xmm0, xmm2
movaps xmm1, xmm2
call _glClearColor
mov edi, 4000h
call _glClear
mov rax, [rbp+var_20]
mov esi, [rax]
mov edi, 0DE1h
call _glBindTexture
mov rax, [rbp+var_10]
mov edi, 0DE1h
xor r9d, r9d
mov edx, 8050h
mov ecx, 140h
mov r8d, 0F0h
mov esi, r9d
mov [rsp+40h+var_40], 80E1h
mov [rsp+40h+var_38], 8366h
mov [rsp+40h+var_30], rax
call _glTexImage2D
mov cl, [rbp+var_11]
mov edx, 2600h
mov eax, 2601h
test cl, 1
cmovnz edx, eax
mov edi, 0DE1h
mov esi, 2800h
call _glTexParameteri
mov cl, [rbp+var_11]
mov edx, 2600h
mov eax, 2601h
test cl, 1
cmovnz edx, eax
mov edi, 0DE1h
mov esi, 2801h
call _glTexParameteri
mov edi, 7
call _glBegin
xorps xmm1, xmm1
movaps xmm0, xmm1
call _glTexCoord2f
mov rax, [rbp+var_20]
cvtsi2ss xmm0, dword ptr [rax+20h]
cvtsi2ss xmm1, dword ptr [rax+24h]
call _glVertex2f
movss xmm0, cs:flt_F25F0
xorps xmm1, xmm1
call _glTexCoord2f
mov rax, [rbp+var_20]
mov ecx, [rax+18h]
sub ecx, [rax+20h]
cvtsi2ss xmm0, ecx
cvtsi2ss xmm1, dword ptr [rax+24h]
call _glVertex2f
movss xmm1, cs:flt_F25F0
movaps xmm0, xmm1
call _glTexCoord2f
mov rcx, [rbp+var_20]
mov eax, [rcx+18h]
sub eax, [rcx+20h]
cvtsi2ss xmm0, eax
mov eax, [rcx+1Ch]
sub eax, [rcx+24h]
cvtsi2ss xmm1, eax
call _glVertex2f
xorps xmm0, xmm0
movss xmm1, cs:flt_F25F0
call _glTexCoord2f
mov rcx, [rbp+var_20]
cvtsi2ss xmm0, dword ptr [rcx+20h]
mov eax, [rcx+1Ch]
sub eax, [rcx+24h]
cvtsi2ss xmm1, eax
call _glVertex2f
call _glEnd
mov edi, 0DE1h
xor esi, esi
call _glBindTexture
add rsp, 40h
pop rbp
retn
| long long GraphicsState::DrawFrame(GraphicsState *this, unsigned __int8 *a2, char a3)
{
long long v3; // rdx
long long v4; // rdx
char v6; // [rsp+2Fh] [rbp-11h]
v6 = a3 & 1;
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(0x4000LL);
glBindTexture(3553LL, *(unsigned int *)this);
glTexImage2D(3553LL, 0LL, 32848LL, 320LL, 240LL, 0LL, 32993, 33638, a2);
v3 = 9728LL;
if ( (v6 & 1) != 0 )
v3 = 9729LL;
glTexParameteri(3553LL, 10240LL, v3);
v4 = 9728LL;
if ( (v6 & 1) != 0 )
v4 = 9729LL;
glTexParameteri(3553LL, 10241LL, v4);
glBegin(7LL);
glTexCoord2f(0.0);
glVertex2f((float)*((int *)this + 8), (float)*((int *)this + 9));
glTexCoord2f(COERCE_DOUBLE(1065353216LL));
glVertex2f((float)(*((_DWORD *)this + 6) - *((_DWORD *)this + 8)), (float)*((int *)this + 9));
glTexCoord2f(COERCE_DOUBLE(1065353216LL));
glVertex2f(
(float)(*((_DWORD *)this + 6) - *((_DWORD *)this + 8)),
(float)(*((_DWORD *)this + 7) - *((_DWORD *)this + 9)));
glTexCoord2f(0.0);
glVertex2f((float)*((int *)this + 8), (float)(*((_DWORD *)this + 7) - *((_DWORD *)this + 9)));
glEnd();
return glBindTexture(3553LL, 0LL);
}
| DrawFrame:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
XORPS XMM2,XMM2
MOVSS XMM3,dword ptr [0x001f25f0]
MOVAPS XMM0,XMM2
MOVAPS XMM1,XMM2
CALL 0x00107150
MOV EDI,0x4000
CALL 0x00107550
MOV RAX,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RAX]
MOV EDI,0xde1
CALL 0x00107af0
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,0xde1
XOR R9D,R9D
MOV EDX,0x8050
MOV ECX,0x140
MOV R8D,0xf0
MOV ESI,R9D
MOV dword ptr [RSP],0x80e1
MOV dword ptr [RSP + 0x8],0x8366
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00107a60
MOV CL,byte ptr [RBP + -0x11]
MOV EDX,0x2600
MOV EAX,0x2601
TEST CL,0x1
CMOVNZ EDX,EAX
MOV EDI,0xde1
MOV ESI,0x2800
CALL 0x001076d0
MOV CL,byte ptr [RBP + -0x11]
MOV EDX,0x2600
MOV EAX,0x2601
TEST CL,0x1
CMOVNZ EDX,EAX
MOV EDI,0xde1
MOV ESI,0x2801
CALL 0x001076d0
MOV EDI,0x7
CALL 0x001079a0
XORPS XMM1,XMM1
MOVAPS XMM0,XMM1
CALL 0x001075c0
MOV RAX,qword ptr [RBP + -0x20]
CVTSI2SS XMM0,dword ptr [RAX + 0x20]
CVTSI2SS XMM1,dword ptr [RAX + 0x24]
CALL 0x001074d0
MOVSS XMM0,dword ptr [0x001f25f0]
XORPS XMM1,XMM1
CALL 0x001075c0
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x18]
SUB ECX,dword ptr [RAX + 0x20]
CVTSI2SS XMM0,ECX
CVTSI2SS XMM1,dword ptr [RAX + 0x24]
CALL 0x001074d0
MOVSS XMM1,dword ptr [0x001f25f0]
MOVAPS XMM0,XMM1
CALL 0x001075c0
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RCX + 0x18]
SUB EAX,dword ptr [RCX + 0x20]
CVTSI2SS XMM0,EAX
MOV EAX,dword ptr [RCX + 0x1c]
SUB EAX,dword ptr [RCX + 0x24]
CVTSI2SS XMM1,EAX
CALL 0x001074d0
XORPS XMM0,XMM0
MOVSS XMM1,dword ptr [0x001f25f0]
CALL 0x001075c0
MOV RCX,qword ptr [RBP + -0x20]
CVTSI2SS XMM0,dword ptr [RCX + 0x20]
MOV EAX,dword ptr [RCX + 0x1c]
SUB EAX,dword ptr [RCX + 0x24]
CVTSI2SS XMM1,EAX
CALL 0x001074d0
CALL 0x00107820
MOV EDI,0xde1
XOR ESI,ESI
CALL 0x00107af0
ADD RSP,0x40
POP RBP
RET
|
/* GraphicsState::DrawFrame(unsigned char*, bool) */
void __thiscall GraphicsState::DrawFrame(GraphicsState *this,uchar *param_1,bool param_2)
{
int8 uVar1;
glClearColor(0,0,0,DAT_001f25f0);
glClear(0x4000);
glBindTexture(0xde1,*(int4 *)this);
glTexImage2D(0xde1,0,0x8050,0x140,0xf0,0,0x80e1,0x8366,param_1);
uVar1 = 0x2600;
if (param_2) {
uVar1 = 0x2601;
}
glTexParameteri(0xde1,0x2800,uVar1);
uVar1 = 0x2600;
if (param_2) {
uVar1 = 0x2601;
}
glTexParameteri(0xde1,0x2801,uVar1);
glBegin(7);
glTexCoord2f(0);
glVertex2f((float)*(int *)(this + 0x20),(float)*(int *)(this + 0x24));
glTexCoord2f(DAT_001f25f0,0);
glVertex2f((float)(*(int *)(this + 0x18) - *(int *)(this + 0x20)),(float)*(int *)(this + 0x24));
glTexCoord2f(DAT_001f25f0);
glVertex2f((float)(*(int *)(this + 0x18) - *(int *)(this + 0x20)),
(float)(*(int *)(this + 0x1c) - *(int *)(this + 0x24)));
glTexCoord2f(0,DAT_001f25f0);
glVertex2f((float)*(int *)(this + 0x20),(float)(*(int *)(this + 0x1c) - *(int *)(this + 0x24)));
glEnd();
glBindTexture(0xde1,0);
return;
}
| |
34,251 | GraphicsState::DrawFrame(unsigned char*, bool) | sp1187[P]veesem/src/ui/graphics_state.cc | void GraphicsState::DrawFrame(uint8_t* fb, bool bilinear) {
glClearColor(0, 0, 0, 1);
glClear(GL_COLOR_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, texture_id_);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 320, 240, 0, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, fb);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, bilinear ? GL_LINEAR : GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, bilinear ? GL_LINEAR : GL_NEAREST);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(margin_width_, margin_height_);
glTexCoord2f(1, 0);
glVertex2f(window_width_ - margin_width_, margin_height_);
glTexCoord2f(1, 1);
glVertex2f(window_width_ - margin_width_, window_height_ - margin_height_);
glTexCoord2f(0, 1);
glVertex2f(margin_width_, window_height_ - margin_height_);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
} | O3 | cpp | GraphicsState::DrawFrame(unsigned char*, bool):
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movss 0x87a96(%rip), %xmm3 # 0x91868
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x6140
movl $0x4000, %edi # imm = 0x4000
callq 0x6540
movl (%rbx), %esi
movl $0xde1, %edi # imm = 0xDE1
callq 0x6ad0
subq $0x8, %rsp
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
movl $0x8050, %edx # imm = 0x8050
movl $0x140, %ecx # imm = 0x140
movl $0xf0, %r8d
xorl %r9d, %r9d
pushq %r14
pushq $0x8366 # imm = 0x8366
pushq $0x80e1 # imm = 0x80E1
callq 0x6a40
addq $0x20, %rsp
orl $0x2600, %ebp # imm = 0x2600
movl $0xde1, %edi # imm = 0xDE1
movl $0x2800, %esi # imm = 0x2800
movl %ebp, %edx
callq 0x66f0
movl $0xde1, %edi # imm = 0xDE1
movl $0x2801, %esi # imm = 0x2801
movl %ebp, %edx
callq 0x66f0
movl $0x7, %edi
callq 0x6990
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
callq 0x65c0
xorps %xmm0, %xmm0
cvtsi2ssl 0x20(%rbx), %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x24(%rbx), %xmm1
callq 0x64b0
xorps %xmm1, %xmm1
movss 0x879e2(%rip), %xmm0 # 0x91868
callq 0x65c0
movl 0x18(%rbx), %eax
subl 0x20(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
xorps %xmm1, %xmm1
cvtsi2ssl 0x24(%rbx), %xmm1
callq 0x64b0
movss 0x879bb(%rip), %xmm0 # 0x91868
movaps %xmm0, %xmm1
callq 0x65c0
movl 0x18(%rbx), %eax
subl 0x20(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movl 0x1c(%rbx), %eax
subl 0x24(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
callq 0x64b0
xorps %xmm0, %xmm0
movss 0x87989(%rip), %xmm1 # 0x91868
callq 0x65c0
xorps %xmm0, %xmm0
cvtsi2ssl 0x20(%rbx), %xmm0
movl 0x1c(%rbx), %eax
subl 0x24(%rbx), %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
callq 0x64b0
callq 0x6820
movl $0xde1, %edi # imm = 0xDE1
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x6ad0
nop
| _ZN13GraphicsState9DrawFrameEPhb:
push rbp
push r14
push rbx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
movss xmm3, cs:flt_91868
xorps xmm0, xmm0
xorps xmm1, xmm1
xorps xmm2, xmm2
call _glClearColor
mov edi, 4000h
call _glClear
mov esi, [rbx]
mov edi, 0DE1h
call _glBindTexture
sub rsp, 8
mov edi, 0DE1h
xor esi, esi
mov edx, 8050h
mov ecx, 140h
mov r8d, 0F0h
xor r9d, r9d
push r14
push 8366h
push 80E1h
call _glTexImage2D
add rsp, 20h
or ebp, 2600h
mov edi, 0DE1h
mov esi, 2800h
mov edx, ebp
call _glTexParameteri
mov edi, 0DE1h
mov esi, 2801h
mov edx, ebp
call _glTexParameteri
mov edi, 7
call _glBegin
xorps xmm0, xmm0
xorps xmm1, xmm1
call _glTexCoord2f
xorps xmm0, xmm0
cvtsi2ss xmm0, dword ptr [rbx+20h]
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr [rbx+24h]
call _glVertex2f
xorps xmm1, xmm1
movss xmm0, cs:flt_91868
call _glTexCoord2f
mov eax, [rbx+18h]
sub eax, [rbx+20h]
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr [rbx+24h]
call _glVertex2f
movss xmm0, cs:flt_91868
movaps xmm1, xmm0
call _glTexCoord2f
mov eax, [rbx+18h]
sub eax, [rbx+20h]
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
mov eax, [rbx+1Ch]
sub eax, [rbx+24h]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
call _glVertex2f
xorps xmm0, xmm0
movss xmm1, cs:flt_91868
call _glTexCoord2f
xorps xmm0, xmm0
cvtsi2ss xmm0, dword ptr [rbx+20h]
mov eax, [rbx+1Ch]
sub eax, [rbx+24h]
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
call _glVertex2f
call _glEnd
mov edi, 0DE1h
xor esi, esi
pop rbx
pop r14
pop rbp
jmp _glBindTexture
| long long GraphicsState::DrawFrame(GraphicsState *this, unsigned __int8 *a2, unsigned int a3)
{
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(0x4000LL);
glBindTexture(3553LL, *(unsigned int *)this);
glTexImage2D(3553LL, 0LL, 32848LL, 320LL, 240LL, 0LL, 32993LL, 33638LL, a2);
a3 |= 0x2600u;
glTexParameteri(3553LL, 10240LL, a3);
glTexParameteri(3553LL, 10241LL, a3);
glBegin(7LL);
glTexCoord2f(0.0, 0.0);
glVertex2f((float)*((int *)this + 8), (float)*((int *)this + 9));
glTexCoord2f(COERCE_DOUBLE(1065353216LL), 0.0);
glVertex2f((float)(*((_DWORD *)this + 6) - *((_DWORD *)this + 8)), (float)*((int *)this + 9));
glTexCoord2f(COERCE_DOUBLE(1065353216LL), COERCE_DOUBLE(1065353216LL));
glVertex2f(
(float)(*((_DWORD *)this + 6) - *((_DWORD *)this + 8)),
(float)(*((_DWORD *)this + 7) - *((_DWORD *)this + 9)));
glTexCoord2f(0.0, COERCE_DOUBLE(1065353216LL));
glVertex2f((float)*((int *)this + 8), (float)(*((_DWORD *)this + 7) - *((_DWORD *)this + 9)));
glEnd();
return glBindTexture(3553LL, 0LL);
}
| DrawFrame:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOVSS XMM3,dword ptr [0x00191868]
XORPS XMM0,XMM0
XORPS XMM1,XMM1
XORPS XMM2,XMM2
CALL 0x00106140
MOV EDI,0x4000
CALL 0x00106540
MOV ESI,dword ptr [RBX]
MOV EDI,0xde1
CALL 0x00106ad0
SUB RSP,0x8
MOV EDI,0xde1
XOR ESI,ESI
MOV EDX,0x8050
MOV ECX,0x140
MOV R8D,0xf0
XOR R9D,R9D
PUSH R14
PUSH 0x8366
PUSH 0x80e1
CALL 0x00106a40
ADD RSP,0x20
OR EBP,0x2600
MOV EDI,0xde1
MOV ESI,0x2800
MOV EDX,EBP
CALL 0x001066f0
MOV EDI,0xde1
MOV ESI,0x2801
MOV EDX,EBP
CALL 0x001066f0
MOV EDI,0x7
CALL 0x00106990
XORPS XMM0,XMM0
XORPS XMM1,XMM1
CALL 0x001065c0
XORPS XMM0,XMM0
CVTSI2SS XMM0,dword ptr [RBX + 0x20]
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [RBX + 0x24]
CALL 0x001064b0
XORPS XMM1,XMM1
MOVSS XMM0,dword ptr [0x00191868]
CALL 0x001065c0
MOV EAX,dword ptr [RBX + 0x18]
SUB EAX,dword ptr [RBX + 0x20]
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [RBX + 0x24]
CALL 0x001064b0
MOVSS XMM0,dword ptr [0x00191868]
MOVAPS XMM1,XMM0
CALL 0x001065c0
MOV EAX,dword ptr [RBX + 0x18]
SUB EAX,dword ptr [RBX + 0x20]
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
MOV EAX,dword ptr [RBX + 0x1c]
SUB EAX,dword ptr [RBX + 0x24]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
CALL 0x001064b0
XORPS XMM0,XMM0
MOVSS XMM1,dword ptr [0x00191868]
CALL 0x001065c0
XORPS XMM0,XMM0
CVTSI2SS XMM0,dword ptr [RBX + 0x20]
MOV EAX,dword ptr [RBX + 0x1c]
SUB EAX,dword ptr [RBX + 0x24]
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
CALL 0x001064b0
CALL 0x00106820
MOV EDI,0xde1
XOR ESI,ESI
POP RBX
POP R14
POP RBP
JMP 0x00106ad0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* GraphicsState::DrawFrame(unsigned char*, bool) */
void __thiscall GraphicsState::DrawFrame(GraphicsState *this,uchar *param_1,bool param_2)
{
int7 in_register_00000011;
uint uVar1;
glClearColor(0,0,0,_DAT_00191868);
glClear(0x4000);
glBindTexture(0xde1,*(int4 *)this);
glTexImage2D(0xde1,0,0x8050,0x140,0xf0,0,0x80e1,0x8366,param_1);
uVar1 = (uint)CONCAT71(in_register_00000011,param_2) | 0x2600;
glTexParameteri(0xde1,0x2800,uVar1);
glTexParameteri(0xde1,0x2801,uVar1);
glBegin(7);
glTexCoord2f(0,0);
glVertex2f((float)*(int *)(this + 0x20),(float)*(int *)(this + 0x24));
glTexCoord2f(_DAT_00191868,0);
glVertex2f((float)(*(int *)(this + 0x18) - *(int *)(this + 0x20)),(float)*(int *)(this + 0x24));
glTexCoord2f(_DAT_00191868,_DAT_00191868);
glVertex2f((float)(*(int *)(this + 0x18) - *(int *)(this + 0x20)),
(float)(*(int *)(this + 0x1c) - *(int *)(this + 0x24)));
glTexCoord2f(0,_DAT_00191868);
glVertex2f((float)*(int *)(this + 0x20),(float)(*(int *)(this + 0x1c) - *(int *)(this + 0x24)));
glEnd();
glBindTexture(0xde1,0);
return;
}
| |
34,252 | ma_flush_table_files | eloqsql/storage/maria/ma_extra.c | int _ma_flush_table_files(MARIA_HA *info, uint flush_data_or_index,
enum flush_type flush_type_for_data,
enum flush_type flush_type_for_index)
{
int error= 0;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_flush_table_files");
/* flush data file first because it's more critical */
if (flush_data_or_index & MARIA_FLUSH_DATA)
{
if ((info->opt_flag & WRITE_CACHE_USED) &&
flush_type_for_data != FLUSH_IGNORE_CHANGED &&
flush_io_cache(&info->rec_cache))
error= 1;
if (share->data_file_type == BLOCK_RECORD)
{
if (flush_type_for_data != FLUSH_IGNORE_CHANGED)
{
if (_ma_bitmap_flush(share))
error= 1;
}
else
{
mysql_mutex_lock(&share->bitmap.bitmap_lock);
share->bitmap.changed= 0;
share->bitmap.changed_not_flushed= 0;
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
}
if (flush_pagecache_blocks(share->pagecache, &info->dfile,
flush_type_for_data))
error= 1;
}
}
if ((flush_data_or_index & MARIA_FLUSH_INDEX) &&
flush_pagecache_blocks(share->pagecache, &share->kfile,
flush_type_for_index))
error= 1;
if (!error)
DBUG_RETURN(0);
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(1);
} | O0 | c | ma_flush_table_files:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x32cf2
movq -0x10(%rbp), %rax
movl 0x61c(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x32c3f
cmpl $0x2, -0x18(%rbp)
je 0x32c3f
movq -0x10(%rbp), %rdi
addq $0x4b8, %rdi # imm = 0x4B8
movl $0x1, %esi
callq 0xe0bb0
cmpl $0x0, %eax
je 0x32c3f
movl $0x1, -0x20(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x3, 0x7d0(%rax)
jne 0x32cf0
cmpl $0x2, -0x18(%rbp)
je 0x32c6c
movq -0x28(%rbp), %rdi
callq 0x41ab0
cmpb $0x0, %al
je 0x32c6a
movl $0x1, -0x20(%rbp)
jmp 0x32cbc
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0x11e7f9(%rip), %rsi # 0x15147e
movl $0x28c, %edx # imm = 0x28C
callq 0x32b00
movq -0x28(%rbp), %rax
movb $0x0, 0xa30(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0xa31(%rax)
movq -0x28(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x32b70
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2f780
cmpl $0x0, %eax
je 0x32cee
movl $0x1, -0x20(%rbp)
jmp 0x32cf0
jmp 0x32cf2
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x32d2f
movq -0x28(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2f780
cmpl $0x0, %eax
je 0x32d2f
movl $0x1, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x32d40
jmp 0x32d37
movl $0x0, -0x4(%rbp)
jmp 0x32d55
movq -0x10(%rbp), %rdi
movl $0x7e, %esi
callq 0x33880
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| _ma_flush_table_files:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov [rbp+var_20], 0
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
mov eax, [rbp+var_14]
and eax, 1
cmp eax, 0
jz loc_32CF2
mov rax, [rbp+var_10]
mov eax, [rax+61Ch]
and eax, 10h
cmp eax, 0
jz short loc_32C3F
cmp [rbp+var_18], 2
jz short loc_32C3F
mov rdi, [rbp+var_10]
add rdi, 4B8h
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_32C3F
mov [rbp+var_20], 1
loc_32C3F:
mov rax, [rbp+var_28]
cmp dword ptr [rax+7D0h], 3
jnz loc_32CF0
cmp [rbp+var_18], 2
jz short loc_32C6C
mov rdi, [rbp+var_28]
call _ma_bitmap_flush
cmp al, 0
jz short loc_32C6A
mov [rbp+var_20], 1
loc_32C6A:
jmp short loc_32CBC
loc_32C6C:
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 28Ch
call inline_mysql_mutex_lock_0
mov rax, [rbp+var_28]
mov byte ptr [rax+0A30h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+0A31h], 0
mov rdi, [rbp+var_28]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_0
loc_32CBC:
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov edx, [rbp+var_18]
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_32CEE
mov [rbp+var_20], 1
loc_32CEE:
jmp short $+2
loc_32CF0:
jmp short $+2
loc_32CF2:
mov eax, [rbp+var_14]
and eax, 2
cmp eax, 0
jz short loc_32D2F
mov rax, [rbp+var_28]
mov rdi, [rax+600h]
mov rsi, [rbp+var_28]
add rsi, 750h
mov edx, [rbp+var_1C]
xor eax, eax
mov r8d, eax
mov rcx, r8
call flush_pagecache_blocks_with_filter
cmp eax, 0
jz short loc_32D2F
mov [rbp+var_20], 1
loc_32D2F:
cmp [rbp+var_20], 0
jnz short loc_32D40
jmp short $+2
loc_32D37:
mov [rbp+var_4], 0
jmp short loc_32D55
loc_32D40:
mov rdi, [rbp+var_10]
mov esi, 7Eh ; '~'
call _ma_set_fatal_error
mov [rbp+var_4], 1
loc_32D55:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long ma_flush_table_files(long long *a1, char a2, unsigned int a3, unsigned int a4)
{
long long v5; // [rsp+8h] [rbp-28h]
BOOL v6; // [rsp+10h] [rbp-20h]
v6 = 0;
v5 = *a1;
if ( (a2 & 1) != 0 )
{
if ( (*((_DWORD *)a1 + 391) & 0x10) != 0 && a3 != 2 )
v6 = my_b_flush_io_cache(a1 + 151, 1LL) != 0;
if ( *(_DWORD *)(v5 + 2000) == 3 )
{
if ( a3 == 2 )
{
inline_mysql_mutex_lock_0(
v5 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c",
0x28Cu);
*(_BYTE *)(v5 + 2608) = 0;
*(_BYTE *)(v5 + 2609) = 0;
inline_mysql_mutex_unlock_0(v5 + 2712);
}
else if ( (unsigned __int8)ma_bitmap_flush(v5) )
{
v6 = 1;
}
if ( (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(v5 + 1536), (long long)(a1 + 142), a3, 0LL, 0LL) )
v6 = 1;
}
}
if ( (a2 & 2) != 0
&& (unsigned int)flush_pagecache_blocks_with_filter(*(_QWORD *)(v5 + 1536), v5 + 1872, a4, 0LL, 0LL) )
{
v6 = 1;
}
if ( v6 )
{
ma_set_fatal_error(a1, 126LL);
return 1;
}
else
{
return 0;
}
}
| _ma_flush_table_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00132cf2
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x61c]
AND EAX,0x10
CMP EAX,0x0
JZ 0x00132c3f
CMP dword ptr [RBP + -0x18],0x2
JZ 0x00132c3f
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x4b8
MOV ESI,0x1
CALL 0x001e0bb0
CMP EAX,0x0
JZ 0x00132c3f
MOV dword ptr [RBP + -0x20],0x1
LAB_00132c3f:
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX + 0x7d0],0x3
JNZ 0x00132cf0
CMP dword ptr [RBP + -0x18],0x2
JZ 0x00132c6c
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00141ab0
CMP AL,0x0
JZ 0x00132c6a
MOV dword ptr [RBP + -0x20],0x1
LAB_00132c6a:
JMP 0x00132cbc
LAB_00132c6c:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x25147e]
MOV EDX,0x28c
CALL 0x00132b00
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xa30],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xa31],0x0
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00132b70
LAB_00132cbc:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV EDX,dword ptr [RBP + -0x18]
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0012f780
CMP EAX,0x0
JZ 0x00132cee
MOV dword ptr [RBP + -0x20],0x1
LAB_00132cee:
JMP 0x00132cf0
LAB_00132cf0:
JMP 0x00132cf2
LAB_00132cf2:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00132d2f
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x750
MOV EDX,dword ptr [RBP + -0x1c]
XOR EAX,EAX
MOV R8D,EAX
MOV RCX,R8
CALL 0x0012f780
CMP EAX,0x0
JZ 0x00132d2f
MOV dword ptr [RBP + -0x20],0x1
LAB_00132d2f:
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x00132d40
JMP 0x00132d37
LAB_00132d37:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00132d55
LAB_00132d40:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7e
CALL 0x00133880
MOV dword ptr [RBP + -0x4],0x1
LAB_00132d55:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
bool _ma_flush_table_files(long *param_1,uint param_2,int param_3,int4 param_4)
{
long lVar1;
bool bVar2;
char cVar3;
int iVar4;
bVar2 = false;
lVar1 = *param_1;
if ((param_2 & 1) != 0) {
if ((((*(uint *)((long)param_1 + 0x61c) & 0x10) != 0) && (param_3 != 2)) &&
(iVar4 = my_b_flush_io_cache(param_1 + 0x97,1), iVar4 != 0)) {
bVar2 = true;
}
if (*(int *)(lVar1 + 2000) == 3) {
if (param_3 == 2) {
inline_mysql_mutex_lock
(lVar1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_extra.c"
,0x28c);
*(int1 *)(lVar1 + 0xa30) = 0;
*(int1 *)(lVar1 + 0xa31) = 0;
inline_mysql_mutex_unlock(lVar1 + 0xa98);
}
else {
cVar3 = _ma_bitmap_flush(lVar1);
if (cVar3 != '\0') {
bVar2 = true;
}
}
iVar4 = flush_pagecache_blocks_with_filter
(*(int8 *)(lVar1 + 0x600),param_1 + 0x8e,param_3,0);
if (iVar4 != 0) {
bVar2 = true;
}
}
}
if (((param_2 & 2) != 0) &&
(iVar4 = flush_pagecache_blocks_with_filter
(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,param_4,0), iVar4 != 0)) {
bVar2 = true;
}
if (bVar2) {
_ma_set_fatal_error(param_1,0x7e);
}
return bVar2;
}
| |
34,253 | common_kv_cache_dump_view(llama_kv_cache_view const&, int) | monkey531[P]llama/common/common.cpp | void common_kv_cache_dump_view(const llama_kv_cache_view & view, int row_size) {
static const char slot_chars[] = ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+";
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d",
view.n_cells, view.n_seq_max, view.used_cells, view.token_count, view.max_contiguous, view.max_contiguous_idx);
llama_kv_cache_view_cell * c_curr = view.cells;
llama_seq_id * cs_curr = view.cells_sequences;
for (int i = 0; i < view.n_cells; i++, c_curr++, cs_curr += view.n_seq_max) {
if (i % row_size == 0) {
printf("\n%5d: ", i);
}
int seq_count = 0;
for (int j = 0; j < view.n_seq_max; j++) {
if (cs_curr[j] >= 0) { seq_count++; }
}
putchar(slot_chars[std::min(sizeof(slot_chars) - 2, size_t(seq_count))]);
}
printf("\n=== Done dumping\n");
} | O2 | cpp | common_kv_cache_dump_view(llama_kv_cache_view const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %esi
movl 0x4(%rdi), %edx
movl 0xc(%rdi), %ecx
movl 0x8(%rdi), %r8d
movl 0x10(%rdi), %r9d
movl 0x14(%rdi), %eax
movl %eax, (%rsp)
leaq 0x5b31b(%rip), %rdi # 0xb246b
xorl %eax, %eax
callq 0x23060
movq 0x20(%r14), %r12
pushq $0x3e
popq %r13
leaq 0x5d84a(%rip), %r15 # 0xb49b0
xorl %ebp, %ebp
cmpl (%r14), %ebp
jge 0x571c5
movl %ebp, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x57186
leaq 0x5b378(%rip), %rdi # 0xb24f5
movl %ebp, %esi
xorl %eax, %eax
callq 0x23060
movl 0x4(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rcx, %rax
je 0x571a8
movl (%r12,%rcx,4), %esi
notl %esi
shrl $0x1f, %esi
addl %esi, %edx
incq %rcx
jmp 0x57193
cmpl $0x3e, %edx
cmovael %r13d, %edx
movsbl (%rdx,%r15), %edi
callq 0x23c50
incl %ebp
movslq 0x4(%r14), %rax
leaq (%r12,%rax,4), %r12
jmp 0x57168
leaq 0x5d7d1(%rip), %rdi # 0xb499d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x23d80
| _Z25common_kv_cache_dump_viewRK19llama_kv_cache_viewi:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebx, esi
mov r14, rdi
mov esi, [rdi]
mov edx, [rdi+4]
mov ecx, [rdi+0Ch]
mov r8d, [rdi+8]
mov r9d, [rdi+10h]
mov eax, [rdi+14h]
mov [rsp+38h+var_38], eax
lea rdi, aDumpingKvCache; "=== Dumping KV cache. total cells %d, m"...
xor eax, eax
call _printf
mov r12, [r14+20h]
push 3Eh ; '>'
pop r13
lea r15, _ZZ25common_kv_cache_dump_viewRK19llama_kv_cache_viewiE10slot_chars; ".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc"...
xor ebp, ebp
loc_57168:
cmp ebp, [r14]
jge short loc_571C5
mov eax, ebp
cdq
idiv ebx
test edx, edx
jnz short loc_57186
lea rdi, a5d; "\n%5d: "
mov esi, ebp
xor eax, eax
call _printf
loc_57186:
mov eax, [r14+4]
xor ecx, ecx
test eax, eax
cmovle eax, ecx
xor edx, edx
loc_57193:
cmp rax, rcx
jz short loc_571A8
mov esi, [r12+rcx*4]
not esi
shr esi, 1Fh
add edx, esi
inc rcx
jmp short loc_57193
loc_571A8:
cmp edx, 3Eh ; '>'
cmovnb edx, r13d
movsx edi, byte ptr [rdx+r15]
call _putchar
inc ebp
movsxd rax, dword ptr [r14+4]
lea r12, [r12+rax*4]
jmp short loc_57168
loc_571C5:
lea rdi, aDoneDumping; "\n=== Done dumping"
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _puts
| long long common_kv_cache_dump_view(long long a1, int a2)
{
long long v2; // r12
int i; // ebp
long long v4; // rax
long long v5; // rcx
long long v6; // rdx
printf(
"=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, large"
"st empty slot=%d @ %d",
*(_DWORD *)a1,
*(_DWORD *)(a1 + 4),
*(_DWORD *)(a1 + 12),
*(_DWORD *)(a1 + 8),
*(_DWORD *)(a1 + 16),
*(_DWORD *)(a1 + 20));
v2 = *(_QWORD *)(a1 + 32);
for ( i = 0; i < *(_DWORD *)a1; ++i )
{
if ( !(i % a2) )
printf("\n%5d: ", i);
v4 = *(unsigned int *)(a1 + 4);
v5 = 0LL;
if ( (int)v4 <= 0 )
v4 = 0LL;
v6 = 0LL;
while ( v4 != v5 )
v6 = (*(_DWORD *)(v2 + 4 * v5++) >= 0) + (unsigned int)v6;
if ( (unsigned int)v6 >= 0x3E )
v6 = 62LL;
putchar((unsigned int)common_kv_cache_dump_view(llama_kv_cache_view const&,int)::slot_chars[v6]);
v2 += 4LL * *(int *)(a1 + 4);
}
return puts("\n=== Done dumping");
}
| common_kv_cache_dump_view:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
MOV ESI,dword ptr [RDI]
MOV EDX,dword ptr [RDI + 0x4]
MOV ECX,dword ptr [RDI + 0xc]
MOV R8D,dword ptr [RDI + 0x8]
MOV R9D,dword ptr [RDI + 0x10]
MOV EAX,dword ptr [RDI + 0x14]
MOV dword ptr [RSP],EAX
LEA RDI,[0x1b246b]
XOR EAX,EAX
CALL 0x00123060
MOV R12,qword ptr [R14 + 0x20]
PUSH 0x3e
POP R13
LEA R15,[0x1b49b0]
XOR EBP,EBP
LAB_00157168:
CMP EBP,dword ptr [R14]
JGE 0x001571c5
MOV EAX,EBP
CDQ
IDIV EBX
TEST EDX,EDX
JNZ 0x00157186
LEA RDI,[0x1b24f5]
MOV ESI,EBP
XOR EAX,EAX
CALL 0x00123060
LAB_00157186:
MOV EAX,dword ptr [R14 + 0x4]
XOR ECX,ECX
TEST EAX,EAX
CMOVLE EAX,ECX
XOR EDX,EDX
LAB_00157193:
CMP RAX,RCX
JZ 0x001571a8
MOV ESI,dword ptr [R12 + RCX*0x4]
NOT ESI
SHR ESI,0x1f
ADD EDX,ESI
INC RCX
JMP 0x00157193
LAB_001571a8:
CMP EDX,0x3e
CMOVNC EDX,R13D
MOVSX EDI,byte ptr [RDX + R15*0x1]
CALL 0x00123c50
INC EBP
MOVSXD RAX,dword ptr [R14 + 0x4]
LEA R12,[R12 + RAX*0x4]
JMP 0x00157168
LAB_001571c5:
LEA RDI,[0x1b499d]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00123d80
|
/* common_kv_cache_dump_view(llama_kv_cache_view const&, int) */
void common_kv_cache_dump_view(llama_kv_cache_view *param_1,int param_2)
{
int8 in_RAX;
ulong uVar1;
uint uVar2;
ulong uVar3;
uint uVar4;
long lVar5;
printf("=== Dumping KV cache. total cells %d, max sequences per cell %d, populated cells %d, total tokens in cache %d, largest empty slot=%d @ %d"
,(ulong)*(uint *)param_1,(ulong)*(uint *)(param_1 + 4),(ulong)*(uint *)(param_1 + 0xc),
(ulong)*(uint *)(param_1 + 8),(ulong)*(uint *)(param_1 + 0x10),
CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(param_1 + 0x14)));
lVar5 = *(long *)(param_1 + 0x20);
for (uVar4 = 0; (int)uVar4 < *(int *)param_1; uVar4 = uVar4 + 1) {
if ((int)uVar4 % param_2 == 0) {
printf("\n%5d: ",(ulong)uVar4);
}
uVar1 = 0;
uVar3 = (ulong)*(uint *)(param_1 + 4);
if ((int)*(uint *)(param_1 + 4) < 1) {
uVar3 = uVar1;
}
uVar2 = 0;
for (; uVar3 != uVar1; uVar1 = uVar1 + 1) {
uVar2 = uVar2 - ((int)~*(uint *)(lVar5 + uVar1 * 4) >> 0x1f);
}
uVar3 = (ulong)uVar2;
if (0x3d < uVar2) {
uVar3 = 0x3e;
}
putchar((int)".123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+"[uVar3]);
lVar5 = lVar5 + (long)*(int *)(param_1 + 4) * 4;
}
puts("\n=== Done dumping");
return;
}
| |
34,254 | codegen_generate_begin | tsotchke[P]eshkol/src/backend/codegen/blocks.c | bool codegen_generate_begin(CodegenContext* context, const AstNode* node) {
assert(context != NULL);
assert(node != NULL);
assert(node->type == AST_BEGIN);
// Get output file
FILE* output = codegen_context_get_output(context);
// Generate code
fprintf(output, "({ ");
// Generate expressions
for (size_t i = 0; i < node->as.begin.expr_count; i++) {
if (i > 0) {
fprintf(output, "; ");
}
// Generate expression
if (!codegen_generate_expression(context, node->as.begin.exprs[i])) {
return false;
}
}
// Close begin
fprintf(output, "; })");
return true;
} | O2 | c | codegen_generate_begin:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12141
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1215a
cmpl $0xa, (%rbx)
jne 0x12173
movq %rdi, %r14
callq 0xa5d5
movq %rax, %r15
leaq 0xb04c(%rip), %rdi # 0x1d10f
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rcx
callq 0x22c0
xorl %ecx, %ecx
pushq $0x2
popq %rbp
movq %rcx, %r12
movq 0x50(%rbx), %r13
cmpq %r13, %rcx
jae 0x12117
testq %r12, %r12
je 0x120fc
leaq 0xc349(%rip), %rdi # 0x1e437
movq %rbp, %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x22c0
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
callq 0xf7f8
leaq 0x1(%r12), %rcx
testb %al, %al
jne 0x120d6
jmp 0x1212c
leaq 0xc4a1(%rip), %rdi # 0x1e5bf
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x22c0
cmpq %r13, %r12
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c17(%rip), %rdi # 0x17d5f
leaq 0xc8eb(%rip), %rsi # 0x1ea3a
leaq 0xc93b(%rip), %rcx # 0x1ea91
pushq $0x12
jmp 0x1218a
leaq 0x776e(%rip), %rdi # 0x198cf
leaq 0xc8d2(%rip), %rsi # 0x1ea3a
leaq 0xc922(%rip), %rcx # 0x1ea91
pushq $0x13
jmp 0x1218a
leaq 0xc957(%rip), %rdi # 0x1ead1
leaq 0xc8b9(%rip), %rsi # 0x1ea3a
leaq 0xc909(%rip), %rcx # 0x1ea91
pushq $0x14
popq %rdx
callq 0x2180
| codegen_generate_begin:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
test rdi, rdi
jz loc_12141
mov rbx, rsi
test rsi, rsi
jz loc_1215A
cmp dword ptr [rbx], 0Ah
jnz loc_12173
mov r14, rdi
call codegen_context_get_output
mov r15, rax
lea rdi, asc_1D10F; "({ "
push 3
pop rsi
push 1
pop rdx
mov rcx, rax
call _fwrite
xor ecx, ecx
push 2
pop rbp
loc_120D6:
mov r12, rcx
mov r13, [rbx+50h]
cmp rcx, r13
jnb short loc_12117
test r12, r12
jz short loc_120FC
lea rdi, aCharBuffer1024+19h; "; "
mov rsi, rbp
push 1
pop rdx
mov rcx, r15
call _fwrite
loc_120FC:
mov rax, [rbx+48h]
mov rsi, [rax+r12*8]
mov rdi, r14
call codegen_generate_expression
lea rcx, [r12+1]
test al, al
jnz short loc_120D6
jmp short loc_1212C
loc_12117:
lea rdi, aVectorFGetComp_0+4Eh; "; })"
push 4
pop rsi
push 1
pop rdx
mov rcx, r15
call _fwrite
loc_1212C:
cmp r12, r13
setnb al
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_12141:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_21; "_Bool codegen_generate_begin(CodegenCon"...
push 12h
jmp short loc_1218A
loc_1215A:
lea rdi, aNodeNull; "node != NULL"
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_21; "_Bool codegen_generate_begin(CodegenCon"...
push 13h
jmp short loc_1218A
loc_12173:
lea rdi, aNodeTypeAstBeg; "node->type == AST_BEGIN"
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_21; "_Bool codegen_generate_begin(CodegenCon"...
push 14h
loc_1218A:
pop rdx
call ___assert_fail
| bool codegen_generate_begin(long long a1, long long a2)
{
long long output; // r15
unsigned long long v3; // rcx
unsigned long long v4; // r12
unsigned long long v5; // r13
char expression; // al
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c",
18LL,
"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
if ( !a2 )
__assert_fail(
"node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c",
19LL,
"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
if ( *(_DWORD *)a2 != 10 )
__assert_fail(
"node->type == AST_BEGIN",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c",
20LL,
"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
output = codegen_context_get_output(a1);
fwrite("({ ", 3LL, 1LL, output);
v3 = 0LL;
while ( 1 )
{
v4 = v3;
v5 = *(_QWORD *)(a2 + 80);
if ( v3 >= v5 )
break;
if ( v3 )
fwrite("; ", 2LL, 1LL, output);
expression = codegen_generate_expression(a1, *(_DWORD **)(*(_QWORD *)(a2 + 72) + 8 * v4));
v3 = v4 + 1;
if ( !expression )
return v4 >= v5;
}
fwrite("; })", 4LL, 1LL, output);
return v4 >= v5;
}
| codegen_generate_begin:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x00112141
MOV RBX,RSI
TEST RSI,RSI
JZ 0x0011215a
CMP dword ptr [RBX],0xa
JNZ 0x00112173
MOV R14,RDI
CALL 0x0010a5d5
MOV R15,RAX
LEA RDI,[0x11d10f]
PUSH 0x3
POP RSI
PUSH 0x1
POP RDX
MOV RCX,RAX
CALL 0x001022c0
XOR ECX,ECX
PUSH 0x2
POP RBP
LAB_001120d6:
MOV R12,RCX
MOV R13,qword ptr [RBX + 0x50]
CMP RCX,R13
JNC 0x00112117
TEST R12,R12
JZ 0x001120fc
LEA RDI,[0x11e437]
MOV RSI,RBP
PUSH 0x1
POP RDX
MOV RCX,R15
CALL 0x001022c0
LAB_001120fc:
MOV RAX,qword ptr [RBX + 0x48]
MOV RSI,qword ptr [RAX + R12*0x8]
MOV RDI,R14
CALL 0x0010f7f8
LEA RCX,[R12 + 0x1]
TEST AL,AL
JNZ 0x001120d6
JMP 0x0011212c
LAB_00112117:
LEA RDI,[0x11e5bf]
PUSH 0x4
POP RSI
PUSH 0x1
POP RDX
MOV RCX,R15
CALL 0x001022c0
LAB_0011212c:
CMP R12,R13
SETNC AL
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00112141:
LEA RDI,[0x117d5f]
LEA RSI,[0x11ea3a]
LEA RCX,[0x11ea91]
PUSH 0x12
JMP 0x0011218a
LAB_0011215a:
LEA RDI,[0x1198cf]
LEA RSI,[0x11ea3a]
LEA RCX,[0x11ea91]
PUSH 0x13
JMP 0x0011218a
LAB_00112173:
LEA RDI,[0x11ead1]
LEA RSI,[0x11ea3a]
LEA RCX,[0x11ea91]
PUSH 0x14
LAB_0011218a:
POP RDX
CALL 0x00102180
|
bool codegen_generate_begin(long param_1,int *param_2)
{
ulong uVar1;
uint __line;
ulong uVar2;
char cVar3;
FILE *__s;
ulong uVar4;
char *__assertion;
if (param_1 == 0) {
__assertion = "context != NULL";
__line = 0x12;
}
else if (param_2 == (int *)0x0) {
__assertion = "node != NULL";
__line = 0x13;
}
else {
if (*param_2 == 10) {
__s = (FILE *)codegen_context_get_output();
fwrite(&DAT_0011d10f,3,1,__s);
uVar2 = 0;
do {
uVar4 = uVar2;
uVar1 = *(ulong *)(param_2 + 0x14);
if (uVar1 <= uVar4) {
fwrite("; })",4,1,__s);
break;
}
if (uVar4 != 0) {
fwrite("; ",2,1,__s);
}
cVar3 = codegen_generate_expression
(param_1,*(int8 *)(*(long *)(param_2 + 0x12) + uVar4 * 8));
uVar2 = uVar4 + 1;
} while (cVar3 != '\0');
return uVar1 <= uVar4;
}
__assertion = "node->type == AST_BEGIN";
__line = 0x14;
}
/* WARNING: Subroutine does not return */
__assert_fail(__assertion,
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c"
,__line,"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
}
| |
34,255 | codegen_generate_begin | tsotchke[P]eshkol/src/backend/codegen/blocks.c | bool codegen_generate_begin(CodegenContext* context, const AstNode* node) {
assert(context != NULL);
assert(node != NULL);
assert(node->type == AST_BEGIN);
// Get output file
FILE* output = codegen_context_get_output(context);
// Generate code
fprintf(output, "({ ");
// Generate expressions
for (size_t i = 0; i < node->as.begin.expr_count; i++) {
if (i > 0) {
fprintf(output, "; ");
}
// Generate expression
if (!codegen_generate_expression(context, node->as.begin.exprs[i])) {
return false;
}
}
// Close begin
fprintf(output, "; })");
return true;
} | O3 | c | codegen_generate_begin:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x13a1c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x13a3b
cmpl $0xa, (%rbx)
jne 0x13a5a
movq %rdi, %r14
callq 0xb394
movq %rax, %r15
leaq 0xb710(%rip), %rdi # 0x1f0a9
movl $0x3, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x22c0
cmpq $0x0, 0x50(%rbx)
je 0x139f3
xorl %r13d, %r13d
leaq 0xca13(%rip), %r12 # 0x203cf
testq %r13, %r13
je 0x139d6
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x22c0
movq 0x48(%rbx), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
callq 0x10f0c
testb %al, %al
je 0x13a10
incq %r13
cmpq 0x50(%rbx), %r13
jb 0x139bc
leaq 0xcb5d(%rip), %rdi # 0x20557
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x22c0
movb $0x1, %al
jmp 0x13a12
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x633c(%rip), %rdi # 0x19d5f
leaq 0xcfa8(%rip), %rsi # 0x209d2
leaq 0xcff8(%rip), %rcx # 0x20a29
movl $0x12, %edx
callq 0x2180
leaq 0x7e8d(%rip), %rdi # 0x1b8cf
leaq 0xcf89(%rip), %rsi # 0x209d2
leaq 0xcfd9(%rip), %rcx # 0x20a29
movl $0x13, %edx
callq 0x2180
leaq 0xd008(%rip), %rdi # 0x20a69
leaq 0xcf6a(%rip), %rsi # 0x209d2
leaq 0xcfba(%rip), %rcx # 0x20a29
movl $0x14, %edx
callq 0x2180
| codegen_generate_begin:
push r15
push r14
push r13
push r12
push rbx
test rdi, rdi
jz loc_13A1C
mov rbx, rsi
test rsi, rsi
jz loc_13A3B
cmp dword ptr [rbx], 0Ah
jnz loc_13A5A
mov r14, rdi
call codegen_context_get_output
mov r15, rax
lea rdi, asc_1F0A9; "({ "
mov esi, 3
mov edx, 1
mov rcx, rax
call _fwrite
cmp qword ptr [rbx+50h], 0
jz short loc_139F3
xor r13d, r13d
lea r12, aCharBuffer1024+19h; "; "
loc_139BC:
test r13, r13
jz short loc_139D6
mov esi, 2
mov edx, 1
mov rdi, r12
mov rcx, r15
call _fwrite
loc_139D6:
mov rax, [rbx+48h]
mov rsi, [rax+r13*8]
mov rdi, r14
call codegen_generate_expression
test al, al
jz short loc_13A10
inc r13
cmp r13, [rbx+50h]
jb short loc_139BC
loc_139F3:
lea rdi, aVectorFGetComp_0+4Eh; "; })"
mov esi, 4
mov edx, 1
mov rcx, r15
call _fwrite
mov al, 1
jmp short loc_13A12
loc_13A10:
xor eax, eax
loc_13A12:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_13A1C:
lea rdi, aContextNull; "context != NULL"
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_21; "_Bool codegen_generate_begin(CodegenCon"...
mov edx, 12h
call ___assert_fail
loc_13A3B:
lea rdi, aNodeNull; "node != NULL"
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_21; "_Bool codegen_generate_begin(CodegenCon"...
mov edx, 13h
call ___assert_fail
loc_13A5A:
lea rdi, aNodeTypeAstBeg; "node->type == AST_BEGIN"
lea rsi, aWorkspaceLlm4b_20; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aBoolCodegenGen_21; "_Bool codegen_generate_begin(CodegenCon"...
mov edx, 14h
call ___assert_fail
| char codegen_generate_begin(long long a1, long long a2)
{
long long output; // r15
long long v3; // r13
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c",
18LL,
"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
if ( !a2 )
__assert_fail(
"node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c",
19LL,
"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
if ( *(_DWORD *)a2 != 10 )
__assert_fail(
"node->type == AST_BEGIN",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c",
20LL,
"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
output = codegen_context_get_output(a1);
fwrite("({ ", 3LL, 1LL, output);
if ( *(_QWORD *)(a2 + 80) )
{
v3 = 0LL;
while ( 1 )
{
if ( v3 )
fwrite("; ", 2LL, 1LL, output);
if ( !(unsigned __int8)codegen_generate_expression(a1, *(_DWORD **)(*(_QWORD *)(a2 + 72) + 8 * v3)) )
return 0;
if ( (unsigned long long)++v3 >= *(_QWORD *)(a2 + 80) )
goto LABEL_10;
}
}
else
{
LABEL_10:
fwrite("; })", 4LL, 1LL, output);
return 1;
}
}
| codegen_generate_begin:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
TEST RDI,RDI
JZ 0x00113a1c
MOV RBX,RSI
TEST RSI,RSI
JZ 0x00113a3b
CMP dword ptr [RBX],0xa
JNZ 0x00113a5a
MOV R14,RDI
CALL 0x0010b394
MOV R15,RAX
LEA RDI,[0x11f0a9]
MOV ESI,0x3
MOV EDX,0x1
MOV RCX,RAX
CALL 0x001022c0
CMP qword ptr [RBX + 0x50],0x0
JZ 0x001139f3
XOR R13D,R13D
LEA R12,[0x1203cf]
LAB_001139bc:
TEST R13,R13
JZ 0x001139d6
MOV ESI,0x2
MOV EDX,0x1
MOV RDI,R12
MOV RCX,R15
CALL 0x001022c0
LAB_001139d6:
MOV RAX,qword ptr [RBX + 0x48]
MOV RSI,qword ptr [RAX + R13*0x8]
MOV RDI,R14
CALL 0x00110f0c
TEST AL,AL
JZ 0x00113a10
INC R13
CMP R13,qword ptr [RBX + 0x50]
JC 0x001139bc
LAB_001139f3:
LEA RDI,[0x120557]
MOV ESI,0x4
MOV EDX,0x1
MOV RCX,R15
CALL 0x001022c0
MOV AL,0x1
JMP 0x00113a12
LAB_00113a10:
XOR EAX,EAX
LAB_00113a12:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00113a1c:
LEA RDI,[0x119d5f]
LEA RSI,[0x1209d2]
LEA RCX,[0x120a29]
MOV EDX,0x12
CALL 0x00102180
LAB_00113a3b:
LEA RDI,[0x11b8cf]
LEA RSI,[0x1209d2]
LEA RCX,[0x120a29]
MOV EDX,0x13
CALL 0x00102180
LAB_00113a5a:
LEA RDI,[0x120a69]
LEA RSI,[0x1209d2]
LEA RCX,[0x120a29]
MOV EDX,0x14
CALL 0x00102180
|
int8 codegen_generate_begin(long param_1,int *param_2)
{
char cVar1;
FILE *__s;
ulong uVar2;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c"
,0x12,"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
}
if (param_2 != (int *)0x0) {
if (*param_2 != 10) {
/* WARNING: Subroutine does not return */
__assert_fail("node->type == AST_BEGIN",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c"
,0x14,"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
}
__s = (FILE *)codegen_context_get_output();
fwrite(&DAT_0011f0a9,3,1,__s);
if (*(long *)(param_2 + 0x14) != 0) {
uVar2 = 0;
do {
if (uVar2 != 0) {
fwrite("; ",2,1,__s);
}
cVar1 = codegen_generate_expression
(param_1,*(int8 *)(*(long *)(param_2 + 0x12) + uVar2 * 8));
if (cVar1 == '\0') {
return 0;
}
uVar2 = uVar2 + 1;
} while (uVar2 < *(ulong *)(param_2 + 0x14));
}
fwrite("; })",4,1,__s);
return 1;
}
/* WARNING: Subroutine does not return */
__assert_fail("node != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/blocks.c"
,0x13,"_Bool codegen_generate_begin(CodegenContext *, const AstNode *)");
}
| |
34,256 | ntt_fft | bluesky950520[P]quickjs/libbf.c | static no_inline int ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
NTTLimb *tmp_buf, int fft_len_log2,
int inverse, int m_idx)
{
limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j, m, m2;
NTTLimb *tab_in, *tab_out, *tmp, a0, a1, b0, b1, c, *trig, c_inv;
int l;
m = ntt_mods[m_idx];
m2 = 2 * m;
n = (limb_t)1 << fft_len_log2;
nb_blocks = n;
fft_per_block = 1;
stride_in = n / 2;
tab_in = in_buf;
tab_out = tmp_buf;
l = fft_len_log2;
while (nb_blocks != 2) {
nb_blocks >>= 1;
p = 0;
k = 0;
trig = get_trig(s, l, inverse, m_idx);
if (!trig)
return -1;
for(i = 0; i < nb_blocks; i++) {
c = trig[0];
c_inv = trig[1];
trig += 2;
for(j = 0; j < fft_per_block; j++) {
a0 = tab_in[k + j];
a1 = tab_in[k + j + stride_in];
b0 = add_mod(a0, a1, m2);
b1 = a0 - a1 + m2;
b1 = mul_mod_fast3(b1, c, m, c_inv);
tab_out[p + j] = b0;
tab_out[p + j + fft_per_block] = b1;
}
k += fft_per_block;
p += 2 * fft_per_block;
}
fft_per_block <<= 1;
l--;
tmp = tab_in;
tab_in = tab_out;
tab_out = tmp;
}
/* no twiddle in last step */
tab_out = out_buf;
for(k = 0; k < stride_in; k++) {
a0 = tab_in[k];
a1 = tab_in[k + stride_in];
b0 = add_mod(a0, a1, m2);
b1 = sub_mod(a0, a1, m2);
tab_out[k] = b0;
tab_out[k + stride_in] = b1;
}
return 0;
} | O2 | c | ntt_fft:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r9d, 0x10(%rsp)
movl %r8d, %r15d
movq %rcx, %r12
movq %rsi, 0x20(%rsp)
movq %rdi, 0x38(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0xea72(%rip), %rax # 0x89fa0
movq %rcx, 0x30(%rsp)
movq (%rax,%rcx,8), %rbx
leaq (%rbx,%rbx), %r14
pushq $0x1
popq %rbp
movq %rbp, %rax
movl %r15d, %ecx
shlq %cl, %rax
movq %rax, 0x8(%rsp)
shrq %rax
movq %rax, 0x18(%rsp)
leaq (,%rax,8), %rax
movq %rax, 0x28(%rsp)
movq %rdx, %r13
cmpq $0x2, 0x8(%rsp)
je 0x7b690
movq 0x38(%rsp), %rdi
movl %r15d, %esi
movl 0x10(%rsp), %edx
movq 0x30(%rsp), %rcx
callq 0x7b788
testq %rax, %rax
je 0x7b6e8
movq %rax, %rcx
movl %r15d, 0x14(%rsp)
shrq 0x8(%rsp)
leaq (,%rbp,2), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rax
leaq (%rax,%r13), %r8
leaq (,%rbp,8), %rax
movq %rax, 0x60(%rsp)
leaq (%r12,%rbp,8), %r10
movq %rbp, %rax
shlq $0x4, %rax
movq %rax, 0x58(%rsp)
movq %r12, 0x50(%rsp)
movq %r13, %rax
movq %r12, %r13
movq %rax, 0x48(%rsp)
movq %rax, %r12
xorl %edx, %edx
cmpq 0x8(%rsp), %rdx
je 0x7b674
movq %rdx, 0x68(%rsp)
movq (%rcx), %r15
movq %rcx, 0x70(%rsp)
movq 0x8(%rcx), %r9
xorl %r11d, %r11d
cmpq %r11, %rbp
je 0x7b648
movq (%r12,%r11,8), %rsi
movq (%r8,%r11,8), %rax
leaq (%rax,%rsi), %rdi
cmpq %r14, %rdi
movl $0x0, %ecx
cmovaeq %r14, %rcx
subq %rax, %rsi
addq %r14, %rsi
movq %rsi, %rax
mulq %r9
subq %rcx, %rdi
imulq %r15, %rsi
imulq %rbx, %rdx
subq %rdx, %rsi
movq %rdi, (%r13,%r11,8)
movq %rsi, (%r10,%r11,8)
incq %r11
jmp 0x7b603
movq 0x70(%rsp), %rcx
addq $0x10, %rcx
movq 0x68(%rsp), %rdx
incq %rdx
movq 0x60(%rsp), %rax
addq %rax, %r8
addq %rax, %r12
movq 0x58(%rsp), %rax
addq %rax, %r10
addq %rax, %r13
jmp 0x7b5e4
movl 0x14(%rsp), %r15d
decl %r15d
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %r12
movq 0x40(%rsp), %rbp
jmp 0x7b561
movq 0x20(%rsp), %r10
movq 0x18(%rsp), %rbx
leaq (%r10,%rbx,8), %r11
leaq (,%rbx,8), %rcx
addq %r13, %rcx
xorl %eax, %eax
xorl %edx, %edx
cmpq %rdx, %rbx
je 0x7b6eb
movq (%r13,%rdx,8), %rsi
movq (%rcx,%rdx,8), %rdi
leaq (%rdi,%rsi), %r8
cmpq %r14, %r8
movq %r14, %r9
cmovbq %rax, %r9
subq %r9, %r8
subq %rdi, %rsi
movl $0x0, %edi
cmovbq %r14, %rdi
addq %rdi, %rsi
movq %r8, (%r10,%rdx,8)
movq %rsi, (%r11,%rdx,8)
incq %rdx
jmp 0x7b6ad
pushq $-0x1
popq %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ntt_fft:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov [rsp+0A8h+var_98], r9d
mov r15d, r8d
mov r12, rcx
mov [rsp+0A8h+var_88], rsi
mov [rsp+0A8h+var_70], rdi
movsxd rcx, [rsp+0A8h+arg_0]
lea rax, ntt_mods
mov [rsp+0A8h+var_78], rcx
mov rbx, [rax+rcx*8]
lea r14, [rbx+rbx]
push 1
pop rbp
mov rax, rbp
mov ecx, r15d
shl rax, cl
mov [rsp+0A8h+var_A0], rax
shr rax, 1
mov [rsp+0A8h+var_90], rax
lea rax, ds:0[rax*8]
mov [rsp+0A8h+var_80], rax
loc_7B561:
mov r13, rdx
cmp [rsp+0A8h+var_A0], 2
jz loc_7B690
mov rdi, [rsp+0A8h+var_70]
mov esi, r15d
mov edx, [rsp+0A8h+var_98]
mov rcx, [rsp+0A8h+var_78]
call get_trig
test rax, rax
jz loc_7B6E8
mov rcx, rax
mov [rsp+0A8h+var_94], r15d
shr [rsp+0A8h+var_A0], 1
lea rax, ds:0[rbp*2]
mov [rsp+0A8h+var_68], rax
mov rax, [rsp+0A8h+var_80]
lea r8, [rax+r13]
lea rax, ds:0[rbp*8]
mov [rsp+0A8h+var_48], rax
lea r10, [r12+rbp*8]
mov rax, rbp
shl rax, 4
mov [rsp+0A8h+var_50], rax
mov [rsp+0A8h+var_58], r12
mov rax, r13
mov r13, r12
mov [rsp+0A8h+var_60], rax
mov r12, rax
xor edx, edx
loc_7B5E4:
cmp rdx, [rsp+0A8h+var_A0]
jz loc_7B674
mov [rsp+0A8h+var_40], rdx
mov r15, [rcx]
mov [rsp+0A8h+var_38], rcx
mov r9, [rcx+8]
xor r11d, r11d
loc_7B603:
cmp rbp, r11
jz short loc_7B648
mov rsi, [r12+r11*8]
mov rax, [r8+r11*8]
lea rdi, [rax+rsi]
cmp rdi, r14
mov ecx, 0
cmovnb rcx, r14
sub rsi, rax
add rsi, r14
mov rax, rsi
mul r9
sub rdi, rcx
imul rsi, r15
imul rdx, rbx
sub rsi, rdx
mov [r13+r11*8+0], rdi
mov [r10+r11*8], rsi
inc r11
jmp short loc_7B603
loc_7B648:
mov rcx, [rsp+0A8h+var_38]
add rcx, 10h
mov rdx, [rsp+0A8h+var_40]
inc rdx
mov rax, [rsp+0A8h+var_48]
add r8, rax
add r12, rax
mov rax, [rsp+0A8h+var_50]
add r10, rax
add r13, rax
jmp loc_7B5E4
loc_7B674:
mov r15d, [rsp+0A8h+var_94]
dec r15d
mov rdx, [rsp+0A8h+var_58]
mov r12, [rsp+0A8h+var_60]
mov rbp, [rsp+0A8h+var_68]
jmp loc_7B561
loc_7B690:
mov r10, [rsp+0A8h+var_88]
mov rbx, [rsp+0A8h+var_90]
lea r11, [r10+rbx*8]
lea rcx, ds:0[rbx*8]
add rcx, r13
xor eax, eax
xor edx, edx
loc_7B6AD:
cmp rbx, rdx
jz short loc_7B6EB
mov rsi, [r13+rdx*8+0]
mov rdi, [rcx+rdx*8]
lea r8, [rdi+rsi]
cmp r8, r14
mov r9, r14
cmovb r9, rax
sub r8, r9
sub rsi, rdi
mov edi, 0
cmovb rdi, r14
add rsi, rdi
mov [r10+rdx*8], r8
mov [r11+rdx*8], rsi
inc rdx
jmp short loc_7B6AD
loc_7B6E8:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_7B6EB:
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ntt_fft(long long a1, long long a2, long long a3, long long a4, unsigned int a5, unsigned int a6, int a7)
{
unsigned int v7; // r15d
long long v9; // rbx
unsigned long long v10; // r14
long long v11; // rbp
long long v12; // r13
long long trig; // rax
_QWORD *v14; // rcx
long long v15; // r8
long long v16; // r10
long long v17; // rax
long long v18; // r13
long long v19; // r12
long long v20; // rdx
long long v21; // r15
unsigned long long v22; // r9
long long i; // r11
long long v24; // rsi
long long v25; // rax
long long v26; // rcx
long long v27; // rcx
long long result; // rax
long long j; // rdx
unsigned long long v30; // rsi
unsigned long long v31; // rdi
long long v32; // r9
long long v33; // r8
bool v34; // cf
unsigned long long v35; // rsi
long long v36; // rdi
unsigned long long v37; // [rsp+8h] [rbp-A0h]
unsigned int v39; // [rsp+14h] [rbp-94h]
unsigned long long v40; // [rsp+18h] [rbp-90h]
long long v42; // [rsp+48h] [rbp-60h]
long long v43; // [rsp+50h] [rbp-58h]
long long v44; // [rsp+58h] [rbp-50h]
long long v45; // [rsp+60h] [rbp-48h]
_QWORD *v46; // [rsp+70h] [rbp-38h]
v7 = a5;
v9 = ntt_mods[a7];
v10 = 2 * v9;
v11 = 1LL;
v37 = 1LL << a5;
v40 = (unsigned long long)(1LL << a5) >> 1;
while ( 1 )
{
v12 = a3;
if ( v37 == 2 )
break;
trig = get_trig(a1, v7, a6, a7);
if ( !trig )
return -1LL;
v14 = (_QWORD *)trig;
v39 = v7;
v37 >>= 1;
v15 = 8 * v40 + v12;
v45 = 8 * v11;
v16 = a4 + 8 * v11;
v44 = 16 * v11;
v43 = a4;
v17 = v12;
v18 = a4;
v42 = v17;
v19 = v17;
v20 = 0LL;
while ( v20 != v37 )
{
v21 = *v14;
v46 = v14;
v22 = v14[1];
for ( i = 0LL; v11 != i; ++i )
{
v24 = *(_QWORD *)(v19 + 8 * i);
v25 = *(_QWORD *)(v15 + 8 * i);
v26 = 0LL;
if ( v25 + v24 >= v10 )
v26 = 2 * v9;
*(_QWORD *)(v18 + 8 * i) = v25 + v24 - v26;
*(_QWORD *)(v16 + 8 * i) = v21 * (v10 + v24 - v25) - v9 * ((v22 * (unsigned __int128)(v10 + v24 - v25)) >> 64);
}
v14 = v46 + 2;
++v20;
v15 += v45;
v19 += v45;
v16 += v44;
v18 += v44;
}
v7 = v39 - 1;
a3 = v43;
a4 = v42;
v11 *= 2LL;
}
v27 = a3 + 8 * v40;
result = 0LL;
for ( j = 0LL; v40 != j; ++j )
{
v30 = *(_QWORD *)(v12 + 8 * j);
v31 = *(_QWORD *)(v27 + 8 * j);
v32 = 2 * v9;
if ( v31 + v30 < v10 )
v32 = 0LL;
v33 = v31 + v30 - v32;
v34 = v30 < v31;
v35 = v30 - v31;
v36 = 0LL;
if ( v34 )
v36 = 2 * v9;
*(_QWORD *)(a2 + 8 * j) = v33;
*(_QWORD *)(a2 + 8 * v40 + 8 * j) = v36 + v35;
}
return result;
}
| ntt_fft:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV dword ptr [RSP + 0x10],R9D
MOV R15D,R8D
MOV R12,RCX
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x38],RDI
MOVSXD RCX,dword ptr [RSP + 0xb0]
LEA RAX,[0x189fa0]
MOV qword ptr [RSP + 0x30],RCX
MOV RBX,qword ptr [RAX + RCX*0x8]
LEA R14,[RBX + RBX*0x1]
PUSH 0x1
POP RBP
MOV RAX,RBP
MOV ECX,R15D
SHL RAX,CL
MOV qword ptr [RSP + 0x8],RAX
SHR RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
LEA RAX,[RAX*0x8]
MOV qword ptr [RSP + 0x28],RAX
LAB_0017b561:
MOV R13,RDX
CMP qword ptr [RSP + 0x8],0x2
JZ 0x0017b690
MOV RDI,qword ptr [RSP + 0x38]
MOV ESI,R15D
MOV EDX,dword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x30]
CALL 0x0017b788
TEST RAX,RAX
JZ 0x0017b6e8
MOV RCX,RAX
MOV dword ptr [RSP + 0x14],R15D
SHR qword ptr [RSP + 0x8],0x1
LEA RAX,[RBP*0x2]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x28]
LEA R8,[RAX + R13*0x1]
LEA RAX,[RBP*0x8]
MOV qword ptr [RSP + 0x60],RAX
LEA R10,[R12 + RBP*0x8]
MOV RAX,RBP
SHL RAX,0x4
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x50],R12
MOV RAX,R13
MOV R13,R12
MOV qword ptr [RSP + 0x48],RAX
MOV R12,RAX
XOR EDX,EDX
LAB_0017b5e4:
CMP RDX,qword ptr [RSP + 0x8]
JZ 0x0017b674
MOV qword ptr [RSP + 0x68],RDX
MOV R15,qword ptr [RCX]
MOV qword ptr [RSP + 0x70],RCX
MOV R9,qword ptr [RCX + 0x8]
XOR R11D,R11D
LAB_0017b603:
CMP RBP,R11
JZ 0x0017b648
MOV RSI,qword ptr [R12 + R11*0x8]
MOV RAX,qword ptr [R8 + R11*0x8]
LEA RDI,[RAX + RSI*0x1]
CMP RDI,R14
MOV ECX,0x0
CMOVNC RCX,R14
SUB RSI,RAX
ADD RSI,R14
MOV RAX,RSI
MUL R9
SUB RDI,RCX
IMUL RSI,R15
IMUL RDX,RBX
SUB RSI,RDX
MOV qword ptr [R13 + R11*0x8],RDI
MOV qword ptr [R10 + R11*0x8],RSI
INC R11
JMP 0x0017b603
LAB_0017b648:
MOV RCX,qword ptr [RSP + 0x70]
ADD RCX,0x10
MOV RDX,qword ptr [RSP + 0x68]
INC RDX
MOV RAX,qword ptr [RSP + 0x60]
ADD R8,RAX
ADD R12,RAX
MOV RAX,qword ptr [RSP + 0x58]
ADD R10,RAX
ADD R13,RAX
JMP 0x0017b5e4
LAB_0017b674:
MOV R15D,dword ptr [RSP + 0x14]
DEC R15D
MOV RDX,qword ptr [RSP + 0x50]
MOV R12,qword ptr [RSP + 0x48]
MOV RBP,qword ptr [RSP + 0x40]
JMP 0x0017b561
LAB_0017b690:
MOV R10,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x18]
LEA R11,[R10 + RBX*0x8]
LEA RCX,[RBX*0x8]
ADD RCX,R13
XOR EAX,EAX
XOR EDX,EDX
LAB_0017b6ad:
CMP RBX,RDX
JZ 0x0017b6eb
MOV RSI,qword ptr [R13 + RDX*0x8]
MOV RDI,qword ptr [RCX + RDX*0x8]
LEA R8,[RDI + RSI*0x1]
CMP R8,R14
MOV R9,R14
CMOVC R9,RAX
SUB R8,R9
SUB RSI,RDI
MOV EDI,0x0
CMOVC RDI,R14
ADD RSI,RDI
MOV qword ptr [R10 + RDX*0x8],R8
MOV qword ptr [R11 + RDX*0x8],RSI
INC RDX
JMP 0x0017b6ad
LAB_0017b6e8:
PUSH -0x1
POP RAX
LAB_0017b6eb:
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
ntt_fft(int8 param_1,long param_2,long param_3,long param_4,int param_5,int4 param_6,
int param_7)
{
ulong uVar1;
long lVar2;
long lVar3;
ulong uVar4;
long lVar5;
long lVar6;
int1 auVar7 [16];
int1 auVar8 [16];
ulong uVar9;
ulong uVar10;
long *plVar11;
ulong uVar12;
long lVar13;
ulong uVar14;
long lVar15;
ulong uVar16;
long lVar17;
long lVar18;
long lVar19;
long lVar20;
long lVar21;
ulong local_a0;
lVar2 = (&ntt_mods)[param_7];
uVar9 = lVar2 * 2;
local_a0 = 1L << ((byte)param_5 & 0x3f);
uVar10 = local_a0 >> 1;
lVar15 = 1;
while( true ) {
lVar13 = param_3;
if (local_a0 == 2) {
for (uVar14 = 0; uVar10 != uVar14; uVar14 = uVar14 + 1) {
uVar4 = *(ulong *)(lVar13 + uVar14 * 8);
uVar1 = *(ulong *)(uVar10 * 8 + lVar13 + uVar14 * 8);
uVar12 = uVar9;
if (uVar1 + uVar4 < uVar9) {
uVar12 = 0;
}
uVar16 = 0;
if (uVar4 < uVar1) {
uVar16 = uVar9;
}
*(ulong *)(param_2 + uVar14 * 8) = (uVar1 + uVar4) - uVar12;
*(ulong *)(param_2 + uVar10 * 8 + uVar14 * 8) = (uVar4 - uVar1) + uVar16;
}
return 0;
}
plVar11 = (long *)get_trig(param_1,param_5,param_6,(long)param_7);
if (plVar11 == (long *)0x0) break;
local_a0 = local_a0 >> 1;
lVar17 = uVar10 * 8 + lVar13;
lVar18 = param_4 + lVar15 * 8;
lVar20 = lVar13;
lVar21 = param_4;
for (uVar14 = 0; uVar14 != local_a0; uVar14 = uVar14 + 1) {
lVar3 = *plVar11;
uVar4 = plVar11[1];
for (lVar19 = 0; lVar15 != lVar19; lVar19 = lVar19 + 1) {
lVar5 = *(long *)(lVar20 + lVar19 * 8);
lVar6 = *(long *)(lVar17 + lVar19 * 8);
uVar1 = lVar6 + lVar5;
uVar12 = 0;
if (uVar9 <= uVar1) {
uVar12 = uVar9;
}
uVar16 = (lVar5 - lVar6) + uVar9;
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar16;
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar4;
*(ulong *)(lVar21 + lVar19 * 8) = uVar1 - uVar12;
*(ulong *)(lVar18 + lVar19 * 8) = uVar16 * lVar3 - SUB168(auVar7 * auVar8,8) * lVar2;
}
plVar11 = plVar11 + 2;
lVar17 = lVar17 + lVar15 * 8;
lVar20 = lVar20 + lVar15 * 8;
lVar18 = lVar18 + lVar15 * 0x10;
lVar21 = lVar21 + lVar15 * 0x10;
}
param_5 = param_5 + -1;
param_3 = param_4;
lVar15 = lVar15 * 2;
param_4 = lVar13;
}
return 0xffffffffffffffff;
}
| |
34,257 | list_cons | eloqsql/libmariadb/libmariadb/ma_list.c | LIST *list_cons(void *data, LIST *list)
{
LIST *new_charset=(LIST*) malloc(sizeof(LIST));
if (!new_charset)
return 0;
new_charset->data=data;
return list_add(list,new_charset);
} | O3 | c | list_cons:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0x13600
testq %rax, %rax
je 0x1d96a
movq %r14, 0x10(%rax)
testq %rbx, %rbx
je 0x1d955
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x1d95e
movq %rax, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x1d960
movq $0x0, (%rax)
jmp 0x1d966
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
| list_cons:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov edi, 18h
call _malloc
test rax, rax
jz short loc_1D96A
mov [rax+10h], r14
test rbx, rbx
jz short loc_1D955
mov rcx, [rbx]
test rcx, rcx
jz short loc_1D95E
mov [rcx+8], rax
mov rcx, [rbx]
jmp short loc_1D960
loc_1D955:
mov qword ptr [rax], 0
jmp short loc_1D966
loc_1D95E:
xor ecx, ecx
loc_1D960:
mov [rax], rcx
mov [rbx], rax
loc_1D966:
mov [rax+8], rbx
loc_1D96A:
pop rbx
pop r14
pop rbp
retn
| _QWORD * list_cons(long long a1, long long *a2)
{
_QWORD *result; // rax
long long v3; // rcx
result = (_QWORD *)malloc(24LL);
if ( result )
{
result[2] = a1;
if ( a2 )
{
if ( *a2 )
{
*(_QWORD *)(*a2 + 8) = result;
v3 = *a2;
}
else
{
v3 = 0LL;
}
*result = v3;
*a2 = (long long)result;
}
else
{
*result = 0LL;
}
result[1] = a2;
}
return result;
}
| list_cons:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV EDI,0x18
CALL 0x00113600
TEST RAX,RAX
JZ 0x0011d96a
MOV qword ptr [RAX + 0x10],R14
TEST RBX,RBX
JZ 0x0011d955
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JZ 0x0011d95e
MOV qword ptr [RCX + 0x8],RAX
MOV RCX,qword ptr [RBX]
JMP 0x0011d960
LAB_0011d955:
MOV qword ptr [RAX],0x0
JMP 0x0011d966
LAB_0011d95e:
XOR ECX,ECX
LAB_0011d960:
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX],RAX
LAB_0011d966:
MOV qword ptr [RAX + 0x8],RBX
LAB_0011d96a:
POP RBX
POP R14
POP RBP
RET
|
void list_cons(long param_1,long *param_2)
{
long *plVar1;
long lVar2;
plVar1 = (long *)malloc(0x18);
if (plVar1 != (long *)0x0) {
plVar1[2] = param_1;
if (param_2 == (long *)0x0) {
*plVar1 = 0;
}
else {
if (*param_2 == 0) {
lVar2 = 0;
}
else {
*(long **)(*param_2 + 8) = plVar1;
lVar2 = *param_2;
}
*plVar1 = lVar2;
*param_2 = (long)plVar1;
}
plVar1[1] = (long)param_2;
}
return;
}
| |
34,258 | mbedtls_md_info_from_string | msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/md.c | const mbedtls_md_info_t *mbedtls_md_info_from_string(const char *md_name)
{
if (NULL == md_name) {
return NULL;
}
/* Get the appropriate digest information */
#if defined(MBEDTLS_MD2_C)
if (!strcmp("MD2", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_MD2);
}
#endif
#if defined(MBEDTLS_MD4_C)
if (!strcmp("MD4", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_MD4);
}
#endif
#if defined(MBEDTLS_MD5_C)
if (!strcmp("MD5", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_MD5);
}
#endif
#if defined(MBEDTLS_RIPEMD160_C)
if (!strcmp("RIPEMD160", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_RIPEMD160);
}
#endif
#if defined(MBEDTLS_SHA1_C)
if (!strcmp("SHA1", md_name) || !strcmp("SHA", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
}
#endif
#if defined(MBEDTLS_SHA256_C)
if (!strcmp("SHA224", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_SHA224);
}
if (!strcmp("SHA256", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_SHA256);
}
#endif
#if defined(MBEDTLS_SHA512_C)
#if !defined(MBEDTLS_SHA512_NO_SHA384)
if (!strcmp("SHA384", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_SHA384);
}
#endif
if (!strcmp("SHA512", md_name)) {
return mbedtls_md_info_from_type(MBEDTLS_MD_SHA512);
}
#endif
return NULL;
} | O3 | c | mbedtls_md_info_from_string:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8a311
movq %rdi, %rbx
leaq 0x27f0d(%rip), %rdi # 0xb216c
movq %rbx, %rsi
callq 0xf630
testl %eax, %eax
je 0x8a316
leaq 0x2615a(%rip), %rdi # 0xb03d0
movq %rbx, %rsi
callq 0xf630
testl %eax, %eax
je 0x8a31f
leaq 0x28007(%rip), %rdi # 0xb2294
movq %rbx, %rsi
callq 0xf630
leaq 0x58804(%rip), %r14 # 0xe2aa0
testl %eax, %eax
je 0x8a326
leaq 0x2612f(%rip), %rdi # 0xb03da
movq %rbx, %rsi
callq 0xf630
testl %eax, %eax
je 0x8a326
leaq 0x28001(%rip), %rdi # 0xb22bf
movq %rbx, %rsi
callq 0xf630
testl %eax, %eax
je 0x8a331
leaq 0x2801b(%rip), %rdi # 0xb22ec
movq %rbx, %rsi
callq 0xf630
testl %eax, %eax
je 0x8a33a
leaq 0x28035(%rip), %rdi # 0xb2319
movq %rbx, %rsi
callq 0xf630
testl %eax, %eax
je 0x8a343
leaq 0x2804f(%rip), %rdi # 0xb2346
movq %rbx, %rsi
callq 0xf630
xorl %r14d, %r14d
testl %eax, %eax
leaq 0x587d5(%rip), %rax # 0xe2ae0
cmoveq %rax, %r14
jmp 0x8a326
xorl %r14d, %r14d
jmp 0x8a326
leaq 0x58763(%rip), %r14 # 0xe2a80
jmp 0x8a326
leaq 0x5876a(%rip), %r14 # 0xe2a90
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x58778(%rip), %r14 # 0xe2ab0
jmp 0x8a326
leaq 0x5877f(%rip), %r14 # 0xe2ac0
jmp 0x8a326
leaq 0x58786(%rip), %r14 # 0xe2ad0
jmp 0x8a326
| mbedtls_md_info_from_string:
push r14
push rbx
push rax
test rdi, rdi
jz loc_8A311
mov rbx, rdi
lea rdi, aRsaWithMd5+9; "MD5"
mov rsi, rbx
call _strcmp
test eax, eax
jz loc_8A316
lea rdi, aRipemd160; "RIPEMD160"
mov rsi, rbx
call _strcmp
test eax, eax
jz loc_8A31F
lea rdi, aEcdsaWithSha1_0+0Bh; "SHA1"
mov rsi, rbx
call _strcmp
lea r14, mbedtls_sha1_info
test eax, eax
jz loc_8A326
lea rdi, aSha; "SHA"
mov rsi, rbx
call _strcmp
test eax, eax
jz short loc_8A326
lea rdi, aEcdsaWithSha22_0+0Bh; "SHA224"
mov rsi, rbx
call _strcmp
test eax, eax
jz short loc_8A331
lea rdi, aEcdsaWithSha25_0+0Bh; "SHA256"
mov rsi, rbx
call _strcmp
test eax, eax
jz short loc_8A33A
lea rdi, aEcdsaWithSha38_0+0Bh; "SHA384"
mov rsi, rbx
call _strcmp
test eax, eax
jz short loc_8A343
lea rdi, aEcdsaWithSha51_0+0Bh; "SHA512"
mov rsi, rbx
call _strcmp
xor r14d, r14d
test eax, eax
lea rax, mbedtls_sha512_info
cmovz r14, rax
jmp short loc_8A326
loc_8A311:
xor r14d, r14d
jmp short loc_8A326
loc_8A316:
lea r14, mbedtls_md5_info
jmp short loc_8A326
loc_8A31F:
lea r14, mbedtls_ripemd160_info
loc_8A326:
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_8A331:
lea r14, mbedtls_sha224_info
jmp short loc_8A326
loc_8A33A:
lea r14, mbedtls_sha256_info
jmp short loc_8A326
loc_8A343:
lea r14, mbedtls_sha384_info
jmp short loc_8A326
| char ** mbedtls_md_info_from_string(long long a1)
{
_UNKNOWN **v1; // r14
if ( !a1 )
return 0LL;
if ( !(unsigned int)strcmp("MD5", a1) )
return (char **)&mbedtls_md5_info;
if ( !(unsigned int)strcmp("RIPEMD160", a1) )
return &mbedtls_ripemd160_info;
v1 = &mbedtls_sha1_info;
if ( (unsigned int)strcmp("SHA1", a1) && (unsigned int)strcmp("SHA", a1) )
{
if ( !(unsigned int)strcmp("SHA224", a1) )
{
return (char **)&mbedtls_sha224_info;
}
else if ( !(unsigned int)strcmp("SHA256", a1) )
{
return (char **)&mbedtls_sha256_info;
}
else if ( !(unsigned int)strcmp("SHA384", a1) )
{
return (char **)&mbedtls_sha384_info;
}
else
{
v1 = 0LL;
if ( !(unsigned int)strcmp("SHA512", a1) )
return (char **)&mbedtls_sha512_info;
}
}
return (char **)v1;
}
| mbedtls_md_info_from_string:
PUSH R14
PUSH RBX
PUSH RAX
TEST RDI,RDI
JZ 0x0018a311
MOV RBX,RDI
LEA RDI,[0x1b216c]
MOV RSI,RBX
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0018a316
LEA RDI,[0x1b03d0]
MOV RSI,RBX
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0018a31f
LEA RDI,[0x1b2294]
MOV RSI,RBX
CALL 0x0010f630
LEA R14,[0x1e2aa0]
TEST EAX,EAX
JZ 0x0018a326
LEA RDI,[0x1b03da]
MOV RSI,RBX
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0018a326
LEA RDI,[0x1b22bf]
MOV RSI,RBX
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0018a331
LEA RDI,[0x1b22ec]
MOV RSI,RBX
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0018a33a
LEA RDI,[0x1b2319]
MOV RSI,RBX
CALL 0x0010f630
TEST EAX,EAX
JZ 0x0018a343
LEA RDI,[0x1b2346]
MOV RSI,RBX
CALL 0x0010f630
XOR R14D,R14D
TEST EAX,EAX
LEA RAX,[0x1e2ae0]
CMOVZ R14,RAX
JMP 0x0018a326
LAB_0018a311:
XOR R14D,R14D
JMP 0x0018a326
LAB_0018a316:
LEA R14,[0x1e2a80]
JMP 0x0018a326
LAB_0018a31f:
LEA R14,[0x1e2a90]
LAB_0018a326:
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0018a331:
LEA R14,[0x1e2ab0]
JMP 0x0018a326
LAB_0018a33a:
LEA R14,[0x1e2ac0]
JMP 0x0018a326
LAB_0018a343:
LEA R14,[0x1e2ad0]
JMP 0x0018a326
|
int1 * mbedtls_md_info_from_string(char *param_1)
{
int iVar1;
int1 *puVar2;
if (param_1 == (char *)0x0) {
puVar2 = (int1 *)0x0;
}
else {
iVar1 = strcmp("MD5",param_1);
if (iVar1 == 0) {
puVar2 = mbedtls_md5_info;
}
else {
iVar1 = strcmp("RIPEMD160",param_1);
if (iVar1 == 0) {
puVar2 = mbedtls_ripemd160_info;
}
else {
iVar1 = strcmp("SHA1",param_1);
puVar2 = mbedtls_sha1_info;
if ((iVar1 != 0) && (iVar1 = strcmp("SHA",param_1), iVar1 != 0)) {
iVar1 = strcmp("SHA224",param_1);
if (iVar1 == 0) {
puVar2 = mbedtls_sha224_info;
}
else {
iVar1 = strcmp("SHA256",param_1);
if (iVar1 == 0) {
puVar2 = mbedtls_sha256_info;
}
else {
iVar1 = strcmp("SHA384",param_1);
if (iVar1 == 0) {
puVar2 = mbedtls_sha384_info;
}
else {
iVar1 = strcmp("SHA512",param_1);
puVar2 = (int1 *)0x0;
if (iVar1 == 0) {
puVar2 = mbedtls_sha512_info;
}
}
}
}
}
}
}
}
return puVar2;
}
| |
34,259 | long minja::Value::get<long>() const | llama.cpp/common/minja/minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O3 | cpp | long minja::Value::get<long>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0xc575d
cmpq $0x0, 0x20(%r14)
jne 0xc575d
cmpq $0x0, 0x30(%r14)
jne 0xc575d
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc582b
movq (%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20680
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0xb99d8
leaq 0x5d5e7(%rip), %rsi # 0x122d6a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb3278
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x204b0
xorl %ebp, %ebp
movq 0xa0817(%rip), %rsi # 0x165fc0
movq 0xa07d0(%rip), %rdx # 0x165f80
movq %rbx, %rdi
callq 0x20ab0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc57d6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20180
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc57f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xc581b
jmp 0xc5823
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc581b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20180
jmp 0xc581b
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f60
movq %r14, %rdi
callq 0x20b50
| _ZNK5minja5Value3getIlEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_C575D
cmp qword ptr [r14+20h], 0
jnz short loc_C575D
cmp qword ptr [r14+30h], 0
jnz short loc_C575D
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
mov rax, [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_C575D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C57D6
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C57D6:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C57F1
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C57F1:
test bpl, bpl
jnz short loc_C581B
jmp short loc_C5823
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C581B
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_C581B
mov r14, rax
loc_C581B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C5823:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<long>(_QWORD *a1)
{
void *exception; // rbx
_BYTE v3[16]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-38h] BYREF
if ( a1[2] || a1[4] || a1[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>(v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4[0] = 0LL;
ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1 + 8,
v4);
return v4[0];
}
| get<long>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x001c575d
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x001c575d
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x001c575d
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001c582b
MOV RAX,qword ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001c575d:
MOV EDI,0x10
CALL 0x00120680
MOV RBX,RAX
LAB_001c576a:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001b99d8
LAB_001c577c:
LEA RSI,[0x222d6a]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001b3278
MOV BPL,0x1
LAB_001c5793:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x001204b0
XOR EBP,EBP
MOV RSI,qword ptr [0x00265fc0]
MOV RDX,qword ptr [0x00265f80]
MOV RDI,RBX
CALL 0x00120ab0
|
/* long minja::Value::get<long>() const */
long __thiscall minja::Value::get<long>(Value *this)
{
runtime_error *this_00;
int1 auStack_58 [32];
long local_38 [4];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_38[0] = 0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEElTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(this + 0x40,local_38);
return local_38[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001c576a to 001c577b has its CatchHandler @ 001c5818 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 001c577c to 001c578f has its CatchHandler @ 001c57f8 */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001c5793 to 001c57b7 has its CatchHandler @ 001c57b8 */
std::runtime_error::runtime_error(this_00,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00265fc0,PTR__runtime_error_00265f80);
}
| |
34,260 | JS_NewContext | bluesky950520[P]quickjs/quickjs.c | JSContext *JS_NewContext(JSRuntime *rt)
{
JSContext *ctx;
ctx = JS_NewContextRaw(rt);
if (!ctx)
return NULL;
JS_AddIntrinsicBaseObjects(ctx);
JS_AddIntrinsicDate(ctx);
JS_AddIntrinsicEval(ctx);
JS_AddIntrinsicRegExp(ctx);
JS_AddIntrinsicJSON(ctx);
JS_AddIntrinsicProxy(ctx);
JS_AddIntrinsicMapSet(ctx);
JS_AddIntrinsicTypedArrays(ctx);
JS_AddIntrinsicPromise(ctx);
JS_AddIntrinsicBigInt(ctx);
JS_AddIntrinsicWeakRef(ctx);
JS_AddPerformance(ctx);
return ctx;
} | O2 | c | JS_NewContext:
pushq %rbx
callq 0x182dd
movq %rax, %rbx
testq %rax, %rax
je 0x18636
movq %rbx, %rdi
callq 0x1863b
movq %rbx, %rdi
callq 0x19121
leaq 0x18319(%rip), %rax # 0x30900
movq %rax, 0x1f8(%rbx)
movq %rbx, %rdi
callq 0x191bb
movq %rbx, %rdi
callq 0x192b1
movq %rbx, %rdi
callq 0x192cf
movq %rbx, %rdi
callq 0x193ab
movq %rbx, %rdi
callq 0x1953d
movq %rbx, %rdi
callq 0x198b8
movq %rbx, %rdi
callq 0x19c5a
movq %rbx, %rdi
callq 0x19ce5
movq %rbx, %rdi
callq 0x19e22
movq %rbx, %rax
popq %rbx
retq
| JS_NewContext:
push rbx
call JS_NewContextRaw
mov rbx, rax
test rax, rax
jz short loc_18636
mov rdi, rbx
call JS_AddIntrinsicBaseObjects
mov rdi, rbx
call JS_AddIntrinsicDate
lea rax, __JS_EvalInternal
mov [rbx+1F8h], rax
mov rdi, rbx
call JS_AddIntrinsicRegExp
mov rdi, rbx
call JS_AddIntrinsicJSON
mov rdi, rbx
call JS_AddIntrinsicProxy
mov rdi, rbx
call JS_AddIntrinsicMapSet
mov rdi, rbx
call JS_AddIntrinsicTypedArrays
mov rdi, rbx
call JS_AddIntrinsicPromise
mov rdi, rbx
call JS_AddIntrinsicBigInt
mov rdi, rbx
call JS_AddIntrinsicWeakRef
mov rdi, rbx
call JS_AddPerformance
loc_18636:
mov rax, rbx
pop rbx
retn
| long long JS_NewContext(long long a1)
{
long long v1; // rax
long long v2; // rbx
v1 = JS_NewContextRaw(a1);
v2 = v1;
if ( v1 )
{
JS_AddIntrinsicBaseObjects(v1);
JS_AddIntrinsicDate(v2);
*(_QWORD *)(v2 + 504) = _JS_EvalInternal;
JS_AddIntrinsicRegExp(v2);
JS_AddIntrinsicJSON(v2);
JS_AddIntrinsicProxy(v2);
JS_AddIntrinsicMapSet(v2);
JS_AddIntrinsicTypedArrays(v2);
JS_AddIntrinsicPromise(v2);
JS_AddIntrinsicBigInt(v2);
JS_AddIntrinsicWeakRef(v2);
JS_AddPerformance(v2);
}
return v2;
}
| JS_NewContext:
PUSH RBX
CALL 0x001182dd
MOV RBX,RAX
TEST RAX,RAX
JZ 0x00118636
MOV RDI,RBX
CALL 0x0011863b
MOV RDI,RBX
CALL 0x00119121
LEA RAX,[0x130900]
MOV qword ptr [RBX + 0x1f8],RAX
MOV RDI,RBX
CALL 0x001191bb
MOV RDI,RBX
CALL 0x001192b1
MOV RDI,RBX
CALL 0x001192cf
MOV RDI,RBX
CALL 0x001193ab
MOV RDI,RBX
CALL 0x0011953d
MOV RDI,RBX
CALL 0x001198b8
MOV RDI,RBX
CALL 0x00119c5a
MOV RDI,RBX
CALL 0x00119ce5
MOV RDI,RBX
CALL 0x00119e22
LAB_00118636:
MOV RAX,RBX
POP RBX
RET
|
long JS_NewContext(void)
{
long lVar1;
lVar1 = JS_NewContextRaw();
if (lVar1 != 0) {
JS_AddIntrinsicBaseObjects(lVar1);
JS_AddIntrinsicDate(lVar1);
*(code **)(lVar1 + 0x1f8) = __JS_EvalInternal;
JS_AddIntrinsicRegExp(lVar1);
JS_AddIntrinsicJSON(lVar1);
JS_AddIntrinsicProxy(lVar1);
JS_AddIntrinsicMapSet(lVar1);
JS_AddIntrinsicTypedArrays(lVar1);
JS_AddIntrinsicPromise(lVar1);
JS_AddIntrinsicBigInt(lVar1);
JS_AddIntrinsicWeakRef(lVar1);
JS_AddPerformance(lVar1);
}
return lVar1;
}
| |
34,261 | my_casedn_str_mb | eloqsql/strings/ctype-mb.c | size_t my_casedn_str_mb(CHARSET_INFO * cs, char *str)
{
register uint32 l;
register const uchar *map= cs->to_lower;
char *str_orig= str;
while (*str)
{
/* Pointing after the '\0' is safe here. */
if ((l= my_ismbchar(cs, str, str + cs->mbmaxlen)))
str+= l;
else
{
*str= (char) map[(uchar)*str];
str++;
}
}
return (size_t) (str - str_orig);
} | O0 | c | my_casedn_str_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9e237
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x9c(%rax), %eax
addq %rax, %rdx
callq 0x9e150
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x9e215
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x9e235
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9e1d4
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_casedn_str_mb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov [rbp+var_28], rax
loc_9E1D4:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_9E237
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+9Ch]
add rdx, rax
call my_ismbchar_0
mov [rbp+var_14], eax
cmp eax, 0
jz short loc_9E215
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp short loc_9E235
loc_9E215:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_10]
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
loc_9E235:
jmp short loc_9E1D4
loc_9E237:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
sub rax, rcx
add rsp, 30h
pop rbp
retn
| _BYTE * my_casedn_str_mb(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-20h]
unsigned int v4; // [rsp+1Ch] [rbp-14h]
_BYTE *v5; // [rsp+20h] [rbp-10h]
v5 = a2;
v3 = *(_QWORD *)(a1 + 72);
while ( *v5 )
{
v4 = my_ismbchar_0(a1, (long long)v5, (long long)&v5[*(unsigned int *)(a1 + 156)]);
if ( v4 )
{
v5 += v4;
}
else
{
*v5 = *(_BYTE *)(v3 + (unsigned __int8)*v5);
++v5;
}
}
return (_BYTE *)(v5 - a2);
}
| my_casedn_str_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_0019e1d4:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x0019e237
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x9c]
ADD RDX,RAX
CALL 0x0019e150
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JZ 0x0019e215
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0019e235
LAB_0019e215:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
LAB_0019e235:
JMP 0x0019e1d4
LAB_0019e237:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
SUB RAX,RCX
ADD RSP,0x30
POP RBP
RET
|
long my_casedn_str_mb(long param_1,byte *param_2)
{
long lVar1;
uint uVar2;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_18 = param_2;
while (*local_18 != 0) {
uVar2 = my_ismbchar(param_1,local_18,local_18 + *(uint *)(param_1 + 0x9c));
if (uVar2 == 0) {
*local_18 = *(byte *)(lVar1 + (ulong)*local_18);
local_18 = local_18 + 1;
}
else {
local_18 = local_18 + uVar2;
}
}
return (long)local_18 - (long)param_2;
}
| |
34,262 | MNN::ImageProcessParam::UnPackTo(MNN::ImageProcessParamT*, std::__1::function<void (void**, unsigned long)> const*) const | mnn-tts/MNN/schema/current/UserDefine_generated.h | inline void ImageProcessParam::UnPackTo(ImageProcessParamT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = filterType(); _o->filterType = _e; };
{ auto _e = sourceFormat(); _o->sourceFormat = _e; };
{ auto _e = destFormat(); _o->destFormat = _e; };
{ auto _e = wrap(); _o->wrap = _e; };
{ auto _e = mean(); if (_e) { _o->mean.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mean[_i] = _e->Get(_i); } } };
{ auto _e = normal(); if (_e) { _o->normal.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->normal[_i] = _e->Get(_i); } } };
{ auto _e = transform(); if (_e) { _o->transform.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->transform[_i] = _e->Get(_i); } } };
{ auto _e = paddingValue(); _o->paddingValue = _e; };
{ auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } };
{ auto _e = outputType(); _o->outputType = _e; };
{ auto _e = draw(); _o->draw = _e; };
} | O0 | c | MNN::ImageProcessParam::UnPackTo(MNN::ImageProcessParamT*, std::__1::function<void (void**, unsigned long)> const*) const:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x2d970
movq 0x40(%rsp), %rdi
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, (%rax)
callq 0x2d990
movq 0x40(%rsp), %rdi
movl %eax, 0x98(%rsp)
movl 0x98(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x4(%rax)
callq 0x2d9b0
movq 0x40(%rsp), %rdi
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x8(%rax)
callq 0x2d9d0
movq 0x40(%rsp), %rdi
movl %eax, 0x90(%rsp)
movl 0x90(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0xc(%rax)
callq 0x2d9f0
movq %rax, 0x88(%rsp)
cmpq $0x0, 0x88(%rsp)
je 0x2d70f
movq 0xa8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rdi
callq 0xb9e0
movq 0x38(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xb970
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x88(%rsp), %rdi
callq 0xb9e0
movl %eax, %ecx
movl 0x34(%rsp), %eax
cmpl %ecx, %eax
jae 0x2d70d
movq 0x88(%rsp), %rdi
movl 0x84(%rsp), %esi
callq 0xba00
movss %xmm0, 0x30(%rsp)
movq 0xa8(%rsp), %rdi
addq $0x10, %rdi
movl 0x84(%rsp), %eax
movl %eax, %esi
callq 0xba70
movss 0x30(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x2d69a
jmp 0x2d70f
movq 0x40(%rsp), %rdi
callq 0x2da10
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x2d7bb
movq 0xa8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rdi
callq 0xb9e0
movq 0x28(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xb970
movl $0x0, 0x74(%rsp)
movl 0x74(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x78(%rsp), %rdi
callq 0xb9e0
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jae 0x2d7b9
movq 0x78(%rsp), %rdi
movl 0x74(%rsp), %esi
callq 0xba00
movss %xmm0, 0x20(%rsp)
movq 0xa8(%rsp), %rdi
addq $0x28, %rdi
movl 0x74(%rsp), %eax
movl %eax, %esi
callq 0xba70
movss 0x20(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x2d75b
jmp 0x2d7bb
movq 0x40(%rsp), %rdi
callq 0x2da30
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x2d867
movq 0xa8(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
callq 0xb9e0
movq 0x18(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xb970
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rdi
callq 0xb9e0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x2d865
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0xba00
movss %xmm0, 0x10(%rsp)
movq 0xa8(%rsp), %rdi
addq $0x40, %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0xba70
movss 0x10(%rsp), %xmm0
movss %xmm0, (%rax)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x2d807
jmp 0x2d867
movq 0x40(%rsp), %rdi
callq 0x2da50
movq 0x40(%rsp), %rdi
movb %al, 0x63(%rsp)
movb 0x63(%rsp), %cl
movq 0xa8(%rsp), %rax
movb %cl, 0x58(%rax)
callq 0x2da70
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x2d928
movq 0xa8(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0xb480
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xb410
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x58(%rsp), %rdi
callq 0xb480
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x2d926
movq 0x58(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0xb4a0
movl %eax, (%rsp)
movq 0xa8(%rsp), %rdi
addq $0x60, %rdi
movl 0x54(%rsp), %eax
movl %eax, %esi
callq 0xb510
movl (%rsp), %ecx
movl %ecx, (%rax)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x2d8d0
jmp 0x2d928
movq 0x40(%rsp), %rdi
callq 0x2da90
movq 0x40(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x78(%rax)
callq 0x2dab0
andb $0x1, %al
movb %al, 0x4f(%rsp)
movb 0x4f(%rsp), %cl
movq 0xa8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x7c(%rax)
addq $0xb8, %rsp
retq
nop
| _ZNK3MNN17ImageProcessParam8UnPackToEPNS_18ImageProcessParamTEPKNSt3__18functionIFvPPvmEEE:
sub rsp, 0B8h
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_10], rsi
mov [rsp+0B8h+var_18], rdx
mov rdi, [rsp+0B8h+var_8]; this
mov [rsp+0B8h+var_78], rdi
call _ZNK3MNN17ImageProcessParam10filterTypeEv; MNN::ImageProcessParam::filterType(void)
mov rdi, [rsp+0B8h+var_78]; this
mov [rsp+0B8h+var_1C], eax
mov ecx, [rsp+0B8h+var_1C]
mov rax, [rsp+0B8h+var_10]
mov [rax], ecx
call _ZNK3MNN17ImageProcessParam12sourceFormatEv; MNN::ImageProcessParam::sourceFormat(void)
mov rdi, [rsp+0B8h+var_78]; this
mov [rsp+0B8h+var_20], eax
mov ecx, [rsp+0B8h+var_20]
mov rax, [rsp+0B8h+var_10]
mov [rax+4], ecx
call _ZNK3MNN17ImageProcessParam10destFormatEv; MNN::ImageProcessParam::destFormat(void)
mov rdi, [rsp+0B8h+var_78]; this
mov [rsp+0B8h+var_24], eax
mov ecx, [rsp+0B8h+var_24]
mov rax, [rsp+0B8h+var_10]
mov [rax+8], ecx
call _ZNK3MNN17ImageProcessParam4wrapEv; MNN::ImageProcessParam::wrap(void)
mov rdi, [rsp+0B8h+var_78]; this
mov [rsp+0B8h+var_28], eax
mov ecx, [rsp+0B8h+var_28]
mov rax, [rsp+0B8h+var_10]
mov [rax+0Ch], ecx
call _ZNK3MNN17ImageProcessParam4meanEv; MNN::ImageProcessParam::mean(void)
mov [rsp+0B8h+var_30], rax
cmp [rsp+0B8h+var_30], 0
jz loc_2D70F
mov rax, [rsp+0B8h+var_10]
add rax, 10h
mov [rsp+0B8h+var_80], rax
mov rdi, [rsp+0B8h+var_30]
call _ZNK11flatbuffers6VectorIfE4sizeEv; flatbuffers::Vector<float>::size(void)
mov rdi, [rsp+0B8h+var_80]
mov eax, eax
mov esi, eax
call _ZNSt3__16vectorIfNS_9allocatorIfEEE6resizeEm; std::vector<float>::resize(ulong)
mov [rsp+0B8h+var_34], 0
loc_2D69A:
mov eax, [rsp+0B8h+var_34]
mov [rsp+0B8h+var_84], eax
mov rdi, [rsp+0B8h+var_30]
call _ZNK11flatbuffers6VectorIfE4sizeEv; flatbuffers::Vector<float>::size(void)
mov ecx, eax
mov eax, [rsp+0B8h+var_84]
cmp eax, ecx
jnb short loc_2D70D
mov rdi, [rsp+0B8h+var_30]
mov esi, [rsp+0B8h+var_34]
call _ZNK11flatbuffers6VectorIfE3GetEj; flatbuffers::Vector<float>::Get(uint)
movss [rsp+0B8h+var_88], xmm0
mov rdi, [rsp+0B8h+var_10]
add rdi, 10h
mov eax, [rsp+0B8h+var_34]
mov esi, eax
call _ZNSt3__16vectorIfNS_9allocatorIfEEEixB8nn200100Em; std::vector<float>::operator[](ulong)
movss xmm0, [rsp+0B8h+var_88]
movss dword ptr [rax], xmm0
mov eax, [rsp+0B8h+var_34]
add eax, 1
mov [rsp+0B8h+var_34], eax
jmp short loc_2D69A
loc_2D70D:
jmp short $+2
loc_2D70F:
mov rdi, [rsp+0B8h+var_78]; this
call _ZNK3MNN17ImageProcessParam6normalEv; MNN::ImageProcessParam::normal(void)
mov [rsp+0B8h+var_40], rax
cmp [rsp+0B8h+var_40], 0
jz loc_2D7BB
mov rax, [rsp+0B8h+var_10]
add rax, 28h ; '('
mov [rsp+0B8h+var_90], rax
mov rdi, [rsp+0B8h+var_40]
call _ZNK11flatbuffers6VectorIfE4sizeEv; flatbuffers::Vector<float>::size(void)
mov rdi, [rsp+0B8h+var_90]
mov eax, eax
mov esi, eax
call _ZNSt3__16vectorIfNS_9allocatorIfEEE6resizeEm; std::vector<float>::resize(ulong)
mov [rsp+0B8h+var_44], 0
loc_2D75B:
mov eax, [rsp+0B8h+var_44]
mov [rsp+0B8h+var_94], eax
mov rdi, [rsp+0B8h+var_40]
call _ZNK11flatbuffers6VectorIfE4sizeEv; flatbuffers::Vector<float>::size(void)
mov ecx, eax
mov eax, [rsp+0B8h+var_94]
cmp eax, ecx
jnb short loc_2D7B9
mov rdi, [rsp+0B8h+var_40]
mov esi, [rsp+0B8h+var_44]
call _ZNK11flatbuffers6VectorIfE3GetEj; flatbuffers::Vector<float>::Get(uint)
movss [rsp+0B8h+var_98], xmm0
mov rdi, [rsp+0B8h+var_10]
add rdi, 28h ; '('
mov eax, [rsp+0B8h+var_44]
mov esi, eax
call _ZNSt3__16vectorIfNS_9allocatorIfEEEixB8nn200100Em; std::vector<float>::operator[](ulong)
movss xmm0, [rsp+0B8h+var_98]
movss dword ptr [rax], xmm0
mov eax, [rsp+0B8h+var_44]
add eax, 1
mov [rsp+0B8h+var_44], eax
jmp short loc_2D75B
loc_2D7B9:
jmp short $+2
loc_2D7BB:
mov rdi, [rsp+0B8h+var_78]; this
call _ZNK3MNN17ImageProcessParam9transformEv; MNN::ImageProcessParam::transform(void)
mov [rsp+0B8h+var_50], rax
cmp [rsp+0B8h+var_50], 0
jz loc_2D867
mov rax, [rsp+0B8h+var_10]
add rax, 40h ; '@'
mov [rsp+0B8h+var_A0], rax
mov rdi, [rsp+0B8h+var_50]
call _ZNK11flatbuffers6VectorIfE4sizeEv; flatbuffers::Vector<float>::size(void)
mov rdi, [rsp+0B8h+var_A0]
mov eax, eax
mov esi, eax
call _ZNSt3__16vectorIfNS_9allocatorIfEEE6resizeEm; std::vector<float>::resize(ulong)
mov [rsp+0B8h+var_54], 0
loc_2D807:
mov eax, [rsp+0B8h+var_54]
mov [rsp+0B8h+var_A4], eax
mov rdi, [rsp+0B8h+var_50]
call _ZNK11flatbuffers6VectorIfE4sizeEv; flatbuffers::Vector<float>::size(void)
mov ecx, eax
mov eax, [rsp+0B8h+var_A4]
cmp eax, ecx
jnb short loc_2D865
mov rdi, [rsp+0B8h+var_50]
mov esi, [rsp+0B8h+var_54]
call _ZNK11flatbuffers6VectorIfE3GetEj; flatbuffers::Vector<float>::Get(uint)
movss [rsp+0B8h+var_A8], xmm0
mov rdi, [rsp+0B8h+var_10]
add rdi, 40h ; '@'
mov eax, [rsp+0B8h+var_54]
mov esi, eax
call _ZNSt3__16vectorIfNS_9allocatorIfEEEixB8nn200100Em; std::vector<float>::operator[](ulong)
movss xmm0, [rsp+0B8h+var_A8]
movss dword ptr [rax], xmm0
mov eax, [rsp+0B8h+var_54]
add eax, 1
mov [rsp+0B8h+var_54], eax
jmp short loc_2D807
loc_2D865:
jmp short $+2
loc_2D867:
mov rdi, [rsp+0B8h+var_78]; this
call _ZNK3MNN17ImageProcessParam12paddingValueEv; MNN::ImageProcessParam::paddingValue(void)
mov rdi, [rsp+0B8h+var_78]; this
mov [rsp+0B8h+var_55], al
mov cl, [rsp+0B8h+var_55]
mov rax, [rsp+0B8h+var_10]
mov [rax+58h], cl
call _ZNK3MNN17ImageProcessParam5shapeEv; MNN::ImageProcessParam::shape(void)
mov [rsp+0B8h+var_60], rax
cmp [rsp+0B8h+var_60], 0
jz loc_2D928
mov rax, [rsp+0B8h+var_10]
add rax, 60h ; '`'
mov [rsp+0B8h+var_B0], rax
mov rdi, [rsp+0B8h+var_60]
call _ZNK11flatbuffers6VectorIiE4sizeEv; flatbuffers::Vector<int>::size(void)
mov rdi, [rsp+0B8h+var_B0]
mov eax, eax
mov esi, eax
call _ZNSt3__16vectorIiNS_9allocatorIiEEE6resizeEm; std::vector<int>::resize(ulong)
mov [rsp+0B8h+var_64], 0
loc_2D8D0:
mov eax, [rsp+0B8h+var_64]
mov [rsp+0B8h+var_B4], eax
mov rdi, [rsp+0B8h+var_60]
call _ZNK11flatbuffers6VectorIiE4sizeEv; flatbuffers::Vector<int>::size(void)
mov ecx, eax
mov eax, [rsp+0B8h+var_B4]
cmp eax, ecx
jnb short loc_2D926
mov rdi, [rsp+0B8h+var_60]
mov esi, [rsp+0B8h+var_64]
call _ZNK11flatbuffers6VectorIiE3GetEj; flatbuffers::Vector<int>::Get(uint)
mov [rsp+0B8h+var_B8], eax
mov rdi, [rsp+0B8h+var_10]
add rdi, 60h ; '`'
mov eax, [rsp+0B8h+var_64]
mov esi, eax
call _ZNSt3__16vectorIiNS_9allocatorIiEEEixB8nn200100Em; std::vector<int>::operator[](ulong)
mov ecx, [rsp+0B8h+var_B8]
mov [rax], ecx
mov eax, [rsp+0B8h+var_64]
add eax, 1
mov [rsp+0B8h+var_64], eax
jmp short loc_2D8D0
loc_2D926:
jmp short $+2
loc_2D928:
mov rdi, [rsp+0B8h+var_78]; this
call _ZNK3MNN17ImageProcessParam10outputTypeEv; MNN::ImageProcessParam::outputType(void)
mov rdi, [rsp+0B8h+var_78]; this
mov [rsp+0B8h+var_68], eax
mov ecx, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_10]
mov [rax+78h], ecx
call _ZNK3MNN17ImageProcessParam4drawEv; MNN::ImageProcessParam::draw(void)
and al, 1
mov [rsp+0B8h+var_69], al
mov cl, [rsp+0B8h+var_69]
mov rax, [rsp+0B8h+var_10]
and cl, 1
mov [rax+7Ch], cl
add rsp, 0B8h
retn
| long long MNN::ImageProcessParam::UnPackTo(MNN::ImageProcessParam *a1, long long a2, float a3)
{
unsigned int v3; // eax
unsigned int v4; // eax
unsigned int v5; // eax
unsigned int v6; // eax
char v7; // cl
long long result; // rax
int v9; // [rsp+0h] [rbp-B8h]
unsigned int m; // [rsp+54h] [rbp-64h]
unsigned int *v11; // [rsp+58h] [rbp-60h]
unsigned int k; // [rsp+64h] [rbp-54h]
unsigned int *v13; // [rsp+68h] [rbp-50h]
unsigned int j; // [rsp+74h] [rbp-44h]
unsigned int *v15; // [rsp+78h] [rbp-40h]
unsigned int i; // [rsp+84h] [rbp-34h]
unsigned int *v17; // [rsp+88h] [rbp-30h]
*(_DWORD *)a2 = MNN::ImageProcessParam::filterType(a1);
*(_DWORD *)(a2 + 4) = MNN::ImageProcessParam::sourceFormat(a1);
*(_DWORD *)(a2 + 8) = MNN::ImageProcessParam::destFormat(a1);
*(_DWORD *)(a2 + 12) = MNN::ImageProcessParam::wrap(a1);
v17 = (unsigned int *)MNN::ImageProcessParam::mean(a1);
if ( v17 )
{
v3 = flatbuffers::Vector<float>::size(v17);
std::vector<float>::resize((_QWORD *)(a2 + 16), v3);
for ( i = 0; i < (unsigned int)flatbuffers::Vector<float>::size(v17); ++i )
{
flatbuffers::Vector<float>::Get(v17, i);
*(float *)std::vector<float>::operator[][abi:nn200100]((_QWORD *)(a2 + 16), i) = a3;
}
}
v15 = (unsigned int *)MNN::ImageProcessParam::normal(a1);
if ( v15 )
{
v4 = flatbuffers::Vector<float>::size(v15);
std::vector<float>::resize((_QWORD *)(a2 + 40), v4);
for ( j = 0; j < (unsigned int)flatbuffers::Vector<float>::size(v15); ++j )
{
flatbuffers::Vector<float>::Get(v15, j);
*(float *)std::vector<float>::operator[][abi:nn200100]((_QWORD *)(a2 + 40), j) = a3;
}
}
v13 = (unsigned int *)MNN::ImageProcessParam::transform(a1);
if ( v13 )
{
v5 = flatbuffers::Vector<float>::size(v13);
std::vector<float>::resize((_QWORD *)(a2 + 64), v5);
for ( k = 0; k < (unsigned int)flatbuffers::Vector<float>::size(v13); ++k )
{
flatbuffers::Vector<float>::Get(v13, k);
*(float *)std::vector<float>::operator[][abi:nn200100]((_QWORD *)(a2 + 64), k) = a3;
}
}
*(_BYTE *)(a2 + 88) = MNN::ImageProcessParam::paddingValue(a1);
v11 = (unsigned int *)MNN::ImageProcessParam::shape(a1);
if ( v11 )
{
v6 = flatbuffers::Vector<int>::size(v11);
std::vector<int>::resize((_QWORD *)(a2 + 96), v6);
for ( m = 0; m < (unsigned int)flatbuffers::Vector<int>::size(v11); ++m )
{
v9 = flatbuffers::Vector<int>::Get(v11, m);
*(_DWORD *)std::vector<int>::operator[][abi:nn200100]((_QWORD *)(a2 + 96), m) = v9;
}
}
*(_DWORD *)(a2 + 120) = MNN::ImageProcessParam::outputType(a1);
v7 = MNN::ImageProcessParam::draw(a1) & 1;
result = a2;
*(_BYTE *)(a2 + 124) = v7 & 1;
return result;
}
| UnPackTo:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDI
MOV qword ptr [RSP + 0xa8],RSI
MOV qword ptr [RSP + 0xa0],RDX
MOV RDI,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x40],RDI
CALL 0x0012d970
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0x9c],EAX
MOV ECX,dword ptr [RSP + 0x9c]
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX],ECX
CALL 0x0012d990
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0x98],EAX
MOV ECX,dword ptr [RSP + 0x98]
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX + 0x4],ECX
CALL 0x0012d9b0
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0x94],EAX
MOV ECX,dword ptr [RSP + 0x94]
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX + 0x8],ECX
CALL 0x0012d9d0
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0x90],EAX
MOV ECX,dword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX + 0xc],ECX
CALL 0x0012d9f0
MOV qword ptr [RSP + 0x88],RAX
CMP qword ptr [RSP + 0x88],0x0
JZ 0x0012d70f
MOV RAX,qword ptr [RSP + 0xa8]
ADD RAX,0x10
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x0010b9e0
MOV RDI,qword ptr [RSP + 0x38]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x0010b970
MOV dword ptr [RSP + 0x84],0x0
LAB_0012d69a:
MOV EAX,dword ptr [RSP + 0x84]
MOV dword ptr [RSP + 0x34],EAX
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x0010b9e0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x34]
CMP EAX,ECX
JNC 0x0012d70d
MOV RDI,qword ptr [RSP + 0x88]
MOV ESI,dword ptr [RSP + 0x84]
CALL 0x0010ba00
MOVSS dword ptr [RSP + 0x30],XMM0
MOV RDI,qword ptr [RSP + 0xa8]
ADD RDI,0x10
MOV EAX,dword ptr [RSP + 0x84]
MOV ESI,EAX
CALL 0x0010ba70
MOVSS XMM0,dword ptr [RSP + 0x30]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RSP + 0x84]
ADD EAX,0x1
MOV dword ptr [RSP + 0x84],EAX
JMP 0x0012d69a
LAB_0012d70d:
JMP 0x0012d70f
LAB_0012d70f:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0012da10
MOV qword ptr [RSP + 0x78],RAX
CMP qword ptr [RSP + 0x78],0x0
JZ 0x0012d7bb
MOV RAX,qword ptr [RSP + 0xa8]
ADD RAX,0x28
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x0010b9e0
MOV RDI,qword ptr [RSP + 0x28]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x0010b970
MOV dword ptr [RSP + 0x74],0x0
LAB_0012d75b:
MOV EAX,dword ptr [RSP + 0x74]
MOV dword ptr [RSP + 0x24],EAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x0010b9e0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,ECX
JNC 0x0012d7b9
MOV RDI,qword ptr [RSP + 0x78]
MOV ESI,dword ptr [RSP + 0x74]
CALL 0x0010ba00
MOVSS dword ptr [RSP + 0x20],XMM0
MOV RDI,qword ptr [RSP + 0xa8]
ADD RDI,0x28
MOV EAX,dword ptr [RSP + 0x74]
MOV ESI,EAX
CALL 0x0010ba70
MOVSS XMM0,dword ptr [RSP + 0x20]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RSP + 0x74]
ADD EAX,0x1
MOV dword ptr [RSP + 0x74],EAX
JMP 0x0012d75b
LAB_0012d7b9:
JMP 0x0012d7bb
LAB_0012d7bb:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0012da30
MOV qword ptr [RSP + 0x68],RAX
CMP qword ptr [RSP + 0x68],0x0
JZ 0x0012d867
MOV RAX,qword ptr [RSP + 0xa8]
ADD RAX,0x40
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0010b9e0
MOV RDI,qword ptr [RSP + 0x18]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x0010b970
MOV dword ptr [RSP + 0x64],0x0
LAB_0012d807:
MOV EAX,dword ptr [RSP + 0x64]
MOV dword ptr [RSP + 0x14],EAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0010b9e0
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,ECX
JNC 0x0012d865
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x64]
CALL 0x0010ba00
MOVSS dword ptr [RSP + 0x10],XMM0
MOV RDI,qword ptr [RSP + 0xa8]
ADD RDI,0x40
MOV EAX,dword ptr [RSP + 0x64]
MOV ESI,EAX
CALL 0x0010ba70
MOVSS XMM0,dword ptr [RSP + 0x10]
MOVSS dword ptr [RAX],XMM0
MOV EAX,dword ptr [RSP + 0x64]
ADD EAX,0x1
MOV dword ptr [RSP + 0x64],EAX
JMP 0x0012d807
LAB_0012d865:
JMP 0x0012d867
LAB_0012d867:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0012da50
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x63],AL
MOV CL,byte ptr [RSP + 0x63]
MOV RAX,qword ptr [RSP + 0xa8]
MOV byte ptr [RAX + 0x58],CL
CALL 0x0012da70
MOV qword ptr [RSP + 0x58],RAX
CMP qword ptr [RSP + 0x58],0x0
JZ 0x0012d928
MOV RAX,qword ptr [RSP + 0xa8]
ADD RAX,0x60
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010b480
MOV RDI,qword ptr [RSP + 0x8]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x0010b410
MOV dword ptr [RSP + 0x54],0x0
LAB_0012d8d0:
MOV EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010b480
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x4]
CMP EAX,ECX
JNC 0x0012d926
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,dword ptr [RSP + 0x54]
CALL 0x0010b4a0
MOV dword ptr [RSP],EAX
MOV RDI,qword ptr [RSP + 0xa8]
ADD RDI,0x60
MOV EAX,dword ptr [RSP + 0x54]
MOV ESI,EAX
CALL 0x0010b510
MOV ECX,dword ptr [RSP]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x54]
ADD EAX,0x1
MOV dword ptr [RSP + 0x54],EAX
JMP 0x0012d8d0
LAB_0012d926:
JMP 0x0012d928
LAB_0012d928:
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0012da90
MOV RDI,qword ptr [RSP + 0x40]
MOV dword ptr [RSP + 0x50],EAX
MOV ECX,dword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX + 0x78],ECX
CALL 0x0012dab0
AND AL,0x1
MOV byte ptr [RSP + 0x4f],AL
MOV CL,byte ptr [RSP + 0x4f]
MOV RAX,qword ptr [RSP + 0xa8]
AND CL,0x1
MOV byte ptr [RAX + 0x7c],CL
ADD RSP,0xb8
RET
|
/* MNN::ImageProcessParam::UnPackTo(MNN::ImageProcessParamT*, std::function<void (void**, unsigned
long)> const*) const */
void MNN::ImageProcessParam::UnPackTo(ImageProcessParamT *param_1,function *param_2)
{
function fVar1;
byte bVar2;
int4 uVar3;
uint uVar4;
Vector<float> *pVVar5;
int4 *puVar6;
Vector<int> *this;
uint local_64;
uint local_54;
uint local_44;
uint local_34;
uVar3 = filterType((ImageProcessParam *)param_1);
*(int4 *)param_2 = uVar3;
uVar3 = sourceFormat((ImageProcessParam *)param_1);
*(int4 *)(param_2 + 4) = uVar3;
uVar3 = destFormat((ImageProcessParam *)param_1);
*(int4 *)(param_2 + 8) = uVar3;
uVar3 = wrap((ImageProcessParam *)param_1);
*(int4 *)(param_2 + 0xc) = uVar3;
pVVar5 = (Vector<float> *)mean((ImageProcessParam *)param_1);
if (pVVar5 != (Vector<float> *)0x0) {
uVar4 = flatbuffers::Vector<float>::size(pVVar5);
std::vector<float,std::allocator<float>>::resize
((vector<float,std::allocator<float>> *)(param_2 + 0x10),(ulong)uVar4);
for (local_34 = 0; uVar4 = flatbuffers::Vector<float>::size(pVVar5), local_34 < uVar4;
local_34 = local_34 + 1) {
uVar3 = flatbuffers::Vector<float>::Get(pVVar5,local_34);
puVar6 = (int4 *)
std::vector<float,std::allocator<float>>::operator[][abi_nn200100_
((vector<float,std::allocator<float>> *)(param_2 + 0x10),(ulong)local_34);
*puVar6 = uVar3;
}
}
pVVar5 = (Vector<float> *)normal((ImageProcessParam *)param_1);
if (pVVar5 != (Vector<float> *)0x0) {
uVar4 = flatbuffers::Vector<float>::size(pVVar5);
std::vector<float,std::allocator<float>>::resize
((vector<float,std::allocator<float>> *)(param_2 + 0x28),(ulong)uVar4);
for (local_44 = 0; uVar4 = flatbuffers::Vector<float>::size(pVVar5), local_44 < uVar4;
local_44 = local_44 + 1) {
uVar3 = flatbuffers::Vector<float>::Get(pVVar5,local_44);
puVar6 = (int4 *)
std::vector<float,std::allocator<float>>::operator[][abi_nn200100_
((vector<float,std::allocator<float>> *)(param_2 + 0x28),(ulong)local_44);
*puVar6 = uVar3;
}
}
pVVar5 = (Vector<float> *)transform((ImageProcessParam *)param_1);
if (pVVar5 != (Vector<float> *)0x0) {
uVar4 = flatbuffers::Vector<float>::size(pVVar5);
std::vector<float,std::allocator<float>>::resize
((vector<float,std::allocator<float>> *)(param_2 + 0x40),(ulong)uVar4);
for (local_54 = 0; uVar4 = flatbuffers::Vector<float>::size(pVVar5), local_54 < uVar4;
local_54 = local_54 + 1) {
uVar3 = flatbuffers::Vector<float>::Get(pVVar5,local_54);
puVar6 = (int4 *)
std::vector<float,std::allocator<float>>::operator[][abi_nn200100_
((vector<float,std::allocator<float>> *)(param_2 + 0x40),(ulong)local_54);
*puVar6 = uVar3;
}
}
fVar1 = (function)paddingValue((ImageProcessParam *)param_1);
param_2[0x58] = fVar1;
this = (Vector<int> *)shape((ImageProcessParam *)param_1);
if (this != (Vector<int> *)0x0) {
uVar4 = flatbuffers::Vector<int>::size(this);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)(param_2 + 0x60),(ulong)uVar4);
for (local_64 = 0; uVar4 = flatbuffers::Vector<int>::size(this), local_64 < uVar4;
local_64 = local_64 + 1) {
uVar3 = flatbuffers::Vector<int>::Get(this,local_64);
puVar6 = (int4 *)
std::vector<int,std::allocator<int>>::operator[][abi_nn200100_
((vector<int,std::allocator<int>> *)(param_2 + 0x60),(ulong)local_64);
*puVar6 = uVar3;
}
}
uVar3 = outputType((ImageProcessParam *)param_1);
*(int4 *)(param_2 + 0x78) = uVar3;
bVar2 = draw((ImageProcessParam *)param_1);
param_2[0x7c] = (function)(bVar2 & 1);
return;
}
| |
34,263 | set_next_block(elf_file*, std::unique_ptr<block, std::default_delete<block>>&, unsigned int) | msxemulator/build_O3/_deps/picotool-src/bintool/bintool.cpp | void set_next_block(elf_file *elf, std::unique_ptr<block> &first_block, uint32_t highest_address) {
// todo this isn't right, but virtual should be physical for now
auto seg = elf->segment_from_physical_address(first_block->physical_addr);
if (seg == nullptr) {
fail(ERROR_NOT_POSSIBLE, "The ELF file does not contain the next block address %x", first_block->physical_addr);
}
std::vector<uint8_t> content = elf->content(*seg);
uint32_t offset = first_block->physical_addr + first_block->next_block_rel_index * 4 - seg->physical_address();
uint32_t delta = highest_address - first_block->physical_addr;
// todo this assumes a 2 word NEXT_BLOCK_ADDR type for now
content[offset] = delta & 0xff;
content[offset+1] = (delta >> 8) & 0xff;
content[offset+2] = (delta >> 16) & 0xff;
content[offset+3] = (delta >> 24) & 0xff;
DEBUG_LOG("defaulting next_block_addr at %08x to %08x\n",
(int)first_block->physical_addr + first_block->next_block_rel_index * 4,
(int)(highest_address));
first_block->next_block_rel = delta;
elf->content(*seg, content);
} | O3 | cpp | set_next_block(elf_file*, std::unique_ptr<block, std::default_delete<block>>&, unsigned int):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movl (%rax), %esi
callq 0xa1f56
movq %rax, %r12
testq %rax, %rax
jne 0x72d07
movq (%r15), %rax
movl (%rax), %edx
leaq 0x37fe1(%rip), %rsi # 0xaacdc
movl $0xfffffff8, %edi # imm = 0xFFFFFFF8
xorl %eax, %eax
callq 0x7b492
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xa1e2a
movq (%r15), %rax
movl (%rax), %ecx
movl 0x8(%rax), %eax
leal (%rcx,%rax,4), %eax
subl 0xc(%r12), %eax
subl %ecx, %ebx
movq (%r13), %rcx
movb %bl, (%rcx,%rax)
leal 0x1(%rax), %ecx
movq (%r13), %rdx
movb %bh, (%rdx,%rcx)
movl %ebx, %ecx
shrl $0x10, %ecx
leal 0x2(%rax), %edx
movq (%r13), %rsi
movb %cl, (%rsi,%rdx)
movl %ebx, %ecx
shrl $0x18, %ecx
addl $0x3, %eax
movq (%r13), %rdx
movb %cl, (%rdx,%rax)
movq (%r15), %rax
movl %ebx, 0x4(%rax)
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xa1e82
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x72d86
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xf470
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x72dae
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf7d0
| _Z14set_next_blockP8elf_fileRSt10unique_ptrI5blockSt14default_deleteIS2_EEj:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 20h
mov ebx, edx
mov r15, rsi
mov r14, rdi
mov rax, [rsi]
mov esi, [rax]; unsigned int
call _ZN8elf_file29segment_from_physical_addressEj; elf_file::segment_from_physical_address(uint)
mov r12, rax
test rax, rax
jnz short loc_72D07
mov rax, [r15]
mov edx, [rax]
lea rsi, aTheElfFileDoes; "The ELF file does not contain the next "...
mov edi, 0FFFFFFF8h; int
xor eax, eax
call _Z4failiPKcz; fail(int,char const*,...)
loc_72D07:
lea r13, [rsp+48h+var_40]
mov rdi, r13
mov rsi, r14
mov rdx, r12
call _ZNK8elf_file7contentERK14elf32_ph_entry; elf_file::content(elf32_ph_entry const&)
mov rax, [r15]
mov ecx, [rax]
mov eax, [rax+8]
lea eax, [rcx+rax*4]
sub eax, [r12+0Ch]
sub ebx, ecx
mov rcx, [r13+0]
mov [rcx+rax], bl
lea ecx, [rax+1]
mov rdx, [r13+0]
mov [rdx+rcx], bh
mov ecx, ebx
shr ecx, 10h
lea edx, [rax+2]
mov rsi, [r13+0]
mov [rsi+rdx], cl
mov ecx, ebx
shr ecx, 18h
add eax, 3
mov rdx, [r13+0]
mov [rdx+rax], cl
mov rax, [r15]
mov [rax+4], ebx
mov rdi, r14; this
mov rsi, r12
mov rdx, r13
call _ZN8elf_file7contentERK14elf32_ph_entryRKSt6vectorIhSaIhEE; elf_file::content(elf32_ph_entry const&,std::vector<uchar> const&)
mov rdi, [rsp+48h+var_40]; void *
test rdi, rdi
jz short loc_72D86
mov rsi, [rsp+48h+var_30]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_72D86:
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
test rdi, rdi
jz short loc_72DAE
mov rsi, [rsp+arg_10]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_72DAE:
mov rdi, rbx
call __Unwind_Resume
| void set_next_block(elf_file *this, unsigned int **a2, int a3)
{
long long v4; // rax
long long v5; // r12
unsigned int v6; // ecx
long long v7; // rax
unsigned int v8; // ebx
void *v9[8]; // [rsp+8h] [rbp-40h] BYREF
v4 = elf_file::segment_from_physical_address(this, **a2);
v5 = v4;
if ( !v4 )
fail(-8, "The ELF file does not contain the next block address %x", **a2);
elf_file::content(v9, this, v4);
v6 = **a2;
v7 = v6 + 4 * (*a2)[2] - *(_DWORD *)(v5 + 12);
v8 = a3 - v6;
*((_BYTE *)v9[0] + v7) = v8;
*((_BYTE *)v9[0] + (unsigned int)(v7 + 1)) = BYTE1(v8);
*((_BYTE *)v9[0] + (unsigned int)(v7 + 2)) = BYTE2(v8);
*((_BYTE *)v9[0] + (unsigned int)(v7 + 3)) = HIBYTE(v8);
(*a2)[1] = v8;
elf_file::content(this);
if ( v9[0] )
operator delete(v9[0], (char *)v9[2] - (char *)v9[0]);
}
| set_next_block:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr [RSI]
MOV ESI,dword ptr [RAX]
CALL 0x001a1f56
MOV R12,RAX
TEST RAX,RAX
JNZ 0x00172d07
MOV RAX,qword ptr [R15]
MOV EDX,dword ptr [RAX]
LEA RSI,[0x1aacdc]
MOV EDI,0xfffffff8
XOR EAX,EAX
CALL 0x0017b492
LAB_00172d07:
LEA R13,[RSP + 0x8]
MOV RDI,R13
MOV RSI,R14
MOV RDX,R12
CALL 0x001a1e2a
MOV RAX,qword ptr [R15]
MOV ECX,dword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x8]
LEA EAX,[RCX + RAX*0x4]
SUB EAX,dword ptr [R12 + 0xc]
SUB EBX,ECX
MOV RCX,qword ptr [R13]
MOV byte ptr [RCX + RAX*0x1],BL
LEA ECX,[RAX + 0x1]
MOV RDX,qword ptr [R13]
MOV byte ptr [RDX + RCX*0x1],BH
MOV ECX,EBX
SHR ECX,0x10
LEA EDX,[RAX + 0x2]
MOV RSI,qword ptr [R13]
MOV byte ptr [RSI + RDX*0x1],CL
MOV ECX,EBX
SHR ECX,0x18
ADD EAX,0x3
MOV RDX,qword ptr [R13]
MOV byte ptr [RDX + RAX*0x1],CL
MOV RAX,qword ptr [R15]
MOV dword ptr [RAX + 0x4],EBX
LAB_00172d61:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
CALL 0x001a1e82
LAB_00172d6f:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00172d86
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0010f470
LAB_00172d86:
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* set_next_block(elf_file*, std::unique_ptr<block, std::default_delete<block> >&, unsigned int) */
void set_next_block(elf_file *param_1,unique_ptr *param_2,uint param_3)
{
uint uVar1;
elf32_ph_entry *peVar2;
int iVar3;
void *local_40 [2];
long local_30;
peVar2 = (elf32_ph_entry *)elf_file::segment_from_physical_address(param_1,**(uint **)param_2);
if (peVar2 == (elf32_ph_entry *)0x0) {
fail(-8,"The ELF file does not contain the next block address %x",(ulong)**(uint **)param_2);
}
elf_file::content((elf32_ph_entry *)local_40);
iVar3 = **(int **)param_2;
uVar1 = (iVar3 + (*(int **)param_2)[2] * 4) - *(int *)(peVar2 + 0xc);
iVar3 = param_3 - iVar3;
*(char *)((long)local_40[0] + (ulong)uVar1) = (char)iVar3;
*(char *)((long)local_40[0] + (ulong)(uVar1 + 1)) = (char)((uint)iVar3 >> 8);
*(char *)((long)local_40[0] + (ulong)(uVar1 + 2)) = (char)((uint)iVar3 >> 0x10);
*(char *)((long)local_40[0] + (ulong)(uVar1 + 3)) = (char)((uint)iVar3 >> 0x18);
*(int *)(*(long *)param_2 + 4) = iVar3;
/* try { // try from 00172d61 to 00172d6e has its CatchHandler @ 00172d94 */
elf_file::content(param_1,peVar2,(elf32_ph_entry *)local_40);
if (local_40[0] != (void *)0x0) {
operator_delete(local_40[0],local_30 - (long)local_40[0]);
}
return;
}
| |
34,264 | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&) | monkey531[P]llama/common/minja.hpp | static void destructuring_assign(const std::vector<std::string> & var_names, const std::shared_ptr<Context> & context, Value& item) {
if (var_names.size() == 1) {
Value name(var_names[0]);
context->set(name, item);
} else {
if (!item.is_array() || item.size() != var_names.size()) {
throw std::runtime_error("Mismatched number of variables and items in destructuring assignment");
}
for (size_t i = 0; i < var_names.size(); ++i) {
context->set(var_names[i], item.at(i));
}
}
} | O2 | cpp | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %rbp
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x27dae
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x40370
movq (%rbp), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x28(%rax)
leaq 0x8(%rsp), %rdi
callq 0x3c7a4
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x10(%rbx)
je 0x27e3e
movq %rdi, %r15
movq %rbx, %rdi
callq 0x4cee2
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jne 0x27e3e
movq %rbx, (%rsp)
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
subq %rsi, %rcx
sarq $0x5, %rcx
cmpq %rcx, %r13
jae 0x27d9f
movq %rbp, %rbx
movq (%rbp), %rbp
addq %r14, %rsi
movq %r12, %rdi
callq 0x40370
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x4cfea
movq (%rbp), %rcx
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq *0x28(%rcx)
movq %r12, %rdi
callq 0x3c7a4
incq %r13
movq (%r15), %rsi
movq 0x8(%r15), %rcx
addq $0x20, %r14
movq %rbx, %rbp
jmp 0x27de9
pushq $0x10
popq %rdi
callq 0x20380
movq %rax, %r14
leaq 0x68b41(%rip), %rsi # 0x90991
movq %rax, %rdi
callq 0x20270
movq 0xa8191(%rip), %rsi # 0xcfff0
movq 0xa810a(%rip), %rdx # 0xcff70
movq %r14, %rdi
callq 0x20b30
movq %rax, %rbx
movq %r14, %rdi
callq 0x20510
jmp 0x27e8a
jmp 0x27e7d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3c7a4
movq %rbx, %rdi
callq 0x20bb0
| _ZN5minjaL20destructuring_assignERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EERKSt10shared_ptrINS_7ContextEERNS_5ValueE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdx
mov rbp, rsi
mov rsi, [rdi]
mov rax, [rdi+8]
sub rax, rsi
cmp rax, 20h ; ' '
jnz short loc_27DAE
lea r15, [rsp+88h+var_80]
mov rdi, r15
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rbp+0]
mov rax, [rdi]
mov rsi, r15
mov rdx, rbx
call qword ptr [rax+28h]
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_27D9F:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_27DAE:
cmp qword ptr [rbx+10h], 0
jz loc_27E3E
mov r15, rdi
mov rdi, rbx; this
call _ZNK5minja5Value4sizeEv; minja::Value::size(void)
mov rsi, [r15]
mov rcx, [r15+8]
mov rdx, rcx
sub rdx, rsi
sar rdx, 5
cmp rax, rdx
jnz short loc_27E3E
mov [rsp+88h+var_88], rbx
xor r14d, r14d
lea r12, [rsp+88h+var_80]
xor r13d, r13d
loc_27DE9:
sub rcx, rsi
sar rcx, 5
cmp r13, rcx
jnb short loc_27D9F
mov rbx, rbp
mov rbp, [rbp+0]
add rsi, r14
mov rdi, r12
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rsp+88h+var_88]; this
mov rsi, r13; unsigned __int64
call _ZN5minja5Value2atEm; minja::Value::at(ulong)
mov rcx, [rbp+0]
mov rdi, rbp
mov rsi, r12
mov rdx, rax
call qword ptr [rcx+28h]
mov rdi, r12; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
inc r13
mov rsi, [r15]
mov rcx, [r15+8]
add r14, 20h ; ' '
mov rbp, rbx
jmp short loc_27DE9
loc_27E3E:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aMismatchedNumb; "Mismatched number of variables and item"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_27E8A
jmp short $+2
loc_27E7D:
mov rbx, rax
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_27E8A:
mov rdi, rbx
call __Unwind_Resume
| void minja::destructuring_assign(_QWORD *a1, _QWORD *a2, minja::Value *a3)
{
_QWORD *v4; // rbp
long long v5; // rax
long long v6; // rsi
long long v7; // rcx
long long v8; // r14
unsigned long long v9; // r13
_QWORD *v10; // rbx
long long v11; // rbp
long long v12; // rax
std::runtime_error *exception; // r14
minja::Value *v14; // [rsp+0h] [rbp-88h]
_BYTE v15[128]; // [rsp+8h] [rbp-80h] BYREF
v4 = a2;
if ( a1[1] - *a1 == 32LL )
{
minja::Value::Value(v15, *a1);
(*(void ( **)(_QWORD, _BYTE *, minja::Value *))(*(_QWORD *)*a2 + 40LL))(*a2, v15, a3);
minja::Value::~Value((minja::Value *)v15);
}
else
{
if ( !*((_QWORD *)a3 + 2) || (v5 = minja::Value::size(a3), v6 = *a1, v7 = a1[1], v5 != (v7 - *a1) >> 5) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(
exception,
"Mismatched number of variables and items in destructuring assignment");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v14 = a3;
v8 = 0LL;
v9 = 0LL;
while ( v9 < (v7 - v6) >> 5 )
{
v10 = v4;
v11 = *v4;
minja::Value::Value(v15, v8 + v6);
v12 = minja::Value::at(v14, v9);
(*(void ( **)(long long, _BYTE *, long long))(*(_QWORD *)v11 + 40LL))(v11, v15, v12);
minja::Value::~Value((minja::Value *)v15);
++v9;
v6 = *a1;
v7 = a1[1];
v8 += 32LL;
v4 = v10;
}
}
}
| destructuring_assign:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDX
MOV RBP,RSI
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RSI
CMP RAX,0x20
JNZ 0x00127dae
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00140370
MOV RDI,qword ptr [RBP]
MOV RAX,qword ptr [RDI]
LAB_00127d8c:
MOV RSI,R15
MOV RDX,RBX
CALL qword ptr [RAX + 0x28]
LAB_00127d95:
LEA RDI,[RSP + 0x8]
CALL 0x0013c7a4
LAB_00127d9f:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00127dae:
CMP qword ptr [RBX + 0x10],0x0
JZ 0x00127e3e
MOV R15,RDI
MOV RDI,RBX
CALL 0x0014cee2
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RDX,RCX
SUB RDX,RSI
SAR RDX,0x5
CMP RAX,RDX
JNZ 0x00127e3e
MOV qword ptr [RSP],RBX
XOR R14D,R14D
LEA R12,[RSP + 0x8]
XOR R13D,R13D
LAB_00127de9:
SUB RCX,RSI
SAR RCX,0x5
CMP R13,RCX
JNC 0x00127d9f
MOV RBX,RBP
MOV RBP,qword ptr [RBP]
ADD RSI,R14
MOV RDI,R12
CALL 0x00140370
LAB_00127e07:
MOV RDI,qword ptr [RSP]
MOV RSI,R13
CALL 0x0014cfea
MOV RCX,qword ptr [RBP]
MOV RDI,RBP
MOV RSI,R12
MOV RDX,RAX
CALL qword ptr [RCX + 0x28]
LAB_00127e23:
MOV RDI,R12
CALL 0x0013c7a4
INC R13
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
ADD R14,0x20
MOV RBP,RBX
JMP 0x00127de9
LAB_00127e3e:
PUSH 0x10
POP RDI
CALL 0x00120380
MOV R14,RAX
LAB_00127e49:
LEA RSI,[0x190991]
MOV RDI,RAX
CALL 0x00120270
LAB_00127e58:
MOV RSI,qword ptr [0x001cfff0]
MOV RDX,qword ptr [0x001cff70]
MOV RDI,R14
CALL 0x00120b30
|
/* minja::destructuring_assign(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string
> > const&, std::shared_ptr<minja::Context> const&, minja::Value&) */
void minja::destructuring_assign(vector *param_1,shared_ptr *param_2,Value *param_3)
{
long *plVar1;
long lVar2;
int8 uVar3;
runtime_error *this;
long lVar4;
long lVar5;
ulong uVar6;
Value local_80 [80];
if (*(long *)(param_1 + 8) - (long)*(string **)param_1 == 0x20) {
Value::Value(local_80,*(string **)param_1);
/* try { // try from 00127d8c to 00127d94 has its CatchHandler @ 00127e7b */
(**(code **)(**(long **)param_2 + 0x28))(*(long **)param_2,local_80,param_3);
Value::~Value(local_80);
return;
}
if (*(long *)(param_3 + 0x10) != 0) {
lVar2 = Value::size(param_3);
lVar5 = *(long *)param_1;
lVar4 = *(long *)(param_1 + 8);
if (lVar2 == lVar4 - lVar5 >> 5) {
lVar2 = 0;
for (uVar6 = 0; uVar6 < (ulong)(lVar4 - lVar5 >> 5); uVar6 = uVar6 + 1) {
plVar1 = *(long **)param_2;
Value::Value(local_80,(string *)(lVar5 + lVar2));
/* try { // try from 00127e07 to 00127e22 has its CatchHandler @ 00127e7d */
uVar3 = Value::at(param_3,uVar6);
(**(code **)(*plVar1 + 0x28))(plVar1,local_80,uVar3);
Value::~Value(local_80);
lVar5 = *(long *)param_1;
lVar4 = *(long *)(param_1 + 8);
lVar2 = lVar2 + 0x20;
}
return;
}
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00127e49 to 00127e57 has its CatchHandler @ 00127e6e */
std::runtime_error::runtime_error
(this,"Mismatched number of variables and items in destructuring assignment");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001cfff0,PTR__runtime_error_001cff70);
}
| |
34,265 | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&) | monkey531[P]llama/common/minja.hpp | static void destructuring_assign(const std::vector<std::string> & var_names, const std::shared_ptr<Context> & context, Value& item) {
if (var_names.size() == 1) {
Value name(var_names[0]);
context->set(name, item);
} else {
if (!item.is_array() || item.size() != var_names.size()) {
throw std::runtime_error("Mismatched number of variables and items in destructuring assignment");
}
for (size_t i = 0; i < var_names.size(); ++i) {
context->set(var_names[i], item.at(i));
}
}
} | O3 | cpp | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x2392b
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x41d1a
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r12, %rdx
callq *0x28(%rax)
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3d0e4
movq %rbx, %rdi
callq 0x49cd2
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x238e1
callq 0x2f20e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x238f0
callq 0x2f20e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x238ff
callq 0x2f20e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23a4d
movq 0xb8684(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x23a38
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x23a42
movq %rbx, (%rsp)
cmpq $0x0, 0x10(%r12)
je 0x23a5c
movq %rdi, %r15
movq %r12, %rdi
callq 0x50fa8
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jne 0x23a5c
cmpq %rsi, %rcx
je 0x23a4d
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
movq (%rsp), %rax
movq (%rax), %r14
addq %rbx, %rsi
movq %r13, %rdi
callq 0x41d1a
movq %r12, %rdi
movq %rbp, %rsi
callq 0x51108
movq (%r14), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq *0x28(%rcx)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3d0e4
movq %r14, %rdi
callq 0x49cd2
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x239c4
callq 0x2f20e
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x239d3
callq 0x2f20e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x239e2
callq 0x2f20e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x23a18
movq 0xb85a5(%rip), %rax # 0xdbf98
cmpb $0x0, (%rax)
je 0x23a03
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x23a0d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x23a18
movq (%rdi), %rax
callq *0x18(%rax)
incq %rbp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbx
cmpq %rax, %rbp
jb 0x23972
jmp 0x23a4d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x23a4d
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x18350
movq %rax, %r14
leaq 0x87f42(%rip), %rsi # 0xab9b2
movq %rax, %rdi
callq 0x18260
movq 0xb8571(%rip), %rsi # 0xdbff0
movq 0xb84ea(%rip), %rdx # 0xdbf70
movq %r14, %rdi
callq 0x18b30
movq %rax, %rbx
movq %r14, %rdi
callq 0x184f0
jmp 0x23aaa
jmp 0x23a9d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d058
movq %rbx, %rdi
callq 0x18bb0
| _ZN5minjaL20destructuring_assignERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EERKSt10shared_ptrINS_7ContextEERNS_5ValueE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r12, rdx
mov rbx, rsi
mov rsi, [rdi]
mov rax, [rdi+8]
sub rax, rsi
cmp rax, 20h ; ' '
jnz loc_2392B
lea r14, [rsp+88h+var_80]
mov rdi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rbx]
mov rax, [rdi]
mov rsi, r14
mov rdx, r12
call qword ptr [rax+28h]
lea rbx, [rsp+88h+var_40]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_238E1
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_238E1:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_238F0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_238F0:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_238FF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_238FF:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz loc_23A4D
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz loc_23A38
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp loc_23A42
loc_2392B:
mov [rsp+88h+var_88], rbx
cmp qword ptr [r12+10h], 0
jz loc_23A5C
mov r15, rdi
mov rdi, r12; this
call _ZNK5minja5Value4sizeEv; minja::Value::size(void)
mov rsi, [r15]
mov rcx, [r15+8]
mov rdx, rcx
sub rdx, rsi
sar rdx, 5
cmp rax, rdx
jnz loc_23A5C
cmp rcx, rsi
jz loc_23A4D
xor ebx, ebx
lea r13, [rsp+88h+var_80]
xor ebp, ebp
loc_23972:
mov rax, [rsp+88h+var_88]
mov r14, [rax]
add rsi, rbx
mov rdi, r13
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r12; this
mov rsi, rbp; unsigned __int64
call _ZN5minja5Value2atEm; minja::Value::at(ulong)
mov rcx, [r14]
mov rdi, r14
mov rsi, r13
mov rdx, rax
call qword ptr [rcx+28h]
lea r14, [rsp+88h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+88h+var_48]
test rdi, rdi
jz short loc_239C4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_239C4:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_239D3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_239D3:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_239E2
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_239E2:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_23A18
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_23A03
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_23A0D
loc_23A03:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_23A0D:
cmp eax, 1
jnz short loc_23A18
mov rax, [rdi]
call qword ptr [rax+18h]
loc_23A18:
inc rbp
mov rsi, [r15]
mov rax, [r15+8]
sub rax, rsi
sar rax, 5
add rbx, 20h ; ' '
cmp rbp, rax
jb loc_23972
jmp short loc_23A4D
loc_23A38:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_23A42:
cmp eax, 1
jnz short loc_23A4D
mov rax, [rdi]
call qword ptr [rax+18h]
loc_23A4D:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_23A5C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aMismatchedNumb; "Mismatched number of variables and item"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_23AAA
jmp short $+2
loc_23A9D:
mov rbx, rax
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_23AAA:
mov rdi, rbx
call __Unwind_Resume
| unsigned long long minja::destructuring_assign(_QWORD *a1, _QWORD *a2, minja::Value *a3)
{
unsigned long long result; // rax
long long v5; // rdi
long long v7; // rsi
long long v8; // rbx
unsigned long long v9; // rbp
long long v10; // r14
long long v11; // rax
long long v12; // rdi
signed __int32 v13; // eax
std::runtime_error *exception; // r14
_BYTE v16[8]; // [rsp+8h] [rbp-80h] BYREF
long long v17; // [rsp+10h] [rbp-78h]
long long v18; // [rsp+20h] [rbp-68h]
long long v19; // [rsp+30h] [rbp-58h]
long long v20; // [rsp+40h] [rbp-48h]
_BYTE v21[64]; // [rsp+48h] [rbp-40h] BYREF
if ( a1[1] - *a1 == 32LL )
{
minja::Value::Value(v16, *a1);
(*(void ( **)(_QWORD, _BYTE *, minja::Value *))(*(_QWORD *)*a2 + 40LL))(*a2, v16, a3);
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(
v21,
0LL);
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>::data::~data(v21);
if ( v20 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
if ( v19 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
if ( v18 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v5 = v17;
if ( v17 )
{
if ( _libc_single_threaded )
{
result = *(unsigned int *)(v17 + 12);
*(_DWORD *)(v17 + 12) = result - 1;
}
else
{
result = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)(v17 + 12), 0xFFFFFFFF);
}
if ( (_DWORD)result == 1 )
return (*(long long ( **)(long long))(*(_QWORD *)v5 + 24LL))(v5);
}
}
else
{
if ( !*((_QWORD *)a3 + 2) || (result = minja::Value::size(a3), v7 = *a1, result != (long long)(a1[1] - *a1) >> 5) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(
exception,
"Mismatched number of variables and items in destructuring assignment");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( a1[1] != v7 )
{
v8 = 0LL;
v9 = 0LL;
do
{
v10 = *a2;
minja::Value::Value(v16, v8 + v7);
v11 = minja::Value::at(a3, v9);
(*(void ( **)(long long, _BYTE *, long long))(*(_QWORD *)v10 + 40LL))(v10, v16, v11);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v21,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v12 = v17;
if ( v17 )
{
if ( _libc_single_threaded )
{
v13 = *(_DWORD *)(v17 + 12);
*(_DWORD *)(v17 + 12) = v13 - 1;
}
else
{
v13 = _InterlockedExchangeAdd((volatile signed __int32 *)(v17 + 12), 0xFFFFFFFF);
}
if ( v13 == 1 )
(*(void ( **)(long long))(*(_QWORD *)v12 + 24LL))(v12);
}
++v9;
v7 = *a1;
result = (long long)(a1[1] - *a1) >> 5;
v8 += 32LL;
}
while ( v9 < result );
}
}
return result;
}
| destructuring_assign:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R12,RDX
MOV RBX,RSI
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RSI
CMP RAX,0x20
JNZ 0x0012392b
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x00141d1a
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LAB_001238b3:
MOV RSI,R14
MOV RDX,R12
CALL qword ptr [RAX + 0x28]
LAB_001238bc:
LEA RBX,[RSP + 0x48]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013d0e4
MOV RDI,RBX
CALL 0x00149cd2
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x001238e1
CALL 0x0012f20e
LAB_001238e1:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001238f0
CALL 0x0012f20e
LAB_001238f0:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x001238ff
CALL 0x0012f20e
LAB_001238ff:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00123a4d
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x00123a38
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00123a42
LAB_0012392b:
MOV qword ptr [RSP],RBX
CMP qword ptr [R12 + 0x10],0x0
JZ 0x00123a5c
MOV R15,RDI
MOV RDI,R12
CALL 0x00150fa8
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RDX,RCX
SUB RDX,RSI
SAR RDX,0x5
CMP RAX,RDX
JNZ 0x00123a5c
CMP RCX,RSI
JZ 0x00123a4d
XOR EBX,EBX
LEA R13,[RSP + 0x8]
XOR EBP,EBP
LAB_00123972:
MOV RAX,qword ptr [RSP]
MOV R14,qword ptr [RAX]
ADD RSI,RBX
MOV RDI,R13
CALL 0x00141d1a
LAB_00123984:
MOV RDI,R12
MOV RSI,RBP
CALL 0x00151108
MOV RCX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R13
MOV RDX,RAX
CALL qword ptr [RCX + 0x28]
LAB_0012399e:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013d0e4
MOV RDI,R14
CALL 0x00149cd2
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x001239c4
CALL 0x0012f20e
LAB_001239c4:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001239d3
CALL 0x0012f20e
LAB_001239d3:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x001239e2
CALL 0x0012f20e
LAB_001239e2:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00123a18
MOV RAX,qword ptr [0x001dbf98]
CMP byte ptr [RAX],0x0
JZ 0x00123a03
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00123a0d
LAB_00123a03:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00123a0d:
CMP EAX,0x1
JNZ 0x00123a18
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00123a18:
INC RBP
MOV RSI,qword ptr [R15]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,RSI
SAR RAX,0x5
ADD RBX,0x20
CMP RBP,RAX
JC 0x00123972
JMP 0x00123a4d
LAB_00123a38:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00123a42:
CMP EAX,0x1
JNZ 0x00123a4d
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00123a4d:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00123a5c:
MOV EDI,0x10
CALL 0x00118350
MOV R14,RAX
LAB_00123a69:
LEA RSI,[0x1ab9b2]
MOV RDI,RAX
CALL 0x00118260
LAB_00123a78:
MOV RSI,qword ptr [0x001dbff0]
MOV RDX,qword ptr [0x001dbf70]
MOV RDI,R14
CALL 0x00118b30
|
/* minja::destructuring_assign(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string
> > const&, std::shared_ptr<minja::Context> const&, minja::Value&) */
void minja::destructuring_assign(vector *param_1,shared_ptr *param_2,Value *param_3)
{
int *piVar1;
long *plVar2;
int iVar3;
long lVar4;
int8 uVar5;
runtime_error *this;
ulong uVar6;
long lVar7;
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
if (*(long *)(param_1 + 8) - (long)*(string **)param_1 == 0x20) {
Value::Value(local_80,*(string **)param_1);
/* try { // try from 001238b3 to 001238bb has its CatchHandler @ 00123a9b */
(**(code **)(**(long **)param_2 + 0x28))(*(long **)param_2,local_80,param_3);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
return;
}
if (*(long *)(param_3 + 0x10) != 0) {
lVar4 = Value::size(param_3);
lVar7 = *(long *)param_1;
if (lVar4 == *(long *)(param_1 + 8) - lVar7 >> 5) {
if (*(long *)(param_1 + 8) == lVar7) {
return;
}
lVar4 = 0;
uVar6 = 0;
do {
plVar2 = *(long **)param_2;
Value::Value(local_80,(string *)(lVar7 + lVar4));
/* try { // try from 00123984 to 0012399d has its CatchHandler @ 00123a9d */
uVar5 = Value::at(param_3,uVar6);
(**(code **)(*plVar2 + 0x28))(plVar2,local_80,uVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001dbf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
uVar6 = uVar6 + 1;
lVar7 = *(long *)param_1;
lVar4 = lVar4 + 0x20;
} while (uVar6 < (ulong)(*(long *)(param_1 + 8) - lVar7 >> 5));
return;
}
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00123a69 to 00123a77 has its CatchHandler @ 00123a8e */
std::runtime_error::runtime_error
(this,"Mismatched number of variables and items in destructuring assignment");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001dbff0,PTR__runtime_error_001dbf70);
}
| |
34,266 | google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc | bool CopyingOutputStreamAdaptor::Next(void** data, int* size) {
if (buffer_used_ == buffer_size_) {
if (!WriteBuffer()) return false;
}
AllocateBufferIfNeeded();
*data = buffer_.get() + buffer_used_;
*size = buffer_size_ - buffer_used_;
buffer_used_ = buffer_size_;
return true;
} | O0 | cpp | google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x2c(%rcx), %eax
cmpl 0x28(%rcx), %eax
jne 0x1726fa
movq (%rsp), %rdi
callq 0x1725c0
testb $0x1, %al
jne 0x1726f8
movb $0x0, 0x27(%rsp)
jmp 0x17273e
jmp 0x1726fa
movq (%rsp), %rdi
callq 0x172750
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x173080
movq %rax, %rdx
movq (%rsp), %rax
movslq 0x2c(%rax), %rcx
addq %rcx, %rdx
movq 0x10(%rsp), %rcx
movq %rdx, (%rcx)
movl 0x28(%rax), %edx
subl 0x2c(%rax), %edx
movq 0x8(%rsp), %rcx
movl %edx, (%rcx)
movl 0x28(%rax), %ecx
movl %ecx, 0x2c(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf2io26CopyingOutputStreamAdaptor4NextEPPvPi:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov rcx, [rsp+28h+var_10]
mov [rsp+28h+var_28], rcx
mov eax, [rcx+2Ch]
cmp eax, [rcx+28h]
jnz short loc_1726FA
mov rdi, [rsp+28h+var_28]; this
call _ZN6google8protobuf2io26CopyingOutputStreamAdaptor11WriteBufferEv; google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(void)
test al, 1
jnz short loc_1726F8
mov [rsp+28h+var_1], 0
jmp short loc_17273E
loc_1726F8:
jmp short $+2
loc_1726FA:
mov rdi, [rsp+28h+var_28]; this
call _ZN6google8protobuf2io26CopyingOutputStreamAdaptor22AllocateBufferIfNeededEv; google::protobuf::io::CopyingOutputStreamAdaptor::AllocateBufferIfNeeded(void)
mov rdi, [rsp+28h+var_28]
add rdi, 20h ; ' '
call _ZNKSt10unique_ptrIA_hSt14default_deleteIS0_EE3getEv; std::unique_ptr<uchar []>::get(void)
mov rdx, rax
mov rax, [rsp+28h+var_28]
movsxd rcx, dword ptr [rax+2Ch]
add rdx, rcx
mov rcx, [rsp+28h+var_18]
mov [rcx], rdx
mov edx, [rax+28h]
sub edx, [rax+2Ch]
mov rcx, [rsp+28h+var_20]
mov [rcx], edx
mov ecx, [rax+28h]
mov [rax+2Ch], ecx
mov [rsp+28h+var_1], 1
loc_17273E:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
| char google::protobuf::io::CopyingOutputStreamAdaptor::Next(
google::protobuf::io::CopyingOutputStreamAdaptor *this,
void **a2,
int *a3)
{
if ( *((_DWORD *)this + 11) == *((_DWORD *)this + 10)
&& (google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(this) & 1) == 0 )
{
return 0;
}
google::protobuf::io::CopyingOutputStreamAdaptor::AllocateBufferIfNeeded(this);
*a2 = (void *)(*((int *)this + 11) + std::unique_ptr<unsigned char []>::get((char *)this + 32));
*a3 = *((_DWORD *)this + 10) - *((_DWORD *)this + 11);
*((_DWORD *)this + 11) = *((_DWORD *)this + 10);
return 1;
}
| |||
34,267 | google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc | bool CopyingOutputStreamAdaptor::Next(void** data, int* size) {
if (buffer_used_ == buffer_size_) {
if (!WriteBuffer()) return false;
}
AllocateBufferIfNeeded();
*data = buffer_.get() + buffer_used_;
*size = buffer_size_ - buffer_used_;
buffer_used_ = buffer_size_;
return true;
} | O3 | cpp | google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x28(%rdi), %ebp
cmpl %ebp, 0x2c(%rdi)
jne 0x7b243
movq %rbx, %rdi
callq 0x7b198
testb %al, %al
je 0x7b27b
movl 0x28(%rbx), %ebp
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0x7b262
testl %ebp, %ebp
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %ebp, %eax
movslq %eax, %rdi
callq 0x2c050
movq %rax, 0x20(%rbx)
movslq 0x2c(%rbx), %rcx
addq %rcx, %rax
movq %rax, (%r15)
subl %ecx, %ebp
movl %ebp, (%r14)
movl 0x28(%rbx), %eax
movl %eax, 0x2c(%rbx)
movb $0x1, %al
jmp 0x7b27d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ZN6google8protobuf2io26CopyingOutputStreamAdaptor4NextEPPvPi:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov ebp, [rdi+28h]
cmp [rdi+2Ch], ebp
jnz short loc_7B243
mov rdi, rbx; this
call _ZN6google8protobuf2io26CopyingOutputStreamAdaptor11WriteBufferEv; google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(void)
test al, al
jz short loc_7B27B
mov ebp, [rbx+28h]
loc_7B243:
mov rax, [rbx+20h]
test rax, rax
jnz short loc_7B262
test ebp, ebp
mov eax, 0FFFFFFFFh
cmovns eax, ebp
movsxd rdi, eax; unsigned __int64
call __Znam; operator new[](ulong)
mov [rbx+20h], rax
loc_7B262:
movsxd rcx, dword ptr [rbx+2Ch]
add rax, rcx
mov [r15], rax
sub ebp, ecx
mov [r14], ebp
mov eax, [rbx+28h]
mov [rbx+2Ch], eax
mov al, 1
jmp short loc_7B27D
loc_7B27B:
xor eax, eax
loc_7B27D:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| char google::protobuf::io::CopyingOutputStreamAdaptor::Next(
google::protobuf::io::CopyingOutputStreamAdaptor *this,
void **a2,
int *a3)
{
int v4; // ebp
long long v5; // rax
int v6; // eax
long long v7; // rcx
v4 = *((_DWORD *)this + 10);
if ( *((_DWORD *)this + 11) == v4 )
{
if ( !(unsigned __int8)google::protobuf::io::CopyingOutputStreamAdaptor::WriteBuffer(this) )
return 0;
v4 = *((_DWORD *)this + 10);
}
v5 = *((_QWORD *)this + 4);
if ( !v5 )
{
v6 = -1;
if ( v4 >= 0 )
v6 = v4;
v5 = operator new[](v6);
*((_QWORD *)this + 4) = v5;
}
v7 = *((int *)this + 11);
*a2 = (void *)(v7 + v5);
*a3 = v4 - v7;
*((_DWORD *)this + 11) = *((_DWORD *)this + 10);
return 1;
}
| Next:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV EBP,dword ptr [RDI + 0x28]
CMP dword ptr [RDI + 0x2c],EBP
JNZ 0x0017b243
MOV RDI,RBX
CALL 0x0017b198
TEST AL,AL
JZ 0x0017b27b
MOV EBP,dword ptr [RBX + 0x28]
LAB_0017b243:
MOV RAX,qword ptr [RBX + 0x20]
TEST RAX,RAX
JNZ 0x0017b262
TEST EBP,EBP
MOV EAX,0xffffffff
CMOVNS EAX,EBP
MOVSXD RDI,EAX
CALL 0x0012c050
MOV qword ptr [RBX + 0x20],RAX
LAB_0017b262:
MOVSXD RCX,dword ptr [RBX + 0x2c]
ADD RAX,RCX
MOV qword ptr [R15],RAX
SUB EBP,ECX
MOV dword ptr [R14],EBP
MOV EAX,dword ptr [RBX + 0x28]
MOV dword ptr [RBX + 0x2c],EAX
MOV AL,0x1
JMP 0x0017b27d
LAB_0017b27b:
XOR EAX,EAX
LAB_0017b27d:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::io::CopyingOutputStreamAdaptor::Next(void**, int*) */
int8 __thiscall
google::protobuf::io::CopyingOutputStreamAdaptor::Next
(CopyingOutputStreamAdaptor *this,void **param_1,int *param_2)
{
char cVar1;
int iVar2;
void *pvVar3;
int iVar4;
iVar4 = *(int *)(this + 0x28);
if (*(int *)(this + 0x2c) == iVar4) {
cVar1 = WriteBuffer(this);
if (cVar1 == '\0') {
return 0;
}
iVar4 = *(int *)(this + 0x28);
}
pvVar3 = *(void **)(this + 0x20);
if (pvVar3 == (void *)0x0) {
iVar2 = -1;
if (-1 < iVar4) {
iVar2 = iVar4;
}
pvVar3 = operator_new__((long)iVar2);
*(void **)(this + 0x20) = pvVar3;
}
iVar2 = *(int *)(this + 0x2c);
*param_1 = (void *)((long)pvVar3 + (long)iVar2);
*param_2 = iVar4 - iVar2;
*(int4 *)(this + 0x2c) = *(int4 *)(this + 0x28);
return CONCAT71((uint7)(uint3)((uint)*(int4 *)(this + 0x28) >> 8),1);
}
| |
34,268 | inline_mysql_mutex_init | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_mutex_init(
#ifdef HAVE_PSI_MUTEX_INTERFACE
PSI_mutex_key key,
#endif
mysql_mutex_t *that,
const pthread_mutexattr_t *attr
#ifdef SAFE_MUTEX
, const char *src_name, const char *src_file, uint src_line
#endif
)
{
#ifdef HAVE_PSI_MUTEX_INTERFACE
that->m_psi= PSI_MUTEX_CALL(init_mutex)(key, &that->m_mutex);
#else
that->m_psi= NULL;
#endif
#ifdef COROUTINE_ENABLED
that->l.data= that;
that->l.prev= that->l.next= NULL;
#endif
#ifdef SAFE_MUTEX
return safe_mutex_init(&that->m_mutex, attr, src_name, src_file, src_line);
#else
return pthread_mutex_init(&that->m_mutex, attr);
#endif
} | O0 | c | inline_mysql_mutex_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x292916(%rip), %rax # 0x2f5a60
movq (%rax), %rax
movq 0x40(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a380
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| inline_mysql_mutex_init_4:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+40h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rcx, [rbp+var_10]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+28h], 0
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_mutex_init
add rsp, 20h
pop rbp
retn
| long long inline_mysql_mutex_init_4(unsigned int a1, _QWORD *a2, long long a3)
{
a2[8] = ((long long ( *)(_QWORD, _QWORD *))PSI_server[8])(a1, a2);
a2[7] = a2;
a2[6] = 0LL;
a2[5] = 0LL;
return pthread_mutex_init(a2, a3);
}
| inline_mysql_mutex_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3f5a60]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x40]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],0x0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a380
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_mutex_init
(int4 param_1,pthread_mutex_t *param_2,pthread_mutexattr_t *param_3)
{
int8 uVar1;
uVar1 = (**(code **)(PSI_server + 0x40))(param_1,param_2);
*(int8 *)((long)param_2 + 0x40) = uVar1;
*(pthread_mutex_t **)((long)param_2 + 0x38) = param_2;
*(int8 *)((long)param_2 + 0x30) = 0;
param_2[1].__align = 0;
pthread_mutex_init(param_2,param_3);
return;
}
| |
34,269 | LEX::which_check_option_applicable() | eloqsql/sql/sql_lex.h | inline bool which_check_option_applicable()
{
switch (sql_command) {
case SQLCOM_UPDATE:
case SQLCOM_UPDATE_MULTI:
case SQLCOM_DELETE:
case SQLCOM_DELETE_MULTI:
case SQLCOM_INSERT:
case SQLCOM_INSERT_SELECT:
case SQLCOM_REPLACE:
case SQLCOM_REPLACE_SELECT:
case SQLCOM_LOAD:
return TRUE;
default:
return FALSE;
}
} | O0 | c | LEX::which_check_option_applicable():
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x44, %eax
ja 0x537917
movq -0x18(%rbp), %rax
leaq 0x8d62fc(%rip), %rcx # 0xe0dc04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x53791b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN3LEX29which_check_option_applicableEv:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax+8]
add eax, 0FFFFFFFCh; switch 69 cases
mov ecx, eax
mov [rbp+var_18], rcx
sub eax, 44h
ja short def_53790F; jumptable 000000000053790F default case, cases 8-29,31-39,42-70
mov rax, [rbp+var_18]
lea rcx, jpt_53790F
movsxd rax, ds:(jpt_53790F - 0E0DC04h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_537911:
mov [rbp+var_1], 1; jumptable 000000000053790F cases 4-7,30,40,41,71,72
jmp short loc_53791B
def_53790F:
mov [rbp+var_1], 0; jumptable 000000000053790F default case, cases 8-29,31-39,42-70
loc_53791B:
mov al, [rbp+var_1]
and al, 1
pop rbp
retn
| char LEX::which_check_option_applicable(LEX *this)
{
char v2; // [rsp+17h] [rbp-1h]
switch ( *((_DWORD *)this + 2) )
{
case 4:
case 5:
case 6:
case 7:
case 0x1E:
case 0x28:
case 0x29:
case 0x47:
case 0x48:
v2 = 1;
break;
default:
v2 = 0;
break;
}
return v2;
}
| __cxx_global_var_init:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x16c27f0]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x005a2df0
POP RBP
RET
|
void __cxx_global_var_init(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_CONV_NONE,0);
return;
}
| |
34,270 | unlock_lock_and_free_resource | eloqsql/mysys/waiting_threads.c | static int unlock_lock_and_free_resource(WT_THD *thd, WT_RESOURCE *rc)
{
uint keylen;
const void *key;
DBUG_ENTER("unlock_lock_and_free_resource");
DBUG_ASSERT(rc->state == ACTIVE);
if (rc->owners.elements || rc->waiter_count)
{
DBUG_PRINT("wt", ("nothing to do, %u owners, %u waiters",
rc->owners.elements, rc->waiter_count));
rc_unlock(rc);
DBUG_RETURN(0);
}
if (fix_thd_pins(thd))
{
rc_unlock(rc);
DBUG_RETURN(1);
}
/* XXX if (rc->id.type->make_key) key= rc->id.type->make_key(&rc->id, &keylen); else */
{
key= &rc->id;
keylen= sizeof_WT_RESOURCE_ID;
}
/*
To free the element correctly we need to:
1. take its lock (already done).
2. set the state to FREE
3. release the lock
4. remove from the hash
*/
rc->state= FREE;
rc_unlock(rc);
DBUG_RETURN(lf_hash_delete(&reshash, thd->pins, key, keylen) == -1);
} | O3 | c | unlock_lock_and_free_resource:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x0, 0xe8(%rsi)
jne 0xa72b6
cmpl $0x0, 0x10(%rbx)
je 0xa72c9
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xa44be
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
cmpq $0x0, 0x30(%rdi)
je 0xa7307
movl $0x1, 0x14(%rbx)
leaq 0x18(%rbx), %rdi
callq 0xa44be
movq 0x30(%r14), %rsi
leaq 0xb617e2(%rip), %rdi # 0xc08ad0
movq %rbx, %rdx
movl $0x10, %ecx
callq 0x2f731
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
jmp 0xa72c4
leaq 0xb617ea(%rip), %rdi # 0xc08af8
callq 0x2f225
movq %rax, 0x30(%r14)
testq %rax, %rax
jne 0xa72d3
addq $0x18, %rbx
movq %rbx, %rdi
callq 0xa44be
movl $0x1, %eax
jmp 0xa72c4
| unlock_lock_and_free_resource:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
cmp dword ptr [rsi+0E8h], 0
jnz short loc_A72B6
cmp dword ptr [rbx+10h], 0
jz short loc_A72C9
loc_A72B6:
add rbx, 18h
mov rdi, rbx
call my_rw_unlock
xor eax, eax
loc_A72C4:
pop rbx
pop r14
pop rbp
retn
loc_A72C9:
mov r14, rdi
cmp qword ptr [rdi+30h], 0
jz short loc_A7307
loc_A72D3:
mov dword ptr [rbx+14h], 1
lea rdi, [rbx+18h]
call my_rw_unlock
mov rsi, [r14+30h]
lea rdi, reshash
mov rdx, rbx
mov ecx, 10h
call lf_hash_delete
mov ecx, eax
xor eax, eax
cmp ecx, 0FFFFFFFFh
setz al
jmp short loc_A72C4
loc_A7307:
lea rdi, unk_C08AF8
call lf_pinbox_get_pins
mov [r14+30h], rax
test rax, rax
jnz short loc_A72D3
add rbx, 18h
mov rdi, rbx
call my_rw_unlock
mov eax, 1
jmp short loc_A72C4
| _BOOL8 unlock_lock_and_free_resource(long long a1, _DWORD *a2)
{
long long pins; // rax
if ( a2[58] || a2[4] )
{
my_rw_unlock((long long)(a2 + 6));
return 0LL;
}
else if ( *(_QWORD *)(a1 + 48)
|| (pins = lf_pinbox_get_pins((long long)&unk_C08AF8), (*(_QWORD *)(a1 + 48) = pins) != 0LL) )
{
a2[5] = 1;
my_rw_unlock((long long)(a2 + 6));
return (unsigned int)lf_hash_delete((long long)&reshash, *(volatile long long **)(a1 + 48), (long long)a2, 0x10u) == -1;
}
else
{
my_rw_unlock((long long)(a2 + 6));
return 1LL;
}
}
| unlock_lock_and_free_resource:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
CMP dword ptr [RSI + 0xe8],0x0
JNZ 0x001a72b6
CMP dword ptr [RBX + 0x10],0x0
JZ 0x001a72c9
LAB_001a72b6:
ADD RBX,0x18
MOV RDI,RBX
CALL 0x001a44be
XOR EAX,EAX
LAB_001a72c4:
POP RBX
POP R14
POP RBP
RET
LAB_001a72c9:
MOV R14,RDI
CMP qword ptr [RDI + 0x30],0x0
JZ 0x001a7307
LAB_001a72d3:
MOV dword ptr [RBX + 0x14],0x1
LEA RDI,[RBX + 0x18]
CALL 0x001a44be
MOV RSI,qword ptr [R14 + 0x30]
LEA RDI,[0xd08ad0]
MOV RDX,RBX
MOV ECX,0x10
CALL 0x0012f731
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,-0x1
SETZ AL
JMP 0x001a72c4
LAB_001a7307:
LEA RDI,[0xd08af8]
CALL 0x0012f225
MOV qword ptr [R14 + 0x30],RAX
TEST RAX,RAX
JNZ 0x001a72d3
ADD RBX,0x18
MOV RDI,RBX
CALL 0x001a44be
MOV EAX,0x1
JMP 0x001a72c4
|
bool unlock_lock_and_free_resource(long param_1,long param_2)
{
int iVar1;
long lVar2;
bool bVar3;
if ((*(int *)(param_2 + 0xe8) == 0) && (*(int *)(param_2 + 0x10) == 0)) {
if (*(long *)(param_1 + 0x30) == 0) {
lVar2 = lf_pinbox_get_pins(0xd08af8);
*(long *)(param_1 + 0x30) = lVar2;
if (lVar2 == 0) {
my_rw_unlock(param_2 + 0x18);
return true;
}
}
*(int4 *)(param_2 + 0x14) = 1;
my_rw_unlock(param_2 + 0x18);
iVar1 = lf_hash_delete(reshash,*(int8 *)(param_1 + 0x30),param_2,0x10);
bVar3 = iVar1 == -1;
}
else {
my_rw_unlock(param_2 + 0x18);
bVar3 = false;
}
return bVar3;
}
| |
34,271 | YogaTest_margin_side_overrides_horizontal_and_vertical_Test::~YogaTest_margin_side_overrides_horizontal_and_vertical_Test() | yoga-mod/tests/YGComputedMarginTest.cpp | TEST(YogaTest, margin_side_overrides_horizontal_and_vertical) {
const std::array<YGEdge, 6> edges = {
{YGEdgeTop,
YGEdgeBottom,
YGEdgeStart,
YGEdgeEnd,
YGEdgeLeft,
YGEdgeRight}};
for (float edgeValue = 0; edgeValue < 2; ++edgeValue) {
for (const auto& edge : edges) {
YGEdge horizontalOrVertical = edge == YGEdgeTop || edge == YGEdgeBottom
? YGEdgeVertical
: YGEdgeHorizontal;
YGNodeRef root = YGNodeNew();
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 100);
YGNodeStyleSetMargin(root, horizontalOrVertical, 10);
YGNodeStyleSetMargin(root, edge, edgeValue);
YGNodeCalculateLayout(root, 100, 100, YGDirectionLTR);
ASSERT_FLOAT_EQ(edgeValue, YGNodeLayoutGetMargin(root, edge));
YGNodeFreeRecursive(root);
}
}
} | O0 | cpp | YogaTest_margin_side_overrides_horizontal_and_vertical_Test::~YogaTest_margin_side_overrides_horizontal_and_vertical_Test():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x704850
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN59YogaTest_margin_side_overrides_horizontal_and_vertical_TestD2Ev:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]; this
call _ZN7testing4TestD2Ev; testing::Test::~Test()
add rsp, 10h
pop rbp
retn
| void YogaTest_margin_side_overrides_horizontal_and_vertical_Test::~YogaTest_margin_side_overrides_horizontal_and_vertical_Test(
YogaTest_margin_side_overrides_horizontal_and_vertical_Test *this)
{
testing::Test::~Test(this);
}
| ~YogaTest_margin_side_overrides_horizontal_and_vertical_Test:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00804850
ADD RSP,0x10
POP RBP
RET
|
/* YogaTest_margin_side_overrides_horizontal_and_vertical_Test::~YogaTest_margin_side_overrides_horizontal_and_vertical_Test()
*/
void __thiscall
YogaTest_margin_side_overrides_horizontal_and_vertical_Test::
~YogaTest_margin_side_overrides_horizontal_and_vertical_Test
(YogaTest_margin_side_overrides_horizontal_and_vertical_Test *this)
{
testing::Test::~Test((Test *)this);
return;
}
| |
34,272 | my_coll_rule_shift_at_level | eloqsql/strings/ctype-uca.c | static void
my_coll_rule_shift_at_level(MY_COLL_RULE *r, int level)
{
switch (level)
{
case 4: /* Quaternary difference */
r->diff[3]++;
break;
case 3: /* Tertiary difference */
r->diff[2]++;
r->diff[3]= 0;
break;
case 2: /* Secondary difference */
r->diff[1]++;
r->diff[2]= r->diff[3]= 0;
break;
case 1: /* Primary difference */
r->diff[0]++;
r->diff[1]= r->diff[2]= r->diff[3]= 0;
break;
case 0:
/* Do nothing for '=': use the previous offsets for all levels */
break;
default:
DBUG_ASSERT(0);
}
} | O0 | c | my_coll_rule_shift_at_level:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x4f09d
movq -0x18(%rbp), %rax
leaq 0xf1c99(%rip), %rcx # 0x140c80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
jmp 0x4f0a3
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
jmp 0x4f0a3
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
jmp 0x4f0a3
movq -0x8(%rbp), %rax
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x84(%rax)
jmp 0x4f0a3
jmp 0x4f0a3
jmp 0x4f09f
jmp 0x4f0a1
jmp 0x4f0a3
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_rule_shift_at_level:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
mov [rbp+var_18], rax
sub rax, 4; switch 5 cases
ja def_4EFEE; jumptable 000000000004EFEE default case
mov rax, [rbp+var_18]
lea rcx, jpt_4EFEE
movsxd rax, ds:(jpt_4EFEE - 140C80h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_4EFF0:
mov rax, [rbp+var_8]; jumptable 000000000004EFEE case 4
mov ecx, [rax+8Ch]
add ecx, 1
mov [rax+8Ch], ecx
jmp loc_4F0A3
loc_4F008:
mov rax, [rbp+var_8]; jumptable 000000000004EFEE case 3
mov ecx, [rax+88h]
add ecx, 1
mov [rax+88h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
jmp short loc_4F0A3
loc_4F02B:
mov rax, [rbp+var_8]; jumptable 000000000004EFEE case 2
mov ecx, [rax+84h]
add ecx, 1
mov [rax+84h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
jmp short loc_4F0A3
loc_4F05C:
mov rax, [rbp+var_8]; jumptable 000000000004EFEE case 1
mov ecx, [rax+80h]
add ecx, 1
mov [rax+80h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+84h], 0
jmp short loc_4F0A3
loc_4F09B:
jmp short loc_4F0A3; jumptable 000000000004EFEE case 0
def_4EFEE:
jmp short $+2; jumptable 000000000004EFEE default case
loc_4F09F:
jmp short $+2
loc_4F0A1:
jmp short $+2
loc_4F0A3:
pop rbp
retn
| unsigned long long my_coll_rule_shift_at_level(_DWORD *a1, unsigned int a2)
{
unsigned long long result; // rax
result = a2;
switch ( a2 )
{
case 1u:
++a1[32];
a1[35] = 0;
a1[34] = 0;
result = (unsigned long long)a1;
a1[33] = 0;
break;
case 2u:
++a1[33];
a1[35] = 0;
result = (unsigned long long)a1;
a1[34] = 0;
break;
case 3u:
++a1[34];
result = (unsigned long long)a1;
a1[35] = 0;
break;
case 4u:
result = (unsigned long long)a1;
++a1[35];
break;
default:
return result;
}
return result;
}
| my_coll_rule_shift_at_level:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x4
JA 0x0014f09d
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x240c80]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8c],ECX
JMP 0x0014f0a3
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x88]
ADD ECX,0x1
MOV dword ptr [RAX + 0x88],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
JMP 0x0014f0a3
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x84]
ADD ECX,0x1
MOV dword ptr [RAX + 0x84],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
JMP 0x0014f0a3
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x80]
ADD ECX,0x1
MOV dword ptr [RAX + 0x80],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x84],0x0
JMP 0x0014f0a3
caseD_0:
JMP 0x0014f0a3
LAB_0014f09d:
JMP 0x0014f09f
LAB_0014f09f:
JMP 0x0014f0a1
LAB_0014f0a1:
JMP 0x0014f0a3
default:
POP RBP
RET
|
void my_coll_rule_shift_at_level(long param_1,int4 param_2)
{
switch(param_2) {
case 0:
break;
case 1:
*(int *)(param_1 + 0x80) = *(int *)(param_1 + 0x80) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
*(int4 *)(param_1 + 0x88) = 0;
*(int4 *)(param_1 + 0x84) = 0;
break;
case 2:
*(int *)(param_1 + 0x84) = *(int *)(param_1 + 0x84) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
*(int4 *)(param_1 + 0x88) = 0;
break;
case 3:
*(int *)(param_1 + 0x88) = *(int *)(param_1 + 0x88) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
break;
case 4:
*(int *)(param_1 + 0x8c) = *(int *)(param_1 + 0x8c) + 1;
}
return;
}
| |
34,273 | js_async_generator_next | bluesky950520[P]quickjs/quickjs.c | static JSValue js_async_generator_next(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv,
int magic)
{
JSAsyncGeneratorData *s = JS_GetOpaque(this_val, JS_CLASS_ASYNC_GENERATOR);
JSValue promise, resolving_funcs[2];
JSAsyncGeneratorRequest *req;
promise = JS_NewPromiseCapability(ctx, resolving_funcs);
if (JS_IsException(promise))
return JS_EXCEPTION;
if (!s) {
JSValue err, res2;
JS_ThrowTypeError(ctx, "not an AsyncGenerator object");
err = JS_GetException(ctx);
res2 = JS_Call(ctx, resolving_funcs[1], JS_UNDEFINED,
1, &err);
JS_FreeValue(ctx, err);
JS_FreeValue(ctx, res2);
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
return promise;
}
req = js_mallocz(ctx, sizeof(*req));
if (!req)
goto fail;
req->completion_type = magic;
req->result = js_dup(argv[0]);
req->promise = js_dup(promise);
req->resolving_funcs[0] = resolving_funcs[0];
req->resolving_funcs[1] = resolving_funcs[1];
list_add_tail(&req->link, &s->queue);
if (s->state != JS_ASYNC_GENERATOR_STATE_EXECUTING) {
js_async_generator_resume_next(ctx, s);
}
return promise;
fail:
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
JS_FreeValue(ctx, promise);
return JS_EXCEPTION;
} | O0 | c | js_async_generator_next:
subq $0x128, %rsp # imm = 0x128
movq %rsi, 0x108(%rsp)
movq %rdx, 0x110(%rsp)
movq %rdi, 0x100(%rsp)
movl %ecx, 0xfc(%rsp)
movq %r8, 0xf0(%rsp)
movl %r9d, 0xec(%rsp)
movq 0x108(%rsp), %rdi
movq 0x110(%rsp), %rsi
movl $0x39, %edx
callq 0x3e640
movq %rax, 0xe0(%rsp)
movq 0x100(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x50780
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x9cac3
movl $0x0, 0x118(%rsp)
movq $0x6, 0x120(%rsp)
jmp 0x9cdf7
cmpq $0x0, 0xe0(%rsp)
jne 0x9cc24
movq 0x100(%rsp), %rdi
leaq 0x78b4b(%rip), %rsi # 0x11562c
movb $0x0, %al
callq 0x335f0
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x100(%rsp), %rdi
callq 0x33260
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x100(%rsp), %rdi
movl $0x0, 0x38(%rsp)
movq $0x3, 0x40(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
movl $0x1, %r9d
leaq 0x88(%rsp), %rax
movq %rax, (%rsp)
callq 0x40340
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x100(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0x29f80
movq 0x100(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x29f80
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x29f80
movq 0x100(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x29f80
movq 0xd0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x120(%rsp)
jmp 0x9cdf7
movq 0x100(%rsp), %rdi
movl $0x58, %esi
callq 0x28020
movq %rax, 0xa8(%rsp)
cmpq $0x0, 0xa8(%rsp)
jne 0x9cc4e
jmp 0x9cd89
movl 0xec(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xf0(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x279c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0x279c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0xa8(%rsp), %rax
movq 0xb0(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0xb8(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0xa8(%rsp), %rax
movq 0xc0(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0xc8(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0xa8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
addq $0x78, %rsi
callq 0x29d40
movq 0xe0(%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x9cd67
movq 0x100(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0x9ce10
movq 0xd0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x120(%rsp)
jmp 0x9cdf7
movq 0x100(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x29f80
movq 0x100(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x29f80
movq 0x100(%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0x29f80
movl $0x0, 0x118(%rsp)
movq $0x6, 0x120(%rsp)
movq 0x118(%rsp), %rax
movq 0x120(%rsp), %rdx
addq $0x128, %rsp # imm = 0x128
retq
nop
| js_async_generator_next:
sub rsp, 128h
mov [rsp+128h+var_20], rsi
mov [rsp+128h+var_18], rdx
mov [rsp+128h+var_28], rdi
mov [rsp+128h+var_2C], ecx
mov [rsp+128h+var_38], r8
mov [rsp+128h+var_3C], r9d
mov rdi, [rsp+128h+var_20]
mov rsi, [rsp+128h+var_18]
mov edx, 39h ; '9'
call JS_GetOpaque
mov [rsp+128h+var_48], rax
mov rdi, [rsp+128h+var_28]
lea rsi, [rsp+128h+var_78]
call JS_NewPromiseCapability
mov [rsp+128h+var_90], rax
mov [rsp+128h+var_88], rdx
mov rax, [rsp+128h+var_90]
mov [rsp+128h+var_58], rax
mov rax, [rsp+128h+var_88]
mov [rsp+128h+var_50], rax
mov rdi, [rsp+128h+var_58]
mov rsi, [rsp+128h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_9CAC3
mov dword ptr [rsp+128h+var_10], 0
mov [rsp+128h+var_8], 6
jmp loc_9CDF7
loc_9CAC3:
cmp [rsp+128h+var_48], 0
jnz loc_9CC24
mov rdi, [rsp+128h+var_28]
lea rsi, aNotAnAsyncgene; "not an AsyncGenerator object"
mov al, 0
call JS_ThrowTypeError
mov [rsp+128h+var_C0], rax
mov [rsp+128h+var_B8], rdx
mov rdi, [rsp+128h+var_28]
call JS_GetException
mov [rsp+128h+var_D0], rax
mov [rsp+128h+var_C8], rdx
mov rax, [rsp+128h+var_D0]
mov [rsp+128h+var_A0], rax
mov rax, [rsp+128h+var_C8]
mov [rsp+128h+var_98], rax
mov rdi, [rsp+128h+var_28]
mov dword ptr [rsp+128h+var_F0], 0
mov [rsp+128h+var_E8], 3
mov rsi, [rsp+128h+var_68]
mov rdx, [rsp+128h+var_60]
mov rcx, [rsp+128h+var_F0]
mov r8, [rsp+128h+var_E8]
mov r9d, 1
lea rax, [rsp+128h+var_A0]
mov [rsp+128h+var_128], rax
call JS_Call
mov [rsp+128h+var_E0], rax
mov [rsp+128h+var_D8], rdx
mov rax, [rsp+128h+var_E0]
mov [rsp+128h+var_B0], rax
mov rax, [rsp+128h+var_D8]
mov [rsp+128h+var_A8], rax
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_A0]
mov rdx, [rsp+128h+var_98]
call JS_FreeValue
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_B0]
mov rdx, [rsp+128h+var_A8]
call JS_FreeValue
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_78]
mov rdx, [rsp+128h+var_70]
call JS_FreeValue
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_68]
mov rdx, [rsp+128h+var_60]
call JS_FreeValue
mov rax, [rsp+128h+var_58]
mov [rsp+128h+var_10], rax
mov rax, [rsp+128h+var_50]
mov [rsp+128h+var_8], rax
jmp loc_9CDF7
loc_9CC24:
mov rdi, [rsp+128h+var_28]
mov esi, 58h ; 'X'
call js_mallocz
mov [rsp+128h+var_80], rax
cmp [rsp+128h+var_80], 0
jnz short loc_9CC4E
jmp loc_9CD89
loc_9CC4E:
mov ecx, [rsp+128h+var_3C]
mov rax, [rsp+128h+var_80]
mov [rax+10h], ecx
mov rax, [rsp+128h+var_80]
mov [rsp+128h+var_120], rax
mov rax, [rsp+128h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rcx, rax
mov rax, [rsp+128h+var_120]
mov [rsp+128h+var_100], rcx
mov [rsp+128h+var_F8], rdx
mov rcx, [rsp+128h+var_100]
mov [rax+18h], rcx
mov rcx, [rsp+128h+var_F8]
mov [rax+20h], rcx
mov rax, [rsp+128h+var_80]
mov [rsp+128h+var_118], rax
mov rdi, [rsp+128h+var_58]
mov rsi, [rsp+128h+var_50]
call js_dup
mov rcx, rax
mov rax, [rsp+128h+var_118]
mov [rsp+128h+var_110], rcx
mov [rsp+128h+var_108], rdx
mov rcx, [rsp+128h+var_110]
mov [rax+28h], rcx
mov rcx, [rsp+128h+var_108]
mov [rax+30h], rcx
mov rax, [rsp+128h+var_80]
mov rcx, [rsp+128h+var_78]
mov [rax+38h], rcx
mov rcx, [rsp+128h+var_70]
mov [rax+40h], rcx
mov rax, [rsp+128h+var_80]
mov rcx, [rsp+128h+var_68]
mov [rax+48h], rcx
mov rcx, [rsp+128h+var_60]
mov [rax+50h], rcx
mov rdi, [rsp+128h+var_80]
mov rsi, [rsp+128h+var_48]
add rsi, 78h ; 'x'
call list_add_tail_1
mov rax, [rsp+128h+var_48]
cmp dword ptr [rax+8], 3
jz short loc_9CD67
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_48]
call js_async_generator_resume_next
loc_9CD67:
mov rax, [rsp+128h+var_58]
mov [rsp+128h+var_10], rax
mov rax, [rsp+128h+var_50]
mov [rsp+128h+var_8], rax
jmp short loc_9CDF7
loc_9CD89:
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_78]
mov rdx, [rsp+128h+var_70]
call JS_FreeValue
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_68]
mov rdx, [rsp+128h+var_60]
call JS_FreeValue
mov rdi, [rsp+128h+var_28]
mov rsi, [rsp+128h+var_58]
mov rdx, [rsp+128h+var_50]
call JS_FreeValue
mov dword ptr [rsp+128h+var_10], 0
mov [rsp+128h+var_8], 6
loc_9CDF7:
mov rax, [rsp+128h+var_10]
mov rdx, [rsp+128h+var_8]
add rsp, 128h
retn
| _DWORD * js_async_generator_next(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long v14; // rdx
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
long long v21; // rdx
long long v22; // rdx
long long v23; // rdx
long long v24; // rdx
long long v25; // rax
long long v26; // rax
char v28; // [rsp+0h] [rbp-128h]
long long v29; // [rsp+8h] [rbp-120h]
long long v30; // [rsp+10h] [rbp-118h]
long long v31; // [rsp+48h] [rbp-E0h]
long long v32; // [rsp+80h] [rbp-A8h]
long long Exception; // [rsp+88h] [rbp-A0h] BYREF
long long v34; // [rsp+90h] [rbp-98h]
_DWORD *v35; // [rsp+98h] [rbp-90h]
long long v36; // [rsp+A0h] [rbp-88h]
long long v37; // [rsp+A8h] [rbp-80h]
long long v38; // [rsp+B0h] [rbp-78h] BYREF
long long v39; // [rsp+B8h] [rbp-70h]
long long v40; // [rsp+C0h] [rbp-68h]
long long v41; // [rsp+C8h] [rbp-60h]
_DWORD *v42; // [rsp+D0h] [rbp-58h]
long long v43; // [rsp+D8h] [rbp-50h]
long long Opaque; // [rsp+E0h] [rbp-48h]
int v45; // [rsp+ECh] [rbp-3Ch]
long long v46; // [rsp+F0h] [rbp-38h]
int v47; // [rsp+FCh] [rbp-2Ch]
long long v48; // [rsp+100h] [rbp-28h]
long long v49; // [rsp+108h] [rbp-20h]
long long v50; // [rsp+110h] [rbp-18h]
_DWORD *v51; // [rsp+118h] [rbp-10h]
long long v52; // [rsp+120h] [rbp-8h]
v49 = a2;
v50 = a3;
v48 = a1;
v47 = a4;
v46 = a5;
v45 = a6;
Opaque = JS_GetOpaque(a2, a3, 57);
v35 = (_DWORD *)JS_NewPromiseCapability(a1, (long long)&v38);
v36 = v14;
v42 = v35;
v43 = v14;
if ( JS_IsException_1((long long)v35, v14) )
{
LODWORD(v51) = 0;
v52 = 6LL;
}
else if ( Opaque )
{
v37 = js_mallocz(v48, 0x58uLL);
if ( v37 )
{
*(_DWORD *)(v37 + 16) = v45;
v29 = v37;
*(_QWORD *)(v37 + 24) = js_dup(*(_DWORD **)v46, *(_QWORD *)(v46 + 8));
*(_QWORD *)(v29 + 32) = v23;
v30 = v37;
*(_QWORD *)(v37 + 40) = js_dup(v42, v43);
*(_QWORD *)(v30 + 48) = v24;
v25 = v37;
*(_QWORD *)(v37 + 56) = v38;
*(_QWORD *)(v25 + 64) = v39;
v26 = v37;
*(_QWORD *)(v37 + 72) = v40;
*(_QWORD *)(v26 + 80) = v41;
list_add_tail_1(v37, (_QWORD *)(Opaque + 120));
if ( *(_DWORD *)(Opaque + 8) != 3 )
js_async_generator_resume_next(v48, Opaque);
v51 = v42;
v52 = v43;
}
else
{
JS_FreeValue(v48, v38, v39);
JS_FreeValue(v48, v40, v41);
JS_FreeValue(v48, (long long)v42, v43);
LODWORD(v51) = 0;
v52 = 6LL;
}
}
else
{
JS_ThrowTypeError(
v48,
(long long)"not an AsyncGenerator object",
v15,
v16,
v17,
v18,
a7,
a8,
a9,
a10,
v19,
v20,
a13,
a14,
v28);
Exception = JS_GetException(v48);
v34 = v21;
v31 = JS_Call(v48, v40, v41, 0, 3, 1, (long long)&Exception);
v32 = v22;
JS_FreeValue(v48, Exception, v34);
JS_FreeValue(v48, v31, v32);
JS_FreeValue(v48, v38, v39);
JS_FreeValue(v48, v40, v41);
v51 = v42;
v52 = v43;
}
return v51;
}
| js_async_generator_next:
SUB RSP,0x128
MOV qword ptr [RSP + 0x108],RSI
MOV qword ptr [RSP + 0x110],RDX
MOV qword ptr [RSP + 0x100],RDI
MOV dword ptr [RSP + 0xfc],ECX
MOV qword ptr [RSP + 0xf0],R8
MOV dword ptr [RSP + 0xec],R9D
MOV RDI,qword ptr [RSP + 0x108]
MOV RSI,qword ptr [RSP + 0x110]
MOV EDX,0x39
CALL 0x0013e640
MOV qword ptr [RSP + 0xe0],RAX
MOV RDI,qword ptr [RSP + 0x100]
LEA RSI,[RSP + 0xb0]
CALL 0x00150780
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xa0],RDX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xd0],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0019cac3
MOV dword ptr [RSP + 0x118],0x0
MOV qword ptr [RSP + 0x120],0x6
JMP 0x0019cdf7
LAB_0019cac3:
CMP qword ptr [RSP + 0xe0],0x0
JNZ 0x0019cc24
MOV RDI,qword ptr [RSP + 0x100]
LEA RSI,[0x21562c]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x00133260
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x90],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x3
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RSP + 0x38]
MOV R8,qword ptr [RSP + 0x40]
MOV R9D,0x1
LEA RAX,[RSP + 0x88]
MOV qword ptr [RSP],RAX
CALL 0x00140340
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0x50],RDX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x80]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x00129f80
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x120],RAX
JMP 0x0019cdf7
LAB_0019cc24:
MOV RDI,qword ptr [RSP + 0x100]
MOV ESI,0x58
CALL 0x00128020
MOV qword ptr [RSP + 0xa8],RAX
CMP qword ptr [RSP + 0xa8],0x0
JNZ 0x0019cc4e
JMP 0x0019cd89
LAB_0019cc4e:
MOV ECX,dword ptr [RSP + 0xec]
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0xf0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001279c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RDX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xd8]
CALL 0x001279c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x28],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0xb0]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RSP + 0xb8]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RSP + 0xa8]
MOV RCX,qword ptr [RSP + 0xc0]
MOV qword ptr [RAX + 0x48],RCX
MOV RCX,qword ptr [RSP + 0xc8]
MOV qword ptr [RAX + 0x50],RCX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xe0]
ADD RSI,0x78
CALL 0x00129d40
MOV RAX,qword ptr [RSP + 0xe0]
CMP dword ptr [RAX + 0x8],0x3
JZ 0x0019cd67
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xe0]
CALL 0x0019ce10
LAB_0019cd67:
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x120],RAX
JMP 0x0019cdf7
LAB_0019cd89:
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x00129f80
MOV RDI,qword ptr [RSP + 0x100]
MOV RSI,qword ptr [RSP + 0xd0]
MOV RDX,qword ptr [RSP + 0xd8]
CALL 0x00129f80
MOV dword ptr [RSP + 0x118],0x0
MOV qword ptr [RSP + 0x120],0x6
LAB_0019cdf7:
MOV RAX,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x120]
ADD RSP,0x128
RET
|
int1 [16]
js_async_generator_next
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5,int4 param_6)
{
long lVar1;
int iVar2;
long lVar3;
int1 auVar4 [16];
uint uStack_ec;
int1 local_a0 [16];
int1 local_90 [16];
long local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int1 local_58 [16];
long local_48;
int4 local_3c;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_GetOpaque(param_2,param_3,0x39);
local_90 = JS_NewPromiseCapability(local_28,&local_78);
local_58 = local_90;
iVar2 = JS_IsException(local_90._0_8_,local_90._8_8_);
if (iVar2 == 0) {
if (local_48 == 0) {
JS_ThrowTypeError(local_28,"not an AsyncGenerator object");
local_a0 = JS_GetException(local_28);
auVar4 = JS_Call(local_28,local_68,local_60,(ulong)uStack_ec << 0x20,3,1,local_a0);
JS_FreeValue(local_28,local_a0._0_8_,local_a0._8_8_);
JS_FreeValue(local_28,auVar4._0_8_,auVar4._8_8_);
JS_FreeValue(local_28,local_78,local_70);
JS_FreeValue(local_28,local_68,local_60);
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
}
else {
lVar3 = js_mallocz(local_28,0x58);
local_80 = lVar3;
if (lVar3 == 0) {
JS_FreeValue(local_28,local_78,local_70);
JS_FreeValue(local_28,local_68,local_60);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = 0;
local_8 = 6;
}
else {
*(int4 *)(lVar3 + 0x10) = local_3c;
auVar4 = js_dup(*local_38,local_38[1]);
lVar1 = local_80;
*(int1 (*) [16])(lVar3 + 0x18) = auVar4;
auVar4 = js_dup(local_58._0_8_,local_58._8_8_);
*(int1 (*) [16])(lVar1 + 0x28) = auVar4;
*(int8 *)(local_80 + 0x38) = local_78;
*(int8 *)(local_80 + 0x40) = local_70;
*(int8 *)(local_80 + 0x48) = local_68;
*(int8 *)(local_80 + 0x50) = local_60;
list_add_tail(local_80,local_48 + 0x78);
if (*(int *)(local_48 + 8) != 3) {
js_async_generator_resume_next(local_28,local_48);
}
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
}
}
}
else {
local_10 = 0;
local_8 = 6;
}
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
| |
34,274 | initialize_variables_for_repair | eloqsql/storage/maria/ma_check.c | static int initialize_variables_for_repair(HA_CHECK *param,
MARIA_SORT_INFO *sort_info,
MARIA_SORT_PARAM *sort_param,
MARIA_HA *info,
my_bool rep_quick,
MARIA_SHARE *org_share)
{
MARIA_SHARE *share= info->s;
size_t tmp;
uint threads;
/*
We have to clear these variables first, as the cleanup-in-case-of-error
handling may touch these.
*/
bzero((char*) sort_info, sizeof(*sort_info));
bzero((char*) sort_param, sizeof(*sort_param));
bzero(&info->rec_cache, sizeof(info->rec_cache));
if (share->data_file_type == NO_RECORD)
{
_ma_check_print_error(param,
"Can't repair tables with record type NO_DATA");
return 1;
}
/* Make a copy to allow us to restore state and check how state changed */
memcpy(org_share, share, sizeof(*share));
/* Repair code relies on share->state.state so we have to update it here */
if (share->lock.update_status)
(*share->lock.update_status)(info->lock.status_param);
param->testflag|= T_REP; /* for easy checking */
if (share->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
param->testflag|= T_CALC_CHECKSUM;
param->glob_crc= 0;
if (rep_quick)
param->testflag|= T_QUICK;
else
param->testflag&= ~T_QUICK;
param->org_key_map= share->state.key_map;
/*
Clear check variables set by repair. This is needed to allow one to run
several repair's in a row with same param
*/
param->retry_repair= 0;
param->warning_printed= 0;
param->error_printed= 0;
param->wrong_trd_printed= 0;
sort_param->sort_info= sort_info;
sort_param->fix_datafile= ! rep_quick;
sort_param->calc_checksum= MY_TEST(param->testflag & T_CALC_CHECKSUM);
sort_info->info= sort_info->new_info= info;
sort_info->param= param;
set_data_file_type(sort_info, info->s);
sort_info->org_data_file_type= share->data_file_type;
info->rec_cache.file= info->dfile.file;
info->update= (short) (HA_STATE_CHANGED | HA_STATE_ROW_CHANGED);
if (protect_against_repair_crash(info, param,
!MY_TEST(param->testflag &
T_CREATE_MISSING_KEYS)))
return 1;
/* calculate max_records */
sort_info->filelength= my_seek(info->dfile.file, 0L, MY_SEEK_END, MYF(0));
param->max_progress= sort_info->filelength;
if ((param->testflag & T_CREATE_MISSING_KEYS) ||
sort_info->org_data_file_type == COMPRESSED_RECORD)
sort_info->max_records= share->state.state.records;
else
{
ulong rec_length;
rec_length= MY_MAX(share->base.min_pack_length,
share->base.min_block_length);
sort_info->max_records= (ha_rows) (sort_info->filelength / rec_length);
}
/* We don't need a bigger sort buffer than file_length * 8 */
threads= (param->testflag & T_REP_PARALLEL) ? (uint) share->base.keys : 1;
tmp= (size_t) MY_MIN(sort_info->filelength,
(my_off_t) (SIZE_T_MAX/10/threads));
tmp= MY_MAX(tmp * 8 * threads, (size_t) 65536); /* Some margin */
param->sort_buffer_length= MY_MIN(param->orig_sort_buffer_length,
tmp);
set_if_smaller(param->sort_buffer_length, tmp);
/* Protect against too big sort buffer length */
#if SIZEOF_SIZE_T >= 8
set_if_smaller(param->sort_buffer_length, 16LL*1024LL*1024LL*1024LL);
#else
set_if_smaller(param->sort_buffer_length, 1L*1024L*1024L*1024L);
#endif
/* Set up transaction handler so that we can see all rows */
if (param->max_trid == 0)
{
if (!ma_control_file_inited())
param->max_trid= 0; /* Give warning for first trid found */
else
param->max_trid= max_trid_in_system();
}
maria_ignore_trids(info);
/* Don't write transid's during repair */
maria_versioning(info, 0);
/* remember original number of rows */
*info->state= info->s->state.state;
return 0;
} | O3 | c | initialize_variables_for_repair:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc58, %rsp # imm = 0xC58
movq %r9, -0xc78(%rbp)
movl %r8d, -0xc70(%rbp)
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rcx), %r12
movl $0x100, %edx # imm = 0x100
movq %rsi, %rdi
xorl %esi, %esi
callq 0x2a2e0
movl $0x6a0, %edx # imm = 0x6A0
movq %r13, %rdi
xorl %esi, %esi
callq 0x2a2e0
leaq 0x4b8(%rbx), %rdi
movl $0x108, %edx # imm = 0x108
xorl %esi, %esi
callq 0x2a2e0
cmpl $0x4, 0x7d0(%r12)
jne 0x796c9
leaq 0x84101(%rip), %rsi # 0xfd7b5
movq %r14, %rdi
xorl %eax, %eax
callq 0x32fb0
movl $0x1, %r13d
jmp 0x799bb
movl $0xc38, %edx # imm = 0xC38
movq -0xc78(%rbp), %rdi
movq %r12, %rsi
callq 0x2a0b0
movq 0x8b0(%r12), %rax
testq %rax, %rax
je 0x796f3
movq 0x6b8(%rbx), %rdi
callq *%rax
movq 0xb10(%r14), %rax
movq %rax, %rcx
orq $0x20000, %rcx # imm = 0x20000
movq %rcx, 0xb10(%r14)
orq $0x20008, %rax # imm = 0x20008
testb $0x24, 0x720(%r12)
cmoveq %rcx, %rax
xorl %ecx, %ecx
movl -0xc70(%rbp), %edx
testb %dl, %dl
setne %cl
andq $-0x8001, %rax # imm = 0xFFFF7FFF
shll $0xf, %ecx
orq %rax, %rcx
xorl %eax, %eax
testb %dl, %dl
movl %eax, 0x304(%r14)
movq %rcx, 0xb10(%r14)
movq %r12, -0xc70(%rbp)
movq 0x140(%r12), %rcx
movq %rcx, 0xb08(%r14)
movb %al, 0x209a8(%r14)
movb %al, 0x209a2(%r14)
movl %eax, 0x2096c(%r14)
movb %al, 0x209a4(%r14)
movq %r15, 0x380(%r13)
sete 0x65c(%r13)
movb 0xb10(%r14), %al
shrb $0x3, %al
andb $0x1, %al
movb %al, 0x65e(%r13)
movq %rbx, 0x88(%r15)
movq %rbx, 0x80(%r15)
movq %r14, 0x90(%r15)
movq (%rbx), %r12
movl 0x7d0(%r12), %eax
movl %eax, 0xf8(%r15)
cmpl $0x2, %eax
jne 0x79822
testb $0x4, 0xb13(%r14)
je 0x79822
movzbl 0x17(%r12), %eax
movl %eax, 0xf8(%r15)
leaq -0xc68(%rbp), %r13
movl $0xc38, %edx # imm = 0xC38
movq %r13, %rdi
movq %r12, %rsi
callq 0x2a0b0
movb 0x17(%r13), %al
movb %al, 0x16(%r13)
movl $0xfffffffb, %eax # imm = 0xFFFFFFFB
movq %rax, 0x720(%r13)
movq %r13, %rdi
callq 0x5a123
movq 0x698(%r13), %rax
movq %rax, 0x698(%r12)
movq -0xc70(%rbp), %r12
movl 0x7d0(%r12), %eax
movl %eax, 0xfc(%r15)
movl 0x480(%rbx), %eax
movl %eax, 0x58c(%rbx)
movl $0x401, 0x624(%rbx) # imm = 0x401
xorl %edx, %edx
testb $0x40, 0xb10(%r14)
sete %dl
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c6cb
movl $0x1, %r13d
testb %al, %al
jne 0x799bb
movl 0x480(%rbx), %edi
xorl %esi, %esi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0xc056c
movq %rax, 0xb8(%r15)
movq %rax, 0x20cd8(%r14)
testb $0x40, 0xb10(%r14)
jne 0x798aa
cmpl $0x2, 0xfc(%r15)
jne 0x798b1
movq 0x18(%r12), %rax
jmp 0x798d4
movq 0x3a8(%r12), %rax
movq 0x3b8(%r12), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq 0xb8(%r15), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0xd8(%r15)
movl $0x1, %ecx
testb $0x8, 0xb12(%r14)
je 0x798f2
movl 0x3e8(%r12), %ecx
movq 0xb8(%r15), %rsi
xorl %r13d, %r13d
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
xorl %edx, %edx
divq %rcx
cmpq %rax, %rsi
cmovbq %rsi, %rax
imulq %rcx, %rax
shlq $0x3, %rax
cmpq $0x10001, %rax # imm = 0x10001
movl $0x10000, %ecx # imm = 0x10000
cmovaeq %rax, %rcx
movq 0xb38(%r14), %rax
cmpq %rcx, %rax
cmovbq %rax, %rcx
movabsq $0x400000000, %rax # imm = 0x400000000
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0xb30(%r14)
cmpq $0x0, 0xb18(%r14)
jne 0x79983
callq 0x4288e
testb %al, %al
je 0x7997a
callq 0x41c3d
leaq 0x3abffa(%rip), %rcx # 0x425968
movq (%rcx), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
jmp 0x7997c
xorl %ecx, %ecx
movq %rcx, 0xb18(%r14)
movq %rbx, %rdi
callq 0x3b7b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3434f
movq (%rbx), %rax
movq 0x20(%rbx), %rcx
movq 0x48(%rax), %rdx
movq %rdx, 0x30(%rcx)
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movups 0x38(%rax), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x799df
movl %r13d, %eax
addq $0xc58, %rsp # imm = 0xC58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a280
| initialize_variables_for_repair:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C58h
mov [rbp+var_C78], r9
mov dword ptr [rbp+var_C70], r8d
mov rbx, rcx
mov r13, rdx
mov r15, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r12, [rcx]
mov edx, 100h
mov rdi, rsi
xor esi, esi
call _memset
mov edx, 6A0h
mov rdi, r13
xor esi, esi
call _memset
lea rdi, [rbx+4B8h]
mov edx, 108h
xor esi, esi
call _memset
cmp dword ptr [r12+7D0h], 4
jnz short loc_796C9
lea rsi, aCanTRepairTabl; "Can't repair tables with record type NO"...
mov rdi, r14
xor eax, eax
call _ma_check_print_error
mov r13d, 1
jmp loc_799BB
loc_796C9:
mov edx, 0C38h
mov rdi, [rbp+var_C78]
mov rsi, r12
call _memcpy
mov rax, [r12+8B0h]
test rax, rax
jz short loc_796F3
mov rdi, [rbx+6B8h]
call rax
loc_796F3:
mov rax, [r14+0B10h]
mov rcx, rax
or rcx, 20000h
mov [r14+0B10h], rcx
or rax, 20008h
test byte ptr [r12+720h], 24h
cmovz rax, rcx
xor ecx, ecx
mov edx, dword ptr [rbp+var_C70]
test dl, dl
setnz cl
and rax, 0FFFFFFFFFFFF7FFFh
shl ecx, 0Fh
or rcx, rax
xor eax, eax
test dl, dl
mov [r14+304h], eax
mov [r14+0B10h], rcx
mov [rbp+var_C70], r12
mov rcx, [r12+140h]
mov [r14+0B08h], rcx
mov [r14+209A8h], al
mov [r14+209A2h], al
mov [r14+2096Ch], eax
mov [r14+209A4h], al
mov [r13+380h], r15
setz byte ptr [r13+65Ch]
mov al, [r14+0B10h]
shr al, 3
and al, 1
mov [r13+65Eh], al
mov [r15+88h], rbx
mov [r15+80h], rbx
mov [r15+90h], r14
mov r12, [rbx]
mov eax, [r12+7D0h]
mov [r15+0F8h], eax
cmp eax, 2
jnz short loc_79822
test byte ptr [r14+0B13h], 4
jz short loc_79822
movzx eax, byte ptr [r12+17h]
mov [r15+0F8h], eax
lea r13, [rbp+var_C68]
mov edx, 0C38h
mov rdi, r13
mov rsi, r12
call _memcpy
mov al, [r13+17h]
mov [r13+16h], al
mov eax, 0FFFFFFFBh
mov [r13+720h], rax
mov rdi, r13
call _ma_setup_functions
mov rax, [r13+698h]
mov [r12+698h], rax
loc_79822:
mov r12, [rbp+var_C70]
mov eax, [r12+7D0h]
mov [r15+0FCh], eax
mov eax, [rbx+480h]
mov [rbx+58Ch], eax
mov dword ptr [rbx+624h], 401h
xor edx, edx
test byte ptr [r14+0B10h], 40h
setz dl
mov rdi, rbx
mov rsi, r14
call protect_against_repair_crash
mov r13d, 1
test al, al
jnz loc_799BB
mov edi, [rbx+480h]
xor esi, esi
mov edx, 2
xor ecx, ecx
call my_seek
mov [r15+0B8h], rax
mov [r14+20CD8h], rax
test byte ptr [r14+0B10h], 40h
jnz short loc_798AA
cmp dword ptr [r15+0FCh], 2
jnz short loc_798B1
loc_798AA:
mov rax, [r12+18h]
jmp short loc_798D4
loc_798B1:
mov rax, [r12+3A8h]
mov rcx, [r12+3B8h]
cmp rax, rcx
cmova rcx, rax
mov rax, [r15+0B8h]
xor edx, edx
div rcx
loc_798D4:
mov [r15+0D8h], rax
mov ecx, 1
test byte ptr [r14+0B12h], 8
jz short loc_798F2
mov ecx, [r12+3E8h]
loc_798F2:
mov rsi, [r15+0B8h]
xor r13d, r13d
mov rax, 1999999999999999h
xor edx, edx
div rcx
cmp rsi, rax
cmovb rax, rsi
imul rax, rcx
shl rax, 3
cmp rax, 10001h
mov ecx, 10000h
cmovnb rcx, rax
mov rax, [r14+0B38h]
cmp rax, rcx
cmovb rcx, rax
mov rax, 400000000h
cmp rcx, rax
cmovnb rcx, rax
mov [r14+0B30h], rcx
cmp qword ptr [r14+0B18h], 0
jnz short loc_79983
call ma_control_file_inited
test al, al
jz short loc_7997A
call trnman_get_max_trid
lea rcx, max_trid_in_control_file
mov rcx, [rcx]
cmp rax, rcx
cmova rcx, rax
jmp short loc_7997C
loc_7997A:
xor ecx, ecx
loc_7997C:
mov [r14+0B18h], rcx
loc_79983:
mov rdi, rbx
call maria_ignore_trids
mov rdi, rbx
xor esi, esi
call maria_versioning
mov rax, [rbx]
mov rcx, [rbx+20h]
mov rdx, [rax+48h]
mov [rcx+30h], rdx
movups xmm0, xmmword ptr [rax+18h]
movups xmm1, xmmword ptr [rax+28h]
movups xmm2, xmmword ptr [rax+38h]
movups xmmword ptr [rcx+20h], xmm2
movups xmmword ptr [rcx+10h], xmm1
movups xmmword ptr [rcx], xmm0
loc_799BB:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_799DF
mov eax, r13d
add rsp, 0C58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_799DF:
call ___stack_chk_fail
| long long initialize_variables_for_repair(
long long a1,
long long a2,
long long a3,
long long *a4,
char a5,
long long a6)
{
long long v9; // r12
unsigned int v10; // r13d
void ( *v11)(long long); // rax
long long v12; // rax
long long v13; // rcx
long long v14; // rax
bool v15; // zf
long long v16; // r12
int v17; // eax
long long v18; // rdi
long long v19; // rax
unsigned long long v20; // rax
unsigned long long v21; // rcx
unsigned long long v22; // rcx
unsigned long long v23; // rax
unsigned long long v24; // rax
unsigned long long v25; // rcx
unsigned long long max_trid; // rax
long long v27; // rcx
long long v28; // rax
long long v29; // rcx
__int128 v30; // xmm0
__int128 v31; // xmm1
long long v35; // [rsp+10h] [rbp-C70h]
_BYTE v36[1688]; // [rsp+18h] [rbp-C68h] BYREF
long long v37; // [rsp+6B0h] [rbp-5D0h]
long long v38; // [rsp+738h] [rbp-548h]
unsigned long long v39; // [rsp+C50h] [rbp-30h]
v39 = __readfsqword(0x28u);
v9 = *a4;
memset(a2, 0LL, 256LL);
memset(a3, 0LL, 1696LL);
memset(a4 + 151, 0LL, 264LL);
if ( *(_DWORD *)(v9 + 2000) == 4 )
{
ma_check_print_error(a1, (long long)"Can't repair tables with record type NO_DATA");
return 1;
}
else
{
memcpy(a6, v9, 3128LL);
v11 = *(void ( **)(long long))(v9 + 2224);
if ( v11 )
v11(a4[215]);
v12 = *(_QWORD *)(a1 + 2832);
v13 = v12 | 0x20000;
*(_QWORD *)(a1 + 2832) = v12 | 0x20000;
v14 = v12 | 0x20008;
if ( (*(_BYTE *)(v9 + 1824) & 0x24) == 0 )
v14 = v13;
v15 = a5 == 0;
*(_DWORD *)(a1 + 772) = 0;
*(_QWORD *)(a1 + 2832) = v14 & 0xFFFFFFFFFFFF7FFFLL | ((unsigned __int8)(a5 != 0) << 15);
v35 = v9;
*(_QWORD *)(a1 + 2824) = *(_QWORD *)(v9 + 320);
*(_BYTE *)(a1 + 133544) = 0;
*(_BYTE *)(a1 + 133538) = 0;
*(_DWORD *)(a1 + 133484) = 0;
*(_BYTE *)(a1 + 133540) = 0;
*(_QWORD *)(a3 + 896) = a2;
*(_BYTE *)(a3 + 1628) = v15;
*(_BYTE *)(a3 + 1630) = (*(_BYTE *)(a1 + 2832) & 8) != 0;
*(_QWORD *)(a2 + 136) = a4;
*(_QWORD *)(a2 + 128) = a4;
*(_QWORD *)(a2 + 144) = a1;
v16 = *a4;
v17 = *(_DWORD *)(*a4 + 2000);
*(_DWORD *)(a2 + 248) = v17;
if ( v17 == 2 && (*(_BYTE *)(a1 + 2835) & 4) != 0 )
{
*(_DWORD *)(a2 + 248) = *(unsigned __int8 *)(v16 + 23);
memcpy(v36, v16, 3128LL);
v36[22] = v36[23];
v38 = 4294967291LL;
ma_setup_functions((long long)v36);
*(_QWORD *)(v16 + 1688) = v37;
}
*(_DWORD *)(a2 + 252) = *(_DWORD *)(v35 + 2000);
*((_DWORD *)a4 + 355) = *((_DWORD *)a4 + 288);
*((_DWORD *)a4 + 393) = 1025;
v10 = 1;
if ( !(unsigned __int8)protect_against_repair_crash(a4, a1, (*(_BYTE *)(a1 + 2832) & 0x40) == 0) )
{
v18 = *((unsigned int *)a4 + 288);
v19 = my_seek(v18, 0LL, 2LL, 0LL);
*(_QWORD *)(a2 + 184) = v19;
*(_QWORD *)(a1 + 134360) = v19;
if ( (*(_BYTE *)(a1 + 2832) & 0x40) != 0 || *(_DWORD *)(a2 + 252) == 2 )
{
v20 = *(_QWORD *)(v35 + 24);
}
else
{
v21 = *(_QWORD *)(v35 + 952);
if ( *(_QWORD *)(v35 + 936) > v21 )
v21 = *(_QWORD *)(v35 + 936);
v20 = *(_QWORD *)(a2 + 184) / v21;
}
*(_QWORD *)(a2 + 216) = v20;
v22 = 1LL;
if ( (*(_BYTE *)(a1 + 2834) & 8) != 0 )
v22 = *(unsigned int *)(v35 + 1000);
v10 = 0;
v23 = 0x1999999999999999LL / v22;
if ( *(_QWORD *)(a2 + 184) < 0x1999999999999999LL / v22 )
v23 = *(_QWORD *)(a2 + 184);
v24 = 8 * v22 * v23;
v25 = 0x10000LL;
if ( v24 >= 0x10001 )
v25 = v24;
if ( *(_QWORD *)(a1 + 2872) < v25 )
v25 = *(_QWORD *)(a1 + 2872);
if ( v25 >= 0x400000000LL )
v25 = 0x400000000LL;
*(_QWORD *)(a1 + 2864) = v25;
if ( !*(_QWORD *)(a1 + 2840) )
{
if ( ma_control_file_inited() )
{
max_trid = trnman_get_max_trid(v18);
v27 = max_trid_in_control_file;
if ( max_trid > max_trid_in_control_file )
v27 = max_trid;
}
else
{
v27 = 0LL;
}
*(_QWORD *)(a1 + 2840) = v27;
}
maria_ignore_trids((long long)a4);
maria_versioning(a4, 0);
v28 = *a4;
v29 = a4[4];
*(_QWORD *)(v29 + 48) = *(_QWORD *)(*a4 + 72);
v30 = *(_OWORD *)(v28 + 24);
v31 = *(_OWORD *)(v28 + 40);
*(_OWORD *)(v29 + 32) = *(_OWORD *)(v28 + 56);
*(_OWORD *)(v29 + 16) = v31;
*(_OWORD *)v29 = v30;
}
}
return v10;
}
| initialize_variables_for_repair:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc58
MOV qword ptr [RBP + -0xc78],R9
MOV dword ptr [RBP + -0xc70],R8D
MOV RBX,RCX
MOV R13,RDX
MOV R15,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R12,qword ptr [RCX]
MOV EDX,0x100
MOV RDI,RSI
XOR ESI,ESI
CALL 0x0012a2e0
MOV EDX,0x6a0
MOV RDI,R13
XOR ESI,ESI
CALL 0x0012a2e0
LEA RDI,[RBX + 0x4b8]
MOV EDX,0x108
XOR ESI,ESI
CALL 0x0012a2e0
CMP dword ptr [R12 + 0x7d0],0x4
JNZ 0x001796c9
LEA RSI,[0x1fd7b5]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00132fb0
MOV R13D,0x1
JMP 0x001799bb
LAB_001796c9:
MOV EDX,0xc38
MOV RDI,qword ptr [RBP + -0xc78]
MOV RSI,R12
CALL 0x0012a0b0
MOV RAX,qword ptr [R12 + 0x8b0]
TEST RAX,RAX
JZ 0x001796f3
MOV RDI,qword ptr [RBX + 0x6b8]
CALL RAX
LAB_001796f3:
MOV RAX,qword ptr [R14 + 0xb10]
MOV RCX,RAX
OR RCX,0x20000
MOV qword ptr [R14 + 0xb10],RCX
OR RAX,0x20008
TEST byte ptr [R12 + 0x720],0x24
CMOVZ RAX,RCX
XOR ECX,ECX
MOV EDX,dword ptr [RBP + -0xc70]
TEST DL,DL
SETNZ CL
AND RAX,-0x8001
SHL ECX,0xf
OR RCX,RAX
XOR EAX,EAX
TEST DL,DL
MOV dword ptr [R14 + 0x304],EAX
MOV qword ptr [R14 + 0xb10],RCX
MOV qword ptr [RBP + -0xc70],R12
MOV RCX,qword ptr [R12 + 0x140]
MOV qword ptr [R14 + 0xb08],RCX
MOV byte ptr [R14 + 0x209a8],AL
MOV byte ptr [R14 + 0x209a2],AL
MOV dword ptr [R14 + 0x2096c],EAX
MOV byte ptr [R14 + 0x209a4],AL
MOV qword ptr [R13 + 0x380],R15
SETZ byte ptr [R13 + 0x65c]
MOV AL,byte ptr [R14 + 0xb10]
SHR AL,0x3
AND AL,0x1
MOV byte ptr [R13 + 0x65e],AL
MOV qword ptr [R15 + 0x88],RBX
MOV qword ptr [R15 + 0x80],RBX
MOV qword ptr [R15 + 0x90],R14
MOV R12,qword ptr [RBX]
MOV EAX,dword ptr [R12 + 0x7d0]
MOV dword ptr [R15 + 0xf8],EAX
CMP EAX,0x2
JNZ 0x00179822
TEST byte ptr [R14 + 0xb13],0x4
JZ 0x00179822
MOVZX EAX,byte ptr [R12 + 0x17]
MOV dword ptr [R15 + 0xf8],EAX
LEA R13,[RBP + -0xc68]
MOV EDX,0xc38
MOV RDI,R13
MOV RSI,R12
CALL 0x0012a0b0
MOV AL,byte ptr [R13 + 0x17]
MOV byte ptr [R13 + 0x16],AL
MOV EAX,0xfffffffb
MOV qword ptr [R13 + 0x720],RAX
MOV RDI,R13
CALL 0x0015a123
MOV RAX,qword ptr [R13 + 0x698]
MOV qword ptr [R12 + 0x698],RAX
LAB_00179822:
MOV R12,qword ptr [RBP + -0xc70]
MOV EAX,dword ptr [R12 + 0x7d0]
MOV dword ptr [R15 + 0xfc],EAX
MOV EAX,dword ptr [RBX + 0x480]
MOV dword ptr [RBX + 0x58c],EAX
MOV dword ptr [RBX + 0x624],0x401
XOR EDX,EDX
TEST byte ptr [R14 + 0xb10],0x40
SETZ DL
MOV RDI,RBX
MOV RSI,R14
CALL 0x0017c6cb
MOV R13D,0x1
TEST AL,AL
JNZ 0x001799bb
MOV EDI,dword ptr [RBX + 0x480]
XOR ESI,ESI
MOV EDX,0x2
XOR ECX,ECX
CALL 0x001c056c
MOV qword ptr [R15 + 0xb8],RAX
MOV qword ptr [R14 + 0x20cd8],RAX
TEST byte ptr [R14 + 0xb10],0x40
JNZ 0x001798aa
CMP dword ptr [R15 + 0xfc],0x2
JNZ 0x001798b1
LAB_001798aa:
MOV RAX,qword ptr [R12 + 0x18]
JMP 0x001798d4
LAB_001798b1:
MOV RAX,qword ptr [R12 + 0x3a8]
MOV RCX,qword ptr [R12 + 0x3b8]
CMP RAX,RCX
CMOVA RCX,RAX
MOV RAX,qword ptr [R15 + 0xb8]
XOR EDX,EDX
DIV RCX
LAB_001798d4:
MOV qword ptr [R15 + 0xd8],RAX
MOV ECX,0x1
TEST byte ptr [R14 + 0xb12],0x8
JZ 0x001798f2
MOV ECX,dword ptr [R12 + 0x3e8]
LAB_001798f2:
MOV RSI,qword ptr [R15 + 0xb8]
XOR R13D,R13D
MOV RAX,0x1999999999999999
XOR EDX,EDX
DIV RCX
CMP RSI,RAX
CMOVC RAX,RSI
IMUL RAX,RCX
SHL RAX,0x3
CMP RAX,0x10001
MOV ECX,0x10000
CMOVNC RCX,RAX
MOV RAX,qword ptr [R14 + 0xb38]
CMP RAX,RCX
CMOVC RCX,RAX
MOV RAX,0x400000000
CMP RCX,RAX
CMOVNC RCX,RAX
MOV qword ptr [R14 + 0xb30],RCX
CMP qword ptr [R14 + 0xb18],0x0
JNZ 0x00179983
CALL 0x0014288e
TEST AL,AL
JZ 0x0017997a
CALL 0x00141c3d
LEA RCX,[0x525968]
MOV RCX,qword ptr [RCX]
CMP RAX,RCX
CMOVA RCX,RAX
JMP 0x0017997c
LAB_0017997a:
XOR ECX,ECX
LAB_0017997c:
MOV qword ptr [R14 + 0xb18],RCX
LAB_00179983:
MOV RDI,RBX
CALL 0x0013b7b0
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013434f
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RAX + 0x48]
MOV qword ptr [RCX + 0x30],RDX
MOVUPS XMM0,xmmword ptr [RAX + 0x18]
MOVUPS XMM1,xmmword ptr [RAX + 0x28]
MOVUPS XMM2,xmmword ptr [RAX + 0x38]
MOVUPS xmmword ptr [RCX + 0x20],XMM2
MOVUPS xmmword ptr [RCX + 0x10],XMM1
MOVUPS xmmword ptr [RCX],XMM0
LAB_001799bb:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001799df
MOV EAX,R13D
ADD RSP,0xc58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001799df:
CALL 0x0012a280
|
int8
initialize_variables_for_repair
(long param_1,void *param_2,void *param_3,long *param_4,char param_5,void *param_6)
{
int iVar1;
void *__src;
void *__src_00;
long lVar2;
int4 *puVar3;
int1 auVar4 [16];
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int8 uVar9;
int8 uVar10;
int8 uVar11;
char cVar12;
ulong uVar13;
ulong uVar14;
int8 uVar15;
long in_FS_OFFSET;
int1 local_c70 [22];
int1 local_c5a;
int1 local_c59;
int8 local_5d8;
int8 local_550;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
__src = (void *)*param_4;
memset(param_2,0,0x100);
memset(param_3,0,0x6a0);
memset(param_4 + 0x97,0,0x108);
if (*(int *)((long)__src + 2000) == 4) {
_ma_check_print_error(param_1,"Can\'t repair tables with record type NO_DATA");
uVar15 = 1;
}
else {
memcpy(param_6,__src,0xc38);
if (*(code **)((long)__src + 0x8b0) != (code *)0x0) {
(**(code **)((long)__src + 0x8b0))(param_4[0xd7]);
}
uVar14 = *(ulong *)(param_1 + 0xb10);
uVar13 = uVar14 | 0x20000;
*(ulong *)(param_1 + 0xb10) = uVar13;
uVar14 = uVar14 | 0x20008;
if ((*(byte *)((long)__src + 0x720) & 0x24) == 0) {
uVar14 = uVar13;
}
*(int4 *)(param_1 + 0x304) = 0;
*(ulong *)(param_1 + 0xb10) = (ulong)(param_5 != '\0') << 0xf | uVar14 & 0xffffffffffff7fff;
*(int8 *)(param_1 + 0xb08) = *(int8 *)((long)__src + 0x140);
*(int1 *)(param_1 + 0x209a8) = 0;
*(int1 *)(param_1 + 0x209a2) = 0;
*(int4 *)(param_1 + 0x2096c) = 0;
*(int1 *)(param_1 + 0x209a4) = 0;
*(void **)((long)param_3 + 0x380) = param_2;
*(bool *)((long)param_3 + 0x65c) = param_5 == '\0';
*(byte *)((long)param_3 + 0x65e) = *(byte *)(param_1 + 0xb10) >> 3 & 1;
*(long **)((long)param_2 + 0x88) = param_4;
*(long **)((long)param_2 + 0x80) = param_4;
*(long *)((long)param_2 + 0x90) = param_1;
__src_00 = (void *)*param_4;
iVar1 = *(int *)((long)__src_00 + 2000);
*(int *)((long)param_2 + 0xf8) = iVar1;
if ((iVar1 == 2) && ((*(byte *)(param_1 + 0xb13) & 4) != 0)) {
*(uint *)((long)param_2 + 0xf8) = (uint)*(byte *)((long)__src_00 + 0x17);
memcpy(local_c70,__src_00,0xc38);
local_c5a = local_c59;
local_550 = 0xfffffffb;
_ma_setup_functions(local_c70);
*(int8 *)((long)__src_00 + 0x698) = local_5d8;
}
*(int4 *)((long)param_2 + 0xfc) = *(int4 *)((long)__src + 2000);
*(int *)((long)param_4 + 0x58c) = (int)param_4[0x90];
*(int4 *)((long)param_4 + 0x624) = 0x401;
cVar12 = protect_against_repair_crash(param_4,param_1,(*(byte *)(param_1 + 0xb10) & 0x40) == 0);
uVar15 = 1;
if (cVar12 == '\0') {
uVar15 = my_seek((int)param_4[0x90],0,2,0);
*(int8 *)((long)param_2 + 0xb8) = uVar15;
*(int8 *)(param_1 + 0x20cd8) = uVar15;
if (((*(byte *)(param_1 + 0xb10) & 0x40) == 0) && (*(int *)((long)param_2 + 0xfc) != 2)) {
uVar14 = *(ulong *)((long)__src + 0x3b8);
if (*(ulong *)((long)__src + 0x3b8) < *(ulong *)((long)__src + 0x3a8)) {
uVar14 = *(ulong *)((long)__src + 0x3a8);
}
uVar14 = *(ulong *)((long)param_2 + 0xb8) / uVar14;
}
else {
uVar14 = *(ulong *)((long)__src + 0x18);
}
*(ulong *)((long)param_2 + 0xd8) = uVar14;
uVar14 = 1;
if ((*(byte *)(param_1 + 0xb12) & 8) != 0) {
uVar14 = (ulong)*(uint *)((long)__src + 1000);
}
uVar15 = 0;
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar14;
uVar13 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(0x1999999999999999)) / auVar4,0);
if (*(ulong *)((long)param_2 + 0xb8) < uVar13) {
uVar13 = *(ulong *)((long)param_2 + 0xb8);
}
uVar13 = uVar13 * uVar14 * 8;
uVar14 = 0x10000;
if (0x10000 < uVar13) {
uVar14 = uVar13;
}
if (*(ulong *)(param_1 + 0xb38) < uVar14) {
uVar14 = *(ulong *)(param_1 + 0xb38);
}
if (0x3ffffffff < uVar14) {
uVar14 = 0x400000000;
}
*(ulong *)(param_1 + 0xb30) = uVar14;
if (*(long *)(param_1 + 0xb18) == 0) {
cVar12 = ma_control_file_inited();
if (cVar12 == '\0') {
uVar14 = 0;
}
else {
uVar13 = trnman_get_max_trid();
uVar14 = max_trid_in_control_file;
if (max_trid_in_control_file < uVar13) {
uVar14 = uVar13;
}
}
*(ulong *)(param_1 + 0xb18) = uVar14;
}
maria_ignore_trids(param_4);
maria_versioning(param_4,0);
lVar2 = *param_4;
puVar3 = (int4 *)param_4[4];
*(int8 *)(puVar3 + 0xc) = *(int8 *)(lVar2 + 0x48);
uVar5 = *(int4 *)(lVar2 + 0x18);
uVar6 = *(int4 *)(lVar2 + 0x1c);
uVar7 = *(int4 *)(lVar2 + 0x20);
uVar8 = *(int4 *)(lVar2 + 0x24);
uVar9 = *(int8 *)(lVar2 + 0x28);
uVar10 = *(int8 *)(lVar2 + 0x30);
uVar11 = *(int8 *)(lVar2 + 0x40);
*(int8 *)(puVar3 + 8) = *(int8 *)(lVar2 + 0x38);
*(int8 *)(puVar3 + 10) = uVar11;
*(int8 *)(puVar3 + 4) = uVar9;
*(int8 *)(puVar3 + 6) = uVar10;
*puVar3 = uVar5;
puVar3[1] = uVar6;
puVar3[2] = uVar7;
puVar3[3] = uVar8;
}
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar15;
}
| |
34,275 | my_coll_parser_scan_shift_sequence | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_shift_sequence(MY_COLL_RULE_PARSER *p)
{
MY_COLL_RULE before_extend;
memset(&p->rule.curr, 0, sizeof(p->rule.curr));
/* Scan single shift character or contraction */
if (!my_coll_parser_scan_character_list(p, p->rule.curr,
MY_UCA_MAX_CONTRACTION,
"Contraction"))
return 0;
before_extend= p->rule; /* Remember the part before "/" */
/* Append the part after "/" as expansion */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_EXTEND)
{
my_coll_parser_scan(p);
if (!my_coll_parser_scan_character_list(p, p->rule.base,
MY_UCA_MAX_EXPANSION,
"Expansion"))
return 0;
}
else if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CONTEXT)
{
/*
We support 2-character long context sequences only:
one character is the previous context, plus the current character.
It's OK as Unicode's CLDR does not have longer examples.
*/
my_coll_parser_scan(p);
p->rule.with_context= TRUE;
if (!my_coll_parser_scan_character_list(p, p->rule.curr + 1, 1, "context"))
return 0;
}
/* Add rule to the rule list */
if (my_coll_rules_add(p->rules, &p->rule))
return 0;
p->rule= before_extend; /* Restore to the state before "/" */
return 1;
} | O0 | c | my_coll_parser_scan_shift_sequence:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x291e0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rsi
movl $0x6, %edx
leaq 0x92e49(%rip), %rcx # 0xf141c
callq 0x5ebc0
cmpl $0x0, %eax
jne 0x5e5e9
movl $0x0, -0x4(%rbp)
jmp 0x5e6e8
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
leaq -0xb0(%rbp), %rdi
movl $0xa0, %edx
callq 0x29270
movq -0x10(%rbp), %rdi
callq 0x5dc00
cmpl $0x8, (%rax)
jne 0x5e649
movq -0x10(%rbp), %rdi
callq 0x5e3e0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movl $0xa, %edx
leaq 0x92c0e(%rip), %rcx # 0xf123f
callq 0x5ebc0
cmpl $0x0, %eax
jne 0x5e647
movl $0x0, -0x4(%rbp)
jmp 0x5e6e8
jmp 0x5e6a2
movq -0x10(%rbp), %rdi
callq 0x5dc00
cmpl $0x9, (%rax)
jne 0x5e6a0
movq -0x10(%rbp), %rdi
callq 0x5e3e0
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rsi
addq $0x8, %rsi
movl $0x1, %edx
leaq 0x938cf(%rip), %rcx # 0xf1f5a
callq 0x5ebc0
cmpl $0x0, %eax
jne 0x5e69e
movl $0x0, -0x4(%rbp)
jmp 0x5e6e8
jmp 0x5e6a0
jmp 0x5e6a2
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x5ef10
cmpl $0x0, %eax
je 0x5e6c8
movl $0x0, -0x4(%rbp)
jmp 0x5e6e8
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa0, %edx
callq 0x29270
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_shift_sequence:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
add rdi, 50h ; 'P'
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
add rsi, 50h ; 'P'
mov edx, 6
lea rcx, aContraction; "Contraction"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_5E5E9
mov [rbp+var_4], 0
jmp loc_5E6E8
loc_5E5E9:
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
lea rdi, [rbp+var_B0]
mov edx, 0A0h
call _memcpy
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 8
jnz short loc_5E649
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
mov edx, 0Ah
lea rcx, aExpansion; "Expansion"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_5E647
mov [rbp+var_4], 0
jmp loc_5E6E8
loc_5E647:
jmp short loc_5E6A2
loc_5E649:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 9
jnz short loc_5E6A0
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
add rsi, 50h ; 'P'
add rsi, 8
mov edx, 1
lea rcx, aCharsetsCharse_52+23h; "context"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_5E69E
mov [rbp+var_4], 0
jmp short loc_5E6E8
loc_5E69E:
jmp short $+2
loc_5E6A0:
jmp short $+2
loc_5E6A2:
mov rax, [rbp+var_10]
mov rdi, [rax+0F0h]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
call my_coll_rules_add
cmp eax, 0
jz short loc_5E6C8
mov [rbp+var_4], 0
jmp short loc_5E6E8
loc_5E6C8:
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, [rbp+var_B0]
mov edx, 0A0h
call _memcpy
mov [rbp+var_4], 1
loc_5E6E8:
mov eax, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
| long long my_coll_parser_scan_shift_sequence(long long a1)
{
_BYTE v2[160]; // [rsp+0h] [rbp-B0h] BYREF
long long v3; // [rsp+A0h] [rbp-10h]
v3 = a1;
memset(a1 + 160, 0LL, 48LL);
if ( (unsigned int)my_coll_parser_scan_character_list(v3, v3 + 160, 6LL, "Contraction") )
{
memcpy(v2, v3 + 80, sizeof(v2));
if ( *(_DWORD *)my_coll_parser_curr(v3) == 8 )
{
my_coll_parser_scan(v3);
if ( !(unsigned int)my_coll_parser_scan_character_list(v3, v3 + 80, 10LL, "Expansion") )
return 0;
}
else if ( *(_DWORD *)my_coll_parser_curr(v3) == 9 )
{
my_coll_parser_scan(v3);
*(_BYTE *)(v3 + 232) = 1;
if ( !(unsigned int)my_coll_parser_scan_character_list(v3, v3 + 168, 1LL, "context") )
return 0;
}
if ( (unsigned int)my_coll_rules_add(*(_QWORD *)(v3 + 240), v3 + 80) )
{
return 0;
}
else
{
memcpy(v3 + 80, v2, 160LL);
return 1;
}
}
else
{
return 0;
}
}
| my_coll_parser_scan_shift_sequence:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
ADD RDI,0x50
XOR ESI,ESI
MOV EDX,0x30
CALL 0x001291e0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
ADD RSI,0x50
MOV EDX,0x6
LEA RCX,[0x1f141c]
CALL 0x0015ebc0
CMP EAX,0x0
JNZ 0x0015e5e9
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015e6e8
LAB_0015e5e9:
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
LEA RDI,[RBP + -0xb0]
MOV EDX,0xa0
CALL 0x00129270
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015dc00
CMP dword ptr [RAX],0x8
JNZ 0x0015e649
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015e3e0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
MOV EDX,0xa
LEA RCX,[0x1f123f]
CALL 0x0015ebc0
CMP EAX,0x0
JNZ 0x0015e647
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015e6e8
LAB_0015e647:
JMP 0x0015e6a2
LAB_0015e649:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015dc00
CMP dword ptr [RAX],0x9
JNZ 0x0015e6a0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0015e3e0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
ADD RSI,0x50
ADD RSI,0x8
MOV EDX,0x1
LEA RCX,[0x1f1f5a]
CALL 0x0015ebc0
CMP EAX,0x0
JNZ 0x0015e69e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015e6e8
LAB_0015e69e:
JMP 0x0015e6a0
LAB_0015e6a0:
JMP 0x0015e6a2
LAB_0015e6a2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xf0]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
CALL 0x0015ef10
CMP EAX,0x0
JZ 0x0015e6c8
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0015e6e8
LAB_0015e6c8:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[RBP + -0xb0]
MOV EDX,0xa0
CALL 0x00129270
MOV dword ptr [RBP + -0x4],0x1
LAB_0015e6e8:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 my_coll_parser_scan_shift_sequence(long param_1)
{
int iVar1;
int *piVar2;
int1 local_b8 [160];
long local_18;
int4 local_c;
local_18 = param_1;
memset((void *)(param_1 + 0xa0),0,0x30);
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0xa0,6,"Contraction");
if (iVar1 == 0) {
local_c = 0;
}
else {
memcpy(local_b8,(void *)(local_18 + 0x50),0xa0);
piVar2 = (int *)my_coll_parser_curr(local_18);
if (*piVar2 == 8) {
my_coll_parser_scan(local_18);
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0x50,10,"Expansion");
if (iVar1 == 0) {
return 0;
}
}
else {
piVar2 = (int *)my_coll_parser_curr(local_18);
if (*piVar2 == 9) {
my_coll_parser_scan(local_18);
*(int1 *)(local_18 + 0xe8) = 1;
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0xa8,1,"context");
if (iVar1 == 0) {
return 0;
}
}
}
iVar1 = my_coll_rules_add(*(int8 *)(local_18 + 0xf0),local_18 + 0x50);
if (iVar1 == 0) {
memcpy((void *)(local_18 + 0x50),local_b8,0xa0);
local_c = 1;
}
else {
local_c = 0;
}
}
return local_c;
}
| |
34,276 | pvio_socket_fast_send | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | int pvio_socket_fast_send(MARIADB_PVIO *pvio)
{
int r= 0;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
/* Setting IP_TOS is not recommended on Windows. See
http://msdn.microsoft.com/en-us/library/windows/desktop/ms738586(v=vs.85).aspx
*/
#if !defined(_WIN32) && defined(IPTOS_THROUGHPUT)
{
int tos = IPTOS_THROUGHPUT;
r= setsockopt(csock->socket, IPPROTO_IP, IP_TOS,
(const void *)&tos, sizeof(tos));
}
#endif /* !_WIN32 && IPTOS_THROUGHPUT */
if (!r)
{
int opt = 1;
/* turn off nagle algorithm */
r= setsockopt(csock->socket, IPPROTO_TCP, TCP_NODELAY,
#ifdef _WIN32
(const char *)&opt, (int)sizeof(opt));
#else
(const void *)&opt, sizeof(opt));
#endif
}
return r;
} | O0 | c | pvio_socket_fast_send:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42e3c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x42e45
movl $0x1, -0x4(%rbp)
jmp 0x42eab
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x8, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
movl $0x1, %edx
leaq -0x24(%rbp), %rcx
movl $0x4, %r8d
callq 0x13770
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x42ea5
movl $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x28(%rbp), %rcx
movl $0x4, %r8d
callq 0x13770
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| pvio_socket_fast_send:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], 0
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jz short loc_42E3C
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_42E45
loc_42E3C:
mov [rbp+var_4], 1
jmp short loc_42EAB
loc_42E45:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov [rbp+var_24], 8
mov rax, [rbp+var_20]
mov edi, [rax]
xor esi, esi
mov edx, 1
lea rcx, [rbp+var_24]
mov r8d, 4
call _setsockopt
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jnz short loc_42EA5
mov [rbp+var_28], 1
mov rax, [rbp+var_20]
mov edi, [rax]
mov esi, 6
mov edx, 1
lea rcx, [rbp+var_28]
mov r8d, 4
call _setsockopt
mov [rbp+var_14], eax
loc_42EA5:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_42EAB:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long pvio_socket_fast_send(unsigned int **a1)
{
int v2; // [rsp+8h] [rbp-28h] BYREF
int v3; // [rsp+Ch] [rbp-24h] BYREF
unsigned int *v4; // [rsp+10h] [rbp-20h]
unsigned int v5; // [rsp+1Ch] [rbp-14h]
unsigned int **v6; // [rsp+20h] [rbp-10h]
v6 = a1;
v5 = 0;
v4 = 0LL;
if ( a1 && *v6 )
{
v4 = *v6;
v3 = 8;
v5 = setsockopt(*v4, 0LL, 1LL, &v3, 4LL);
if ( !v5 )
{
v2 = 1;
return (unsigned int)setsockopt(*v4, 6LL, 1LL, &v2, 4LL);
}
return v5;
}
else
{
return 1;
}
}
| pvio_socket_fast_send:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x0
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00142e3c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00142e45
LAB_00142e3c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00142eab
LAB_00142e45:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x24],0x8
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
XOR ESI,ESI
MOV EDX,0x1
LEA RCX,[RBP + -0x24]
MOV R8D,0x4
CALL 0x00113770
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00142ea5
MOV dword ptr [RBP + -0x28],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
MOV ESI,0x6
MOV EDX,0x1
LEA RCX,[RBP + -0x28]
MOV R8D,0x4
CALL 0x00113770
MOV dword ptr [RBP + -0x14],EAX
LAB_00142ea5:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_00142eab:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int pvio_socket_fast_send(long *param_1)
{
int4 local_30;
int4 local_2c;
int *local_28;
int local_1c;
long *local_18;
int local_c;
local_1c = 0;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 1;
}
else {
local_28 = (int *)*param_1;
local_2c = 8;
local_18 = param_1;
local_1c = setsockopt(*local_28,0,1,&local_2c,4);
if (local_1c == 0) {
local_30 = 1;
local_1c = setsockopt(*local_28,6,1,&local_30,4);
}
local_c = local_1c;
}
return local_c;
}
| |
34,277 | intern_filename | eloqsql/mysys/mf_pack.c | char *intern_filename(char *to, const char *from)
{
size_t length, to_length;
char buff[FN_REFLEN + 1];
if (from == to)
{ /* Dirname may destroy from */
(void) strnmov(buff, from, FN_REFLEN);
from=buff;
}
length= dirname_part(to, from, &to_length); /* Copy dirname & fix chars */
(void) strnmov(to + to_length, from + length, FN_REFLEN - to_length);
return (to);
} | O0 | c | intern_filename:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq -0x220(%rbp), %rax
cmpq -0x218(%rbp), %rax
jne 0x76ddc
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0xc8780
leaq -0x210(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rsi
leaq -0x230(%rbp), %rdx
callq 0x762c0
movq %rax, -0x228(%rbp)
movq -0x218(%rbp), %rdi
movq -0x230(%rbp), %rax
addq %rax, %rdi
movq -0x220(%rbp), %rsi
movq -0x228(%rbp), %rcx
addq %rcx, %rsi
movl $0x200, %edx # imm = 0x200
subq %rax, %rdx
callq 0xc8780
movq -0x218(%rbp), %rax
movq %rax, -0x238(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x76e5c
movq -0x238(%rbp), %rax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x362a0
nopw %cs:(%rax,%rax)
| intern_filename:
push rbp
mov rbp, rsp
sub rsp, 240h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov rax, [rbp+var_220]
cmp rax, [rbp+var_218]
jnz short loc_76DDC
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 200h
call strnmov
lea rax, [rbp+var_210]
mov [rbp+var_220], rax
loc_76DDC:
mov rdi, [rbp+var_218]
mov rsi, [rbp+var_220]
lea rdx, [rbp+var_230]
call dirname_part
mov [rbp+var_228], rax
mov rdi, [rbp+var_218]
mov rax, [rbp+var_230]
add rdi, rax
mov rsi, [rbp+var_220]
mov rcx, [rbp+var_228]
add rsi, rcx
mov edx, 200h
sub rdx, rax
call strnmov
mov rax, [rbp+var_218]
mov [rbp+var_238], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_76E5C
mov rax, [rbp+var_238]
add rsp, 240h
pop rbp
retn
loc_76E5C:
call ___stack_chk_fail
| long long intern_filename(long long a1, _BYTE *a2)
{
long long v3; // [rsp+10h] [rbp-230h] BYREF
long long v4; // [rsp+18h] [rbp-228h]
_BYTE *v5; // [rsp+20h] [rbp-220h]
long long v6; // [rsp+28h] [rbp-218h]
_BYTE v7[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v8; // [rsp+238h] [rbp-8h]
v8 = __readfsqword(0x28u);
v6 = a1;
v5 = a2;
if ( a2 == (_BYTE *)a1 )
{
strnmov(v7, v5, 512LL);
v5 = v7;
}
v4 = dirname_part(v6, v5, &v3);
strnmov(v3 + v6, &v5[v4], 512 - v3);
return v6;
}
| intern_filename:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x240
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV RAX,qword ptr [RBP + -0x220]
CMP RAX,qword ptr [RBP + -0x218]
JNZ 0x00176ddc
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x200
CALL 0x001c8780
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x220],RAX
LAB_00176ddc:
MOV RDI,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RBP + -0x220]
LEA RDX,[RBP + -0x230]
CALL 0x001762c0
MOV qword ptr [RBP + -0x228],RAX
MOV RDI,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x230]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x228]
ADD RSI,RCX
MOV EDX,0x200
SUB RDX,RAX
CALL 0x001c8780
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x238],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00176e5c
MOV RAX,qword ptr [RBP + -0x238]
ADD RSP,0x240
POP RBP
RET
LAB_00176e5c:
CALL 0x001362a0
|
int1 * intern_filename(int1 *param_1,int1 *param_2)
{
long in_FS_OFFSET;
long local_238;
long local_230;
int1 *local_228;
int1 *local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
if (param_2 == param_1) {
strnmov(local_218,param_2,0x200);
local_228 = local_218;
}
local_230 = dirname_part(local_220,local_228,&local_238);
strnmov(local_220 + local_238,local_228 + local_230,0x200 - local_238);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_220;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
34,278 | coro::io_scheduler::process_scheduled_execute_inline() | AlayaLite/build_O3/_deps/libcoro-src/src/io_scheduler.cpp | auto io_scheduler::process_scheduled_execute_inline() -> void
{
std::vector<std::coroutine_handle<>> tasks{};
{
// Acquire the entire list, and then reset it.
std::scoped_lock lk{m_scheduled_tasks_mutex};
tasks.swap(m_scheduled_tasks);
// Clear the schedule eventfd if this is a scheduled task.
eventfd_t value{0};
eventfd_read(m_schedule_fd, &value);
// Clear the in memory flag to reduce eventfd_* calls on scheduling.
m_schedule_fd_triggered.exchange(false, std::memory_order::release);
}
// This set of handles can be safely resumed now since they do not have a corresponding timeout event.
for (auto& task : tasks)
{
task.resume();
}
m_size.fetch_sub(tasks.size(), std::memory_order::release);
} | O3 | cpp | coro::io_scheduler::process_scheduled_execute_inline():
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x138(%rdi), %r12
movq %r12, %rdi
callq 0x33a0
testl %eax, %eax
jne 0x769a
movq 0x160(%r15), %rbx
movq 0x168(%r15), %r13
movq 0x170(%r15), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x160(%r15)
xorl %eax, %eax
movq %rax, 0x170(%r15)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl 0xb4(%r15), %edi
callq 0x32c0
xorl %eax, %eax
xchgb %al, 0xb8(%r15)
movq %r12, %rdi
callq 0x3220
cmpq %r13, %rbx
je 0x766a
movq %rbx, %r12
movq (%r12), %rdi
callq *(%rdi)
addq $0x8, %r12
cmpq %r13, %r12
jne 0x765b
subq %rbx, %r13
sarq $0x3, %r13
lock
subq %r13, 0xc0(%r15)
testq %rbx, %rbx
je 0x768c
subq %rbx, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32d0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x31c0
movq %rax, %r15
movq %r12, %rdi
callq 0x3220
jmp 0x76b1
movq %rax, %r15
testq %rbx, %rbx
je 0x76c4
subq %rbx, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32d0
movq %r15, %rdi
callq 0x3430
| _ZN4coro12io_scheduler32process_scheduled_execute_inlineEv:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r15, rdi
lea r12, [rdi+138h]
mov rdi, r12
call _pthread_mutex_lock
test eax, eax
jnz loc_769A
mov rbx, [r15+160h]
mov r13, [r15+168h]
mov r14, [r15+170h]
xorps xmm0, xmm0
movups xmmword ptr [r15+160h], xmm0
xor eax, eax
mov [r15+170h], rax
lea rsi, [rsp+38h+var_30]
mov [rsi], rax
mov edi, [r15+0B4h]
call _eventfd_read
xor eax, eax
xchg al, [r15+0B8h]
mov rdi, r12
call _pthread_mutex_unlock
cmp rbx, r13
jz short loc_766A
mov r12, rbx
loc_765B:
mov rdi, [r12]
call qword ptr [rdi]
add r12, 8
cmp r12, r13
jnz short loc_765B
loc_766A:
sub r13, rbx
sar r13, 3
lock sub [r15+0C0h], r13
test rbx, rbx
jz short loc_768C
sub r14, rbx
mov rdi, rbx; void *
mov rsi, r14; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_768C:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_769A:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r15, rax
mov rdi, r12
call _pthread_mutex_unlock
jmp short loc_76B1
mov r15, rax
loc_76B1:
test rbx, rbx
jz short loc_76C4
sub r14, rbx
mov rdi, rbx; void *
mov rsi, r14; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76C4:
mov rdi, r15
call __Unwind_Resume
| void coro::io_scheduler::process_scheduled_execute_inline(coro::io_scheduler *this)
{
int v1; // eax
void (***v2)(void); // rbx
void (***v3)(void); // r13
long long v4; // r14
void (***v5)(void); // r12
_QWORD v6[6]; // [rsp+8h] [rbp-30h] BYREF
v1 = pthread_mutex_lock((char *)this + 312);
if ( v1 )
std::__throw_system_error(v1);
v2 = (void (***)(void))*((_QWORD *)this + 44);
v3 = (void (***)(void))*((_QWORD *)this + 45);
v4 = *((_QWORD *)this + 46);
*((_OWORD *)this + 22) = 0LL;
*((_QWORD *)this + 46) = 0LL;
v6[0] = 0LL;
eventfd_read(*((unsigned int *)this + 45), v6);
*((_BYTE *)this + 184) = 0;
pthread_mutex_unlock((char *)this + 312);
if ( v2 != v3 )
{
v5 = v2;
do
(**v5++)();
while ( v5 != v3 );
}
_InterlockedSub64((volatile signed long long *)this + 24, v3 - v2);
if ( v2 )
operator delete(v2, v4 - (_QWORD)v2);
}
| process_scheduled_execute_inline:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RDI
LEA R12,[RDI + 0x138]
MOV RDI,R12
CALL 0x001033a0
TEST EAX,EAX
JNZ 0x0010769a
MOV RBX,qword ptr [R15 + 0x160]
MOV R13,qword ptr [R15 + 0x168]
MOV R14,qword ptr [R15 + 0x170]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + 0x160],XMM0
XOR EAX,EAX
MOV qword ptr [R15 + 0x170],RAX
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
MOV EDI,dword ptr [R15 + 0xb4]
LAB_0010763d:
CALL 0x001032c0
XOR EAX,EAX
XCHG byte ptr [R15 + 0xb8],AL
MOV RDI,R12
CALL 0x00103220
CMP RBX,R13
JZ 0x0010766a
MOV R12,RBX
LAB_0010765b:
MOV RDI,qword ptr [R12]
LAB_0010765f:
CALL qword ptr [RDI]
LAB_00107661:
ADD R12,0x8
CMP R12,R13
JNZ 0x0010765b
LAB_0010766a:
SUB R13,RBX
SAR R13,0x3
SUB.LOCK qword ptr [R15 + 0xc0],R13
TEST RBX,RBX
JZ 0x0010768c
SUB R14,RBX
MOV RDI,RBX
MOV RSI,R14
CALL 0x001032d0
LAB_0010768c:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010769a:
MOV EDI,EAX
CALL 0x001031c0
LAB_001076a1:
MOV R15,RAX
MOV RDI,R12
CALL 0x00103220
JMP 0x001076b1
LAB_001076b1:
TEST RBX,RBX
JZ 0x001076c4
SUB R14,RBX
MOV RDI,RBX
MOV RSI,R14
CALL 0x001032d0
LAB_001076c4:
MOV RDI,R15
CALL 0x00103430
|
/* coro::io_scheduler::process_scheduled_execute_inline() */
void __thiscall coro::io_scheduler::process_scheduled_execute_inline(io_scheduler *this)
{
pthread_mutex_t *__mutex;
int8 *puVar1;
int8 *puVar2;
long lVar3;
int iVar4;
int8 uVar5;
void *unaff_RBX;
int8 *puVar6;
long unaff_R14;
eventfd_t local_30;
__mutex = (pthread_mutex_t *)(this + 0x138);
iVar4 = pthread_mutex_lock(__mutex);
if (iVar4 == 0) {
puVar1 = *(int8 **)(this + 0x160);
puVar2 = *(int8 **)(this + 0x168);
lVar3 = *(long *)(this + 0x170);
*(int8 *)(this + 0x160) = 0;
*(int8 *)(this + 0x168) = 0;
*(int8 *)(this + 0x170) = 0;
local_30 = 0;
/* try { // try from 0010763d to 00107641 has its CatchHandler @ 001076a1 */
eventfd_read(*(int *)(this + 0xb4),&local_30);
LOCK();
this[0xb8] = (io_scheduler)0x0;
UNLOCK();
pthread_mutex_unlock(__mutex);
for (puVar6 = puVar1; puVar6 != puVar2; puVar6 = puVar6 + 1) {
/* try { // try from 0010765f to 00107660 has its CatchHandler @ 001076ae */
(**(code **)*puVar6)();
}
LOCK();
*(long *)(this + 0xc0) = *(long *)(this + 0xc0) - ((long)puVar2 - (long)puVar1 >> 3);
UNLOCK();
if (puVar1 != (int8 *)0x0) {
operator_delete(puVar1,lVar3 - (long)puVar1);
}
return;
}
uVar5 = std::__throw_system_error(iVar4);
/* catch() { ... } // from try @ 0010763d with catch @ 001076a1 */
pthread_mutex_unlock(__mutex);
if (unaff_RBX != (void *)0x0) {
operator_delete(unaff_RBX,unaff_R14 - (long)unaff_RBX);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar5);
}
| |
34,279 | my_instr_simple | eloqsql/strings/ctype-simple.c | uint my_instr_simple(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if (cs->sort_order[*str++] == cs->sort_order[*search])
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if (cs->sort_order[*i++] != cs->sort_order[*j++])
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
} | O0 | c | my_instr_simple:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x4ddde
cmpq $0x0, -0x30(%rbp)
jne 0x4dc76
cmpl $0x0, 0x10(%rbp)
je 0x4dc6a
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4dde5
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x4dcad
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x4dddc
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x48(%rbp), %rdx
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x4ddd7
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x4dd59
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x60(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x68(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4dd57
jmp 0x4dcab
jmp 0x4dd08
cmpl $0x0, 0x10(%rbp)
jbe 0x4ddce
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x1, 0x10(%rbp)
jbe 0x4ddcc
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x38(%rbp), %rax
subl 0xc(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x4ddce
movl $0x2, -0x4(%rbp)
jmp 0x4dde5
jmp 0x4dcad
jmp 0x4ddde
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| my_instr_simple:
push rbp
mov rbp, rsp
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
ja loc_4DDDE
cmp [rbp+var_30], 0
jnz short loc_4DC76
cmp [rbp+arg_0], 0
jz short loc_4DC6A
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
loc_4DC6A:
mov [rbp+var_4], 1
jmp loc_4DDE5
loc_4DC76:
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_30]
add rax, rcx
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_58], rax
loc_4DCAB:
jmp short $+2
loc_4DCAD:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_50]
jz loc_4DDDC
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_40]
mov rdx, rcx
add rdx, 1
mov [rbp+var_40], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_48]
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jnz loc_4DDD7
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_68], rax
loc_4DD08:
mov rax, [rbp+var_68]
cmp rax, [rbp+var_58]
jz short loc_4DD59
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_60]
mov rdx, rcx
add rdx, 1
mov [rbp+var_60], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_68]
mov rsi, rdx
add rsi, 1
mov [rbp+var_68], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_4DD57
jmp loc_4DCAB
loc_4DD57:
jmp short loc_4DD08
loc_4DD59:
cmp [rbp+arg_0], 0
jbe short loc_4DDCE
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
sub rax, rcx
sub rax, 1
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+4], ecx
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+8], ecx
cmp [rbp+arg_0], 1
jbe short loc_4DDCC
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+0Ch], ecx
mov rax, [rbp+var_38]
mov eax, [rax+4]
add rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov ecx, [rax+10h]
mov rax, [rbp+var_38]
sub ecx, [rax+0Ch]
mov rax, [rbp+var_38]
mov [rax+14h], ecx
loc_4DDCC:
jmp short $+2
loc_4DDCE:
mov [rbp+var_4], 2
jmp short loc_4DDE5
loc_4DDD7:
jmp loc_4DCAD
loc_4DDDC:
jmp short $+2
loc_4DDDE:
mov [rbp+var_4], 0
loc_4DDE5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_instr_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
_DWORD *a6,
unsigned int a7)
{
unsigned __int8 *v7; // rcx
unsigned __int8 *v8; // rcx
unsigned __int8 *v9; // rdx
unsigned __int8 *v11; // [rsp+0h] [rbp-68h]
unsigned __int8 *v12; // [rsp+8h] [rbp-60h]
unsigned __int8 *v13; // [rsp+10h] [rbp-58h]
long long v14; // [rsp+18h] [rbp-50h]
unsigned __int8 *v15; // [rsp+28h] [rbp-40h]
if ( a5 > a3 )
return 0;
if ( a5 )
{
v15 = a2;
v14 = (long long)&a2[a3 - a5 + 1];
v13 = &a4[a5];
LABEL_7:
while ( v15 != (unsigned __int8 *)v14 )
{
v7 = v15++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v7) == *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a4) )
{
v12 = v15;
v11 = a4 + 1;
while ( v11 != v13 )
{
v8 = v12++;
v9 = v11++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v8) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v9) )
goto LABEL_7;
}
if ( a7 )
{
*a6 = 0;
a6[1] = (_DWORD)v15 - (_DWORD)a2 - 1;
a6[2] = a6[1];
if ( a7 > 1 )
{
a6[3] = a6[1];
a6[4] = a5 + a6[1];
a6[5] = a6[4] - a6[3];
}
}
return 2;
}
}
return 0;
}
if ( a7 )
{
*a6 = 0;
a6[1] = 0;
a6[2] = 0;
}
return 1;
}
| my_instr_simple:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x0014ddde
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0014dc76
CMP dword ptr [RBP + 0x10],0x0
JZ 0x0014dc6a
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
LAB_0014dc6a:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0014dde5
LAB_0014dc76:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
LAB_0014dcab:
JMP 0x0014dcad
LAB_0014dcad:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x50]
JZ 0x0014dddc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x40],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x48]
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JNZ 0x0014ddd7
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
LAB_0014dd08:
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x58]
JZ 0x0014dd59
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x68]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x68],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x0014dd57
JMP 0x0014dcab
LAB_0014dd57:
JMP 0x0014dd08
LAB_0014dd59:
CMP dword ptr [RBP + 0x10],0x0
JBE 0x0014ddce
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
SUB RAX,0x1
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
CMP dword ptr [RBP + 0x10],0x1
JBE 0x0014ddcc
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x4]
ADD RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
SUB ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x14],ECX
LAB_0014ddcc:
JMP 0x0014ddce
LAB_0014ddce:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0014dde5
LAB_0014ddd7:
JMP 0x0014dcad
LAB_0014dddc:
JMP 0x0014ddde
LAB_0014ddde:
MOV dword ptr [RBP + -0x4],0x0
LAB_0014dde5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4
my_instr_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
int4 *param_6,uint param_7)
{
byte bVar1;
byte bVar2;
byte *pbVar3;
byte *local_70;
byte *local_68;
byte *local_48;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = 0;
param_6[2] = 0;
}
return 1;
}
local_48 = param_2;
while (local_48 != param_2 + (param_3 - param_5) + 1) {
pbVar3 = local_48 + 1;
bVar1 = *local_48;
local_48 = pbVar3;
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar1) ==
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_4)) {
local_70 = param_4 + 1;
local_68 = pbVar3;
do {
if (local_70 == param_4 + param_5) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = ((int)pbVar3 - (int)param_2) + -1;
param_6[2] = param_6[1];
if (1 < param_7) {
param_6[3] = param_6[1];
param_6[4] = param_6[1] + (int)param_5;
param_6[5] = param_6[4] - param_6[3];
}
}
return 2;
}
bVar1 = *local_68;
bVar2 = *local_70;
local_70 = local_70 + 1;
local_68 = local_68 + 1;
} while (*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar1) ==
*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar2));
}
}
}
return 0;
}
| |
34,280 | my_instr_simple | eloqsql/strings/ctype-simple.c | uint my_instr_simple(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if (cs->sort_order[*str++] == cs->sort_order[*search])
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if (cs->sort_order[*i++] != cs->sort_order[*j++])
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
} | O3 | c | my_instr_simple:
xorl %eax, %eax
cmpq %rdx, %r8
ja 0x3e2c4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x10(%rbp), %r11d
testq %r8, %r8
je 0x3e28a
addq %rsi, %rdx
subq %r8, %rdx
incq %rdx
movq %rsi, %r10
cmpq %rdx, %r10
je 0x3e2ba
movq %r10, %rbx
movq 0x58(%rdi), %r14
incq %r10
movzbl (%rbx), %r15d
movb (%r14,%r15), %r15b
movzbl (%rcx), %r12d
cmpb (%r14,%r12), %r15b
jne 0x3e20a
movl $0x1, %r15d
cmpq %r15, %r8
je 0x3e253
movzbl (%rbx,%r15), %r12d
movb (%r14,%r12), %r12b
movzbl (%rcx,%r15), %r13d
incq %r15
cmpb (%r14,%r13), %r12b
je 0x3e235
jmp 0x3e20a
movl $0x2, %eax
testl %r11d, %r11d
je 0x3e2ba
movl $0x0, (%r9)
notl %esi
addl %esi, %r10d
movl %r10d, 0x4(%r9)
movl %r10d, 0x8(%r9)
cmpl $0x1, %r11d
je 0x3e2ba
movl %r10d, 0xc(%r9)
addl %r8d, %r10d
movl $0x14, %ecx
movl $0x10, %edx
jmp 0x3e2ab
testl %r11d, %r11d
je 0x3e2b5
movl $0x0, (%r9)
movl $0x1, %eax
movl $0x8, %ecx
xorl %r10d, %r10d
movl $0x4, %edx
xorl %r8d, %r8d
movl %r10d, (%r9,%rdx)
movl %r8d, (%r9,%rcx)
jmp 0x3e2ba
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_instr_simple:
xor eax, eax
cmp r8, rdx
ja locret_3E2C4
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov r11d, [rbp+10h]
test r8, r8
jz loc_3E28A
add rdx, rsi
sub rdx, r8
inc rdx
mov r10, rsi
loc_3E20A:
cmp r10, rdx
jz loc_3E2BA
mov rbx, r10
mov r14, [rdi+58h]
inc r10
movzx r15d, byte ptr [rbx]
mov r15b, [r14+r15]
movzx r12d, byte ptr [rcx]
cmp r15b, [r14+r12]
jnz short loc_3E20A
mov r15d, 1
loc_3E235:
cmp r8, r15
jz short loc_3E253
movzx r12d, byte ptr [rbx+r15]
mov r12b, [r14+r12]
movzx r13d, byte ptr [rcx+r15]
inc r15
cmp r12b, [r14+r13]
jz short loc_3E235
jmp short loc_3E20A
loc_3E253:
mov eax, 2
test r11d, r11d
jz short loc_3E2BA
mov dword ptr [r9], 0
not esi
add r10d, esi
mov [r9+4], r10d
mov [r9+8], r10d
cmp r11d, 1
jz short loc_3E2BA
mov [r9+0Ch], r10d
add r10d, r8d
mov ecx, 14h
mov edx, 10h
jmp short loc_3E2AB
loc_3E28A:
test r11d, r11d
jz short loc_3E2B5
mov dword ptr [r9], 0
mov eax, 1
mov ecx, 8
xor r10d, r10d
mov edx, 4
xor r8d, r8d
loc_3E2AB:
mov [r9+rdx], r10d
mov [r9+rcx], r8d
jmp short loc_3E2BA
loc_3E2B5:
mov eax, 1
loc_3E2BA:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_3E2C4:
retn
| long long my_instr_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
_DWORD *a6,
int a7)
{
long long result; // rax
long long v8; // rdx
unsigned __int8 *v9; // r10
unsigned __int8 *v10; // rbx
long long v11; // r14
long long v12; // r15
char v13; // r12
long long v14; // r13
int v15; // r10d
int v16; // r10d
long long v17; // rcx
long long v18; // rdx
result = 0LL;
if ( a5 <= a3 )
{
if ( a5 )
{
v8 = (long long)&a2[a3 - a5 + 1];
v9 = a2;
LABEL_4:
while ( v9 != (unsigned __int8 *)v8 )
{
v10 = v9;
v11 = *(_QWORD *)(a1 + 88);
++v9;
if ( *(_BYTE *)(v11 + *v10) == *(_BYTE *)(v11 + *a4) )
{
v12 = 1LL;
while ( a5 != v12 )
{
v13 = *(_BYTE *)(v11 + v10[v12]);
v14 = a4[v12++];
if ( v13 != *(_BYTE *)(v11 + v14) )
goto LABEL_4;
}
result = 2LL;
if ( a7 )
{
*a6 = 0;
v15 = ~(_DWORD)a2 + (_DWORD)v9;
a6[1] = v15;
a6[2] = v15;
if ( a7 != 1 )
{
a6[3] = v15;
v16 = a5 + v15;
v17 = 5LL;
v18 = 4LL;
goto LABEL_15;
}
}
return result;
}
}
}
else if ( a7 )
{
*a6 = 0;
result = 1LL;
v17 = 2LL;
v16 = 0;
v18 = 1LL;
LODWORD(a5) = 0;
LABEL_15:
a6[v18] = v16;
a6[v17] = a5;
}
else
{
return 1LL;
}
}
return result;
}
| my_instr_simple:
XOR EAX,EAX
CMP R8,RDX
JA 0x0013e2c4
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R11D,dword ptr [RBP + 0x10]
TEST R8,R8
JZ 0x0013e28a
ADD RDX,RSI
SUB RDX,R8
INC RDX
MOV R10,RSI
LAB_0013e20a:
CMP R10,RDX
JZ 0x0013e2ba
MOV RBX,R10
MOV R14,qword ptr [RDI + 0x58]
INC R10
MOVZX R15D,byte ptr [RBX]
MOV R15B,byte ptr [R14 + R15*0x1]
MOVZX R12D,byte ptr [RCX]
CMP R15B,byte ptr [R14 + R12*0x1]
JNZ 0x0013e20a
MOV R15D,0x1
LAB_0013e235:
CMP R8,R15
JZ 0x0013e253
MOVZX R12D,byte ptr [RBX + R15*0x1]
MOV R12B,byte ptr [R14 + R12*0x1]
MOVZX R13D,byte ptr [RCX + R15*0x1]
INC R15
CMP R12B,byte ptr [R14 + R13*0x1]
JZ 0x0013e235
JMP 0x0013e20a
LAB_0013e253:
MOV EAX,0x2
TEST R11D,R11D
JZ 0x0013e2ba
MOV dword ptr [R9],0x0
NOT ESI
ADD R10D,ESI
MOV dword ptr [R9 + 0x4],R10D
MOV dword ptr [R9 + 0x8],R10D
CMP R11D,0x1
JZ 0x0013e2ba
MOV dword ptr [R9 + 0xc],R10D
ADD R10D,R8D
MOV ECX,0x14
MOV EDX,0x10
JMP 0x0013e2ab
LAB_0013e28a:
TEST R11D,R11D
JZ 0x0013e2b5
MOV dword ptr [R9],0x0
MOV EAX,0x1
MOV ECX,0x8
XOR R10D,R10D
MOV EDX,0x4
XOR R8D,R8D
LAB_0013e2ab:
MOV dword ptr [R9 + RDX*0x1],R10D
MOV dword ptr [R9 + RCX*0x1],R8D
JMP 0x0013e2ba
LAB_0013e2b5:
MOV EAX,0x1
LAB_0013e2ba:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_0013e2c4:
RET
|
int8
my_instr_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
int4 *param_6,int param_7)
{
byte *pbVar1;
byte *pbVar2;
int8 uVar3;
long lVar4;
long lVar5;
int iVar6;
byte *pbVar7;
byte *pbVar8;
ulong uVar9;
uVar3 = 0;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 == 0) {
uVar3 = 1;
}
else {
*param_6 = 0;
uVar3 = 1;
lVar4 = 8;
iVar6 = 0;
lVar5 = 4;
param_5 = 0;
LAB_0013e2ab:
*(int *)((long)param_6 + lVar5) = iVar6;
*(int *)((long)param_6 + lVar4) = (int)param_5;
}
}
else {
pbVar8 = param_2;
while (pbVar7 = pbVar8, pbVar7 != param_2 + (param_3 - param_5) + 1) {
lVar4 = *(long *)(param_1 + 0x58);
pbVar8 = pbVar7 + 1;
if (*(char *)(lVar4 + (ulong)*pbVar7) == *(char *)(lVar4 + (ulong)*param_4)) {
uVar9 = 1;
do {
if (param_5 == uVar9) {
uVar3 = 2;
if (param_7 == 0) {
return 2;
}
*param_6 = 0;
iVar6 = (int)pbVar8 + ~(uint)param_2;
param_6[1] = iVar6;
param_6[2] = iVar6;
if (param_7 == 1) {
return 2;
}
param_6[3] = iVar6;
iVar6 = iVar6 + (int)param_5;
lVar4 = 0x14;
lVar5 = 0x10;
goto LAB_0013e2ab;
}
pbVar1 = pbVar7 + uVar9;
pbVar2 = param_4 + uVar9;
uVar9 = uVar9 + 1;
} while (*(char *)(lVar4 + (ulong)*pbVar1) == *(char *)(lVar4 + (ulong)*pbVar2));
}
}
}
}
return uVar3;
}
| |
34,281 | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {} | O2 | cpp | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x66d3c
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x67d7e
addq $0x40, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c616
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x4ebae
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x632ea
movq %r14, %rdi
callq 0x23f10
| _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
add rdi, 20h ; ' '
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
call _ZSt11make_sharedIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>>()
lea rdi, [rbx+30h]
mov rsi, r14
call _ZNSt12__shared_ptrISt8functionIFN5minja5ValueERKSt10shared_ptrINS1_7ContextEERNS1_14ArgumentsValueEEELN9__gnu_cxx12_Lock_policyE2EEC2ERKSE_; std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2> const&)
add rbx, 40h ; '@'
mov rdi, rbx
xor esi, esi
add rsp, 8
pop rbx
pop r14
jmp _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov r14, rax
lea rdi, [rbx+18h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
add rbx, 8
mov rdi, rbx
call _ZNSt12__weak_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__weak_count<(__gnu_cxx::_Lock_policy)2>::~__weak_count()
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::Value(long long a1, _QWORD *a2)
{
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
std::make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(a1 + 32);
std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(
(_QWORD *)(a1 + 48),
a2);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(a1 + 64);
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
ADD RDI,0x20
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0016f268:
CALL 0x00166d3c
LAB_0016f26d:
LEA RDI,[RBX + 0x30]
MOV RSI,R14
CALL 0x00167d7e
ADD RBX,0x40
MOV RDI,RBX
XOR ESI,ESI
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0013c616
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0016f268 to 0016f26c has its CatchHandler @ 0016f28e */
std::
make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
();
std::
__shared_ptr<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2>
::__shared_ptr((__shared_ptr<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2>
*)(this + 0x30),(__shared_ptr *)param_1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)(this + 0x40));
return;
}
| |
34,282 | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {} | O3 | cpp | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x30, %edi
callq 0x1a870
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x92e07(%rip), %rcx # 0x128438
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x9567f
movq 0x9490f(%rip), %rcx # 0x129f80
cmpb $0x0, (%rcx)
je 0x9567b
incl 0x8(%rax)
jmp 0x9567f
lock
incl 0x8(%rax)
leaq 0x40(%rbx), %r14
movb $0x0, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x579d6
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x579d6
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x956c1
callq 0x6c8e8
movq %rbx, %rdi
callq 0x869cc
movq %r14, %rdi
callq 0x1af20
nop
| _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEESaISN_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<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>>>,std::allocator<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>>>>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
mov rcx, rax
add rcx, 10h
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov qword ptr [rax+20h], 0
mov [rbx+28h], rax
mov [rbx+20h], rcx
mov rax, [r14]
mov [rbx+30h], rax
mov rax, [r14+8]
mov [rbx+38h], rax
test rax, rax
jz short loc_9567F
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_9567B
inc dword ptr [rax+8]
jmp short loc_9567F
loc_9567B:
lock inc dword ptr [rax+8]
loc_9567F:
lea r14, [rbx+40h]
mov byte ptr [rbx+40h], 0
mov qword ptr [rbx+48h], 0
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
add rsp, 8
pop rbx
pop r14
jmp _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 r14, rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_956C1
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_956C1:
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::Value(long long a1, _QWORD *a2)
{
long long v2; // rax
long long result; // rax
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = operator new(0x30uLL);
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = &`vtable for'std::_Sp_counted_ptr_inplace<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>>>,std::allocator<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>>>>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_OWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(v2 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = v2;
*(_QWORD *)(a1 + 32) = v2 + 16;
*(_QWORD *)(a1 + 48) = *a2;
result = a2[1];
*(_QWORD *)(a1 + 56) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
*(_BYTE *)(a1 + 64) = 0;
*(_QWORD *)(a1 + 72) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
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 *)(a1 + 64));
return result;
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_00195612:
MOV EDI,0x30
CALL 0x0011a870
LAB_0019561c:
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x228438]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RCX,RAX
ADD RCX,0x10
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x20],RCX
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x38],RAX
TEST RAX,RAX
JZ 0x0019567f
MOV RCX,qword ptr [0x00229f80]
CMP byte ptr [RCX],0x0
JZ 0x0019567b
INC dword ptr [RAX + 0x8]
JMP 0x0019567f
LAB_0019567b:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019567f:
LEA R14,[RBX + 0x40]
MOV byte ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001579d6
MOV RDI,R14
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001579d6
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
long lVar1;
int8 *puVar2;
bool bVar3;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 00195612 to 0019561b has its CatchHandler @ 001956b0 */
puVar2 = (int8 *)operator_new(0x30);
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_ptr_inplace_00228448;
puVar2[2] = 0;
puVar2[3] = 0;
puVar2[4] = 0;
*(int8 **)(this + 0x28) = puVar2;
*(int8 **)(this + 0x20) = puVar2 + 2;
*(int8 *)(this + 0x30) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x38) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
bVar3 = (bool)((char)this + '@');
this[0x40] = (Value)0x0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar3);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar3);
return;
}
| |
34,283 | testing::internal::ParseInternalRunDeathTestFlag() | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-death-test.cc | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr;
// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
// can use it here.
int line = -1;
int index = -1;
::std::vector< ::std::string> fields;
SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
int write_fd = -1;
#ifdef GTEST_OS_WINDOWS
unsigned int parent_process_id = 0;
size_t write_handle_as_size_t = 0;
size_t event_handle_as_size_t = 0;
if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) ||
!ParseNaturalNumber(fields[2], &index) ||
!ParseNaturalNumber(fields[3], &parent_process_id) ||
!ParseNaturalNumber(fields[4], &write_handle_as_size_t) ||
!ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
GTEST_FLAG_GET(internal_run_death_test));
}
write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
event_handle_as_size_t);
#elif defined(GTEST_OS_FUCHSIA)
if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
!ParseNaturalNumber(fields[2], &index)) {
DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
GTEST_FLAG_GET(internal_run_death_test));
}
#else
if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) ||
!ParseNaturalNumber(fields[2], &index) ||
!ParseNaturalNumber(fields[3], &write_fd)) {
DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
GTEST_FLAG_GET(internal_run_death_test));
}
#endif // GTEST_OS_WINDOWS
return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
} | O0 | cpp | testing::internal::ParseInternalRunDeathTestFlag():
subq $0x78, %rsp
leaq 0xd9ac5(%rip), %rdi # 0x1d0bb0
callq 0x7bfe0
testb $0x1, %al
jne 0xf70f6
jmp 0xf7104
movq $0x0, 0x70(%rsp)
jmp 0xf72a8
movl $0xffffffff, 0x6c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x68(%rsp) # imm = 0xFFFFFFFF
leaq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1240e0
movq 0x18(%rsp), %rdx
leaq 0xd9a81(%rip), %rdi # 0x1d0bb0
movl $0x7c, %esi
callq 0xf72c0
jmp 0xf713b
movl $0xffffffff, 0x40(%rsp) # imm = 0xFFFFFFFF
leaq 0x50(%rsp), %rdi
callq 0x1240f0
cmpq $0x4, %rax
jne 0xf71db
leaq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x124270
movq %rax, %rdi
leaq 0x6c(%rsp), %rsi
callq 0x124110
movb %al, 0x17(%rsp)
jmp 0xf7179
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xf7183
jmp 0xf71db
leaq 0x50(%rsp), %rdi
movl $0x2, %esi
callq 0x124270
movq %rax, %rdi
leaq 0x68(%rsp), %rsi
callq 0x124110
movb %al, 0x16(%rsp)
jmp 0xf71a5
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0xf71af
jmp 0xf71db
leaq 0x50(%rsp), %rdi
movl $0x3, %esi
callq 0x124270
movq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x124110
movb %al, 0x15(%rsp)
jmp 0xf71d1
movb 0x15(%rsp), %al
testb $0x1, %al
jne 0xf722e
jmp 0xf71db
leaq 0x5de3b(%rip), %rsi # 0x15501d
leaq 0xd99c7(%rip), %rdx # 0x1d0bb0
leaq 0x20(%rsp), %rdi
callq 0x7cc30
jmp 0xf71f5
leaq 0x20(%rsp), %rdi
callq 0xf1e10
jmp 0xf7201
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xf729c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1c160
jmp 0xf729c
movl $0x30, %edi
callq 0x15760
movq %rax, 0x8(%rsp)
jmp 0xf723f
xorl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0x124270
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x6c(%rsp), %edx
movl 0x68(%rsp), %ecx
movl 0x40(%rsp), %r8d
callq 0x124290
jmp 0xf7269
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x123ed0
jmp 0xf72a8
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x30, %esi
callq 0x15780
leaq 0x50(%rsp), %rdi
callq 0x123ed0
jmp 0xf72b2
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x15dd0
nopl (%rax)
| _ZN7testing8internal29ParseInternalRunDeathTestFlagEv:
sub rsp, 78h
lea rdi, _ZN7testing35FLAGS_gtest_internal_run_death_testB5cxx11E; testing::FLAGS_gtest_internal_run_death_test
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz short loc_F70F6
jmp short loc_F7104
loc_F70F6:
mov qword ptr [rsp+70h], 0
jmp loc_F72A8
loc_F7104:
mov dword ptr [rsp+78h+var_10+4], 0FFFFFFFFh
mov dword ptr [rsp+78h+var_10], 0FFFFFFFFh
lea rdi, [rsp+78h+var_28]
mov [rsp+78h+var_60], rdi; int
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rdx, [rsp+78h+var_60]
lea rdi, _ZN7testing35FLAGS_gtest_internal_run_death_testB5cxx11E; testing::FLAGS_gtest_internal_run_death_test
mov esi, 7Ch ; '|'
call _ZN7testing8internal11SplitStringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcPSt6vectorIS6_SaIS6_EE; testing::internal::SplitString(std::string const&,char,std::vector<std::string> *)
jmp short $+2
loc_F713B:
mov dword ptr [rsp+78h+var_38], 0FFFFFFFFh
lea rdi, [rsp+78h+var_28]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
cmp rax, 4
jnz loc_F71DB
lea rdi, [rsp+78h+var_28]
mov esi, 1
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax; char
lea rsi, [rsp+78h+var_10+4]; __int64
call _ZN7testing8internal18ParseNaturalNumberIiEEbRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPT_; testing::internal::ParseNaturalNumber<int>(std::string const&,int *)
mov [rsp+78h+var_61], al
jmp short $+2
loc_F7179:
mov al, [rsp+78h+var_61]
test al, 1
jnz short loc_F7183
jmp short loc_F71DB
loc_F7183:
lea rdi, [rsp+78h+var_28]
mov esi, 2
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax; char
lea rsi, [rsp+78h+var_10]; __int64
call _ZN7testing8internal18ParseNaturalNumberIiEEbRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPT_; testing::internal::ParseNaturalNumber<int>(std::string const&,int *)
mov [rsp+78h+var_62], al
jmp short $+2
loc_F71A5:
mov al, [rsp+78h+var_62]
test al, 1
jnz short loc_F71AF
jmp short loc_F71DB
loc_F71AF:
lea rdi, [rsp+78h+var_28]
mov esi, 3
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax; char
lea rsi, [rsp+78h+var_38]; __int64
call _ZN7testing8internal18ParseNaturalNumberIiEEbRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPT_; testing::internal::ParseNaturalNumber<int>(std::string const&,int *)
mov [rsp+78h+var_63], al
jmp short $+2
loc_F71D1:
mov al, [rsp+78h+var_63]
test al, 1
jnz short loc_F722E
jmp short $+2
loc_F71DB:
lea rsi, aBadGtestIntern; "Bad --gtest_internal_run_death_test fla"...
lea rdx, _ZN7testing35FLAGS_gtest_internal_run_death_testB5cxx11E; int
lea rdi, [rsp+78h+var_58]; int
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
jmp short $+2
loc_F71F5:
lea rdi, [rsp+78h+var_58]
call _ZN7testing8internalL14DeathTestAbortERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::DeathTestAbort(std::string const&)
jmp short $+2
loc_F7201:
mov rcx, rax
mov eax, edx
mov [rsp+78h+var_30], rcx
mov dword ptr [rsp+78h+var_38+4], eax
jmp loc_F729C
mov rcx, rax
mov eax, edx
mov [rsp+78h+var_30], rcx
mov dword ptr [rsp+78h+var_38+4], eax
lea rdi, [rsp+78h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_F729C
loc_F722E:
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov [rsp+78h+var_70], rax
jmp short $+2
loc_F723F:
xor eax, eax
mov esi, eax
lea rdi, [rsp+78h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, [rsp+78h+var_70]
mov rsi, rax
mov edx, dword ptr [rsp+78h+var_10+4]
mov ecx, dword ptr [rsp+78h+var_10]
mov r8d, dword ptr [rsp+78h+var_38]
call _ZN7testing8internal24InternalRunDeathTestFlagC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiii; testing::internal::InternalRunDeathTestFlag::InternalRunDeathTestFlag(std::string const&,int,int,int)
jmp short $+2
loc_F7269:
mov rax, [rsp+78h+var_70]
mov [rsp+70h], rax
lea rdi, [rsp+78h+var_28]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_F72A8
mov rdi, [rsp+78h+var_70]; void *
mov rcx, rax
mov eax, edx
mov [rsp+78h+var_30], rcx
mov dword ptr [rsp+78h+var_38+4], eax
mov esi, 30h ; '0'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F729C:
lea rdi, [rsp+78h+var_28]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_F72B2
loc_F72A8:
mov rax, [rsp+70h]
add rsp, 78h
retn
loc_F72B2:
mov rdi, [rsp+78h+var_30]
call __Unwind_Resume
| void * testing::internal::ParseInternalRunDeathTestFlag(testing::internal *this)
{
int v1; // ecx
int v2; // r8d
int v3; // r9d
char v4; // al
char v5; // al
char v6; // al
long long v7; // rax
int v9; // [rsp+0h] [rbp-78h]
int v10; // [rsp+0h] [rbp-78h]
int v11; // [rsp+0h] [rbp-78h]
int v12; // [rsp+8h] [rbp-70h]
int v13; // [rsp+8h] [rbp-70h]
int v14; // [rsp+8h] [rbp-70h]
void *v15; // [rsp+8h] [rbp-70h]
int v16; // [rsp+10h] [rbp-68h]
int v17; // [rsp+10h] [rbp-68h]
int v18; // [rsp+10h] [rbp-68h]
long long v19; // [rsp+18h] [rbp-60h]
long long v20; // [rsp+18h] [rbp-60h]
char v21[32]; // [rsp+20h] [rbp-58h] BYREF
long long v22; // [rsp+40h] [rbp-38h] BYREF
long long v23[3]; // [rsp+50h] [rbp-28h] BYREF
long long v24; // [rsp+68h] [rbp-10h] BYREF
void *v25; // [rsp+70h] [rbp-8h]
if ( std::string::empty((long long)&testing::FLAGS_gtest_internal_run_death_test[abi:cxx11]) )
return 0LL;
v24 = -1LL;
std::vector<std::string>::vector(v23);
testing::internal::SplitString(
(unsigned int)&testing::FLAGS_gtest_internal_run_death_test[abi:cxx11],
124,
(unsigned int)v23,
v1,
v2,
v3);
LODWORD(v22) = -1;
if ( std::vector<std::string>::size(v23) != 4
|| (v4 = std::vector<std::string>::operator[](v23, 1LL),
(testing::internal::ParseNaturalNumber<int>(v4, (long long)&v24 + 4, v9, v12, v16, (long long)v23, v21[0]) & 1) == 0)
|| (v5 = std::vector<std::string>::operator[](v23, 2LL),
(testing::internal::ParseNaturalNumber<int>(v5, (long long)&v24, v10, v13, v17, v19, v21[0]) & 1) == 0)
|| (v6 = std::vector<std::string>::operator[](v23, 3LL),
(testing::internal::ParseNaturalNumber<int>(v6, (long long)&v22, v11, v14, v18, v20, v21[0]) & 1) == 0) )
{
std::operator+<char>(
(long long)v21,
(long long)"Bad --gtest_internal_run_death_test flag: ",
(long long)&testing::FLAGS_gtest_internal_run_death_test[abi:cxx11]);
testing::internal::DeathTestAbort((testing::internal *)v21);
}
v15 = (void *)operator new(0x30uLL);
v7 = std::vector<std::string>::operator[](v23, 0LL);
testing::internal::InternalRunDeathTestFlag::InternalRunDeathTestFlag(
v15,
v7,
HIDWORD(v24),
(unsigned int)v24,
(unsigned int)v22);
v25 = v15;
std::vector<std::string>::~vector(v23);
return v25;
}
| ParseInternalRunDeathTestFlag:
SUB RSP,0x78
LEA RDI,[0x2d0bb0]
CALL 0x0017bfe0
TEST AL,0x1
JNZ 0x001f70f6
JMP 0x001f7104
LAB_001f70f6:
MOV qword ptr [RSP + 0x70],0x0
JMP 0x001f72a8
LAB_001f7104:
MOV dword ptr [RSP + 0x6c],0xffffffff
MOV dword ptr [RSP + 0x68],0xffffffff
LEA RDI,[RSP + 0x50]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x002240e0
MOV RDX,qword ptr [RSP + 0x18]
LAB_001f7128:
LEA RDI,[0x2d0bb0]
MOV ESI,0x7c
CALL 0x001f72c0
JMP 0x001f713b
LAB_001f713b:
MOV dword ptr [RSP + 0x40],0xffffffff
LEA RDI,[RSP + 0x50]
CALL 0x002240f0
CMP RAX,0x4
JNZ 0x001f71db
LEA RDI,[RSP + 0x50]
MOV ESI,0x1
CALL 0x00224270
MOV RDI,RAX
LEA RSI,[RSP + 0x6c]
CALL 0x00224110
MOV byte ptr [RSP + 0x17],AL
JMP 0x001f7179
LAB_001f7179:
MOV AL,byte ptr [RSP + 0x17]
TEST AL,0x1
JNZ 0x001f7183
JMP 0x001f71db
LAB_001f7183:
LEA RDI,[RSP + 0x50]
MOV ESI,0x2
CALL 0x00224270
MOV RDI,RAX
LEA RSI,[RSP + 0x68]
CALL 0x00224110
MOV byte ptr [RSP + 0x16],AL
JMP 0x001f71a5
LAB_001f71a5:
MOV AL,byte ptr [RSP + 0x16]
TEST AL,0x1
JNZ 0x001f71af
JMP 0x001f71db
LAB_001f71af:
LEA RDI,[RSP + 0x50]
MOV ESI,0x3
CALL 0x00224270
MOV RDI,RAX
LEA RSI,[RSP + 0x40]
CALL 0x00224110
MOV byte ptr [RSP + 0x15],AL
JMP 0x001f71d1
LAB_001f71d1:
MOV AL,byte ptr [RSP + 0x15]
TEST AL,0x1
JNZ 0x001f722e
JMP 0x001f71db
LAB_001f71db:
LEA RSI,[0x25501d]
LEA RDX,[0x2d0bb0]
LEA RDI,[RSP + 0x20]
CALL 0x0017cc30
JMP 0x001f71f5
LAB_001f71f5:
LEA RDI,[RSP + 0x20]
CALL 0x001f1e10
JMP 0x001f7201
LAB_001f7201:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x48],RCX
MOV dword ptr [RSP + 0x44],EAX
JMP 0x001f729c
LAB_001f722e:
MOV EDI,0x30
CALL 0x00115760
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001f723f
LAB_001f723f:
XOR EAX,EAX
MOV ESI,EAX
LEA RDI,[RSP + 0x50]
CALL 0x00224270
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RAX
MOV EDX,dword ptr [RSP + 0x6c]
MOV ECX,dword ptr [RSP + 0x68]
MOV R8D,dword ptr [RSP + 0x40]
LAB_001f7262:
CALL 0x00224290
LAB_001f7267:
JMP 0x001f7269
LAB_001f7269:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x70],RAX
LEA RDI,[RSP + 0x50]
CALL 0x00223ed0
JMP 0x001f72a8
LAB_001f729c:
LEA RDI,[RSP + 0x50]
CALL 0x00223ed0
JMP 0x001f72b2
LAB_001f72a8:
MOV RAX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
LAB_001f72b2:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x00115dd0
|
/* testing::internal::ParseInternalRunDeathTestFlag() */
InternalRunDeathTestFlag * testing::internal::ParseInternalRunDeathTestFlag(void)
{
bool bVar1;
ulong uVar2;
long lVar3;
string *psVar4;
InternalRunDeathTestFlag *this;
int1 auVar5 [12];
string local_58 [32];
int local_38;
int4 local_34;
int8 local_30;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_28 [24];
int local_10;
int local_c;
InternalRunDeathTestFlag *local_8;
uVar2 = std::__cxx11::string::empty((string *)FLAGS_gtest_internal_run_death_test_abi_cxx11_);
if ((uVar2 & 1) != 0) {
return (InternalRunDeathTestFlag *)0x0;
}
local_c = -1;
local_10 = -1;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_28);
/* try { // try from 001f7128 to 001f71f2 has its CatchHandler @ 001f7201 */
SplitString((string *)FLAGS_gtest_internal_run_death_test_abi_cxx11_,'|',(vector *)local_28);
local_38 = -1;
lVar3 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size(local_28);
if (lVar3 == 4) {
psVar4 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,1);
bVar1 = ParseNaturalNumber<int>(psVar4,&local_c);
if (bVar1) {
psVar4 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,2);
bVar1 = ParseNaturalNumber<int>(psVar4,&local_10);
if (bVar1) {
psVar4 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,3);
bVar1 = ParseNaturalNumber<int>(psVar4,&local_38);
if (bVar1) {
/* try { // try from 001f722e to 001f7237 has its CatchHandler @ 001f7201 */
this = (InternalRunDeathTestFlag *)operator_new(0x30);
psVar4 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
operator[](local_28,0);
/* try { // try from 001f7262 to 001f7266 has its CatchHandler @ 001f727f */
InternalRunDeathTestFlag::InternalRunDeathTestFlag(this,psVar4,local_c,local_10,local_38);
local_8 = this;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_28);
return local_8;
}
}
}
}
std::operator+((char *)local_58,(string *)"Bad --gtest_internal_run_death_test flag: ");
/* try { // try from 001f71f5 to 001f71fe has its CatchHandler @ 001f7214 */
auVar5 = DeathTestAbort(local_58);
local_34 = auVar5._8_4_;
local_30 = auVar5._0_8_;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_28);
/* WARNING: Subroutine does not return */
_Unwind_Resume(local_30);
/* catch() { ... } // from try @ 001f7128 with catch @ 001f7201
catch() { ... } // from try @ 001f722e with catch @ 001f7201 */
}
| |
34,284 | split_rtree_node | eloqsql/storage/myisam/rt_split.c | static int split_rtree_node(SplitStruct *node, int n_entries,
int all_size, /* Total key's size */
int key_size,
int min_size, /* Minimal group size */
int size1, int size2 /* initial group sizes */,
double **d_buffer, int n_dim)
{
SplitStruct *cur;
SplitStruct *UNINIT_VAR(a), *UNINIT_VAR(b);
double *g1 = reserve_coords(d_buffer, n_dim);
double *g2 = reserve_coords(d_buffer, n_dim);
SplitStruct *UNINIT_VAR(next);
int UNINIT_VAR(next_node);
int i;
SplitStruct *end = node + n_entries;
if (all_size < min_size * 2)
{
return 1;
}
cur = node;
for (; cur<end; ++cur)
{
cur->square = count_square(cur->coords, n_dim);
cur->n_node = 0;
}
pick_seeds(node, n_entries, &a, &b, n_dim);
a->n_node = 1;
b->n_node = 2;
copy_coords(g1, a->coords, n_dim);
size1 += key_size;
copy_coords(g2, b->coords, n_dim);
size2 += key_size;
for (i=n_entries - 2; i>0; --i)
{
if (all_size - (size2 + key_size) < min_size) /* Can't write into group 2 */
{
mark_all_entries(node, n_entries, 1);
break;
}
if (all_size - (size1 + key_size) < min_size) /* Can't write into group 1 */
{
mark_all_entries(node, n_entries, 2);
break;
}
pick_next(node, n_entries, g1, g2, &next, &next_node, n_dim);
if (next_node == 1)
{
size1 += key_size;
mbr_join(g1, next->coords, n_dim);
}
else
{
size2 += key_size;
mbr_join(g2, next->coords, n_dim);
}
next->n_node = next_node;
}
return 0;
} | O0 | c | split_rtree_node:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x20(%rbp), %eax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0xd58b0
movq %rax, -0x48(%rbp)
movq 0x18(%rbp), %rdi
movl 0x20(%rbp), %esi
callq 0xd58b0
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movl -0x18(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jge 0xd5980
movl $0x1, -0x4(%rbp)
jmp 0xd5b0a
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0xd59c3
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x20(%rbp), %esi
callq 0xd5b20
movq -0x30(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x30(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
jmp 0xd5988
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl 0x20(%rbp), %r8d
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0xd5b90
movq -0x38(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x40(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0xd5cb0
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0xd5cb0
movl -0x1c(%rbp), %eax
addl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x60(%rbp)
cmpl $0x0, -0x60(%rbp)
jle 0xd5b03
movl -0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl %ecx, %eax
cmpl -0x20(%rbp), %eax
jge 0xd5a64
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1, %edx
callq 0xd5cf0
jmp 0xd5b03
movl -0x18(%rbp), %eax
movl -0x24(%rbp), %ecx
addl -0x1c(%rbp), %ecx
subl %ecx, %eax
cmpl -0x20(%rbp), %eax
jge 0xd5a87
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x2, %edx
callq 0xd5cf0
jmp 0xd5b03
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
movl 0x20(%rbp), %eax
leaq -0x58(%rbp), %r8
leaq -0x5c(%rbp), %r9
movl %eax, (%rsp)
callq 0xd5d50
cmpl $0x1, -0x5c(%rbp)
jne 0xd5ace
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0xd5e70
jmp 0xd5aeb
movl -0x1c(%rbp), %eax
addl 0x10(%rbp), %eax
movl %eax, 0x10(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rbp), %edx
callq 0xd5e70
movl -0x5c(%rbp), %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x60(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xd5a34
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| split_rtree_node:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_1C], ecx
mov [rbp+var_20], r8d
mov [rbp+var_24], r9d
mov rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
mov [rbp+var_40], rax
mov rdi, [rbp+arg_8]
mov esi, [rbp+arg_10]
call reserve_coords_0
mov [rbp+var_48], rax
mov rdi, [rbp+arg_8]
mov esi, [rbp+arg_10]
call reserve_coords_0
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
mov [rbp+var_58], rax
mov eax, [rbp+var_5C]
mov [rbp+var_5C], eax
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_14]
shl rcx, 5
add rax, rcx
mov [rbp+var_68], rax
mov eax, [rbp+var_18]
mov ecx, [rbp+var_20]
shl ecx, 1
cmp eax, ecx
jge short loc_D5980
mov [rbp+var_4], 1
jmp loc_D5B0A
loc_D5980:
mov rax, [rbp+var_10]
mov [rbp+var_30], rax
loc_D5988:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_68]
jnb short loc_D59C3
mov rax, [rbp+var_30]
mov rdi, [rax+18h]
mov esi, [rbp+arg_10]
call count_square_0
mov rax, [rbp+var_30]
movsd qword ptr [rax], xmm0
mov rax, [rbp+var_30]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_30]
add rax, 20h ; ' '
mov [rbp+var_30], rax
jmp short loc_D5988
loc_D59C3:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov r8d, [rbp+arg_10]
lea rdx, [rbp+var_38]
lea rcx, [rbp+var_40]
call pick_seeds_0
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 1
mov rax, [rbp+var_40]
mov dword ptr [rax+8], 2
mov rdi, [rbp+var_48]
mov rax, [rbp+var_38]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call copy_coords_0
mov eax, [rbp+var_1C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_40]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call copy_coords_0
mov eax, [rbp+var_1C]
add eax, [rbp+arg_0]
mov [rbp+arg_0], eax
mov eax, [rbp+var_14]
sub eax, 2
mov [rbp+var_60], eax
loc_D5A34:
cmp [rbp+var_60], 0
jle loc_D5B03
mov eax, [rbp+var_18]
mov ecx, [rbp+arg_0]
add ecx, [rbp+var_1C]
sub eax, ecx
cmp eax, [rbp+var_20]
jge short loc_D5A64
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, 1
call mark_all_entries_0
jmp loc_D5B03
loc_D5A64:
mov eax, [rbp+var_18]
mov ecx, [rbp+var_24]
add ecx, [rbp+var_1C]
sub eax, ecx
cmp eax, [rbp+var_20]
jge short loc_D5A87
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov edx, 2
call mark_all_entries_0
jmp short loc_D5B03
loc_D5A87:
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_48]
mov rcx, [rbp+var_50]
mov eax, [rbp+arg_10]
lea r8, [rbp+var_58]
lea r9, [rbp+var_5C]
mov [rsp+70h+var_70], eax
call pick_next_0
cmp [rbp+var_5C], 1
jnz short loc_D5ACE
mov eax, [rbp+var_1C]
add eax, [rbp+var_24]
mov [rbp+var_24], eax
mov rdi, [rbp+var_48]
mov rax, [rbp+var_58]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call mbr_join_0
jmp short loc_D5AEB
loc_D5ACE:
mov eax, [rbp+var_1C]
add eax, [rbp+arg_0]
mov [rbp+arg_0], eax
mov rdi, [rbp+var_50]
mov rax, [rbp+var_58]
mov rsi, [rax+18h]
mov edx, [rbp+arg_10]
call mbr_join_0
loc_D5AEB:
mov ecx, [rbp+var_5C]
mov rax, [rbp+var_58]
mov [rax+8], ecx
mov eax, [rbp+var_60]
add eax, 0FFFFFFFFh
mov [rbp+var_60], eax
jmp loc_D5A34
loc_D5B03:
mov [rbp+var_4], 0
loc_D5B0A:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long split_rtree_node(
unsigned long long a1,
unsigned int a2,
int a3,
int a4,
int a5,
int a6,
int a7,
long long *a8,
unsigned int a9)
{
int j; // [rsp+10h] [rbp-60h]
int v11; // [rsp+14h] [rbp-5Ch] BYREF
long long v12; // [rsp+18h] [rbp-58h] BYREF
long long v13; // [rsp+20h] [rbp-50h]
long long v14; // [rsp+28h] [rbp-48h]
long long v15; // [rsp+30h] [rbp-40h] BYREF
long long v16; // [rsp+38h] [rbp-38h] BYREF
unsigned long long i; // [rsp+40h] [rbp-30h]
int v18; // [rsp+4Ch] [rbp-24h]
int v19; // [rsp+50h] [rbp-20h]
int v20; // [rsp+54h] [rbp-1Ch]
int v21; // [rsp+58h] [rbp-18h]
unsigned int v22; // [rsp+5Ch] [rbp-14h]
unsigned long long v23; // [rsp+60h] [rbp-10h]
int v25; // [rsp+80h] [rbp+10h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v14 = reserve_coords_0(a8, a9);
v13 = reserve_coords_0(a8, a9);
if ( v21 >= 2 * v19 )
{
for ( i = v23; i < 32LL * (int)a2 + a1; i += 32LL )
{
*(double *)i = count_square_0(*(_QWORD *)(i + 24), a9);
*(_DWORD *)(i + 8) = 0;
}
pick_seeds_0(v23, v22, &v16, &v15, a9);
*(_DWORD *)(v16 + 8) = 1;
*(_DWORD *)(v15 + 8) = 2;
copy_coords_0(v14, *(_QWORD *)(v16 + 24), a9);
v18 += v20;
copy_coords_0(v13, *(_QWORD *)(v15 + 24), a9);
v25 = a7 + v20;
for ( j = v22 - 2; j > 0; --j )
{
if ( v21 - (v20 + v25) < v19 )
{
mark_all_entries_0(v23, v22, 1LL);
break;
}
if ( v21 - (v20 + v18) < v19 )
{
mark_all_entries_0(v23, v22, 2LL);
break;
}
pick_next_0(v23, v22, v14, v13, (unsigned int)&v12, (unsigned int)&v11, a9);
if ( v11 == 1 )
{
v18 += v20;
mbr_join_0(v14, *(_QWORD *)(v12 + 24), a9);
}
else
{
v25 += v20;
mbr_join_0(v13, *(_QWORD *)(v12 + 24), a9);
}
*(_DWORD *)(v12 + 8) = v11;
}
return 0;
}
else
{
return 1;
}
}
| split_rtree_node:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV dword ptr [RBP + -0x1c],ECX
MOV dword ptr [RBP + -0x20],R8D
MOV dword ptr [RBP + -0x24],R9D
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x001d58b0
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x001d58b0
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x14]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x20]
SHL ECX,0x1
CMP EAX,ECX
JGE 0x001d5980
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001d5b0a
LAB_001d5980:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x30],RAX
LAB_001d5988:
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x001d59c3
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RAX + 0x18]
MOV ESI,dword ptr [RBP + 0x20]
CALL 0x001d5b20
MOV RAX,qword ptr [RBP + -0x30]
MOVSD qword ptr [RAX],XMM0
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x20
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001d5988
LAB_001d59c3:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV R8D,dword ptr [RBP + 0x20]
LEA RDX,[RBP + -0x38]
LEA RCX,[RBP + -0x40]
CALL 0x001d5b90
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0x8],0x2
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x001d5cb0
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x001d5cb0
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + 0x10],EAX
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
MOV dword ptr [RBP + -0x60],EAX
LAB_001d5a34:
CMP dword ptr [RBP + -0x60],0x0
JLE 0x001d5b03
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + 0x10]
ADD ECX,dword ptr [RBP + -0x1c]
SUB EAX,ECX
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x001d5a64
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,0x1
CALL 0x001d5cf0
JMP 0x001d5b03
LAB_001d5a64:
MOV EAX,dword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD ECX,dword ptr [RBP + -0x1c]
SUB EAX,ECX
CMP EAX,dword ptr [RBP + -0x20]
JGE 0x001d5a87
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV EDX,0x2
CALL 0x001d5cf0
JMP 0x001d5b03
LAB_001d5a87:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + 0x20]
LEA R8,[RBP + -0x58]
LEA R9,[RBP + -0x5c]
MOV dword ptr [RSP],EAX
CALL 0x001d5d50
CMP dword ptr [RBP + -0x5c],0x1
JNZ 0x001d5ace
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x001d5e70
JMP 0x001d5aeb
LAB_001d5ace:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + 0x10]
MOV dword ptr [RBP + 0x10],EAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RAX + 0x18]
MOV EDX,dword ptr [RBP + 0x20]
CALL 0x001d5e70
LAB_001d5aeb:
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x58]
MOV dword ptr [RAX + 0x8],ECX
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x60],EAX
JMP 0x001d5a34
LAB_001d5b03:
MOV dword ptr [RBP + -0x4],0x0
LAB_001d5b0a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int4
split_rtree_node(int8 *param_1,int param_2,int param_3,int param_4,int param_5,int param_6,
int param_7,int8 param_8,int4 param_9)
{
int8 *puVar1;
int8 uVar2;
int local_68;
int local_64;
long local_60;
int8 local_58;
int8 local_50;
long local_48;
long local_40;
int8 *local_38;
int local_2c;
int local_28;
int local_24;
int local_20;
int local_1c;
int8 *local_18;
int4 local_c;
local_2c = param_6;
local_28 = param_5;
local_24 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_50 = reserve_coords(param_8,param_9);
local_58 = reserve_coords(param_8,param_9);
puVar1 = local_18 + (long)local_1c * 4;
if (SBORROW4(local_20,local_28 * 2) == local_20 + local_28 * -2 < 0) {
for (local_38 = local_18; local_38 < puVar1; local_38 = local_38 + 4) {
uVar2 = count_square(local_38[3],param_9);
*local_38 = uVar2;
*(int4 *)(local_38 + 1) = 0;
}
pick_seeds(local_18,local_1c,&local_40,&local_48,param_9);
*(int4 *)(local_40 + 8) = 1;
*(int4 *)(local_48 + 8) = 2;
copy_coords(local_50,*(int8 *)(local_40 + 0x18),param_9);
local_2c = local_24 + local_2c;
copy_coords(local_58,*(int8 *)(local_48 + 0x18),param_9);
param_7 = local_24 + param_7;
for (local_68 = local_1c + -2; 0 < local_68; local_68 = local_68 + -1) {
if (local_20 - (param_7 + local_24) < local_28) {
mark_all_entries(local_18,local_1c,1);
break;
}
if (local_20 - (local_2c + local_24) < local_28) {
mark_all_entries(local_18,local_1c,2);
break;
}
pick_next(local_18,local_1c,local_50,local_58,&local_60,&local_64,param_9);
if (local_64 == 1) {
local_2c = local_24 + local_2c;
mbr_join(local_50,*(int8 *)(local_60 + 0x18),param_9);
}
else {
param_7 = local_24 + param_7;
mbr_join(local_58,*(int8 *)(local_60 + 0x18),param_9);
}
*(int *)(local_60 + 8) = local_64;
}
local_c = 0;
}
else {
local_c = 1;
}
return local_c;
}
| |
34,285 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const | monkey531[P]llama/common/./json.hpp | const_reference operator[](size_type idx) const
{
// const operator[] only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
return m_data.m_value.array->operator[](idx);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a numeric argument with ", type_name()), this));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](unsigned long) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x2, (%rdi)
jne 0x5660f
movq 0x8(%r14), %rax
shlq $0x4, %rsi
addq (%rax), %rsi
movq %rsi, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
movq %r14, %rdi
callq 0x568fa
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xf0458(%rip), %rsi # 0x146a8b
leaq 0x10(%rsp), %rdi
callq 0x56871
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x566a6
xorl %ebp, %ebp
leaq 0x14c352(%rip), %rsi # 0x1a29b0
leaq 0x26959(%rip), %rdx # 0x7cfbe
movq %rbx, %rdi
callq 0x202e0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5668b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1fae0
testb %bpl, %bpl
jne 0x56695
jmp 0x5669d
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f7e0
movq %r14, %rdi
callq 0x20380
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixEm:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 2
jnz short loc_5660F
mov rax, [r14+8]
shl rsi, 4
add rsi, [rax]
mov rax, rsi
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_5660F:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseOpera; "cannot use operator[] with a numeric ar"...
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA52_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[52],char const*>(char const(&)[52],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_5668B
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5668B:
test bpl, bpl
jnz short loc_56695
jmp short loc_5669D
mov r14, rax
loc_56695:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5669D:
mov rdi, r14
call __Unwind_Resume
| operator[]:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x2
JNZ 0x0015660f
MOV RAX,qword ptr [R14 + 0x8]
SHL RSI,0x4
ADD RSI,qword ptr [RAX]
MOV RAX,RSI
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0015660f:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
MOV RDI,R14
CALL 0x001568fa
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_0015662c:
LEA RSI,[0x246a8b]
LEA RDI,[RSP + 0x10]
CALL 0x00156871
MOV BPL,0x1
LAB_00156640:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x001566a6
XOR EBP,EBP
LEA RSI,[0x2a29b0]
LEA RDX,[0x17cfbe]
MOV RDI,RBX
CALL 0x001202e0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::operator[](unsigned long) const */
long __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[](basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,ulong param_1)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
return param_1 * 0x10 + **(long **)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 0015662c to 0015663c has its CatchHandler @ 00156692 */
detail::concat<std::__cxx11::string,char_const(&)[52],char_const*>
(local_38,"cannot use operator[] with a numeric argument with ",&local_40);
/* try { // try from 00156640 to 0015666c has its CatchHandler @ 0015666d */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x131,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| ||
34,286 | lunasvg::SVGRectElement::updateShape(lunasvg::Path&) | dmazzella[P]pylunasvg/lunasvg/source/svggeometryelement.cpp | Rect SVGRectElement::updateShape(Path& path)
{
LengthContext lengthContext(this);
auto width = lengthContext.valueForLength(m_width);
auto height = lengthContext.valueForLength(m_height);
if(width <= 0.f || height <= 0.f) {
return Rect::Empty;
}
auto x = lengthContext.valueForLength(m_x);
auto y = lengthContext.valueForLength(m_y);
auto rx = lengthContext.valueForLength(m_rx);
auto ry = lengthContext.valueForLength(m_ry);
if(rx <= 0.f) rx = ry;
if(ry <= 0.f) ry = rx;
rx = std::min(rx, width / 2.f);
ry = std::min(ry, height / 2.f);
path.addRoundRect(x, y, width, height, rx, ry);
return Rect(x, y, width, height);
} | O1 | cpp | lunasvg::SVGRectElement::updateShape(lunasvg::Path&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %r15
movq %rdi, (%r15)
movb $0x0, 0x8(%r15)
leaq 0x154(%rdi), %rsi
movzbl 0x151(%rdi), %edx
movq %r15, %rdi
callq 0x1f7ea
movaps %xmm0, (%rsp)
leaq 0x16c(%r14), %rsi
movzbl 0x169(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movaps (%rsp), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm1, %xmm2
jae 0x147c2
ucomiss %xmm0, %xmm2
jae 0x147c2
leaq 0x124(%r14), %rsi
movzbl 0x121(%r14), %edx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movaps %xmm0, 0x10(%rsp)
callq 0x1f7ea
movaps %xmm0, 0x30(%rsp)
leaq 0x13c(%r14), %rsi
movzbl 0x139(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movaps %xmm0, 0x20(%rsp)
leaq 0x184(%r14), %rsi
movzbl 0x181(%r14), %edx
movq %r15, %rdi
callq 0x1f7ea
movaps %xmm0, 0x40(%rsp)
movzbl 0x199(%r14), %edx
addq $0x19c, %r14 # imm = 0x19C
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f7ea
xorps %xmm1, %xmm1
movaps 0x40(%rsp), %xmm3
movaps %xmm3, %xmm2
cmpnless %xmm1, %xmm2
andps %xmm2, %xmm3
andnps %xmm0, %xmm2
orps %xmm3, %xmm2
movaps %xmm0, %xmm6
cmpnless %xmm1, %xmm6
movaps %xmm6, %xmm1
andnps %xmm2, %xmm1
andps %xmm0, %xmm6
orps %xmm1, %xmm6
movss 0x2f0d1(%rip), %xmm0 # 0x4384c
movaps (%rsp), %xmm4
mulss %xmm0, %xmm4
minss %xmm2, %xmm4
movaps 0x10(%rsp), %xmm3
movaps %xmm3, %xmm5
mulss %xmm0, %xmm5
minss %xmm6, %xmm5
movq %rbx, %rdi
movaps 0x30(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movaps (%rsp), %xmm2
callq 0xd0b8
movaps 0x30(%rsp), %xmm0
movaps (%rsp), %xmm1
unpcklps 0x20(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
unpcklps 0x10(%rsp), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
jmp 0x147d2
leaq 0x2e9b3(%rip), %rax # 0x4317c
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
| _ZN7lunasvg14SVGRectElement11updateShapeERNS_4PathE:
push r15
push r14
push rbx
sub rsp, 60h
mov rbx, rsi
mov r14, rdi
lea r15, [rsp+78h+var_28]
mov [r15], rdi
mov byte ptr [r15+8], 0
lea rsi, [rdi+154h]
movzx edx, byte ptr [rdi+151h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps xmmword ptr [rsp+78h+var_78], xmm0
lea rsi, [r14+16Ch]
movzx edx, byte ptr [r14+169h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps xmm1, xmmword ptr [rsp+78h+var_78]
xorps xmm2, xmm2
ucomiss xmm2, xmm1
jnb loc_147C2
ucomiss xmm2, xmm0
jnb loc_147C2
lea rsi, [r14+124h]
movzx edx, byte ptr [r14+121h]
lea r15, [rsp+78h+var_28]
mov rdi, r15
movaps xmmword ptr [rsp+78h+var_68], xmm0
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps xmmword ptr [rsp+78h+var_48], xmm0
lea rsi, [r14+13Ch]
movzx edx, byte ptr [r14+139h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps xmmword ptr [rsp+78h+var_58], xmm0
lea rsi, [r14+184h]
movzx edx, byte ptr [r14+181h]
mov rdi, r15
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
movaps [rsp+78h+var_38], xmm0
movzx edx, byte ptr [r14+199h]
add r14, 19Ch
mov rdi, r15
mov rsi, r14
call _ZNK7lunasvg13LengthContext14valueForLengthERKNS_6LengthENS_15LengthDirectionE; lunasvg::LengthContext::valueForLength(lunasvg::Length const&,lunasvg::LengthDirection)
xorps xmm1, xmm1
movaps xmm3, [rsp+78h+var_38]
movaps xmm2, xmm3
cmpnless xmm2, xmm1
andps xmm3, xmm2
andnps xmm2, xmm0
orps xmm2, xmm3
movaps xmm6, xmm0
cmpnless xmm6, xmm1
movaps xmm1, xmm6
andnps xmm1, xmm2
andps xmm6, xmm0
orps xmm6, xmm1
movss xmm0, cs:dword_4384C
movaps xmm4, xmmword ptr [rsp+78h+var_78]
mulss xmm4, xmm0
minss xmm4, xmm2; float
movaps xmm3, xmmword ptr [rsp+78h+var_68]; float
movaps xmm5, xmm3
mulss xmm5, xmm0
minss xmm5, xmm6; float
mov rdi, rbx; this
movaps xmm0, xmmword ptr [rsp+78h+var_48]; float
movaps xmm1, xmmword ptr [rsp+78h+var_58]; float
movaps xmm2, xmmword ptr [rsp+78h+var_78]; float
call _ZN7lunasvg4Path12addRoundRectEffffff; lunasvg::Path::addRoundRect(float,float,float,float,float,float)
movaps xmm0, xmmword ptr [rsp+78h+var_48]
movaps xmm1, xmmword ptr [rsp+78h+var_78]
unpcklps xmm0, xmmword ptr [rsp+78h+var_58]
unpcklps xmm1, xmmword ptr [rsp+78h+var_68]
jmp short loc_147D2
loc_147C2:
lea rax, _ZN7lunasvg4Rect5EmptyE; lunasvg::Rect::Empty
movsd xmm0, qword ptr [rax]
movsd xmm1, qword ptr [rax+8]
loc_147D2:
add rsp, 60h
pop rbx
pop r14
pop r15
retn
| double lunasvg::SVGRectElement::updateShape(lunasvg::SVGRectElement *this, lunasvg::Path *a2, __m128 a3)
{
double v3; // xmm0_8
__m128 v4; // xmm1
__m128 v5; // xmm2
__m128 v6; // xmm2
__m128 v7; // xmm6
double result; // xmm0_8
float v9; // [rsp+0h] [rbp-78h]
float v10; // [rsp+10h] [rbp-68h]
__m128 v11; // [rsp+20h] [rbp-58h]
__m128 v12; // [rsp+30h] [rbp-48h]
__m128 v13; // [rsp+40h] [rbp-38h]
lunasvg::SVGRectElement *v14; // [rsp+50h] [rbp-28h] BYREF
char v15; // [rsp+58h] [rbp-20h]
v14 = this;
v15 = 0;
v3 = lunasvg::LengthContext::valueForLength(&v14, (char *)this + 340, *((unsigned __int8 *)this + 337));
v9 = *(float *)&v3;
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(
&v14,
(char *)this + 364,
*((unsigned __int8 *)this + 361));
if ( v9 <= 0.0 || a3.m128_f32[0] <= 0.0 )
return *(double *)lunasvg::Rect::Empty;
v10 = a3.m128_f32[0];
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(
&v14,
(char *)this + 292,
*((unsigned __int8 *)this + 289));
v12 = a3;
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(
&v14,
(char *)this + 316,
*((unsigned __int8 *)this + 313));
v11 = a3;
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(
&v14,
(char *)this + 388,
*((unsigned __int8 *)this + 385));
v13 = a3;
*(double *)a3.m128_u64 = lunasvg::LengthContext::valueForLength(
&v14,
(char *)this + 412,
*((unsigned __int8 *)this + 409));
v4.m128_i32[0] = 0;
v5 = _mm_cmpgt_ss(v13, v4);
v6 = _mm_or_ps(_mm_andnot_ps(v5, a3), _mm_and_ps(v13, v5));
v7 = _mm_cmpgt_ss(a3, v4);
lunasvg::Path::addRoundRect(
a2,
v12.m128_f32[0],
v11.m128_f32[0],
v9,
v10,
fminf(v9 * 0.5, v6.m128_f32[0]),
fminf(v10 * 0.5, COERCE_FLOAT(v7.m128_i32[0] & a3.m128_i32[0] | _mm_andnot_ps(v7, v6).m128_u32[0])));
*(_QWORD *)&result = _mm_unpacklo_ps(v12, v11).m128_u64[0];
return result;
}
| updateShape:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x60
MOV RBX,RSI
MOV R14,RDI
LEA R15,[RSP + 0x50]
MOV qword ptr [R15],RDI
MOV byte ptr [R15 + 0x8],0x0
LEA RSI,[RDI + 0x154]
MOVZX EDX,byte ptr [RDI + 0x151]
MOV RDI,R15
CALL 0x0011f7ea
MOVAPS xmmword ptr [RSP],XMM0
LEA RSI,[R14 + 0x16c]
MOVZX EDX,byte ptr [R14 + 0x169]
MOV RDI,R15
CALL 0x0011f7ea
MOVAPS XMM1,xmmword ptr [RSP]
XORPS XMM2,XMM2
UCOMISS XMM2,XMM1
JNC 0x001147c2
UCOMISS XMM2,XMM0
JNC 0x001147c2
LEA RSI,[R14 + 0x124]
MOVZX EDX,byte ptr [R14 + 0x121]
LEA R15,[RSP + 0x50]
MOV RDI,R15
MOVAPS xmmword ptr [RSP + 0x10],XMM0
CALL 0x0011f7ea
MOVAPS xmmword ptr [RSP + 0x30],XMM0
LEA RSI,[R14 + 0x13c]
MOVZX EDX,byte ptr [R14 + 0x139]
MOV RDI,R15
CALL 0x0011f7ea
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LEA RSI,[R14 + 0x184]
MOVZX EDX,byte ptr [R14 + 0x181]
MOV RDI,R15
CALL 0x0011f7ea
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVZX EDX,byte ptr [R14 + 0x199]
ADD R14,0x19c
MOV RDI,R15
MOV RSI,R14
CALL 0x0011f7ea
XORPS XMM1,XMM1
MOVAPS XMM3,xmmword ptr [RSP + 0x40]
MOVAPS XMM2,XMM3
CMPNLESS XMM2,XMM1
ANDPS XMM3,XMM2
ANDNPS XMM2,XMM0
ORPS XMM2,XMM3
MOVAPS XMM6,XMM0
CMPNLESS XMM6,XMM1
MOVAPS XMM1,XMM6
ANDNPS XMM1,XMM2
ANDPS XMM6,XMM0
ORPS XMM6,XMM1
MOVSS XMM0,dword ptr [0x0014384c]
MOVAPS XMM4,xmmword ptr [RSP]
MULSS XMM4,XMM0
MINSS XMM4,XMM2
MOVAPS XMM3,xmmword ptr [RSP + 0x10]
MOVAPS XMM5,XMM3
MULSS XMM5,XMM0
MINSS XMM5,XMM6
MOV RDI,RBX
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MOVAPS XMM2,xmmword ptr [RSP]
CALL 0x0010d0b8
MOVAPS XMM0,xmmword ptr [RSP + 0x30]
MOVAPS XMM1,xmmword ptr [RSP]
UNPCKLPS XMM0,xmmword ptr [RSP + 0x20]
UNPCKLPS XMM1,xmmword ptr [RSP + 0x10]
JMP 0x001147d2
LAB_001147c2:
LEA RAX,[0x14317c]
MOVSD XMM0,qword ptr [RAX]
MOVSD XMM1,qword ptr [RAX + 0x8]
LAB_001147d2:
ADD RSP,0x60
POP RBX
POP R14
POP R15
RET
|
/* lunasvg::SVGRectElement::updateShape(lunasvg::Path&) */
int8 __thiscall lunasvg::SVGRectElement::updateShape(SVGRectElement *this,Path *param_1)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
SVGRectElement *local_28;
int1 local_20;
local_20 = 0;
local_28 = this;
fVar1 = (float)LengthContext::valueForLength((LengthContext *)&local_28,this + 0x154,this[0x151]);
fVar2 = (float)LengthContext::valueForLength((LengthContext *)&local_28,this + 0x16c,this[0x169]);
if ((fVar1 <= 0.0) || (fVar2 <= 0.0)) {
fVar3 = (float)Rect::Empty;
fVar4 = (float)((ulong)Rect::Empty >> 0x20);
}
else {
fVar3 = (float)LengthContext::valueForLength
((LengthContext *)&local_28,this + 0x124,this[0x121]);
fVar4 = (float)LengthContext::valueForLength
((LengthContext *)&local_28,this + 0x13c,this[0x139]);
fVar5 = (float)LengthContext::valueForLength
((LengthContext *)&local_28,this + 0x184,this[0x181]);
fVar6 = (float)LengthContext::valueForLength
((LengthContext *)&local_28,this + 0x19c,this[0x199]);
fVar7 = (float)(~-(uint)(0.0 < fVar5) & (uint)fVar6 | (uint)fVar5 & -(uint)(0.0 < fVar5));
fVar6 = (float)(-(uint)(0.0 < fVar6) & (uint)fVar6 | ~-(uint)(0.0 < fVar6) & (uint)fVar7);
fVar5 = fVar1 * DAT_0014384c;
if (fVar7 <= fVar1 * DAT_0014384c) {
fVar5 = fVar7;
}
fVar7 = fVar2 * DAT_0014384c;
if (fVar6 <= fVar2 * DAT_0014384c) {
fVar7 = fVar6;
}
Path::addRoundRect(param_1,fVar3,fVar4,fVar1,fVar2,fVar5,fVar7);
}
return CONCAT44(fVar4,fVar3);
}
| |
34,287 | js_same_value | bluesky950520[P]quickjs/quickjs.c | static BOOL js_same_value(JSContext *ctx, JSValue op1, JSValue op2)
{
return js_strict_eq2(ctx, js_dup(op1), js_dup(op2), JS_EQ_SAME_VALUE);
} | O1 | c | js_same_value:
movq %rsi, -0x8(%rsp)
cmpl $-0x9, %edx
jb 0x2a4ce
movq -0x8(%rsp), %rax
incl (%rax)
movq %rcx, -0x8(%rsp)
cmpl $-0x9, %r8d
jb 0x2a4e0
movq -0x8(%rsp), %rax
incl (%rax)
movl $0x1, %r9d
jmp 0x3e180
| js_same_value:
mov [rsp+var_8], rsi
cmp edx, 0FFFFFFF7h
jb short loc_2A4CE
mov rax, [rsp+var_8]
inc dword ptr [rax]
loc_2A4CE:
mov [rsp+var_8], rcx
cmp r8d, 0FFFFFFF7h
jb short loc_2A4E0
mov rax, [rsp+var_8]
inc dword ptr [rax]
loc_2A4E0:
mov r9d, 1
jmp js_strict_eq2
| long long js_same_value(long long a1, _DWORD *a2, long long a3, _DWORD *a4, long long a5)
{
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*a2;
if ( (unsigned int)a5 >= 0xFFFFFFF7 )
++*a4;
return js_strict_eq2(a1, a2, a3, a4, a5, 1LL);
}
| js_same_value:
MOV qword ptr [RSP + -0x8],RSI
CMP EDX,-0x9
JC 0x0012a4ce
MOV RAX,qword ptr [RSP + -0x8]
INC dword ptr [RAX]
LAB_0012a4ce:
MOV qword ptr [RSP + -0x8],RCX
CMP R8D,-0x9
JC 0x0012a4e0
MOV RAX,qword ptr [RSP + -0x8]
INC dword ptr [RAX]
LAB_0012a4e0:
MOV R9D,0x1
JMP 0x0013e180
|
void js_same_value(int8 param_1,int *param_2,uint param_3,int *param_4,uint param_5)
{
if (0xfffffff6 < param_3) {
*param_2 = *param_2 + 1;
}
if (0xfffffff6 < param_5) {
*param_4 = *param_4 + 1;
}
js_strict_eq2();
return;
}
| |
34,288 | my_8bit_collation_flags_from_data | eloqsql/strings/ctype-simple.c | uint my_8bit_collation_flags_from_data(CHARSET_INFO *cs)
{
uint flags= 0;
if (cs->sort_order && cs->sort_order['A'] < cs->sort_order['a'] &&
cs->sort_order['a'] < cs->sort_order['B'])
flags|= MY_CS_CSSORT;
return flags;
} | O0 | c | my_8bit_collation_flags_from_data:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x4df5d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzbl 0x41(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movzbl 0x61(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4df5d
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movzbl 0x61(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
movzbl 0x42(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4df5d
movl -0xc(%rbp), %eax
orl $0x400, %eax # imm = 0x400
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_8bit_collation_flags_from_data:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
cmp qword ptr [rax+58h], 0
jz short loc_4DF5D
mov rax, [rbp+var_8]
mov rax, [rax+58h]
movzx eax, byte ptr [rax+41h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+58h]
movzx ecx, byte ptr [rcx+61h]
cmp eax, ecx
jge short loc_4DF5D
mov rax, [rbp+var_8]
mov rax, [rax+58h]
movzx eax, byte ptr [rax+61h]
mov rcx, [rbp+var_8]
mov rcx, [rcx+58h]
movzx ecx, byte ptr [rcx+42h]
cmp eax, ecx
jge short loc_4DF5D
mov eax, [rbp+var_C]
or eax, 400h
mov [rbp+var_C], eax
loc_4DF5D:
mov eax, [rbp+var_C]
pop rbp
retn
| long long my_8bit_collation_flags_from_data(long long a1)
{
unsigned int v2; // [rsp+0h] [rbp-Ch]
v2 = 0;
if ( *(_QWORD *)(a1 + 88)
&& *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 65LL) < (int)*(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 97LL)
&& *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 97LL) < (int)*(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + 66LL) )
{
return 1024;
}
return v2;
}
| my_8bit_collation_flags_from_data:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x58],0x0
JZ 0x0014df5d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX EAX,byte ptr [RAX + 0x41]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x58]
MOVZX ECX,byte ptr [RCX + 0x61]
CMP EAX,ECX
JGE 0x0014df5d
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
MOVZX EAX,byte ptr [RAX + 0x61]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x58]
MOVZX ECX,byte ptr [RCX + 0x42]
CMP EAX,ECX
JGE 0x0014df5d
MOV EAX,dword ptr [RBP + -0xc]
OR EAX,0x400
MOV dword ptr [RBP + -0xc],EAX
LAB_0014df5d:
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int4 my_8bit_collation_flags_from_data(long param_1)
{
int4 local_14;
local_14 = 0;
if (((*(long *)(param_1 + 0x58) != 0) &&
(*(byte *)(*(long *)(param_1 + 0x58) + 0x41) < *(byte *)(*(long *)(param_1 + 0x58) + 0x61)))
&& (*(byte *)(*(long *)(param_1 + 0x58) + 0x61) < *(byte *)(*(long *)(param_1 + 0x58) + 0x42)))
{
local_14 = 0x400;
}
return local_14;
}
| |
34,289 | ggml_get_f32_nd | ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.c | float ggml_get_f32_nd(const struct ggml_tensor * tensor, int i0, int i1, int i2, int i3) {
void * data = (char *) tensor->data + i0*tensor->nb[0] + i1*tensor->nb[1] + i2*tensor->nb[2] + i3*tensor->nb[3];
switch (tensor->type) {
case GGML_TYPE_I8:
return ((int8_t *) data)[0];
case GGML_TYPE_I16:
return ((int16_t *) data)[0];
case GGML_TYPE_I32:
return ((int32_t *) data)[0];
case GGML_TYPE_F16:
return GGML_FP16_TO_FP32(((ggml_fp16_t *) data)[0]);
case GGML_TYPE_BF16:
return GGML_BF16_TO_FP32(((ggml_bf16_t *) data)[0]);
case GGML_TYPE_F32:
return ((float *) data)[0];
default:
GGML_ABORT("fatal error");
}
} | O1 | c | ggml_get_f32_nd:
movslq %esi, %rsi
imulq 0x30(%rdi), %rsi
addq 0xf8(%rdi), %rsi
movslq %edx, %rdx
imulq 0x38(%rdi), %rdx
movslq %ecx, %rax
imulq 0x40(%rdi), %rax
addq %rdx, %rax
addq %rsi, %rax
movslq %r8d, %rcx
imulq 0x48(%rdi), %rcx
movl (%rdi), %edx
leal -0x18(%rdx), %esi
cmpl $0x6, %esi
ja 0xcfa2
leaq 0x3c1d9(%rip), %rdx # 0x4916c
movslq (%rdx,%rsi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
movsbl (%rax,%rcx), %eax
jmp 0xcfc0
testl %edx, %edx
je 0xcfd7
cmpl $0x1, %edx
jne 0xcfdd
movzwl (%rax,%rcx), %eax
movq 0x4efaa(%rip), %rcx # 0x5bf60
vmovss (%rcx,%rax,4), %xmm0
retq
movswl (%rax,%rcx), %eax
vcvtsi2ss %eax, %xmm0, %xmm0
retq
vcvtsi2ssl (%rax,%rcx), %xmm0, %xmm0
retq
movzwl (%rax,%rcx), %eax
shll $0x10, %eax
vmovd %eax, %xmm0
retq
vmovss (%rax,%rcx), %xmm0
retq
pushq %rax
leaq 0x3c52d(%rip), %rdi # 0x49512
leaq 0x3c694(%rip), %rdx # 0x49680
movl $0x46e, %esi # imm = 0x46E
xorl %eax, %eax
callq 0xaf40
| ggml_get_f32_nd:
movsxd rsi, esi
imul rsi, [rdi+30h]
add rsi, [rdi+0F8h]
movsxd rdx, edx
imul rdx, [rdi+38h]
movsxd rax, ecx
imul rax, [rdi+40h]
add rax, rdx
add rax, rsi
movsxd rcx, r8d
imul rcx, [rdi+48h]
mov edx, [rdi]
lea esi, [rdx-18h]; switch 7 cases
cmp esi, 6
ja short def_CF9A; jumptable 000000000000CF9A default case
lea rdx, jpt_CF9A
movsxd rsi, ds:(jpt_CF9A - 4916Ch)[rdx+rsi*4]
add rsi, rdx
jmp rsi; switch jump
loc_CF9C:
movsx eax, byte ptr [rax+rcx]; jumptable 000000000000CF9A case 24
jmp short loc_CFC0
def_CF9A:
test edx, edx; jumptable 000000000000CF9A default case
jz short loc_CFD7
cmp edx, 1
jnz short loc_CFDD; jumptable 000000000000CF9A cases 27-29
movzx eax, word ptr [rax+rcx]
mov rcx, cs:ggml_table_f32_f16_ptr
vmovss xmm0, dword ptr [rcx+rax*4]
retn
loc_CFBC:
movsx eax, word ptr [rax+rcx]; jumptable 000000000000CF9A case 25
loc_CFC0:
vcvtsi2ss xmm0, xmm0, eax
retn
loc_CFC5:
vcvtsi2ss xmm0, xmm0, dword ptr [rax+rcx]; jumptable 000000000000CF9A case 26
retn
loc_CFCB:
movzx eax, word ptr [rax+rcx]; jumptable 000000000000CF9A case 30
shl eax, 10h
vmovd xmm0, eax
retn
loc_CFD7:
vmovss xmm0, dword ptr [rax+rcx]
retn
loc_CFDD:
push rax; jumptable 000000000000CF9A cases 27-29
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aFatalError; "fatal error"
mov esi, 46Eh
xor eax, eax
call _ggml_abort
| long long ggml_get_f32_nd(int *a1, int a2, int a3, int a4, int a5, __m128 _XMM0)
{
long long result; // rax
int v8; // edx
result = *((_QWORD *)a1 + 31) + *((_QWORD *)a1 + 6) * a2 + *((_QWORD *)a1 + 7) * a3 + *((_QWORD *)a1 + 8) * a4;
_RCX = *((_QWORD *)a1 + 9) * a5;
v8 = *a1;
switch ( *a1 )
{
case 24:
result = (unsigned int)*(char *)(result + _RCX);
goto LABEL_7;
case 25:
result = (unsigned int)*(__int16 *)(result + _RCX);
LABEL_7:
__asm { vcvtsi2ss xmm0, xmm0, eax }
return result;
case 26:
__asm { vcvtsi2ss xmm0, xmm0, dword ptr [rax+rcx]; jumptable 000000000000CF9A case 26 }
return result;
case 27:
case 28:
case 29:
goto LABEL_11;
case 30:
result = *(unsigned __int16 *)(result + _RCX) << 16;
__asm { vmovd xmm0, eax }
return result;
default:
if ( v8 )
{
if ( v8 == 1 )
{
result = *(unsigned __int16 *)(result + _RCX);
_RCX = &ggml_table_f32_f16;
__asm { vmovss xmm0, dword ptr [rcx+rax*4] }
}
else
{
LABEL_11:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.c",
1134LL,
"fatal error",
_RCX);
return ggml_set_f32_1d();
}
}
else
{
__asm { vmovss xmm0, dword ptr [rax+rcx] }
}
return result;
}
}
| ggml_get_f32_nd:
MOVSXD RSI,ESI
IMUL RSI,qword ptr [RDI + 0x30]
ADD RSI,qword ptr [RDI + 0xf8]
MOVSXD RDX,EDX
IMUL RDX,qword ptr [RDI + 0x38]
MOVSXD RAX,ECX
IMUL RAX,qword ptr [RDI + 0x40]
ADD RAX,RDX
ADD RAX,RSI
MOVSXD RCX,R8D
IMUL RCX,qword ptr [RDI + 0x48]
MOV EDX,dword ptr [RDI]
LEA ESI,[RDX + -0x18]
CMP ESI,0x6
JA 0x0010cfa2
LEA RDX,[0x14916c]
MOVSXD RSI,dword ptr [RDX + RSI*0x4]
ADD RSI,RDX
switchD:
JMP RSI
caseD_18:
MOVSX EAX,byte ptr [RAX + RCX*0x1]
JMP 0x0010cfc0
default:
TEST EDX,EDX
JZ 0x0010cfd7
CMP EDX,0x1
JNZ 0x0010cfdd
MOVZX EAX,word ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [0x0015bf60]
VMOVSS XMM0,dword ptr [RCX + RAX*0x4]
RET
caseD_19:
MOVSX EAX,word ptr [RAX + RCX*0x1]
LAB_0010cfc0:
VCVTSI2SS XMM0,XMM0,EAX
RET
caseD_1a:
VCVTSI2SS XMM0,XMM0,dword ptr [RAX + RCX*0x1]
RET
caseD_1e:
MOVZX EAX,word ptr [RAX + RCX*0x1]
SHL EAX,0x10
VMOVD XMM0,EAX
RET
LAB_0010cfd7:
VMOVSS XMM0,dword ptr [RAX + RCX*0x1]
RET
caseD_1b:
PUSH RAX
LEA RDI,[0x149512]
LEA RDX,[0x149680]
MOV ESI,0x46e
XOR EAX,EAX
CALL 0x0010af40
|
ulong ggml_get_f32_nd(int *param_1,int param_2,int param_3,int param_4,int param_5)
{
int iVar1;
long lVar2;
long lVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 in_ZMM0 [64];
lVar2 = (long)param_4 * *(long *)(param_1 + 0x10) + (long)param_3 * *(long *)(param_1 + 0xe) +
(long)param_2 * *(long *)(param_1 + 0xc) + *(long *)(param_1 + 0x3e);
lVar3 = (long)param_5 * *(long *)(param_1 + 0x12);
iVar1 = *param_1;
auVar4._4_12_ = in_ZMM0._4_12_;
switch(iVar1) {
case 0x18:
iVar1 = (int)*(char *)(lVar2 + lVar3);
break;
case 0x19:
iVar1 = (int)*(short *)(lVar2 + lVar3);
break;
case 0x1a:
auVar5._0_4_ = (float)*(int *)(lVar2 + lVar3);
auVar5._4_12_ = auVar4._4_12_;
return auVar5._0_8_;
case 0x1e:
return (ulong)*(ushort *)(lVar2 + lVar3) << 0x10;
default:
if (iVar1 == 0) {
return (ulong)*(uint *)(lVar2 + lVar3);
}
if (iVar1 == 1) {
return (ulong)*(uint *)(PTR_ggml_table_f32_f16_0015bf60 +
(ulong)*(ushort *)(lVar2 + lVar3) * 4);
}
case 0x1b:
case 0x1c:
case 0x1d:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml-cpu/ggml-cpu.c"
,0x46e,"fatal error");
}
auVar4._0_4_ = (float)iVar1;
return auVar4._0_8_;
}
| |
34,290 | void Acore::Abort<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&, char const*&>(std::basic_string_view<char, std::char_traits<char>>, unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&, char const*&) | SylCore-WoTLK/src/common/Debugging/Errors.h | AC_COMMON_API inline void Abort(std::string_view file, uint32 line, std::string_view function, std::string_view fmt, Args&&... args)
{
Abort(file, line, function, StringFormat(fmt, std::forward<Args>(args)...));
} | O3 | c | void Acore::Abort<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&, char const*&>(std::basic_string_view<char, std::char_traits<char>>, unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int&, char const*&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movq 0xf8(%rsp), %rax
movq 0xf0(%rsp), %rcx
movq 0xe0(%rsp), %r13
movq 0xe8(%rsp), %rbx
movups (%r9), %xmm0
movl (%rcx), %ecx
movq (%rax), %rax
leaq 0x70(%rsp), %r8
movaps %xmm0, (%r8)
movq %rcx, 0x10(%r8)
movq %rax, 0x20(%r8)
leaq 0x20(%rsp), %rdi
movl $0xc2d, %ecx # imm = 0xC2D
movq %rbx, %rsi
movq %r13, %rdx
callq 0xea7c3
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0xc783c
movq %rax, %r14
cmpl $0x1, %edx
jne 0x73ae6
movq %r14, %rdi
callq 0x1b0d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x50(%rsp), %r8
movq %rax, (%r8)
movq %rbx, 0x10(%r8)
movq %r13, 0x18(%r8)
leaq 0x861ae(%rip), %rsi # 0xf9c49
leaq 0x20(%rsp), %rdi
movl $0x2c, %edx
movl $0xdc, %ecx
callq 0xea7c3
callq 0x1be70
jmp 0x73a37
movq %rax, %r14
callq 0x1be70
jmp 0x73ae6
movq %rax, %rdi
callq 0x2841d
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73ae6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xd32e8
movq %r14, %rdi
callq 0x1bba0
| _ZN5Acore5AbortIJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERjRPKcEEEvSt17basic_string_viewIcS4_EjSD_SD_DpOT_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov qword ptr [rsp+0D8h+var_C0], r8; int
mov [rsp+0D8h+var_C8], rcx; void *
mov ebp, edx
mov r15, rsi
mov r12, rdi
mov rax, [rsp+0D8h+arg_18]
mov rcx, [rsp+0D8h+arg_10]
mov r13, qword ptr [rsp+0D8h+arg_0]
mov rbx, qword ptr [rsp+0D8h+arg_8]
movups xmm0, xmmword ptr [r9]
mov ecx, [rcx]
mov rax, [rax]
lea r8, [rsp+0D8h+var_68]; int
movaps xmmword ptr [r8], xmm0
mov [r8+10h], rcx
mov [r8+20h], rax
lea rdi, [rsp+0D8h+var_B8]; int
mov ecx, 0C2Dh; int
mov rsi, rbx; int
mov rdx, r13; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
loc_73A37:
mov rax, qword ptr [rsp+0D8h+var_B8]
mov rcx, [rsp+0D8h+var_B0]
mov qword ptr [rsp+0D8h+var_98], rcx
mov qword ptr [rsp+0D8h+var_98+8], rax
movups xmm0, [rsp+0D8h+var_98]
movups [rsp+0D8h+var_D8], xmm0
mov rdi, r12
mov rsi, r15
mov edx, ebp
mov rcx, [rsp+0D8h+var_C8]
mov r8, qword ptr [rsp+0D8h+var_C0]
call _ZN5Acore5AbortESt17basic_string_viewIcSt11char_traitsIcEEjS3_S3_; Acore::Abort(std::string_view,uint,std::string_view,std::string_view)
mov r14, rax
cmp edx, 1
jnz short loc_73AE6
mov rdi, r14; void *
call ___cxa_begin_catch
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
lea r8, [rsp+0D8h+var_88]; int
mov [r8], rax
mov [r8+10h], rbx
mov [r8+18h], r13
lea rsi, aWrongFormatOcc_0; "Wrong format occurred ({}). Fmt string:"...
lea rdi, [rsp+0D8h+var_B8]; int
mov edx, 2Ch ; ','; int
mov ecx, 0DCh; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
call ___cxa_end_catch
jmp short loc_73A37
mov r14, rax
call ___cxa_end_catch
jmp short loc_73AE6
mov rdi, rax
call __clang_call_terminate
mov r14, rax
lea rax, [rsp+0D8h+var_A8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_73AE6
mov rsi, [rsp+0D8h+var_A8]
inc rsi; unsigned __int64
call _ZdlPvm; operator delete(void *,ulong)
loc_73AE6:
mov rdi, r14
call __Unwind_Resume
| void __noreturn Acore::Abort<std::string &,unsigned int &,char const*&>(
int a1,
int a2,
int a3,
void *a4,
int a5,
__int128 *a6,
int a7,
int a8,
unsigned int *a9,
long long *a10)
{
long long v11; // rcx
long long v12; // rax
int v13; // r9d
int v14; // [rsp+0h] [rbp-D8h]
int v15; // [rsp+8h] [rbp-D0h]
int v17; // [rsp+10h] [rbp-C8h]
int v18; // [rsp+18h] [rbp-C0h]
int v19[2]; // [rsp+20h] [rbp-B8h] BYREF
long long v20; // [rsp+28h] [rbp-B0h]
long long v21; // [rsp+40h] [rbp-98h]
unsigned long long v22; // [rsp+48h] [rbp-90h]
__int128 v23; // [rsp+70h] [rbp-68h] BYREF
long long v24; // [rsp+80h] [rbp-58h]
long long v25; // [rsp+90h] [rbp-48h]
v11 = *a9;
v12 = *a10;
v23 = *a6;
v24 = v11;
v25 = v12;
fmt::v10::vformat[abi:cxx11]((int)v19, a8, a7, 3117, (int)&v23, (int)a6, v14, v15, a4, a5, *(unsigned long long *)v19);
v21 = v20;
v22 = *(_QWORD *)v19;
Acore::Abort(a1, a2, a3, v17, v18, v13, v20, *(long long *)v19);
}
| Abort<std::__cxx11::string&,unsigned_int&,char_const*&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x18],R8
MOV qword ptr [RSP + 0x10],RCX
MOV EBP,EDX
MOV R15,RSI
MOV R12,RDI
MOV RAX,qword ptr [RSP + 0xf8]
MOV RCX,qword ptr [RSP + 0xf0]
MOV R13,qword ptr [RSP + 0xe0]
MOV RBX,qword ptr [RSP + 0xe8]
MOVUPS XMM0,xmmword ptr [R9]
MOV ECX,dword ptr [RCX]
MOV RAX,qword ptr [RAX]
LEA R8,[RSP + 0x70]
MOVAPS xmmword ptr [R8],XMM0
MOV qword ptr [R8 + 0x10],RCX
MOV qword ptr [R8 + 0x20],RAX
LAB_00173a22:
LEA RDI,[RSP + 0x20]
MOV ECX,0xc2d
MOV RSI,RBX
MOV RDX,R13
CALL 0x001ea7c3
LAB_00173a37:
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x40],RCX
MOV qword ptr [RSP + 0x48],RAX
LAB_00173a4b:
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R12
MOV RSI,R15
MOV EDX,EBP
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x18]
CALL 0x001c783c
LAB_00173a6b:
MOV R14,RAX
CMP EDX,0x1
JNZ 0x00173ae6
MOV RDI,R14
CALL 0x0011b0d0
MOV RCX,qword ptr [RAX]
MOV RDI,RAX
CALL qword ptr [RCX + 0x10]
LEA R8,[RSP + 0x50]
MOV qword ptr [R8],RAX
MOV qword ptr [R8 + 0x10],RBX
MOV qword ptr [R8 + 0x18],R13
LAB_00173a94:
LEA RSI,[0x1f9c49]
LEA RDI,[RSP + 0x20]
MOV EDX,0x2c
MOV ECX,0xdc
CALL 0x001ea7c3
LAB_00173aaf:
CALL 0x0011be70
JMP 0x00173a37
LAB_00173ae6:
MOV RDI,R14
CALL 0x0011bba0
|
/* void Acore::Abort<std::__cxx11::string&, unsigned int&, char
const*&>(std::basic_string_view<char, std::char_traits<char> >, unsigned int,
std::basic_string_view<char, std::char_traits<char> >, std::basic_string_view<char,
std::char_traits<char> >, std::__cxx11::string&, unsigned int&, char const*&) */
void Acore::Abort<std::__cxx11::string&,unsigned_int&,char_const*&>
(int8 param_1,int8 param_2,int4 param_3,int8 param_4,
int8 param_5,int4 *param_6,int8 param_7,int8 param_8,
uint *param_9,int8 *param_10)
{
long *plVar1;
int1 auVar2 [12];
int8 local_b8;
int8 local_b0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 local_78;
int8 local_70;
int4 local_68;
int4 uStack_64;
int4 uStack_60;
int4 uStack_5c;
ulong local_58;
int8 local_48;
local_68 = *param_6;
uStack_64 = param_6[1];
uStack_60 = param_6[2];
uStack_5c = param_6[3];
local_58 = (ulong)*param_9;
local_48 = *param_10;
/* try { // try from 00173a22 to 00173a36 has its CatchHandler @ 00173a6b */
fmt::v10::vformat_abi_cxx11_(&local_b8,param_8,param_7,0xc2d);
while( true ) {
local_98 = local_b0;
uStack_90 = local_b8;
/* try { // try from 00173a4b to 00173a6a has its CatchHandler @ 00173ac8 */
auVar2 = Abort(param_1,param_2,param_3,param_4,param_5);
/* catch(type#1 @ 004812a0) { ... } // from try @ 00173a22 with catch @ 00173a6b
*/
if (auVar2._8_4_ != 1) break;
plVar1 = (long *)__cxa_begin_catch(auVar2._0_8_);
local_88 = (**(code **)(*plVar1 + 0x10))(plVar1);
local_78 = param_8;
local_70 = param_7;
/* try { // try from 00173a94 to 00173aae has its CatchHandler @ 00173ab6 */
fmt::v10::vformat_abi_cxx11_
(&local_b8,"Wrong format occurred ({}). Fmt string: \'{}\'",0x2c,0xdc);
__cxa_end_catch();
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(auVar2._0_8_);
}
| |
34,291 | httplib::detail::SocketStream::is_writable() const | nickolajgrishuk[P]metricz-cpp/build_O1/_deps/httplib-src/httplib.h | inline bool SocketStream::is_writable() const {
return select_write(sock_, write_timeout_sec_, write_timeout_usec_) > 0 &&
is_socket_alive(sock_);
} | O1 | c | httplib::detail::SocketStream::is_writable() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
cmpl $0x3ff, %r14d # imm = 0x3FF
jg 0xa63a
movups 0x20(%rbx), %xmm0
xorps %xmm1, %xmm1
leaq 0x10(%rsp), %r15
movaps %xmm1, 0x70(%r15)
movaps %xmm1, 0x60(%r15)
movaps %xmm1, 0x50(%r15)
movaps %xmm1, 0x40(%r15)
movaps %xmm1, 0x30(%r15)
movaps %xmm1, 0x20(%r15)
movaps %xmm1, 0x10(%r15)
movaps %xmm1, (%r15)
leal 0x3f(%r14), %eax
testl %r14d, %r14d
cmovnsl %r14d, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %r14d, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x10(%rsp,%rax,8)
movq %rsp, %r12
movups %xmm0, (%r12)
incl %r14d
movl %r14d, %edi
xorl %esi, %esi
movq %r15, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x8540
movl %eax, %ebp
testl %eax, %eax
jns 0xa636
callq 0x8050
cmpl $0x4, (%rax)
je 0xa614
testl %ebp, %ebp
jle 0xa652
movl 0x8(%rbx), %edi
callq 0x17da9
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0xa642
| _ZNK7httplib6detail12SocketStream11is_writableEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 90h
mov rbx, rdi
mov r14d, [rdi+8]
cmp r14d, 3FFh
jg loc_A63A
movups xmm0, xmmword ptr [rbx+20h]
xorps xmm1, xmm1
lea r15, [rsp+0B8h+var_A8]
movaps xmmword ptr [r15+70h], xmm1
movaps xmmword ptr [r15+60h], xmm1
movaps xmmword ptr [r15+50h], xmm1
movaps xmmword ptr [r15+40h], xmm1
movaps xmmword ptr [r15+30h], xmm1
movaps xmmword ptr [r15+20h], xmm1
movaps xmmword ptr [r15+10h], xmm1
movaps xmmword ptr [r15], xmm1
lea eax, [r14+3Fh]
test r14d, r14d
cmovns eax, r14d
mov edx, eax
and edx, 0FFFFFFC0h
mov ecx, r14d
sub ecx, edx
mov edx, 1
shl rdx, cl
sar eax, 6
cdqe
or [rsp+rax*8+0B8h+var_A8], rdx
mov r12, rsp
movups xmmword ptr [r12], xmm0
inc r14d
loc_A614:
mov edi, r14d
xor esi, esi; int
mov rdx, r15
xor ecx, ecx
mov r8, r12
call _select
mov ebp, eax
test eax, eax
jns short loc_A636
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_A614
loc_A636:
test ebp, ebp
jle short loc_A652
loc_A63A:
mov edi, [rbx+8]; this
call _ZN7httplib6detail15is_socket_aliveEi; httplib::detail::is_socket_alive(int)
loc_A642:
add rsp, 90h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A652:
xor eax, eax
jmp short loc_A642
| long long httplib::detail::SocketStream::is_writable(
httplib::detail::SocketStream *this,
int a2,
long long a3,
long long a4,
long long a5,
long long a6)
{
char v6; // al
int v7; // r14d
__int128 v8; // xmm0
unsigned int v9; // r14d
long long v10; // rdx
long long v11; // rcx
int v12; // ebp
long long v13; // r8
long long v14; // r9
__int128 v16; // [rsp+0h] [rbp-B8h] BYREF
__int128 v17; // [rsp+10h] [rbp-A8h] BYREF
__int128 v18; // [rsp+20h] [rbp-98h]
__int128 v19; // [rsp+30h] [rbp-88h]
__int128 v20; // [rsp+40h] [rbp-78h]
__int128 v21; // [rsp+50h] [rbp-68h]
__int128 v22; // [rsp+60h] [rbp-58h]
__int128 v23; // [rsp+70h] [rbp-48h]
__int128 v24; // [rsp+80h] [rbp-38h]
v7 = *((_DWORD *)this + 2);
if ( v7 > 1023 )
return httplib::detail::is_socket_alive((httplib::detail *)*((unsigned int *)this + 2), a2);
v8 = *((_OWORD *)this + 2);
v24 = 0LL;
v23 = 0LL;
v22 = 0LL;
v21 = 0LL;
v20 = 0LL;
v19 = 0LL;
v18 = 0LL;
v17 = 0LL;
*((_QWORD *)&v17 + v7 / 64) |= 1LL << (v7 - (v6 & 0xC0u));
v16 = v8;
v9 = v7 + 1;
do
{
a2 = 0;
v12 = ((long long ( *)(_QWORD, _QWORD, __int128 *, _QWORD, __int128 *, long long))select)(
v9,
0LL,
&v17,
0LL,
&v16,
a6);
}
while ( v12 < 0
&& *(_DWORD *)__errno_location(
v9,
0LL,
v10,
v11,
v13,
v14,
v16,
*((_QWORD *)&v16 + 1),
v17,
*((_QWORD *)&v17 + 1),
v18,
*((_QWORD *)&v18 + 1),
v19,
*((_QWORD *)&v19 + 1),
v20,
*((_QWORD *)&v20 + 1),
v21,
*((_QWORD *)&v21 + 1)) == 4 );
if ( v12 <= 0 )
return 0LL;
else
return httplib::detail::is_socket_alive((httplib::detail *)*((unsigned int *)this + 2), a2);
}
| is_writable:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x90
MOV RBX,RDI
MOV R14D,dword ptr [RDI + 0x8]
CMP R14D,0x3ff
JG 0x0010a63a
MOVUPS XMM0,xmmword ptr [RBX + 0x20]
XORPS XMM1,XMM1
LEA R15,[RSP + 0x10]
MOVAPS xmmword ptr [R15 + 0x70],XMM1
MOVAPS xmmword ptr [R15 + 0x60],XMM1
MOVAPS xmmword ptr [R15 + 0x50],XMM1
MOVAPS xmmword ptr [R15 + 0x40],XMM1
MOVAPS xmmword ptr [R15 + 0x30],XMM1
MOVAPS xmmword ptr [R15 + 0x20],XMM1
MOVAPS xmmword ptr [R15 + 0x10],XMM1
MOVAPS xmmword ptr [R15],XMM1
LEA EAX,[R14 + 0x3f]
TEST R14D,R14D
CMOVNS EAX,R14D
MOV EDX,EAX
AND EDX,0xffffffc0
MOV ECX,R14D
SUB ECX,EDX
MOV EDX,0x1
SHL RDX,CL
SAR EAX,0x6
CDQE
OR qword ptr [RSP + RAX*0x8 + 0x10],RDX
MOV R12,RSP
MOVUPS xmmword ptr [R12],XMM0
INC R14D
LAB_0010a614:
MOV EDI,R14D
XOR ESI,ESI
MOV RDX,R15
XOR ECX,ECX
MOV R8,R12
CALL 0x00108540
MOV EBP,EAX
TEST EAX,EAX
JNS 0x0010a636
CALL 0x00108050
CMP dword ptr [RAX],0x4
JZ 0x0010a614
LAB_0010a636:
TEST EBP,EBP
JLE 0x0010a652
LAB_0010a63a:
MOV EDI,dword ptr [RBX + 0x8]
CALL 0x00117da9
LAB_0010a642:
ADD RSP,0x90
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010a652:
XOR EAX,EAX
JMP 0x0010a642
|
/* httplib::detail::SocketStream::is_writable() const */
int8 __thiscall httplib::detail::SocketStream::is_writable(SocketStream *this)
{
int iVar1;
int iVar2;
int *piVar3;
int8 uVar4;
timeval local_b8;
fd_set local_a8;
iVar1 = *(int *)(this + 8);
if (iVar1 < 0x400) {
local_b8.tv_sec = *(__time_t *)(this + 0x20);
local_b8.tv_usec = *(__suseconds_t *)(this + 0x28);
local_a8.fds_bits[0xe] = 0;
local_a8.fds_bits[0xf] = 0;
local_a8.fds_bits[0xc] = 0;
local_a8.fds_bits[0xd] = 0;
local_a8.fds_bits[10] = 0;
local_a8.fds_bits[0xb] = 0;
local_a8.fds_bits[8] = 0;
local_a8.fds_bits[9] = 0;
local_a8.fds_bits[6] = 0;
local_a8.fds_bits[7] = 0;
local_a8.fds_bits[4] = 0;
local_a8.fds_bits[5] = 0;
local_a8.fds_bits[2] = 0;
local_a8.fds_bits[3] = 0;
local_a8.fds_bits[0] = 0;
local_a8.fds_bits[1] = 0;
iVar2 = iVar1 + 0x3f;
if (-1 < iVar1) {
iVar2 = iVar1;
}
local_a8.fds_bits[iVar2 >> 6] =
local_a8.fds_bits[iVar2 >> 6] | 1L << ((byte)(iVar1 % 0x40) & 0x3f);
do {
iVar2 = select(iVar1 + 1,(fd_set *)0x0,&local_a8,(fd_set *)0x0,&local_b8);
if (-1 < iVar2) break;
piVar3 = __errno_location();
} while (*piVar3 == 4);
if (iVar2 < 1) {
return 0;
}
}
uVar4 = is_socket_alive(*(int *)(this + 8));
return uVar4;
}
| |
34,292 | mi_get_pointer_length | eloqsql/storage/myisam/mi_create.c | uint mi_get_pointer_length(ulonglong file_length, uint def)
{
DBUG_ASSERT(def >= 2 && def <= 7);
if (file_length) /* If not default */
{
#ifdef NOT_YET_READY_FOR_8_BYTE_POINTERS
if (file_length >= 1ULL << 56)
def=8;
else
#endif
if (file_length >= 1ULL << 48)
def=7;
else if (file_length >= 1ULL << 40)
def=6;
else if (file_length >= 1ULL << 32)
def=5;
else if (file_length >= 1ULL << 24)
def=4;
else if (file_length >= 1ULL << 16)
def=3;
else
def=2;
}
return def;
} | O0 | c | mi_get_pointer_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
jmp 0xdae2d
cmpq $0x0, -0x8(%rbp)
je 0xdaeba
movabsq $0x1000000000000, %rax # imm = 0x1000000000000
cmpq %rax, -0x8(%rbp)
jb 0xdae51
movl $0x7, -0xc(%rbp)
jmp 0xdaeb8
movabsq $0x10000000000, %rax # imm = 0x10000000000
cmpq %rax, -0x8(%rbp)
jb 0xdae6a
movl $0x6, -0xc(%rbp)
jmp 0xdaeb6
movabsq $0x100000000, %rax # imm = 0x100000000
cmpq %rax, -0x8(%rbp)
jb 0xdae83
movl $0x5, -0xc(%rbp)
jmp 0xdaeb4
cmpq $0x1000000, -0x8(%rbp) # imm = 0x1000000
jb 0xdae96
movl $0x4, -0xc(%rbp)
jmp 0xdaeb2
cmpq $0x10000, -0x8(%rbp) # imm = 0x10000
jb 0xdaea9
movl $0x3, -0xc(%rbp)
jmp 0xdaeb0
movl $0x2, -0xc(%rbp)
jmp 0xdaeb2
jmp 0xdaeb4
jmp 0xdaeb6
jmp 0xdaeb8
jmp 0xdaeba
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
| mi_get_pointer_length:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
jmp short $+2
loc_DAE2D:
cmp [rbp+var_8], 0
jz loc_DAEBA
mov rax, 1000000000000h
cmp [rbp+var_8], rax
jb short loc_DAE51
mov [rbp+var_C], 7
jmp short loc_DAEB8
loc_DAE51:
mov rax, 10000000000h
cmp [rbp+var_8], rax
jb short loc_DAE6A
mov [rbp+var_C], 6
jmp short loc_DAEB6
loc_DAE6A:
mov rax, 100000000h
cmp [rbp+var_8], rax
jb short loc_DAE83
mov [rbp+var_C], 5
jmp short loc_DAEB4
loc_DAE83:
cmp [rbp+var_8], 1000000h
jb short loc_DAE96
mov [rbp+var_C], 4
jmp short loc_DAEB2
loc_DAE96:
cmp [rbp+var_8], 10000h
jb short loc_DAEA9
mov [rbp+var_C], 3
jmp short loc_DAEB0
loc_DAEA9:
mov [rbp+var_C], 2
loc_DAEB0:
jmp short $+2
loc_DAEB2:
jmp short $+2
loc_DAEB4:
jmp short $+2
loc_DAEB6:
jmp short $+2
loc_DAEB8:
jmp short $+2
loc_DAEBA:
mov eax, [rbp+var_C]
pop rbp
retn
| long long mi_get_pointer_length(unsigned long long a1, unsigned int a2)
{
if ( a1 )
{
if ( a1 < 0x1000000000000LL )
{
if ( a1 < 0x10000000000LL )
{
if ( a1 < 0x100000000LL )
{
if ( a1 < 0x1000000 )
{
if ( a1 < 0x10000 )
return 2;
else
return 3;
}
else
{
return 4;
}
}
else
{
return 5;
}
}
else
{
return 6;
}
}
else
{
return 7;
}
}
return a2;
}
| mi_get_pointer_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
JMP 0x001dae2d
LAB_001dae2d:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001daeba
MOV RAX,0x1000000000000
CMP qword ptr [RBP + -0x8],RAX
JC 0x001dae51
MOV dword ptr [RBP + -0xc],0x7
JMP 0x001daeb8
LAB_001dae51:
MOV RAX,0x10000000000
CMP qword ptr [RBP + -0x8],RAX
JC 0x001dae6a
MOV dword ptr [RBP + -0xc],0x6
JMP 0x001daeb6
LAB_001dae6a:
MOV RAX,0x100000000
CMP qword ptr [RBP + -0x8],RAX
JC 0x001dae83
MOV dword ptr [RBP + -0xc],0x5
JMP 0x001daeb4
LAB_001dae83:
CMP qword ptr [RBP + -0x8],0x1000000
JC 0x001dae96
MOV dword ptr [RBP + -0xc],0x4
JMP 0x001daeb2
LAB_001dae96:
CMP qword ptr [RBP + -0x8],0x10000
JC 0x001daea9
MOV dword ptr [RBP + -0xc],0x3
JMP 0x001daeb0
LAB_001daea9:
MOV dword ptr [RBP + -0xc],0x2
LAB_001daeb0:
JMP 0x001daeb2
LAB_001daeb2:
JMP 0x001daeb4
LAB_001daeb4:
JMP 0x001daeb6
LAB_001daeb6:
JMP 0x001daeb8
LAB_001daeb8:
JMP 0x001daeba
LAB_001daeba:
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET
|
int4 mi_get_pointer_length(ulong param_1,int4 param_2)
{
int4 local_14;
local_14 = param_2;
if (param_1 != 0) {
if (param_1 < 0x1000000000000) {
if (param_1 < 0x10000000000) {
if (param_1 < 0x100000000) {
if (param_1 < 0x1000000) {
if (param_1 < 0x10000) {
local_14 = 2;
}
else {
local_14 = 3;
}
}
else {
local_14 = 4;
}
}
else {
local_14 = 5;
}
}
else {
local_14 = 6;
}
}
else {
local_14 = 7;
}
}
return local_14;
}
| |
34,293 | nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>) | ng-log[P]ng-log/src/logging.cc | LogMessageTime::LogMessageTime(std::chrono::system_clock::time_point now)
: timestamp_{now} {
std::time_t timestamp;
std::tie(tm_, timestamp, gmtoffset_) = Breakdown(now);
usecs_ = std::chrono::duration_cast<std::chrono::microseconds>(
now - std::chrono::system_clock::from_time_t(timestamp));
} | O1 | cpp | nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>):
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x0, 0x20(%rdi)
movups %xmm0, 0x28(%rdi)
movq %rsi, 0x38(%rdi)
movabsq $0x112e0be826d694b3, %rcx # imm = 0x112E0BE826D694B3
movq %rsi, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
movq %rdx, (%rsp)
leaq 0x22908(%rip), %rax # 0x32b51
cmpb $0x1, (%rax)
jne 0x1025d
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x79f0
jmp 0x1026a
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x7250
movq 0x30(%rsp), %rax
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, 0x70(%rsp)
imulq $-0x3b9aca00, (%rsp), %rcx # imm = 0xC4653600
movq %rdx, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movabsq $0x48d159e26af37c05, %rdx # imm = 0x48D159E26AF37C05
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xa, %rdx
addq %rax, %rdx
imulq $0xe10, %rdx, %rax # imm = 0xE10
movq %rax, 0x48(%rbx)
addq %r14, %rcx
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, 0x40(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
retq
nop
| _ZN5nglog14LogMessageTimeC2ENSt6chrono10time_pointINS1_3_V212system_clockENS1_8durationIlSt5ratioILl1ELl1000000000EEEEEE:
push r14; Alternative name is 'nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>)'
push rbx
sub rsp, 78h
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov dword ptr [rdi+20h], 0
movups xmmword ptr [rdi+28h], xmm0
mov [rdi+38h], rsi
mov rcx, 112E0BE826D694B3h
mov rax, rsi
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 1Ah
add rdx, rax
mov [rsp+88h+var_88], rdx
lea rax, _ZN3fLB18FLAGS_log_utc_timeE; fLB::FLAGS_log_utc_time
cmp byte ptr [rax], 1
jnz short loc_1025D
mov rdi, rsp
lea rsi, [rsp+88h+var_80]
call _gmtime_r
jmp short loc_1026A
loc_1025D:
mov rdi, rsp
lea rsi, [rsp+88h+var_80]
call _localtime_r
loc_1026A:
mov rax, [rsp+88h+var_58]
movups xmm0, [rsp+88h+var_80]
movups xmm1, [rsp+88h+var_70]
movups xmm2, xmmword ptr [rsp+28h]
movaps [rsp+88h+var_48], xmm0
movaps [rsp+88h+var_38], xmm1
movaps [rsp+88h+var_28], xmm2
mov rdx, [rsp+88h+var_50]
mov [rsp+88h+var_18], rdx
imul rcx, [rsp+88h+var_88], 0FFFFFFFFC4653600h
mov [rbx+30h], rdx
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov rdx, 48D159E26AF37C05h
imul rdx
mov rax, rdx
shr rax, 3Fh
sar rdx, 0Ah
add rdx, rax
imul rax, rdx, 0E10h
mov [rbx+48h], rax
add rcx, r14
mov rdx, 20C49BA5E353F7CFh
mov rax, rcx
imul rdx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
mov [rbx+40h], rdx
add rsp, 78h
pop rbx
pop r14
retn
| unsigned long long nglog::LogMessageTime::LogMessageTime(long long a1, long long a2)
{
long long v2; // rax
__int128 v3; // xmm0
__int128 v4; // xmm1
__int128 v5; // xmm2
long long v6; // rcx
long long v7; // rcx
unsigned long long result; // rax
long long v9; // [rsp+0h] [rbp-88h] BYREF
_OWORD v10[2]; // [rsp+8h] [rbp-80h] BYREF
__int128 v11; // [rsp+28h] [rbp-60h]
long long v12; // [rsp+38h] [rbp-50h]
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_DWORD *)(a1 + 32) = 0;
*(_OWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 56) = a2;
v9 = a2 / 1000000000;
if ( fLB::FLAGS_log_utc_time == 1 )
gmtime_r(&v9, v10);
else
localtime_r(&v9, v10);
v2 = *((_QWORD *)&v11 + 1);
v3 = v10[0];
v4 = v10[1];
v5 = v11;
v6 = -1000000000 * v9;
*(_QWORD *)(a1 + 48) = v12;
*(_OWORD *)(a1 + 32) = v5;
*(_OWORD *)(a1 + 16) = v4;
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 72) = 3600 * (v2 / 3600);
v7 = a2 + v6;
result = (unsigned long long)((unsigned __int128)(0x20C49BA5E353F7CFLL * (__int128)v7) >> 64) >> 63;
*(_QWORD *)(a1 + 64) = v7 / 1000;
return result;
}
| LogMessageTime:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV dword ptr [RDI + 0x20],0x0
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOV qword ptr [RDI + 0x38],RSI
MOV RCX,0x112e0be826d694b3
MOV RAX,RSI
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x1a
ADD RDX,RAX
MOV qword ptr [RSP],RDX
LEA RAX,[0x132b51]
CMP byte ptr [RAX],0x1
JNZ 0x0011025d
MOV RDI,RSP
LEA RSI,[RSP + 0x8]
CALL 0x001079f0
JMP 0x0011026a
LAB_0011025d:
MOV RDI,RSP
LEA RSI,[RSP + 0x8]
CALL 0x00107250
LAB_0011026a:
MOV RAX,qword ptr [RSP + 0x30]
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS XMM1,xmmword ptr [RSP + 0x18]
MOVUPS XMM2,xmmword ptr [RSP + 0x28]
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOV RDX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x70],RDX
IMUL RCX,qword ptr [RSP],-0x3b9aca00
MOV qword ptr [RBX + 0x30],RDX
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV RDX,0x48d159e26af37c05
IMUL RDX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0xa
ADD RDX,RAX
IMUL RAX,RDX,0xe10
MOV qword ptr [RBX + 0x48],RAX
ADD RCX,R14
MOV RDX,0x20c49ba5e353f7cf
MOV RAX,RCX
IMUL RDX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
MOV qword ptr [RBX + 0x40],RDX
ADD RSP,0x78
POP RBX
POP R14
RET
|
/* nglog::LogMessageTime::LogMessageTime(std::chrono::time_point<std::chrono::_V2::system_clock,
std::chrono::duration<long, std::ratio<1l, 1000000000l> > >) */
void __thiscall nglog::LogMessageTime::LogMessageTime(LogMessageTime *this,long param_2)
{
long local_88;
tm local_80 [2];
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int4 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(long *)(this + 0x38) = param_2;
local_88 = param_2 / 1000000000;
if (fLB::FLAGS_log_utc_time == '\x01') {
gmtime_r(&local_88,local_80);
}
else {
localtime_r(&local_88,local_80);
}
*(char **)(this + 0x30) = local_80[0].tm_zone;
*(int8 *)(this + 0x20) = local_80[0]._32_8_;
*(long *)(this + 0x28) = local_80[0].tm_gmtoff;
*(int8 *)(this + 0x10) = local_80[0]._16_8_;
*(int8 *)(this + 0x18) = local_80[0]._24_8_;
*(int8 *)this = local_80[0]._0_8_;
*(int8 *)(this + 8) = local_80[0]._8_8_;
*(long *)(this + 0x48) = (local_80[0].tm_gmtoff / 0xe10) * 0xe10;
*(long *)(this + 0x40) = (local_88 * -1000000000 + param_2) / 1000;
return;
}
| |
34,294 | init_alloc_root | eloqsql/mysys/my_alloc.c | void init_alloc_root(PSI_memory_key key, MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)),
myf my_flags)
{
DBUG_ENTER("init_alloc_root");
DBUG_PRINT("enter",("root: %p prealloc: %zu", mem_root, pre_alloc_size));
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc= 32;
mem_root->block_size= (block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1;
if (my_flags & MY_THREAD_SPECIFIC)
mem_root->block_size|= 1;
mem_root->error_handler= 0;
mem_root->block_num= 4; /* We shift this with >>2 */
mem_root->first_block_usage= 0;
mem_root->m_psi_key= key;
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if ((mem_root->free= mem_root->pre_alloc=
(USED_MEM*) my_malloc(key, size, MYF(my_flags))))
{
mem_root->free->size= size;
mem_root->free->left= pre_alloc_size;
mem_root->free->next= 0;
TRASH_MEM(mem_root->free);
}
}
#endif
DBUG_VOID_RETURN;
} | O3 | c | init_alloc_root:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
movq $0x20, 0x18(%rsi)
andq $-0x2, %rdx
movl %r8d, %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addq %rdx, %rcx
addq $-0x28, %rcx
movq %rcx, 0x20(%rsi)
movq %rax, 0x30(%rsi)
movq $0x4, 0x28(%rsi)
movl %edi, 0x38(%rsi)
testq %rbx, %rbx
je 0x9d310
movq %rsi, %r14
leaq 0x18(%rbx), %r15
movq %r15, %rsi
movq %r8, %rdx
callq 0xa06a1
movq %rax, 0x10(%r14)
movq %rax, (%r14)
testq %rax, %rax
je 0x9d310
movq %r15, 0x10(%rax)
movq (%r14), %rax
movq %rbx, 0x8(%rax)
movq (%r14), %rax
movq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| init_alloc_root:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
xor eax, eax
mov [rsi+10h], rax
mov qword ptr [rsi+18h], 20h ; ' '
and rdx, 0FFFFFFFFFFFFFFFEh
mov ecx, r8d
shr ecx, 10h
and ecx, 1
add rcx, rdx
add rcx, 0FFFFFFFFFFFFFFD8h
mov [rsi+20h], rcx
mov [rsi+30h], rax
mov qword ptr [rsi+28h], 4
mov [rsi+38h], edi
test rbx, rbx
jz short loc_9D310
mov r14, rsi
lea r15, [rbx+18h]
mov rsi, r15
mov rdx, r8
call my_malloc
mov [r14+10h], rax
mov [r14], rax
test rax, rax
jz short loc_9D310
mov [rax+10h], r15
mov rax, [r14]
mov [rax+8], rbx
mov rax, [r14]
mov qword ptr [rax], 0
loc_9D310:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long init_alloc_root(long long a1, long long *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
*(_OWORD *)a2 = 0LL;
result = 0LL;
a2[2] = 0LL;
a2[3] = 32LL;
a2[4] = (a3 & 0xFFFFFFFFFFFFFFFELL) + (WORD1(a5) & 1) - 40;
a2[6] = 0LL;
a2[5] = 4LL;
*((_DWORD *)a2 + 14) = a1;
if ( a4 )
{
result = my_malloc(a1, a4 + 24, a5);
a2[2] = result;
*a2 = result;
if ( result )
{
*(_QWORD *)(result + 16) = a4 + 24;
*(_QWORD *)(*a2 + 8) = a4;
result = *a2;
*(_QWORD *)*a2 = 0LL;
}
}
return result;
}
| init_alloc_root:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI + 0x18],0x20
AND RDX,-0x2
MOV ECX,R8D
SHR ECX,0x10
AND ECX,0x1
ADD RCX,RDX
ADD RCX,-0x28
MOV qword ptr [RSI + 0x20],RCX
MOV qword ptr [RSI + 0x30],RAX
MOV qword ptr [RSI + 0x28],0x4
MOV dword ptr [RSI + 0x38],EDI
TEST RBX,RBX
JZ 0x0019d310
MOV R14,RSI
LEA R15,[RBX + 0x18]
MOV RSI,R15
MOV RDX,R8
CALL 0x001a06a1
MOV qword ptr [R14 + 0x10],RAX
MOV qword ptr [R14],RAX
TEST RAX,RAX
JZ 0x0019d310
MOV qword ptr [RAX + 0x10],R15
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX + 0x8],RBX
MOV RAX,qword ptr [R14]
MOV qword ptr [RAX],0x0
LAB_0019d310:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void init_alloc_root(int4 param_1,long *param_2,ulong param_3,long param_4,int8 param_5)
{
long lVar1;
*param_2 = 0;
param_2[1] = 0;
param_2[2] = 0;
param_2[3] = 0x20;
param_2[4] = (ulong)((uint)param_5 >> 0x10 & 1) + (param_3 & 0xfffffffffffffffe) + -0x28;
param_2[6] = 0;
param_2[5] = 4;
*(int4 *)(param_2 + 7) = param_1;
if (param_4 != 0) {
lVar1 = my_malloc(param_1,param_4 + 0x18,param_5);
param_2[2] = lVar1;
*param_2 = lVar1;
if (lVar1 != 0) {
*(long *)(lVar1 + 0x10) = param_4 + 0x18;
*(long *)(*param_2 + 8) = param_4;
*(int8 *)*param_2 = 0;
}
}
return;
}
| |
34,295 | google::protobuf::FileDescriptorTables::BuildLocationsByPath(std::pair<google::protobuf::FileDescriptorTables const*, google::protobuf::SourceCodeInfo const*>*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void FileDescriptorTables::BuildLocationsByPath(
std::pair<const FileDescriptorTables*, const SourceCodeInfo*>* p) {
for (int i = 0, len = p->second->location_size(); i < len; ++i) {
const SourceCodeInfo_Location* loc = &p->second->location().Get(i);
p->first->locations_by_path_[Join(loc->path(), ",")] = loc;
}
} | O0 | cpp | google::protobuf::FileDescriptorTables::BuildLocationsByPath(std::pair<google::protobuf::FileDescriptorTables const*, google::protobuf::SourceCodeInfo const*>*):
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x74020
movl %eax, 0x58(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x58(%rsp), %eax
jge 0x34460
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x74030
movq %rax, %rdi
movl 0x5c(%rsp), %esi
callq 0x74040
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rax
addq $0x100, %rax # imm = 0x100
movq %rax, 0x8(%rsp)
callq 0x74160
movq %rax, %rsi
leaq 0x1b93e8(%rip), %rdx # 0x1ed7e3
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x74090
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x74060
movq %rax, 0x18(%rsp)
jmp 0x34420
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
leaq 0x30(%rsp), %rdi
callq 0x13290
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x343a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x13290
jmp 0x34465
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x13750
nop
| _ZN6google8protobuf20FileDescriptorTables20BuildLocationsByPathEPSt4pairIPKS1_PKNS0_14SourceCodeInfoEE:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_C], 0
mov rax, [rsp+68h+var_8]
mov rdi, [rax+8]; this
call _ZNK6google8protobuf14SourceCodeInfo13location_sizeEv; google::protobuf::SourceCodeInfo::location_size(void)
mov [rsp+68h+var_10], eax
loc_343A3:
mov eax, [rsp+68h+var_C]
cmp eax, [rsp+68h+var_10]
jge loc_34460
mov rax, [rsp+68h+var_8]
mov rdi, [rax+8]; this
call _ZNK6google8protobuf14SourceCodeInfo8locationEv; google::protobuf::SourceCodeInfo::location(void)
mov rdi, rax
mov esi, [rsp+68h+var_C]
call _ZNK6google8protobuf16RepeatedPtrFieldINS0_23SourceCodeInfo_LocationEE3GetEi; google::protobuf::RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::Get(int)
mov [rsp+68h+var_18], rax
mov rdi, [rsp+68h+var_18]; this
mov [rsp+68h+var_68], rdi
mov rax, [rsp+68h+var_8]
mov rax, [rax]
add rax, 100h
mov [rsp+68h+var_60], rax
call _ZNK6google8protobuf23SourceCodeInfo_Location4pathEv; google::protobuf::SourceCodeInfo_Location::path(void)
mov rsi, rax
lea rdx, asc_1ED7E3; ","
lea rdi, [rsp+68h+var_38]
mov [rsp+68h+var_58], rdi
call _ZN6google8protobuf4JoinINS0_13RepeatedFieldIiEEEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_PKc; google::protobuf::Join<google::protobuf::RepeatedField<int>>(google::protobuf::RepeatedField<int> const&,char const*)
mov rdi, [rsp+68h+var_60]
mov rsi, [rsp+68h+var_58]
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPKN6google8protobuf23SourceCodeInfo_LocationESt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_SA_EEEixEOS5_; std::unordered_map<std::string,google::protobuf::SourceCodeInfo_Location const*>::operator[](std::string&&)
mov [rsp+68h+var_50], rax
jmp short $+2
loc_34420:
mov rax, [rsp+68h+var_50]
mov rcx, [rsp+68h+var_68]
mov [rax], rcx
lea rdi, [rsp+68h+var_38]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov eax, [rsp+68h+var_C]
add eax, 1
mov [rsp+68h+var_C], eax
jmp loc_343A3
mov rcx, rax
mov eax, edx
mov [rsp+arg_20], rcx
mov [rsp+arg_1C], eax
lea rdi, [rsp+arg_28]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_34465
loc_34460:
add rsp, 68h
retn
loc_34465:
mov rdi, [rsp+arg_20]
call __Unwind_Resume
| long long google::protobuf::FileDescriptorTables::BuildLocationsByPath(long long a1)
{
long long result; // rax
long long v2; // rax
int v3; // eax
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v7; // [rsp+0h] [rbp-68h]
long long v8; // [rsp+0h] [rbp-68h]
long long v9; // [rsp+8h] [rbp-60h]
long long v10; // [rsp+8h] [rbp-60h]
long long v11; // [rsp+10h] [rbp-58h]
_QWORD *v12; // [rsp+18h] [rbp-50h]
int v13; // [rsp+20h] [rbp-48h]
int v14; // [rsp+28h] [rbp-40h]
long long v15[4]; // [rsp+30h] [rbp-38h] BYREF
google::protobuf::SourceCodeInfo_Location *v16; // [rsp+50h] [rbp-18h]
int v17; // [rsp+58h] [rbp-10h]
unsigned int v18; // [rsp+5Ch] [rbp-Ch]
long long v19; // [rsp+60h] [rbp-8h]
v19 = a1;
v18 = 0;
v17 = google::protobuf::SourceCodeInfo::location_size(*(google::protobuf::SourceCodeInfo **)(a1 + 8));
while ( 1 )
{
result = v18;
if ( (int)v18 >= v17 )
break;
v2 = google::protobuf::SourceCodeInfo::location(*(google::protobuf::SourceCodeInfo **)(v19 + 8));
v16 = (google::protobuf::SourceCodeInfo_Location *)google::protobuf::RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::Get(
v2,
v18);
v7 = (int)v16;
v9 = *(_QWORD *)v19 + 256LL;
v3 = google::protobuf::SourceCodeInfo_Location::path(v16);
google::protobuf::Join<google::protobuf::RepeatedField<int>>(
(unsigned int)v15,
v3,
(unsigned int)",",
v4,
v5,
v6,
v7,
v9,
(unsigned int)v15,
(_DWORD)v12,
v13,
v14,
v15[0]);
v12 = (_QWORD *)std::unordered_map<std::string,google::protobuf::SourceCodeInfo_Location const*>::operator[](
v10,
v11);
*v12 = v8;
std::string::~string(v15);
++v18;
}
return result;
}
| BuildLocationsByPath:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV dword ptr [RSP + 0x5c],0x0
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00174020
MOV dword ptr [RSP + 0x58],EAX
LAB_001343a3:
MOV EAX,dword ptr [RSP + 0x5c]
CMP EAX,dword ptr [RSP + 0x58]
JGE 0x00134460
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00174030
MOV RDI,RAX
MOV ESI,dword ptr [RSP + 0x5c]
CALL 0x00174040
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP],RDI
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX]
ADD RAX,0x100
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00174160
MOV RSI,RAX
LEA RDX,[0x2ed7e3]
LEA RDI,[RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00174090
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
LAB_00134414:
CALL 0x00174060
LAB_00134419:
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00134420
LAB_00134420:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX],RCX
LEA RDI,[RSP + 0x30]
CALL 0x00113290
MOV EAX,dword ptr [RSP + 0x5c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x5c],EAX
JMP 0x001343a3
LAB_00134460:
ADD RSP,0x68
RET
|
/* google::protobuf::FileDescriptorTables::BuildLocationsByPath(std::pair<google::protobuf::FileDescriptorTables
const*, google::protobuf::SourceCodeInfo const*>*) */
void google::protobuf::FileDescriptorTables::BuildLocationsByPath(pair *param_1)
{
long lVar1;
RepeatedPtrField<google::protobuf::SourceCodeInfo_Location> *this;
SourceCodeInfo_Location *this_00;
RepeatedField *pRVar2;
int8 *puVar3;
protobuf local_38 [32];
SourceCodeInfo_Location *local_18;
int local_10;
int local_c;
pair *local_8;
local_c = 0;
local_8 = param_1;
local_10 = SourceCodeInfo::location_size(*(SourceCodeInfo **)(param_1 + 8));
for (; local_c < local_10; local_c = local_c + 1) {
this = (RepeatedPtrField<google::protobuf::SourceCodeInfo_Location> *)
SourceCodeInfo::location(*(SourceCodeInfo **)(local_8 + 8));
this_00 = (SourceCodeInfo_Location *)
RepeatedPtrField<google::protobuf::SourceCodeInfo_Location>::Get(this,local_c);
lVar1 = *(long *)local_8;
local_18 = this_00;
pRVar2 = (RepeatedField *)SourceCodeInfo_Location::path(this_00);
Join<google::protobuf::RepeatedField<int>>(local_38,pRVar2,",");
/* try { // try from 00134414 to 00134418 has its CatchHandler @ 00134446 */
puVar3 = (int8 *)
std::
unordered_map<std::__cxx11::string,google::protobuf::SourceCodeInfo_Location_const*,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,google::protobuf::SourceCodeInfo_Location_const*>>>
::operator[]((unordered_map<std::__cxx11::string,google::protobuf::SourceCodeInfo_Location_const*,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,google::protobuf::SourceCodeInfo_Location_const*>>>
*)(lVar1 + 0x100),(string *)local_38);
*puVar3 = this_00;
std::__cxx11::string::~string((string *)local_38);
}
return;
}
| |
34,296 | aimrt::protocols::geometry::Quaternion::Quaternion(aimrt::protocols::geometry::Quaternion const&) | aimrt_mujoco_sim/_deps/aimrt-build/src/protocols/pb/geometry/quaternion.pb.cc | Quaternion::Quaternion(const Quaternion& from)
: ::PROTOBUF_NAMESPACE_ID::Message() {
Quaternion* const _this = this; (void)_this;
new (&_impl_) Impl_{
decltype(_impl_.x_){}
, decltype(_impl_.y_){}
, decltype(_impl_.z_){}
, decltype(_impl_.w_){}
, /*decltype(_impl_._cached_size_)*/{}};
_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
::memcpy(&_impl_.x_, &from._impl_.x_,
static_cast<size_t>(reinterpret_cast<char*>(&_impl_.w_) -
reinterpret_cast<char*>(&_impl_.x_)) + sizeof(_impl_.w_));
// @@protoc_insertion_point(copy_constructor:aimrt.protocols.geometry.Quaternion)
} | O3 | cpp | aimrt::protocols::geometry::Quaternion::Quaternion(aimrt::protocols::geometry::Quaternion const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x1946de(%rip), %rcx # 0x209e40
movq %rcx, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq 0x8(%rsi), %rsi
testb $0x1, %sil
je 0x75792
leaq 0x8(%rbx), %r15
andq $-0x4, %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x734be
addq $0x10, %rbx
movups 0x10(%r14), %xmm0
movups 0x20(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x194d69(%rip), %rax # 0x20a520
addq $0x10, %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x73456
movq %r14, %rdi
callq 0x2e220
| _ZN5aimrt9protocols8geometry10QuaternionC2ERKS2_:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
xor eax, eax
mov [rdi+8], rax
lea rcx, off_209E40
mov [rdi], rcx
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi+20h], xmm0
mov [rdi+30h], rax
mov rsi, [rsi+8]
test sil, 1
jz short loc_75792
lea r15, [rbx+8]
and rsi, 0FFFFFFFFFFFFFFFCh
add rsi, 8
mov rdi, r15
call _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_75792:
add rbx, 10h
movups xmm0, xmmword ptr [r14+10h]
movups xmm1, xmmword ptr [r14+20h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
pop rbx
pop r14
pop r15
retn
mov r14, rax
lea rax, _ZTVN6google8protobuf11MessageLiteE; `vtable for'google::protobuf::MessageLite
add rax, 10h
mov [rbx], rax
mov rdi, r15; this
call _ZN6google8protobuf8internal16InternalMetadataD2Ev; google::protobuf::internal::InternalMetadata::~InternalMetadata()
mov rdi, r14
call __Unwind_Resume
| long long aimrt::protocols::geometry::Quaternion::Quaternion(
aimrt::protocols::geometry::Quaternion *this,
const aimrt::protocols::geometry::Quaternion *a2)
{
long long result; // rax
long long v4; // rsi
__int128 v5; // xmm0
result = 0LL;
*((_QWORD *)this + 1) = 0LL;
*(_QWORD *)this = off_209E40;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_QWORD *)this + 6) = 0LL;
v4 = *((_QWORD *)a2 + 1);
if ( (v4 & 1) != 0 )
result = google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
(long long *)this + 1,
(const google::protobuf::UnknownFieldSet *)((v4 & 0xFFFFFFFFFFFFFFFCLL) + 8));
v5 = *((_OWORD *)a2 + 1);
*((_OWORD *)this + 2) = *((_OWORD *)a2 + 2);
*((_OWORD *)this + 1) = v5;
return result;
}
| Quaternion:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
XOR EAX,EAX
MOV qword ptr [RDI + 0x8],RAX
LEA RCX,[0x309e40]
MOV qword ptr [RDI],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV qword ptr [RDI + 0x30],RAX
MOV RSI,qword ptr [RSI + 0x8]
TEST SIL,0x1
JZ 0x00175792
LEA R15,[RBX + 0x8]
AND RSI,-0x4
ADD RSI,0x8
LAB_0017578a:
MOV RDI,R15
CALL 0x001734be
LAB_00175792:
ADD RBX,0x10
MOVUPS XMM0,xmmword ptr [R14 + 0x10]
MOVUPS XMM1,xmmword ptr [R14 + 0x20]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
POP RBX
POP R14
POP R15
RET
|
/* aimrt::protocols::geometry::Quaternion::Quaternion(aimrt::protocols::geometry::Quaternion const&)
*/
void __thiscall
aimrt::protocols::geometry::Quaternion::Quaternion(Quaternion *this,Quaternion *param_1)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
*(int8 *)(this + 8) = 0;
*(int ***)this = &PTR__Quaternion_00309e40;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
/* try { // try from 0017578a to 00175791 has its CatchHandler @ 001757ad */
google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(this + 8),
(UnknownFieldSet *)((*(ulong *)(param_1 + 8) & 0xfffffffffffffffc) + 8));
}
uVar1 = *(int8 *)(param_1 + 0x10);
uVar2 = *(int8 *)(param_1 + 0x18);
uVar3 = *(int8 *)(param_1 + 0x28);
*(int8 *)(this + 0x20) = *(int8 *)(param_1 + 0x20);
*(int8 *)(this + 0x28) = uVar3;
*(int8 *)(this + 0x10) = uVar1;
*(int8 *)(this + 0x18) = uVar2;
return;
}
| |
34,297 | CLI::App::_add_flag_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | MikePodsytnik[P]TCRtrie/build_O2/_deps/cli11-src/include/CLI/impl/App_inl.hpp | CLI11_INLINE Option *App::_add_flag_internal(std::string flag_name, CLI::callback_t fun, std::string flag_description) {
Option *opt = nullptr;
if(detail::has_default_flag_values(flag_name)) {
// check for default values and if it has them
auto flag_defaults = detail::get_default_flag_values(flag_name);
detail::remove_default_flag_values(flag_name);
opt = add_option(std::move(flag_name), std::move(fun), std::move(flag_description), false);
for(const auto &fname : flag_defaults)
opt->fnames_.push_back(fname.first);
opt->default_flag_values_ = std::move(flag_defaults);
} else {
opt = add_option(std::move(flag_name), std::move(fun), std::move(flag_description), false);
}
// flags cannot have positional values
if(opt->get_positional()) {
auto pos_name = opt->get_name(true);
remove_option(opt);
throw IncorrectConstruction::PositionalFlag(pos_name);
}
opt->multi_option_policy(MultiOptionPolicy::TakeLast);
opt->expected(0);
opt->required(false);
return opt;
} | O2 | cpp | CLI::App::_add_flag_internal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x134a1
testb %al, %al
je 0x13286
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
callq 0x134b9
movq %r12, %rdi
callq 0x13680
leaq 0x80(%rsp), %rdi
movq %r12, %rsi
callq 0x7560
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movq 0x18(%r15), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x131e8
movups (%r15), %xmm0
addq $0x10, %r15
movaps %xmm0, 0x20(%rsp)
movq %rax, 0x30(%rsp)
movups %xmm1, (%r15)
leaq 0x128(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7560
leaq 0xc0(%rsp), %r9
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
leaq 0x80(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x13724
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0x1b754
leaq 0x128(%rsp), %rdi
callq 0x7860
leaq 0x20(%rsp), %rdi
callq 0x1b754
leaq 0x80(%rsp), %rdi
callq 0x7860
movq 0x40(%rsp), %r15
movq 0x48(%rsp), %r13
leaq 0x70(%r14), %r12
cmpq %r13, %r15
je 0x13335
movq %r12, %rdi
movq %r15, %rsi
callq 0xdf4e
addq $0x40, %r15
jmp 0x1326c
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x7560
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
andq $0x0, 0x10(%rsp)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x132c7
movups (%r15), %xmm0
addq $0x10, %r15
movaps %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movups %xmm1, (%r15)
leaq 0x108(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7560
leaq 0xa0(%rsp), %r9
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
leaq 0x60(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x13724
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
callq 0x1b754
leaq 0x108(%rsp), %rdi
callq 0x7860
movq %rsp, %rdi
callq 0x1b754
leaq 0x60(%rsp), %rdi
callq 0x7860
jmp 0x13351
movq %r14, %rdi
addq $0x58, %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x15fc2
movq %r15, %rdi
callq 0x13032
cmpq $0x0, 0x90(%r14)
jne 0x13390
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x13b00
andq $0x0, 0x170(%r14)
movb $0x1, 0x24a(%r14)
movb $0x0, 0x20(%r14)
movq %r14, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xf2c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12b88
pushq $0x38
popq %rdi
callq 0x7210
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x75e0
movb $0x1, %bpl
leaq 0xe8(%rsp), %rsi
movq %r14, %rdi
callq 0x13aac
xorl %ebp, %ebp
leaq 0x2c08a(%rip), %rsi # 0x3f470
leaq 0xa877(%rip), %rdx # 0x1dc64
movq %r14, %rdi
callq 0x7750
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x7860
testb %bpl, %bpl
jne 0x1340f
jmp 0x1341c
movq %rax, %rbx
movq %r14, %rdi
callq 0x7360
jmp 0x1341c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x13483
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x1b754
leaq 0x128(%rsp), %rdi
callq 0x7860
leaq 0x20(%rsp), %rdi
callq 0x1b754
leaq 0x80(%rsp), %rdi
callq 0x7860
jmp 0x1348f
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x1b754
leaq 0x108(%rsp), %rdi
callq 0x7860
movq %rsp, %rdi
callq 0x1b754
leaq 0x60(%rsp), %rdi
callq 0x7860
jmp 0x13499
jmp 0x1348c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x13032
movq %rbx, %rdi
callq 0x7770
| _ZN3CLI3App18_add_flag_internalENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFbRKSt6vectorIS6_SaIS6_EEEES6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rdi, rsi
call _ZN3CLI6detail23has_default_flag_valuesERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::has_default_flag_values(std::string const&)
test al, al
jz loc_13286
lea rdi, [rsp+178h+var_138]
mov rsi, r12
call _ZN3CLI6detail23get_default_flag_valuesERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::get_default_flag_values(std::string const&)
mov rdi, r12
call _ZN3CLI6detail26remove_default_flag_valuesERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::detail::remove_default_flag_values(std::string &)
lea rdi, [rsp+178h+var_F8]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
xorps xmm1, xmm1
movaps [rsp+178h+var_158], xmm1
and [rsp+178h+var_148], 0
mov rax, [r15+18h]
mov [rsp+178h+var_140], rax
mov rax, [r15+10h]
test rax, rax
jz short loc_131E8
movups xmm0, xmmword ptr [r15]
add r15, 10h
movaps [rsp+178h+var_158], xmm0
mov [rsp+178h+var_148], rax
movups xmmword ptr [r15], xmm1
loc_131E8:
lea r15, [rsp+178h+var_50]
mov rdi, r15
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
lea r9, [rsp+178h+var_B8]
xorps xmm0, xmm0
movaps xmmword ptr [r9+10h], xmm0
movaps xmmword ptr [r9], xmm0
lea rsi, [rsp+178h+var_F8]
lea rdx, [rsp+178h+var_158]
mov rdi, rbx; int
mov rcx, r15
xor r8d, r8d
call _ZN3CLI3App10add_optionENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFbRKSt6vectorIS6_SaIS6_EEEES6_bS7_IFS6_vEE; CLI::App::add_option(std::string,std::function<bool ()(std::vector<std::string> const&)>,std::string,bool,std::function<std::string ()(void)>)
mov r14, rax
lea rdi, [rsp+178h+var_B8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+178h+var_158]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov r15, [rsp+178h+var_138]
mov r13, [rsp+178h+var_130]
lea r12, [r14+70h]
loc_1326C:
cmp r15, r13
jz loc_13335
mov rdi, r12
mov rsi, r15
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
add r15, 40h ; '@'
jmp short loc_1326C
loc_13286:
lea rdi, [rsp+178h+var_118]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
xorps xmm1, xmm1
movaps [rsp+178h+var_178], xmm1
and [rsp+178h+var_168], 0
mov rax, [r15+18h]
mov [rsp+178h+var_160], rax
mov rax, [r15+10h]
test rax, rax
jz short loc_132C7
movups xmm0, xmmword ptr [r15]
add r15, 10h
movaps [rsp+178h+var_178], xmm0
mov [rsp+178h+var_168], rax
movups xmmword ptr [r15], xmm1
loc_132C7:
lea r15, [rsp+178h+var_70]
mov rdi, r15
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_; std::string::basic_string(std::string&&)
lea r9, [rsp+178h+var_D8]
xorps xmm0, xmm0
movaps xmmword ptr [r9+10h], xmm0
movaps xmmword ptr [r9], xmm0
lea rsi, [rsp+178h+var_118]
mov rdx, rsp
mov rdi, rbx; int
mov rcx, r15
xor r8d, r8d
call _ZN3CLI3App10add_optionENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFbRKSt6vectorIS6_SaIS6_EEEES6_bS7_IFS6_vEE; CLI::App::add_option(std::string,std::function<bool ()(std::vector<std::string> const&)>,std::string,bool,std::function<std::string ()(void)>)
mov r14, rax
lea rdi, [rsp+178h+var_D8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_118]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_13351
loc_13335:
mov rdi, r14
add rdi, 58h ; 'X'
lea r15, [rsp+178h+var_138]
mov rsi, r15
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EE14_M_move_assignEOS9_St17integral_constantIbLb1EE; std::vector<std::pair<std::string,std::string>>::_M_move_assign(std::vector<std::pair<std::string,std::string>>&&,std::integral_constant<bool,true>)
mov rdi, r15
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EED2Ev; std::vector<std::pair<std::string,std::string>>::~vector()
loc_13351:
cmp qword ptr [r14+90h], 0
jnz short loc_13390
push 1
pop rsi
mov rdi, r14
call _ZN3CLI6Option19multi_option_policyENS_17MultiOptionPolicyE; CLI::Option::multi_option_policy(CLI::MultiOptionPolicy)
and qword ptr [r14+170h], 0
mov byte ptr [r14+24Ah], 1
mov byte ptr [r14+20h], 0
mov rax, r14
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_13390:
lea rdi, [rsp+178h+var_138]
push 1
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK3CLI6Option8get_nameB5cxx11Ebb; CLI::Option::get_name(bool,bool)
mov rdi, rbx; this
mov rsi, r14; CLI::Option *
call _ZN3CLI3App13remove_optionEPNS_6OptionE; CLI::App::remove_option(CLI::Option *)
push 38h ; '8'
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rdi, [rsp+178h+var_90]
lea rsi, [rsp+178h+var_138]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov bpl, 1
lea rsi, [rsp+178h+var_90]
mov rdi, r14
call _ZN3CLI21IncorrectConstruction14PositionalFlagENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; CLI::IncorrectConstruction::PositionalFlag(std::string)
xor ebp, ebp
lea rsi, _ZTIN3CLI21IncorrectConstructionE; lptinfo
lea rdx, _ZN3CLI5ErrorD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rdi, [rsp+178h+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_1340F
jmp short loc_1341C
mov rbx, rax
loc_1340F:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_1341C
mov rbx, rax
loc_1341C:
lea rdi, [rsp+178h+var_138]
jmp short loc_13483
mov rbx, rax
lea rdi, [rsp+178h+var_B8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+178h+var_158]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_1348F
mov rbx, rax
lea rdi, [rsp+178h+var_D8]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+178h+var_118]; void *
loc_13483:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_13499
jmp short $+2
loc_1348C:
mov rbx, rax
loc_1348F:
lea rdi, [rsp+178h+var_138]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EED2Ev; std::vector<std::pair<std::string,std::string>>::~vector()
loc_13499:
mov rdi, rbx
call __Unwind_Resume
| long long CLI::App::_add_flag_internal(CLI::App *this, long long a2, __int128 *a3, long long a4)
{
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rax
long long v11; // r14
long long v12; // r15
long long v13; // r13
long long v14; // rax
long long v15; // rdx
long long v16; // rcx
long long v17; // r8
long long v18; // r9
void *exception; // r14
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
__int128 v25; // [rsp+0h] [rbp-178h] BYREF
long long v26; // [rsp+10h] [rbp-168h]
long long v27; // [rsp+18h] [rbp-160h]
__int128 v28; // [rsp+20h] [rbp-158h] BYREF
long long v29; // [rsp+30h] [rbp-148h]
long long v30; // [rsp+38h] [rbp-140h]
_QWORD v31[4]; // [rsp+40h] [rbp-138h] BYREF
_BYTE v32[32]; // [rsp+60h] [rbp-118h] BYREF
_BYTE v33[32]; // [rsp+80h] [rbp-F8h] BYREF
_BYTE v34[32]; // [rsp+A0h] [rbp-D8h] BYREF
_BYTE v35[40]; // [rsp+C0h] [rbp-B8h] BYREF
_BYTE v36[32]; // [rsp+E8h] [rbp-90h] BYREF
_BYTE v37[32]; // [rsp+108h] [rbp-70h] BYREF
_BYTE v38[80]; // [rsp+128h] [rbp-50h] BYREF
if ( (unsigned __int8)CLI::detail::has_default_flag_values(a2) )
{
CLI::detail::get_default_flag_values(
(unsigned int)v31,
a2,
v6,
v7,
v8,
v9,
v25,
DWORD2(v25),
v26,
v27,
v28,
DWORD2(v28),
v29,
v30,
v31[0]);
CLI::detail::remove_default_flag_values(a2);
std::string::basic_string(v33, a2);
v28 = 0LL;
v29 = 0LL;
v30 = *((_QWORD *)a3 + 3);
v10 = *((_QWORD *)a3 + 2);
if ( v10 )
{
v28 = *a3;
v29 = v10;
a3[1] = 0LL;
}
std::string::basic_string(v38, a4);
memset(v35, 0, 32);
v11 = CLI::App::add_option((int)this);
std::_Function_base::~_Function_base((std::_Function_base *)v35);
std::string::~string(v38);
std::_Function_base::~_Function_base((std::_Function_base *)&v28);
std::string::~string(v33);
v12 = v31[0];
v13 = v31[1];
while ( v12 != v13 )
{
std::vector<std::string>::push_back(v11 + 112, v12);
v12 += 64LL;
}
std::vector<std::pair<std::string,std::string>>::_M_move_assign(v11 + 88, v31);
std::vector<std::pair<std::string,std::string>>::~vector((long long)v31);
}
else
{
std::string::basic_string(v32, a2);
v25 = 0LL;
v26 = 0LL;
v27 = *((_QWORD *)a3 + 3);
v14 = *((_QWORD *)a3 + 2);
if ( v14 )
{
v25 = *a3;
v26 = v14;
a3[1] = 0LL;
}
std::string::basic_string(v37, a4);
memset(v34, 0, sizeof(v34));
v11 = CLI::App::add_option((int)this);
std::_Function_base::~_Function_base((std::_Function_base *)v34);
std::string::~string(v37);
std::_Function_base::~_Function_base((std::_Function_base *)&v25);
std::string::~string(v32);
}
if ( *(_QWORD *)(v11 + 144) )
{
CLI::Option::get_name[abi:cxx11]((long long)v31, v11, 1, 0);
CLI::App::remove_option(this, (CLI::Option *)v11);
exception = __cxa_allocate_exception(0x38uLL);
std::string::basic_string(v36);
CLI::IncorrectConstruction::PositionalFlag((_DWORD)exception, (unsigned int)v36, v21, v22, v23, v24, v25);
__cxa_throw(exception, (struct type_info *)&`typeinfo for'CLI::IncorrectConstruction, CLI::Error::~Error);
}
CLI::Option::multi_option_policy(
v11,
1LL,
v15,
v16,
v17,
v18,
v25,
*((_QWORD *)&v25 + 1),
v26,
v27,
v28,
*((_QWORD *)&v28 + 1),
v29,
v30);
*(_QWORD *)(v11 + 368) = 0LL;
*(_BYTE *)(v11 + 586) = 1;
*(_BYTE *)(v11 + 32) = 0;
return v11;
}
| _add_flag_internal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001134a1
TEST AL,AL
JZ 0x00113286
LEA RDI,[RSP + 0x40]
MOV RSI,R12
CALL 0x001134b9
LAB_0011319a:
MOV RDI,R12
CALL 0x00113680
LEA RDI,[RSP + 0x80]
MOV RSI,R12
CALL 0x00107560
XORPS XMM1,XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM1
AND qword ptr [RSP + 0x30],0x0
MOV RAX,qword ptr [R15 + 0x18]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [R15 + 0x10]
TEST RAX,RAX
JZ 0x001131e8
MOVUPS XMM0,xmmword ptr [R15]
ADD R15,0x10
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],RAX
MOVUPS xmmword ptr [R15],XMM1
LAB_001131e8:
LEA R15,[RSP + 0x128]
MOV RDI,R15
MOV RSI,R14
CALL 0x00107560
LEA R9,[RSP + 0xc0]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R9 + 0x10],XMM0
MOVAPS xmmword ptr [R9],XMM0
LAB_0011320f:
LEA RSI,[RSP + 0x80]
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV RCX,R15
XOR R8D,R8D
CALL 0x00113724
MOV R14,RAX
LEA RDI,[RSP + 0xc0]
CALL 0x0011b754
LEA RDI,[RSP + 0x128]
CALL 0x00107860
LEA RDI,[RSP + 0x20]
CALL 0x0011b754
LEA RDI,[RSP + 0x80]
CALL 0x00107860
MOV R15,qword ptr [RSP + 0x40]
MOV R13,qword ptr [RSP + 0x48]
LEA R12,[R14 + 0x70]
LAB_0011326c:
CMP R15,R13
JZ 0x00113335
LAB_00113275:
MOV RDI,R12
MOV RSI,R15
CALL 0x0010df4e
ADD R15,0x40
JMP 0x0011326c
LAB_00113286:
LEA RDI,[RSP + 0x60]
MOV RSI,R12
CALL 0x00107560
XORPS XMM1,XMM1
MOVAPS xmmword ptr [RSP],XMM1
AND qword ptr [RSP + 0x10],0x0
MOV RAX,qword ptr [R15 + 0x18]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [R15 + 0x10]
TEST RAX,RAX
JZ 0x001132c7
MOVUPS XMM0,xmmword ptr [R15]
ADD R15,0x10
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],RAX
MOVUPS xmmword ptr [R15],XMM1
LAB_001132c7:
LEA R15,[RSP + 0x108]
MOV RDI,R15
MOV RSI,R14
CALL 0x00107560
LEA R9,[RSP + 0xa0]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R9 + 0x10],XMM0
MOVAPS xmmword ptr [R9],XMM0
LAB_001132ee:
LEA RSI,[RSP + 0x60]
MOV RDX,RSP
MOV RDI,RBX
MOV RCX,R15
XOR R8D,R8D
CALL 0x00113724
LAB_00113304:
MOV R14,RAX
LEA RDI,[RSP + 0xa0]
CALL 0x0011b754
LEA RDI,[RSP + 0x108]
CALL 0x00107860
MOV RDI,RSP
CALL 0x0011b754
LEA RDI,[RSP + 0x60]
CALL 0x00107860
JMP 0x00113351
LAB_00113335:
MOV RDI,R14
ADD RDI,0x58
LEA R15,[RSP + 0x40]
MOV RSI,R15
CALL 0x00115fc2
MOV RDI,R15
CALL 0x00113032
LAB_00113351:
CMP qword ptr [R14 + 0x90],0x0
JNZ 0x00113390
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x00113b00
AND qword ptr [R14 + 0x170],0x0
MOV byte ptr [R14 + 0x24a],0x1
MOV byte ptr [R14 + 0x20],0x0
MOV RAX,R14
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00113390:
LEA RDI,[RSP + 0x40]
PUSH 0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x0010f2c4
LAB_001133a2:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00112b88
LAB_001133ad:
PUSH 0x38
POP RDI
CALL 0x00107210
MOV R14,RAX
LAB_001133b8:
LEA RDI,[RSP + 0xe8]
LEA RSI,[RSP + 0x40]
CALL 0x001075e0
MOV BPL,0x1
LAB_001133cd:
LEA RSI,[RSP + 0xe8]
MOV RDI,R14
CALL 0x00113aac
XOR EBP,EBP
LEA RSI,[0x13f470]
LEA RDX,[0x11dc64]
MOV RDI,R14
CALL 0x00107750
|
/* CLI::App::_add_flag_internal(std::__cxx11::string, std::function<bool
(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > > const&)>,
std::__cxx11::string) */
Option * __thiscall
CLI::App::_add_flag_internal(App *this,string *param_2,int8 *param_3,string *param_4)
{
long lVar1;
char cVar2;
Option *pOVar3;
IncorrectConstruction *pIVar4;
string *psVar5;
int8 local_178;
int8 uStack_170;
long local_168;
int8 local_160;
int8 local_158;
int8 uStack_150;
long local_148;
int8 local_140;
string *local_138;
string *local_130;
string local_118 [32];
string local_f8 [32];
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
int8 uStack_a0;
string local_90 [32];
string local_70 [32];
string local_50 [32];
cVar2 = detail::has_default_flag_values(param_2);
if (cVar2 == '\0') {
std::__cxx11::string::string(local_118,param_2);
local_178 = 0;
uStack_170 = 0;
local_168 = 0;
local_160 = param_3[3];
lVar1 = param_3[2];
if (lVar1 != 0) {
local_178 = *param_3;
uStack_170 = param_3[1];
param_3[2] = 0;
param_3[3] = 0;
local_168 = lVar1;
}
std::__cxx11::string::string(local_70,param_4);
local_c8 = 0;
uStack_c0 = 0;
local_d8 = 0;
uStack_d0 = 0;
/* try { // try from 001132ee to 00113303 has its CatchHandler @ 00113459 */
pOVar3 = (Option *)add_option(this,local_118,&local_178,local_70,0);
std::_Function_base::~_Function_base((_Function_base *)&local_d8);
std::__cxx11::string::~string(local_70);
std::_Function_base::~_Function_base((_Function_base *)&local_178);
std::__cxx11::string::~string(local_118);
}
else {
detail::get_default_flag_values((detail *)&local_138,param_2);
/* try { // try from 0011319a to 001131a1 has its CatchHandler @ 0011348a */
detail::remove_default_flag_values(param_2);
std::__cxx11::string::string(local_f8,param_2);
local_158 = 0;
uStack_150 = 0;
local_148 = 0;
local_140 = param_3[3];
lVar1 = param_3[2];
if (lVar1 != 0) {
local_158 = *param_3;
uStack_150 = param_3[1];
param_3[2] = 0;
param_3[3] = 0;
local_148 = lVar1;
}
std::__cxx11::string::string(local_50,param_4);
local_a8 = 0;
uStack_a0 = 0;
local_b8 = 0;
uStack_b0 = 0;
/* try { // try from 0011320f to 00113229 has its CatchHandler @ 00113423 */
pOVar3 = (Option *)add_option(this,local_f8,&local_158,local_50,0);
std::_Function_base::~_Function_base((_Function_base *)&local_b8);
std::__cxx11::string::~string(local_50);
std::_Function_base::~_Function_base((_Function_base *)&local_158);
std::__cxx11::string::~string(local_f8);
for (psVar5 = local_138; psVar5 != local_130; psVar5 = psVar5 + 0x40) {
/* try { // try from 00113275 to 0011327f has its CatchHandler @ 0011348c */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
(pOVar3 + 0x70),psVar5);
}
std::
vector<std::pair<std::__cxx11::string,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string,std::__cxx11::string>>>
::_M_move_assign(pOVar3 + 0x58,
(vector<std::pair<std::__cxx11::string,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string,std::__cxx11::string>>>
*)&local_138);
std::
vector<std::pair<std::__cxx11::string,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string,std::__cxx11::string>>>
::~vector((vector<std::pair<std::__cxx11::string,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string,std::__cxx11::string>>>
*)&local_138);
}
if (*(long *)(pOVar3 + 0x90) == 0) {
Option::multi_option_policy(pOVar3,1);
*(int8 *)(pOVar3 + 0x170) = 0;
pOVar3[0x24a] = (Option)0x1;
pOVar3[0x20] = (Option)0x0;
return pOVar3;
}
Option::get_name_abi_cxx11_(SUB81(&local_138,0),SUB81(pOVar3,0));
/* try { // try from 001133a2 to 001133ac has its CatchHandler @ 00113419 */
remove_option(this,pOVar3);
pIVar4 = (IncorrectConstruction *)__cxa_allocate_exception(0x38);
/* try { // try from 001133b8 to 001133c9 has its CatchHandler @ 0011340c */
std::__cxx11::string::string(local_90,(string *)&local_138);
/* try { // try from 001133cd to 001133f4 has its CatchHandler @ 001133f5 */
IncorrectConstruction::PositionalFlag(pIVar4,local_90);
/* WARNING: Subroutine does not return */
__cxa_throw(pIVar4,&IncorrectConstruction::typeinfo,Error::~Error);
}
| |
34,298 | translog_buffer_lock | eloqsql/storage/maria/ma_loghandler.c | static void translog_buffer_lock(struct st_translog_buffer *buffer)
{
DBUG_ENTER("translog_buffer_lock");
DBUG_PRINT("enter",
("Lock buffer #%u: %p", buffer->buffer_no,
buffer));
mysql_mutex_lock(&buffer->mutex);
DBUG_VOID_RETURN;
} | O0 | c | translog_buffer_lock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x514fe
movq -0x8(%rbp), %rdi
addq $0x100090, %rdi # imm = 0x100090
leaq 0x101aa9(%rip), %rsi # 0x152fb9
movl $0x6cb, %edx # imm = 0x6CB
callq 0x510a0
jmp 0x5151c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| translog_buffer_lock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
jmp short $+2
loc_514FE:
mov rdi, [rbp+var_8]
add rdi, 100090h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 6CBh
call inline_mysql_mutex_lock_8
jmp short $+2
loc_5151C:
add rsp, 10h
pop rbp
retn
| long long translog_buffer_lock(long long a1)
{
return inline_mysql_mutex_lock_8(
a1 + 1048720,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x6CBu);
}
| translog_buffer_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
JMP 0x001514fe
LAB_001514fe:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x100090
LEA RSI,[0x252fb9]
MOV EDX,0x6cb
CALL 0x001510a0
JMP 0x0015151c
LAB_0015151c:
ADD RSP,0x10
POP RBP
RET
|
void translog_buffer_lock(long param_1)
{
inline_mysql_mutex_lock
(param_1 + 0x100090,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0x6cb);
return;
}
| |
34,299 | ma_bitmap_reset_full_page_bits | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page,
uint page_count)
{
ulonglong bitmap_page;
uint offset, bit_start, bit_count, tmp, byte_offset;
uchar *data;
DBUG_ENTER("_ma_bitmap_reset_full_page_bits");
DBUG_PRINT("enter", ("page: %lu page_count: %u", (ulong) page, page_count));
mysql_mutex_assert_owner(&info->s->bitmap.bitmap_lock);
bitmap_page= page - page % bitmap->pages_covered;
DBUG_ASSERT(page != bitmap_page);
if (bitmap_page != bitmap->page &&
_ma_change_bitmap_page(info, bitmap, bitmap_page))
DBUG_RETURN(1);
/* Find page number from start of bitmap */
offset= (uint) (page - bitmap->page - 1);
/* Clear bits from 'page * 3' -> '(page + page_count) * 3' */
bit_start= offset * 3;
bit_count= page_count * 3;
byte_offset= bit_start/8;
data= bitmap->map + byte_offset;
offset= bit_start & 7;
tmp= (255 << offset); /* Bits to keep */
if (bit_count + offset < 8)
{
/* Only clear bits between 'offset' and 'offset+bit_count-1' */
tmp^= (255 << (offset + bit_count));
}
*data&= ~tmp;
set_if_smaller(bitmap->full_head_size, byte_offset);
set_if_smaller(bitmap->full_tail_size, byte_offset);
if ((int) (bit_count-= (8 - offset)) > 0)
{
uint fill;
data++;
/*
-1 is here to avoid one 'if' statement and to let the following code
handle the last byte
*/
if ((fill= (bit_count - 1) / 8))
{
bzero(data, fill);
data+= fill;
}
bit_count-= fill * 8; /* Bits left to clear */
tmp= (1 << bit_count) - 1;
*data&= ~tmp;
}
set_if_smaller(info->s->state.first_bitmap_with_space, bitmap_page);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_RETURN(0);
} | O0 | c | ma_bitmap_reset_full_page_bits:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
jmp 0x63d69
jmp 0x63d6b
jmp 0x63d6d
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
xorl %edx, %edx
divq 0x138(%rcx)
movq -0x60(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x30(%rbp)
jmp 0x63d93
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x63dc5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x63a90
movsbl %al, %eax
cmpl $0x0, %eax
je 0x63dc5
jmp 0x63dbc
movb $0x1, -0x1(%rbp)
jmp 0x63f33
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
movl %eax, -0x34(%rbp)
imull $0x3, -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
imull $0x3, -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %eax
shrl $0x3, %eax
movl %eax, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x44(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x38(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movl $0xff, %eax
shll %cl, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl $0x8, %eax
jae 0x63e35
movl -0x34(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movl $0xff, %eax
shll %cl, %eax
xorl -0x40(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edx
xorl $-0x1, %edx
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
cmpl -0x44(%rbp), %eax
jbe 0x63e5c
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x63e5e
jmp 0x63e60
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0x44(%rbp), %eax
jbe 0x63e76
movl -0x44(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2c(%rax)
jmp 0x63e78
movl $0x8, %ecx
subl -0x34(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jle 0x63ef9
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movl -0x3c(%rbp), %eax
subl $0x1, %eax
shrl $0x3, %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, %eax
je 0x63eca
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
movl -0x54(%rbp), %ecx
movq -0x50(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x54(%rbp), %ecx
shll $0x3, %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %edx
xorl $-0x1, %edx
movq -0x50(%rbp), %rax
movzbl (%rax), %ecx
andl %edx, %ecx
movb %cl, (%rax)
jmp 0x63efb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0xd0(%rax), %rax
cmpq -0x30(%rbp), %rax
jbe 0x63f21
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0xd0(%rax)
jmp 0x63f23
movq -0x18(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0x63f2d
jmp 0x63f2f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_bitmap_reset_full_page_bits:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
jmp short $+2
loc_63D69:
jmp short $+2
loc_63D6B:
jmp short $+2
loc_63D6D:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
xor edx, edx
div qword ptr [rcx+138h]
mov rax, [rbp+var_60]
sub rax, rdx
mov [rbp+var_30], rax
jmp short $+2
loc_63D93:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
cmp rax, [rcx+10h]
jz short loc_63DC5
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
call _ma_change_bitmap_page
movsx eax, al
cmp eax, 0
jz short loc_63DC5
jmp short $+2
loc_63DBC:
mov [rbp+var_1], 1
jmp loc_63F33
loc_63DC5:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, [rcx+10h]
sub rax, 1
mov [rbp+var_34], eax
imul eax, [rbp+var_34], 3
mov [rbp+var_38], eax
imul eax, [rbp+var_24], 3
mov [rbp+var_3C], eax
mov eax, [rbp+var_38]
shr eax, 3
mov [rbp+var_44], eax
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov ecx, [rbp+var_44]
add rax, rcx
mov [rbp+var_50], rax
mov eax, [rbp+var_38]
and eax, 7
mov [rbp+var_34], eax
mov ecx, [rbp+var_34]
mov eax, 0FFh
shl eax, cl
mov [rbp+var_40], eax
mov eax, [rbp+var_3C]
add eax, [rbp+var_34]
cmp eax, 8
jnb short loc_63E35
mov ecx, [rbp+var_34]
add ecx, [rbp+var_3C]
mov eax, 0FFh
shl eax, cl
xor eax, [rbp+var_40]
mov [rbp+var_40], eax
loc_63E35:
mov edx, [rbp+var_40]
xor edx, 0FFFFFFFFh
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
and ecx, edx
mov [rax], cl
mov rax, [rbp+var_18]
mov eax, [rax+28h]
cmp eax, [rbp+var_44]
jbe short loc_63E5C
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
mov [rax+28h], ecx
loc_63E5C:
jmp short $+2
loc_63E5E:
jmp short $+2
loc_63E60:
mov rax, [rbp+var_18]
mov eax, [rax+2Ch]
cmp eax, [rbp+var_44]
jbe short loc_63E76
mov ecx, [rbp+var_44]
mov rax, [rbp+var_18]
mov [rax+2Ch], ecx
loc_63E76:
jmp short $+2
loc_63E78:
mov ecx, 8
sub ecx, [rbp+var_34]
mov eax, [rbp+var_3C]
sub eax, ecx
mov [rbp+var_3C], eax
cmp eax, 0
jle short loc_63EF9
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
mov eax, [rbp+var_3C]
sub eax, 1
shr eax, 3
mov [rbp+var_54], eax
cmp eax, 0
jz short loc_63ECA
mov rdi, [rbp+var_50]
mov eax, [rbp+var_54]
mov edx, eax
xor esi, esi
call _memset
mov ecx, [rbp+var_54]
mov rax, [rbp+var_50]
mov ecx, ecx
add rax, rcx
mov [rbp+var_50], rax
loc_63ECA:
mov ecx, [rbp+var_54]
shl ecx, 3
mov eax, [rbp+var_3C]
sub eax, ecx
mov [rbp+var_3C], eax
mov ecx, [rbp+var_3C]
mov eax, 1
shl eax, cl
sub eax, 1
mov [rbp+var_40], eax
mov edx, [rbp+var_40]
xor edx, 0FFFFFFFFh
mov rax, [rbp+var_50]
movzx ecx, byte ptr [rax]
and ecx, edx
mov [rax], cl
loc_63EF9:
jmp short $+2
loc_63EFB:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+0D0h]
cmp rax, [rbp+var_30]
jbe short loc_63F21
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rax+0D0h], rcx
loc_63F21:
jmp short $+2
loc_63F23:
mov rax, [rbp+var_18]
mov byte ptr [rax+20h], 1
jmp short $+2
loc_63F2D:
jmp short $+2
loc_63F2F:
mov [rbp+var_1], 0
loc_63F33:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
| char ma_bitmap_reset_full_page_bits(long long *a1, long long a2, unsigned long long a3, int a4)
{
unsigned int v5; // [rsp+Ch] [rbp-54h]
_BYTE *v6; // [rsp+10h] [rbp-50h]
_BYTE *v7; // [rsp+10h] [rbp-50h]
unsigned int v8; // [rsp+1Ch] [rbp-44h]
int v9; // [rsp+20h] [rbp-40h]
int v10; // [rsp+24h] [rbp-3Ch]
int v11; // [rsp+24h] [rbp-3Ch]
int v12; // [rsp+2Ch] [rbp-34h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14; // [rsp+30h] [rbp-30h]
int v16; // [rsp+40h] [rbp-20h]
v16 = a3;
v14 = a3 - a3 % *(_QWORD *)(a2 + 312);
if ( v14 != *(_QWORD *)(a2 + 16) && ma_change_bitmap_page(a1, a2, v14) )
return 1;
v12 = v16 - *(_DWORD *)(a2 + 16) - 1;
v10 = 3 * a4;
v8 = (unsigned int)(3 * v12) >> 3;
v6 = (_BYTE *)(v8 + *(_QWORD *)(a2 + 8));
v13 = (3 * (_BYTE)v12) & 7;
v9 = 255 << v13;
if ( (unsigned int)(v13 + 3 * a4) < 8 )
v9 ^= 255 << (v10 + v13);
*v6 &= ~(_BYTE)v9;
if ( *(_DWORD *)(a2 + 40) > v8 )
*(_DWORD *)(a2 + 40) = v8;
if ( *(_DWORD *)(a2 + 44) > v8 )
*(_DWORD *)(a2 + 44) = v8;
v11 = v10 - (8 - v13);
if ( v11 > 0 )
{
v7 = v6 + 1;
v5 = (unsigned int)(v11 - 1) >> 3;
if ( v5 )
{
memset(v7, 0LL, v5);
v7 += v5;
}
*v7 &= ~((1 << (v11 - 8 * v5)) - 1);
}
if ( *(_QWORD *)(*a1 + 208) > v14 )
*(_QWORD *)(*a1 + 208) = v14;
*(_BYTE *)(a2 + 32) = 1;
return 0;
}
| _ma_bitmap_reset_full_page_bits:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
JMP 0x00163d69
LAB_00163d69:
JMP 0x00163d6b
LAB_00163d6b:
JMP 0x00163d6d
LAB_00163d6d:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
XOR EDX,EDX
DIV qword ptr [RCX + 0x138]
MOV RAX,qword ptr [RBP + -0x60]
SUB RAX,RDX
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00163d93
LAB_00163d93:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x10]
JZ 0x00163dc5
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x00163a90
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00163dc5
JMP 0x00163dbc
LAB_00163dbc:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00163f33
LAB_00163dc5:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RCX + 0x10]
SUB RAX,0x1
MOV dword ptr [RBP + -0x34],EAX
IMUL EAX,dword ptr [RBP + -0x34],0x3
MOV dword ptr [RBP + -0x38],EAX
IMUL EAX,dword ptr [RBP + -0x24],0x3
MOV dword ptr [RBP + -0x3c],EAX
MOV EAX,dword ptr [RBP + -0x38]
SHR EAX,0x3
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x44]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x38]
AND EAX,0x7
MOV dword ptr [RBP + -0x34],EAX
MOV ECX,dword ptr [RBP + -0x34]
MOV EAX,0xff
SHL EAX,CL
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,dword ptr [RBP + -0x34]
CMP EAX,0x8
JNC 0x00163e35
MOV ECX,dword ptr [RBP + -0x34]
ADD ECX,dword ptr [RBP + -0x3c]
MOV EAX,0xff
SHL EAX,CL
XOR EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x40],EAX
LAB_00163e35:
MOV EDX,dword ptr [RBP + -0x40]
XOR EDX,0xffffffff
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
AND ECX,EDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x28]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x00163e5c
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x28],ECX
LAB_00163e5c:
JMP 0x00163e5e
LAB_00163e5e:
JMP 0x00163e60
LAB_00163e60:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x2c]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x00163e76
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x2c],ECX
LAB_00163e76:
JMP 0x00163e78
LAB_00163e78:
MOV ECX,0x8
SUB ECX,dword ptr [RBP + -0x34]
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,0x0
JLE 0x00163ef9
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,0x1
SHR EAX,0x3
MOV dword ptr [RBP + -0x54],EAX
CMP EAX,0x0
JZ 0x00163eca
MOV RDI,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_00163eca:
MOV ECX,dword ptr [RBP + -0x54]
SHL ECX,0x3
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV EAX,0x1
SHL EAX,CL
SUB EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
MOV EDX,dword ptr [RBP + -0x40]
XOR EDX,0xffffffff
MOV RAX,qword ptr [RBP + -0x50]
MOVZX ECX,byte ptr [RAX]
AND ECX,EDX
MOV byte ptr [RAX],CL
LAB_00163ef9:
JMP 0x00163efb
LAB_00163efb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0xd0]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x00163f21
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0xd0],RCX
LAB_00163f21:
JMP 0x00163f23
LAB_00163f23:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x20],0x1
JMP 0x00163f2d
LAB_00163f2d:
JMP 0x00163f2f
LAB_00163f2f:
MOV byte ptr [RBP + -0x1],0x0
LAB_00163f33:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int1 _ma_bitmap_reset_full_page_bits(long *param_1,long param_2,ulong param_3,int param_4)
{
char cVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
byte *local_58;
byte local_48;
uVar4 = param_3 - param_3 % *(ulong *)(param_2 + 0x138);
if ((uVar4 != *(ulong *)(param_2 + 0x10)) &&
(cVar1 = _ma_change_bitmap_page(param_1,param_2,uVar4), cVar1 != '\0')) {
return 1;
}
uVar2 = (((int)param_3 - (int)*(int8 *)(param_2 + 0x10)) + -1) * 3;
param_4 = param_4 * 3;
uVar3 = uVar2 >> 3;
local_58 = (byte *)(*(long *)(param_2 + 8) + (ulong)uVar3);
uVar2 = uVar2 & 7;
local_48 = (byte)(0xff << (sbyte)uVar2);
if (param_4 + uVar2 < 8) {
local_48 = (byte)(0xff << ((sbyte)uVar2 + (char)param_4 & 0x1fU)) ^ local_48;
}
*local_58 = *local_58 & (local_48 ^ 0xff);
if (uVar3 < *(uint *)(param_2 + 0x28)) {
*(uint *)(param_2 + 0x28) = uVar3;
}
if (uVar3 < *(uint *)(param_2 + 0x2c)) {
*(uint *)(param_2 + 0x2c) = uVar3;
}
param_4 = param_4 - (8 - uVar2);
if (0 < param_4) {
local_58 = local_58 + 1;
uVar3 = param_4 - 1U >> 3;
if (uVar3 != 0) {
memset(local_58,0,(ulong)uVar3);
local_58 = local_58 + uVar3;
}
*local_58 = *local_58 & ((char)(1 << ((char)param_4 + (char)uVar3 * -8 & 0x1fU)) - 1U ^ 0xff);
}
if (uVar4 < *(ulong *)(*param_1 + 0xd0)) {
*(ulong *)(*param_1 + 0xd0) = uVar4;
}
*(int1 *)(param_2 + 0x20) = 1;
return 0;
}
|
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.