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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
22,400 | seek_io_cache | eloqsql/mysys/mf_iocache.c | void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset)
{
my_off_t cached_data_start= cache->pos_in_file;
my_off_t cached_data_end= cache->pos_in_file + (cache->read_end -
cache->buffer);
if (needed_offset >= cached_data_start &&
needed_offset < cached_data_end)
{
/*
The offset we're seeking to is in the buffer.
Move buffer's read position accordingly
*/
cache->read_pos= cache->buffer + (needed_offset - cached_data_start);
}
else
{
if (needed_offset > cache->end_of_file)
needed_offset= cache->end_of_file;
/*
The offset we're seeking to is not in the buffer.
- Set the buffer to be exhausted.
- Make the next read to a mysql_file_seek() call to the required
offset.
TODO(cvicentiu, spetrunia) properly implement aligned seeks for
efficiency.
*/
cache->seek_not_done= 1;
cache->pos_in_file= needed_offset;
/* When reading it must appear as if we've started from the offset
that we've seeked here. We must let _my_b_cache_read assume that
by implying "no reading starting from pos_in_file" has happened. */
cache->read_pos= cache->buffer;
cache->read_end= cache->buffer;
}
} | O0 | c | seek_io_cache:
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 -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0xe07c9
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe07c9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xe081c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xe07e3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nop
| seek_io_cache:
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_8]
mov rax, [rax]
mov rcx, [rbp+var_8]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_8]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jb short loc_E07C9
mov rax, [rbp+var_10]
cmp rax, [rbp+var_20]
jnb short loc_E07C9
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
sub rax, [rbp+var_18]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+10h], rcx
jmp short loc_E081C
loc_E07C9:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
cmp rax, [rcx+8]
jbe short loc_E07E3
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_10], rax
loc_E07E3:
mov rax, [rbp+var_8]
mov dword ptr [rax+0E0h], 1
mov rcx, [rbp+var_10]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+10h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+20h]
mov rax, [rbp+var_8]
mov [rax+18h], rcx
loc_E081C:
pop rbp
retn
| long long seek_io_cache(long long a1, unsigned long long a2)
{
long long result; // rax
unsigned long long v3; // [rsp+10h] [rbp-10h]
v3 = a2;
if ( a2 < *(_QWORD *)a1 || a2 >= *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1 )
{
if ( a2 > *(_QWORD *)(a1 + 8) )
v3 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 224) = 1;
*(_QWORD *)a1 = v3;
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
result = a1;
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 32);
}
else
{
result = a1;
*(_QWORD *)(a1 + 16) = a2 - *(_QWORD *)a1 + *(_QWORD *)(a1 + 32);
}
return result;
}
| seek_io_cache:
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 + -0x8]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JC 0x001e07c9
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e07c9
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
SUB RAX,qword ptr [RBP + -0x18]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001e081c
LAB_001e07c9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x8]
JBE 0x001e07e3
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x10],RAX
LAB_001e07e3:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0xe0],0x1
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],RCX
LAB_001e081c:
POP RBP
RET
|
void seek_io_cache(ulong *param_1,ulong param_2)
{
ulong local_18;
if ((param_2 < *param_1) || (*param_1 + (param_1[3] - param_1[4]) <= param_2)) {
local_18 = param_2;
if (param_1[1] < param_2) {
local_18 = param_1[1];
}
*(int4 *)(param_1 + 0x1c) = 1;
*param_1 = local_18;
param_1[2] = param_1[4];
param_1[3] = param_1[4];
}
else {
param_1[2] = param_1[4] + (param_2 - *param_1);
}
return;
}
| |
22,401 | seek_io_cache | eloqsql/mysys/mf_iocache.c | void seek_io_cache(IO_CACHE *cache, my_off_t needed_offset)
{
my_off_t cached_data_start= cache->pos_in_file;
my_off_t cached_data_end= cache->pos_in_file + (cache->read_end -
cache->buffer);
if (needed_offset >= cached_data_start &&
needed_offset < cached_data_end)
{
/*
The offset we're seeking to is in the buffer.
Move buffer's read position accordingly
*/
cache->read_pos= cache->buffer + (needed_offset - cached_data_start);
}
else
{
if (needed_offset > cache->end_of_file)
needed_offset= cache->end_of_file;
/*
The offset we're seeking to is not in the buffer.
- Set the buffer to be exhausted.
- Make the next read to a mysql_file_seek() call to the required
offset.
TODO(cvicentiu, spetrunia) properly implement aligned seeks for
efficiency.
*/
cache->seek_not_done= 1;
cache->pos_in_file= needed_offset;
/* When reading it must appear as if we've started from the offset
that we've seeked here. We must let _my_b_cache_read assume that
by implying "no reading starting from pos_in_file" has happened. */
cache->read_pos= cache->buffer;
cache->read_end= cache->buffer;
}
} | O3 | c | seek_io_cache:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
movq 0x20(%rdi), %rax
movq %rsi, %rcx
subq %rdx, %rcx
jb 0x951f2
subq %rax, %rdx
addq 0x18(%rdi), %rdx
cmpq %rsi, %rdx
jbe 0x951f2
addq %rcx, %rax
movq %rax, 0x10(%rdi)
jmp 0x95212
movq 0x8(%rdi), %rcx
cmpq %rsi, %rcx
cmovbq %rcx, %rsi
movl $0x1, 0xe0(%rdi)
movq %rsi, (%rdi)
movq %rax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
popq %rbp
retq
| seek_io_cache:
push rbp
mov rbp, rsp
mov rdx, [rdi]
mov rax, [rdi+20h]
mov rcx, rsi
sub rcx, rdx
jb short loc_951F2
sub rdx, rax
add rdx, [rdi+18h]
cmp rdx, rsi
jbe short loc_951F2
add rax, rcx
mov [rdi+10h], rax
jmp short loc_95212
loc_951F2:
mov rcx, [rdi+8]
cmp rcx, rsi
cmovb rsi, rcx
mov dword ptr [rdi+0E0h], 1
mov [rdi], rsi
mov [rdi+10h], rax
mov [rdi+18h], rax
loc_95212:
pop rbp
retn
| long long seek_io_cache(long long a1, unsigned long long a2)
{
long long result; // rax
result = *(_QWORD *)(a1 + 32);
if ( a2 < *(_QWORD *)a1 || *(_QWORD *)(a1 + 24) + *(_QWORD *)a1 - result <= a2 )
{
if ( *(_QWORD *)(a1 + 8) < a2 )
a2 = *(_QWORD *)(a1 + 8);
*(_DWORD *)(a1 + 224) = 1;
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 16) = result;
*(_QWORD *)(a1 + 24) = result;
}
else
{
result += a2 - *(_QWORD *)a1;
*(_QWORD *)(a1 + 16) = result;
}
return result;
}
| seek_io_cache:
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x20]
MOV RCX,RSI
SUB RCX,RDX
JC 0x001951f2
SUB RDX,RAX
ADD RDX,qword ptr [RDI + 0x18]
CMP RDX,RSI
JBE 0x001951f2
ADD RAX,RCX
MOV qword ptr [RDI + 0x10],RAX
JMP 0x00195212
LAB_001951f2:
MOV RCX,qword ptr [RDI + 0x8]
CMP RCX,RSI
CMOVC RSI,RCX
MOV dword ptr [RDI + 0xe0],0x1
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],RAX
LAB_00195212:
POP RBP
RET
|
void seek_io_cache(ulong *param_1,ulong param_2)
{
ulong uVar1;
ulong uVar2;
uVar1 = *param_1;
uVar2 = param_1[4];
if ((param_2 < uVar1) || ((uVar1 - uVar2) + param_1[3] <= param_2)) {
if (param_1[1] < param_2) {
param_2 = param_1[1];
}
*(int4 *)(param_1 + 0x1c) = 1;
*param_1 = param_2;
param_1[2] = uVar2;
param_1[3] = uVar2;
}
else {
param_1[2] = uVar2 + (param_2 - uVar1);
}
return;
}
| |
22,402 | CLI::Option::check_sname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/Option.hpp | CLI11_NODISCARD bool check_sname(std::string name) const {
return (detail::find_member(std::move(name), snames_, ignore_case_) >= 0);
} | O1 | cpp | CLI::Option::check_sname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsi), %rcx
leaq 0x10(%rsi), %rax
cmpq %rax, %rcx
je 0x1d90f
movq %rcx, (%rsp)
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
jmp 0x1d916
movups (%rax), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, (%rsi)
movq $0x0, 0x8(%rsi)
movb $0x0, 0x10(%rsi)
leaq 0x28(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x13372
movzbl 0x21(%rbx), %edx
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x151ae
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xaf62
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1d972
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
testq %rbx, %rbx
setns %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xaf62
jmp 0x1d992
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x1d9a8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rdi
callq 0x7780
| _ZNK3CLI6Option11check_snameENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14; __int64
push rbx; int
sub rsp, 38h
mov rbx, rdi
lea r14, [rsp+48h+var_38]
mov [r14-10h], r14
mov rcx, [rsi]
lea rax, [rsi+10h]
cmp rcx, rax
jz short loc_1D90F
mov [rsp+48h+var_48], rcx
mov rcx, [rax]
mov [rsp+48h+var_38], rcx
jmp short loc_1D916
loc_1D90F:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r14], xmm0
loc_1D916:
mov rcx, [rsi+8]
mov qword ptr [rsp+48h+var_40], rcx; int
mov [rsi], rax
mov qword ptr [rsi+8], 0
mov byte ptr [rsi+10h], 0
lea rsi, [rbx+28h]
lea rdi, [rsp+48h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
movzx edx, byte ptr [rbx+21h]; int
mov rdi, rsp; int
lea rsi, [rsp+48h+var_28]; int
xor ecx, ecx; int
call _ZN3CLI6detail11find_memberENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEbb; CLI::detail::find_member(std::string,std::vector<std::string>,bool,bool)
mov rbx, rax
lea rdi, [rsp+48h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r14
jz short loc_1D972
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D972:
test rbx, rbx
setns al
add rsp, 38h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
jmp short loc_1D992
mov rbx, rax
loc_1D992:
mov rdi, [rsp+0]; void *
cmp rdi, r14
jz short loc_1D9A8
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D9A8:
mov rdi, rbx
call __Unwind_Resume
| bool CLI::Option::check_sname(long long a1, long long a2)
{
__int128 *v2; // rax
long long member; // rbx
void *v5; // [rsp+0h] [rbp-48h] BYREF
int v6[2]; // [rsp+8h] [rbp-40h]
__int128 v7; // [rsp+10h] [rbp-38h] BYREF
_QWORD v8[5]; // [rsp+20h] [rbp-28h] BYREF
v5 = &v7;
v2 = (__int128 *)(a2 + 16);
if ( *(_QWORD *)a2 == a2 + 16 )
{
v7 = *v2;
}
else
{
v5 = *(void **)a2;
*(_QWORD *)&v7 = *(_QWORD *)v2;
}
*(_QWORD *)v6 = *(_QWORD *)(a2 + 8);
*(_QWORD *)a2 = v2;
*(_QWORD *)(a2 + 8) = 0LL;
*(_BYTE *)(a2 + 16) = 0;
std::vector<std::string>::vector((long long)v8, (_QWORD *)(a1 + 40));
member = CLI::detail::find_member(&v5, v8, *(unsigned __int8 *)(a1 + 33), 0);
std::vector<std::string>::~vector(v8);
if ( v5 != &v7 )
operator delete(v5, v7 + 1);
return member >= 0;
}
| check_sname:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
LEA R14,[RSP + 0x10]
MOV qword ptr [R14 + -0x10],R14
MOV RCX,qword ptr [RSI]
LEA RAX,[RSI + 0x10]
CMP RCX,RAX
JZ 0x0011d90f
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0x10],RCX
JMP 0x0011d916
LAB_0011d90f:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R14],XMM0
LAB_0011d916:
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSI],RAX
MOV qword ptr [RSI + 0x8],0x0
MOV byte ptr [RSI + 0x10],0x0
LEA RSI,[RBX + 0x28]
LAB_0011d932:
LEA RDI,[RSP + 0x20]
CALL 0x00113372
MOVZX EDX,byte ptr [RBX + 0x21]
LAB_0011d940:
MOV RDI,RSP
LEA RSI,[RSP + 0x20]
XOR ECX,ECX
CALL 0x001151ae
LAB_0011d94f:
MOV RBX,RAX
LEA RDI,[RSP + 0x20]
CALL 0x0010af62
MOV RDI,qword ptr [RSP]
CMP RDI,R14
JZ 0x0011d972
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00107430
LAB_0011d972:
TEST RBX,RBX
SETNS AL
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* CLI::Option::check_sname(std::__cxx11::string) const */
bool __thiscall CLI::Option::check_sname(Option *this,long *param_2)
{
long *plVar1;
long lVar2;
long *local_48;
long local_40;
long local_38;
long lStack_30;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_28 [24];
plVar1 = param_2 + 2;
if ((long *)*param_2 == plVar1) {
local_38 = *plVar1;
lStack_30 = param_2[3];
local_48 = &local_38;
}
else {
local_38 = *plVar1;
local_48 = (long *)*param_2;
}
local_40 = param_2[1];
*param_2 = (long)plVar1;
param_2[1] = 0;
*(int1 *)(param_2 + 2) = 0;
/* try { // try from 0011d932 to 0011d93b has its CatchHandler @ 0011d98f */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
(local_28,(vector *)(this + 0x28));
/* try { // try from 0011d940 to 0011d94e has its CatchHandler @ 0011d980 */
lVar2 = detail::find_member(&local_48,local_28,this[0x21],0);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_28);
if (local_48 != &local_38) {
operator_delete(local_48,local_38 + 1);
}
return -1 < lVar2;
}
| |
22,403 | write_changed_bitmap | eloqsql/storage/maria/ma_bitmap.c | static inline my_bool write_changed_bitmap(MARIA_SHARE *share,
MARIA_FILE_BITMAP *bitmap)
{
my_bool res;
DBUG_ENTER("write_changed_bitmap");
DBUG_ASSERT(share->pagecache->block_size == bitmap->block_size);
DBUG_ASSERT(bitmap->file.pre_write_hook != 0);
DBUG_PRINT("info", ("bitmap->non_flushable: %u", bitmap->non_flushable));
/*
Mark that a bitmap page has been written to page cache and we have
to flush it during checkpoint.
*/
bitmap->changed_not_flushed= 1;
if ((bitmap->non_flushable == 0) || WRONG_BITMAP_FLUSH)
{
res= pagecache_write(share->pagecache,
&bitmap->file, bitmap->page, 0,
bitmap->map, PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED,
PAGECACHE_PIN_LEFT_UNPINNED,
PAGECACHE_WRITE_DELAY, 0, LSN_IMPOSSIBLE);
DBUG_ASSERT(!res);
DBUG_RETURN(res);
}
else
{
/*
bitmap->non_flushable means that someone has changed the bitmap,
but it's not yet complete so it can't yet be written to disk.
In this case we write the changed bitmap to the disk cache,
but keep it pinned until the change is completed. The page will
be unpinned later by _ma_bitmap_unpin_all() as soon as non_flushable
is set back to 0.
*/
MARIA_PINNED_PAGE page_link;
DBUG_PRINT("info", ("Writing pinned bitmap page"));
res= pagecache_write(share->pagecache,
&bitmap->file, bitmap->page, 0,
bitmap->map, PAGECACHE_PLAIN_PAGE,
PAGECACHE_LOCK_LEFT_UNLOCKED, PAGECACHE_PIN,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE);
page_link.unlock= PAGECACHE_LOCK_LEFT_UNLOCKED;
page_link.changed= 1;
push_dynamic(&bitmap->pinned_pages, (const uchar*) (void*) &page_link);
DBUG_ASSERT(!res);
DBUG_RETURN(res);
}
} | O0 | c | write_changed_bitmap:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x43122
jmp 0x43124
jmp 0x43126
jmp 0x43128
jmp 0x4312a
movq -0x18(%rbp), %rax
movb $0x1, 0x21(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x431cb
movq -0x10(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x600(%rax), %rax
movl 0x80(%rax), %eax
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x303f0
movb %al, -0x19(%rbp)
jmp 0x431be
jmp 0x431c0
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x43274
jmp 0x431cd
jmp 0x431cf
movq -0x10(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
leaq -0x38(%rbp), %r10
movq -0x10(%rbp), %rax
movq 0x600(%rax), %rax
movl 0x80(%rax), %eax
xorl %ecx, %ecx
movl $0x1, %r9d
xorl %r11d, %r11d
movl $0x0, (%rsp)
movl $0x2, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x303f0
movb %al, -0x19(%rbp)
movl $0x0, -0x30(%rbp)
movb $0x1, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x140, %rdi # imm = 0x140
leaq -0x38(%rbp), %rsi
callq 0xdbcc0
jmp 0x4326c
jmp 0x4326e
movb -0x19(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
| write_changed_bitmap:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
jmp short $+2
loc_43122:
jmp short $+2
loc_43124:
jmp short $+2
loc_43126:
jmp short $+2
loc_43128:
jmp short $+2
loc_4312A:
mov rax, [rbp+var_18]
mov byte ptr [rax+21h], 1
mov rax, [rbp+var_18]
cmp dword ptr [rax+38h], 0
jnz loc_431CB
mov rax, [rbp+var_10]
mov rdi, [rax+600h]
mov rsi, [rbp+var_18]
add rsi, 40h ; '@'
mov rax, [rbp+var_18]
mov rdx, [rax+10h]
mov rax, [rbp+var_18]
mov r8, [rax+8]
mov rax, [rbp+var_10]
mov rax, [rax+600h]
mov eax, [rax+80h]
xor ecx, ecx
mov r9d, 1
xor r10d, r10d
mov [rsp+70h+var_70], 0
mov [rsp+70h+var_68], 1
mov [rsp+70h+var_60], 0
mov [rsp+70h+var_58], 0
mov [rsp+70h+var_50], 0
mov [rsp+70h+var_48], 0
mov [rsp+70h+var_40], eax
call pagecache_write_part
mov [rbp+var_19], al
jmp short $+2
loc_431BE:
jmp short $+2
loc_431C0:
mov al, [rbp+var_19]
mov [rbp+var_1], al
jmp loc_43274
loc_431CB:
jmp short $+2
loc_431CD:
jmp short $+2
loc_431CF:
mov rax, [rbp+var_10]
mov rdi, [rax+600h]
mov rsi, [rbp+var_18]
add rsi, 40h ; '@'
mov rax, [rbp+var_18]
mov rdx, [rax+10h]
mov rax, [rbp+var_18]
mov r8, [rax+8]
lea r10, [rbp+var_38]
mov rax, [rbp+var_10]
mov rax, [rax+600h]
mov eax, [rax+80h]
xor ecx, ecx
mov r9d, 1
xor r11d, r11d
mov [rsp+70h+var_70], 0
mov [rsp+70h+var_68], 2
mov [rsp+70h+var_60], 0
mov [rsp+70h+var_58], r10
mov [rsp+70h+var_50], 0
mov [rsp+70h+var_48], 0
mov [rsp+70h+var_40], eax
call pagecache_write_part
mov [rbp+var_19], al
mov [rbp+var_30], 0
mov [rbp+var_28], 1
mov rdi, [rbp+var_18]
add rdi, 140h
lea rsi, [rbp+var_38]
call insert_dynamic
jmp short $+2
loc_4326C:
jmp short $+2
loc_4326E:
mov al, [rbp+var_19]
mov [rbp+var_1], al
loc_43274:
mov al, [rbp+var_1]
add rsp, 70h
pop rbp
retn
| char write_changed_bitmap(long long a1, long long a2)
{
char v3[8]; // [rsp+38h] [rbp-38h] BYREF
int v4; // [rsp+40h] [rbp-30h]
char v5; // [rsp+48h] [rbp-28h]
char v6; // [rsp+57h] [rbp-19h]
long long v7; // [rsp+58h] [rbp-18h]
long long v8; // [rsp+60h] [rbp-10h]
v8 = a1;
v7 = a2;
*(_BYTE *)(a2 + 33) = 1;
if ( !*(_DWORD *)(v7 + 56) )
return pagecache_write_part(
*(_QWORD **)(v8 + 1536),
v7 + 64,
*(_QWORD *)(v7 + 16),
0,
*(_QWORD *)(v7 + 8),
1u,
0,
1u,
0,
0LL,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v8 + 1536) + 128LL));
v6 = pagecache_write_part(
*(_QWORD **)(v8 + 1536),
v7 + 64,
*(_QWORD *)(v7 + 16),
0,
*(_QWORD *)(v7 + 8),
1u,
0,
2u,
0,
v3,
0LL,
0,
*(_DWORD *)(*(_QWORD *)(v8 + 1536) + 128LL));
v4 = 0;
v5 = 1;
insert_dynamic(v7 + 320, v3);
return v6;
}
| write_changed_bitmap:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
JMP 0x00143122
LAB_00143122:
JMP 0x00143124
LAB_00143124:
JMP 0x00143126
LAB_00143126:
JMP 0x00143128
LAB_00143128:
JMP 0x0014312a
LAB_0014312a:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x21],0x1
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x38],0x0
JNZ 0x001431cb
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x40
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RAX + 0x80]
XOR ECX,ECX
MOV R9D,0x1
XOR R10D,R10D
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x1
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x001303f0
MOV byte ptr [RBP + -0x19],AL
JMP 0x001431be
LAB_001431be:
JMP 0x001431c0
LAB_001431c0:
MOV AL,byte ptr [RBP + -0x19]
MOV byte ptr [RBP + -0x1],AL
JMP 0x00143274
LAB_001431cb:
JMP 0x001431cd
LAB_001431cd:
JMP 0x001431cf
LAB_001431cf:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x40
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RAX + 0x8]
LEA R10,[RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x600]
MOV EAX,dword ptr [RAX + 0x80]
XOR ECX,ECX
MOV R9D,0x1
XOR R11D,R11D
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x2
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R10
MOV qword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x001303f0
MOV byte ptr [RBP + -0x19],AL
MOV dword ptr [RBP + -0x30],0x0
MOV byte ptr [RBP + -0x28],0x1
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x140
LEA RSI,[RBP + -0x38]
CALL 0x001dbcc0
JMP 0x0014326c
LAB_0014326c:
JMP 0x0014326e
LAB_0014326e:
MOV AL,byte ptr [RBP + -0x19]
MOV byte ptr [RBP + -0x1],AL
LAB_00143274:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x70
POP RBP
RET
|
int8 write_changed_bitmap(long param_1,long param_2)
{
int8 uVar1;
int7 uVar2;
int1 local_40 [8];
int4 local_38;
int1 local_30;
int1 local_21;
long local_20;
long local_18;
int1 local_9;
*(int1 *)(param_2 + 0x21) = 1;
local_20 = param_2;
local_18 = param_1;
if (*(int *)(param_2 + 0x38) == 0) {
uVar1 = pagecache_write_part
(*(int8 *)(param_1 + 0x600),param_2 + 0x40,
*(int8 *)(param_2 + 0x10),0,*(int8 *)(param_2 + 8),1,0,1,0,0,0,0,
*(int4 *)(*(long *)(param_1 + 0x600) + 0x80));
local_9 = (int1)uVar1;
uVar2 = (int7)((ulong)uVar1 >> 8);
}
else {
local_21 = pagecache_write_part
(*(int8 *)(param_1 + 0x600),param_2 + 0x40,
*(int8 *)(param_2 + 0x10),0,*(int8 *)(param_2 + 8),1,0,2,0,
local_40,0,0,*(int4 *)(*(long *)(param_1 + 0x600) + 0x80));
local_38 = 0;
local_30 = 1;
uVar1 = insert_dynamic(local_20 + 0x140,local_40);
uVar2 = (int7)((ulong)uVar1 >> 8);
local_9 = local_21;
}
return CONCAT71(uVar2,local_9);
}
| |
22,404 | inline_mysql_file_chsize | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_chsize(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, my_off_t newlength, int filler, 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_descriptor_locker)(&state, file, PSI_FILE_CHSIZE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) newlength, src_file,
src_line);
result= my_chsize(file, newlength, filler, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) newlength);
return result;
}
#endif
result= my_chsize(file, newlength, filler, flags);
return result;
} | O3 | c | inline_mysql_file_chsize:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x2f51c7(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
movl %r14d, %esi
movl $0xd, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x90e7d
movl %r14d, %edi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x9dc8c
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %r15
movq %rax, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x2e7ec
movl (%r15), %eax
jmp 0x90e72
| inline_mysql_file_chsize_1:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 58h
mov rbx, rsi
mov r14d, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_68]
mov esi, r14d
mov edx, 0Dh
call qword ptr [rax+158h]
test rax, rax
jnz short loc_90E7D
mov edi, r14d
mov rsi, rbx
xor edx, edx
xor ecx, ecx
call my_chsize
loc_90E72:
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_90E7D:
lea r15, [rbp+var_1C]
mov rdi, rax
mov rsi, rbx
mov edx, r14d
mov rcx, r15
call inline_mysql_file_chsize_cold_1_0
mov eax, [r15]
jmp short loc_90E72
| long long inline_mysql_file_chsize_1(unsigned int a1, long long a2)
{
long long v2; // rax
_BYTE v4[76]; // [rsp+8h] [rbp-68h] BYREF
_DWORD v5[7]; // [rsp+54h] [rbp-1Ch] BYREF
v2 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v4, a1, 13LL);
if ( !v2 )
return my_chsize(a1, a2, 0LL, 0LL);
inline_mysql_file_chsize_cold_1_0(v2, a2, a1, v5);
return v5[0];
}
| inline_mysql_file_chsize:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV RBX,RSI
MOV R14D,EDI
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x68]
MOV ESI,R14D
MOV EDX,0xd
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00190e7d
MOV EDI,R14D
MOV RSI,RBX
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0019dc8c
LAB_00190e72:
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00190e7d:
LEA R15,[RBP + -0x1c]
MOV RDI,RAX
MOV RSI,RBX
MOV EDX,R14D
MOV RCX,R15
CALL 0x0012e7ec
MOV EAX,dword ptr [R15]
JMP 0x00190e72
|
ulong inline_mysql_file_chsize(int4 param_1,int8 param_2)
{
long lVar1;
ulong uVar2;
int1 local_70 [76];
uint local_24;
lVar1 = (**(code **)(PSI_server + 0x158))(local_70,param_1,0xd);
if (lVar1 == 0) {
uVar2 = my_chsize(param_1,param_2,0,0);
}
else {
inline_mysql_file_chsize_cold_1(lVar1,param_2,param_1,&local_24);
uVar2 = (ulong)local_24;
}
return uVar2;
}
| |
22,405 | stbi__jpeg_test(stbi__context*) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static int stbi__jpeg_test(stbi__context *s)
{
int r;
stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
if (!j) return stbi__err("outofmem", "Out of memory");
memset(j, 0, sizeof(stbi__jpeg));
j->s = s;
stbi__setup_jpeg(j);
r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
stbi__rewind(s);
STBI_FREE(j);
return r;
} | O0 | c | stbi__jpeg_test(stbi__context*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x4888, %edi # imm = 0x4888
callq 0x78ac0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x8eda2
leaq 0x1c24f4(%rip), %rdi # 0x25128b
callq 0x77500
movl %eax, 0x24(%rsp)
jmp 0x8edf9
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x4888, %edx # imm = 0x4888
callq 0x616d0
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
callq 0x96990
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x96a10
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x907c0
movq 0x8(%rsp), %rdi
callq 0x613a0
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZL15stbi__jpeg_testP13stbi__context:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov edi, 4888h; unsigned __int64
call _ZL12stbi__mallocm; stbi__malloc(ulong)
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jnz short loc_8EDA2
lea rdi, aOutofmem; "outofmem"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+28h+var_4], eax
jmp short loc_8EDF9
loc_8EDA2:
mov rdi, [rsp+28h+var_20]
xor esi, esi
mov edx, 4888h
call _memset
mov rcx, [rsp+28h+var_10]
mov rax, [rsp+28h+var_20]
mov [rax], rcx
mov rdi, [rsp+28h+var_20]
call _ZL16stbi__setup_jpegP10stbi__jpeg; stbi__setup_jpeg(stbi__jpeg *)
mov rdi, [rsp+28h+var_20]
mov esi, 1
call _ZL24stbi__decode_jpeg_headerP10stbi__jpegi; stbi__decode_jpeg_header(stbi__jpeg *,int)
mov [rsp+28h+var_14], eax
mov rdi, [rsp+28h+var_10]
call _ZL12stbi__rewindP13stbi__context; stbi__rewind(stbi__context *)
mov rdi, [rsp+28h+var_20]
call _free
mov eax, [rsp+28h+var_14]
mov [rsp+28h+var_4], eax
loc_8EDF9:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long stbi__jpeg_test(long long a1)
{
_QWORD *v2; // [rsp+8h] [rbp-20h]
unsigned int v3; // [rsp+14h] [rbp-14h]
v2 = (_QWORD *)stbi__malloc(18568LL);
if ( v2 )
{
memset(v2, 0LL, 18568LL);
*v2 = a1;
stbi__setup_jpeg(v2);
v3 = stbi__decode_jpeg_header(v2, 1LL);
stbi__rewind(a1);
free(v2);
return v3;
}
else
{
return (unsigned int)stbi__err("outofmem");
}
}
| stbi__jpeg_test:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV EDI,0x4888
CALL 0x00178ac0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x0018eda2
LEA RDI,[0x35128b]
CALL 0x00177500
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0018edf9
LAB_0018eda2:
MOV RDI,qword ptr [RSP + 0x8]
XOR ESI,ESI
MOV EDX,0x4888
CALL 0x001616d0
MOV RCX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00196990
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1
CALL 0x00196a10
MOV dword ptr [RSP + 0x14],EAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001907c0
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001613a0
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x24],EAX
LAB_0018edf9:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
/* stbi__jpeg_test(stbi__context*) */
int4 stbi__jpeg_test(stbi__context *param_1)
{
stbi__jpeg *__s;
int4 local_4;
__s = (stbi__jpeg *)stbi__malloc(0x4888);
if (__s == (stbi__jpeg *)0x0) {
local_4 = stbi__err("outofmem");
}
else {
memset(__s,0,0x4888);
*(stbi__context **)__s = param_1;
stbi__setup_jpeg(__s);
local_4 = stbi__decode_jpeg_header(__s,1);
stbi__rewind(param_1);
free(__s);
}
return local_4;
}
| |
22,406 | stbi__jpeg_test(stbi__context*) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static int stbi__jpeg_test(stbi__context *s)
{
int r;
stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg));
if (!j) return stbi__err("outofmem", "Out of memory");
memset(j, 0, sizeof(stbi__jpeg));
j->s = s;
stbi__setup_jpeg(j);
r = stbi__decode_jpeg_header(j, STBI__SCAN_type);
stbi__rewind(s);
STBI_FREE(j);
return r;
} | O3 | c | stbi__jpeg_test(stbi__context*):
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x4888, %esi # imm = 0x4888
callq 0x1d7f0
testq %rax, %rax
je 0x390b8
movq %rax, %r14
movq %rbx, (%rax)
leaq 0x700e(%rip), %rax # 0x4004b
movq %rax, 0x4870(%r14)
leaq 0x7769(%rip), %rax # 0x407b4
movq %rax, 0x4878(%r14)
leaq 0x795b(%rip), %rax # 0x409b4
movq %rax, 0x4880(%r14)
movl $0xffffffff, 0x484c(%r14) # imm = 0xFFFFFFFF
movb $-0x1, 0x4828(%r14)
movq %r14, %rdi
callq 0x40b4d
movl $0x1, %ebp
cmpb $-0x28, %al
je 0x390a0
movq %fs:0x0, %rax
leaq 0xd26d8(%rip), %rcx # 0x10b76f
movq %rcx, -0x20(%rax)
xorl %ebp, %ebp
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
movq %r14, %rdi
callq 0x1de80
jmp 0x390d4
movq %fs:0x0, %rax
leaq 0xd2508(%rip), %rcx # 0x10b5d3
movq %rcx, -0x20(%rax)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| _ZL15stbi__jpeg_testP13stbi__context:
push rbp
push r14
push rbx
mov rbx, rdi
mov edi, 1
mov esi, 4888h
call _calloc
test rax, rax
jz loc_390B8
mov r14, rax
mov [rax], rbx
lea rax, _ZL15stbi__idct_simdPhiPs; stbi__idct_simd(uchar *,int,short *)
mov [r14+4870h], rax
lea rax, _ZL23stbi__YCbCr_to_RGB_simdPhPKhS1_S1_ii; stbi__YCbCr_to_RGB_simd(uchar *,uchar const*,uchar const*,uchar const*,int,int)
mov [r14+4878h], rax
lea rax, _ZL28stbi__resample_row_hv_2_simdPhS_S_ii; stbi__resample_row_hv_2_simd(uchar *,uchar *,uchar *,int,int)
mov [r14+4880h], rax
mov dword ptr [r14+484Ch], 0FFFFFFFFh
mov byte ptr [r14+4828h], 0FFh
mov rdi, r14
call _ZL16stbi__get_markerP10stbi__jpeg; stbi__get_marker(stbi__jpeg *)
mov ebp, 1
cmp al, 0D8h
jz short loc_390A0
mov rax, fs:0
lea rcx, aNoSoi; "no SOI"
mov [rax-20h], rcx
xor ebp, ebp
loc_390A0:
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
mov rdi, r14
call _free
jmp short loc_390D4
loc_390B8:
mov rax, fs:0
lea rcx, aOutofmem; "outofmem"
mov [rax-20h], rcx
xor ebp, ebp
loc_390D4:
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
| long long stbi__jpeg_test(long long a1)
{
long long v1; // rax
long long v2; // r14
unsigned int v3; // ebp
v1 = calloc(1LL, 18568LL);
if ( v1 )
{
v2 = v1;
*(_QWORD *)v1 = a1;
*(_QWORD *)(v1 + 18544) = stbi__idct_simd;
*(_QWORD *)(v1 + 18552) = stbi__YCbCr_to_RGB_simd;
*(_QWORD *)(v1 + 18560) = stbi__resample_row_hv_2_simd;
*(_DWORD *)(v1 + 18508) = -1;
*(_BYTE *)(v1 + 18472) = -1;
v3 = 1;
if ( (unsigned __int8)stbi__get_marker(v1) != 0xD8 )
{
*(_QWORD *)(__readfsqword(0) - 32) = "no SOI";
v3 = 0;
}
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
free(v2);
}
else
{
*(_QWORD *)(__readfsqword(0) - 32) = "outofmem";
return 0;
}
return v3;
}
| stbi__jpeg_test:
PUSH RBP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV EDI,0x1
MOV ESI,0x4888
CALL 0x0011d7f0
TEST RAX,RAX
JZ 0x001390b8
MOV R14,RAX
MOV qword ptr [RAX],RBX
LEA RAX,[0x14004b]
MOV qword ptr [R14 + 0x4870],RAX
LEA RAX,[0x1407b4]
MOV qword ptr [R14 + 0x4878],RAX
LEA RAX,[0x1409b4]
MOV qword ptr [R14 + 0x4880],RAX
MOV dword ptr [R14 + 0x484c],0xffffffff
MOV byte ptr [R14 + 0x4828],0xff
MOV RDI,R14
CALL 0x00140b4d
MOV EBP,0x1
CMP AL,0xd8
JZ 0x001390a0
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x20b76f]
MOV qword ptr [RAX + -0x20],RCX
XOR EBP,EBP
LAB_001390a0:
MOVUPS XMM0,xmmword ptr [RBX + 0xd0]
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
MOV RDI,R14
CALL 0x0011de80
JMP 0x001390d4
LAB_001390b8:
MOV RAX,qword ptr FS:[0x0]
LEA RCX,[0x20b5d3]
MOV qword ptr [RAX + -0x20],RCX
XOR EBP,EBP
LAB_001390d4:
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
|
/* stbi__jpeg_test(stbi__context*) */
bool stbi__jpeg_test(stbi__context *param_1)
{
char cVar1;
stbi__jpeg *__ptr;
long *in_FS_OFFSET;
bool bVar2;
__ptr = (stbi__jpeg *)calloc(1,0x4888);
if (__ptr == (stbi__jpeg *)0x0) {
*(char **)(*in_FS_OFFSET + -0x20) = "outofmem";
bVar2 = false;
}
else {
*(stbi__context **)__ptr = param_1;
*(code **)(__ptr + 0x4870) = stbi__idct_simd;
*(code **)(__ptr + 0x4878) = stbi__YCbCr_to_RGB_simd;
*(code **)(__ptr + 0x4880) = stbi__resample_row_hv_2_simd;
*(int4 *)(__ptr + 0x484c) = 0xffffffff;
__ptr[0x4828] = (stbi__jpeg)0xff;
cVar1 = stbi__get_marker(__ptr);
bVar2 = cVar1 == -0x28;
if (!bVar2) {
*(char **)(*in_FS_OFFSET + -0x20) = "no SOI";
}
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 0xd0);
*(int8 *)(param_1 + 200) = *(int8 *)(param_1 + 0xd8);
free(__ptr);
}
return bVar2;
}
| |
22,407 | format_literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | static std::string format_literal(const std::string & literal) {
std::string escaped = replacePattern(literal, GRAMMAR_LITERAL_ESCAPE_RE, [&](const std::smatch & match) {
char c = match.str()[0];
return GRAMMAR_LITERAL_ESCAPES.at(c);
});
return "\"" + escaped + "\"";
} | O2 | cpp | format_literal(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 $0x98, %rsp
movq %rdi, 0x28(%rsp)
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rcx
movaps %xmm0, (%rcx)
leaq 0x190(%rip), %rax # 0x8d128
movq %rax, 0x18(%rcx)
leaq 0x1d7(%rip), %rax # 0x8d17a
movq %rax, 0x10(%rcx)
movq %rsp, %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rsi), %r14
movq 0x8(%rsi), %r12
addq %r14, %r12
leaq 0x7333b(%rip), %r13 # 0x100310
leaq 0x30(%rsp), %rbp
leaq 0x78(%rsp), %rbx
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
callq 0x50e3a
testb %al, %al
je 0x8d05e
movq %r15, %rdi
xorl %esi, %esi
callq 0x628ce
addq %r14, %rax
movq %rbp, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x93446
movq %rbx, %rdi
leaq 0x50(%rsp), %rsi
movq %r15, %rdx
callq 0x9345c
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x24130
movq %rbx, %rdi
callq 0x241c8
movq 0x8(%rsp), %rcx
movq %rcx, %rax
subq (%rsp), %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
leaq -0x18(%rcx), %rdx
addq $-0x48, %rcx
cmpq $0x4, %rax
cmovaeq %rdx, %rcx
movq (%rcx), %r14
jmp 0x8cfdf
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x93446
movq %rsp, %rdi
callq 0x51368
leaq 0x50(%rsp), %rdi
callq 0x49072
leaq 0x2eb1d(%rip), %rsi # 0xbbba4
movq %rsp, %rdi
leaq 0x30(%rsp), %rdx
callq 0x3aa98
leaq 0x2eb09(%rip), %rdx # 0xbbba4
movq %rsp, %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3983c
movq %rsp, %rdi
callq 0x241c8
leaq 0x30(%rsp), %rdi
callq 0x241c8
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x241c8
jmp 0x8d0e2
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x241c8
jmp 0x8d120
jmp 0x8d101
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x241c8
jmp 0x8d104
jmp 0x8d101
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x241c8
movq %rsp, %rdi
callq 0x51368
leaq 0x50(%rsp), %rdi
callq 0x49072
movq %rbx, %rdi
callq 0x23f80
| _ZL14format_literalRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_A0], rdi
xorps xmm0, xmm0
lea rcx, [rsp+0C8h+var_78]
movaps xmmword ptr [rcx], xmm0
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_13match_resultsIN9__gnu_cxx17__normal_iteratorIPKcS5_EESaINS0_9sub_matchISB_EEEEEEZL14format_literalRKS5_E3$_0E9_M_invokeERKSt9_Any_dataSH_; std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_invoke(std::_Any_data const&,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)
mov [rcx+18h], rax
lea rax, _ZNSt17_Function_handlerIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_13match_resultsIN9__gnu_cxx17__normal_iteratorIPKcS5_EESaINS0_9sub_matchISB_EEEEEEZL14format_literalRKS5_E3$_0E10_M_managerERSt9_Any_dataRKSN_St18_Manager_operation; std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rcx+10h], rax
mov r15, rsp
movaps xmmword ptr [r15+10h], xmm0
movaps xmmword ptr [r15], xmm0
lea rax, [rsp+0C8h+var_88]
mov [rax-10h], rax
and qword ptr [rax-8], 0
mov byte ptr [rax], 0
mov r14, [rsi]
mov r12, [rsi+8]
add r12, r14
lea r13, _Z25GRAMMAR_LITERAL_ESCAPE_REB5cxx11; GRAMMAR_LITERAL_ESCAPE_RE
lea rbp, [rsp+0C8h+var_98]
lea rbx, [rsp+0C8h+var_50]
loc_8CFDF:
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov rcx, r13
xor r8d, r8d
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_8D05E
mov rdi, r15
xor esi, esi
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE8positionEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position(ulong)
add rax, r14
mov rdi, rbp
mov rsi, r14
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendIN9__gnu_cxx17__normal_iteratorIPKcS4_EEvEERS4_T_SC_; std::string::append<__gnu_cxx::__normal_iterator<char const*,std::string>,void>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>)
mov rdi, rbx
lea rsi, [rsp+0C8h+var_78]
mov rdx, r15
call _ZNKSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_13match_resultsIN9__gnu_cxx17__normal_iteratorIPKcS5_EESaINS0_9sub_matchISB_EEEEEEEclESH_; std::function<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)>::operator()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)
mov rdi, rbp
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_; std::string::append(std::string const&)
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rcx, [rsp+0C8h+var_C0]
mov rax, rcx
sub rax, [rsp+0C8h+var_C8]
cqo
push 18h
pop rsi
idiv rsi
lea rdx, [rcx-18h]
add rcx, 0FFFFFFFFFFFFFFB8h
cmp rax, 4
cmovnb rcx, rdx
mov r14, [rcx]
jmp short loc_8CFDF
loc_8D05E:
lea rdi, [rsp+0C8h+var_98]
mov rsi, r14
mov rdx, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendIN9__gnu_cxx17__normal_iteratorIPKcS4_EEvEERS4_T_SC_; std::string::append<__gnu_cxx::__normal_iterator<char const*,std::string>,void>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>)
mov rdi, rsp
call _ZNSt12_Vector_baseINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::_Vector_base<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~_Vector_base()
lea rdi, [rsp+0C8h+var_78]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rsi, aName_2+9; "\""
mov rdi, rsp
lea rdx, [rsp+0C8h+var_98]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aName_2+9; "\""
mov rsi, rsp
mov rbx, [rsp+0C8h+var_A0]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0C8h+var_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8D0E2
mov rbx, rax
loc_8D0E2:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8D120
jmp short loc_8D101
mov rbx, rax
lea rdi, [rsp+arg_70]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_8D104
jmp short $+2
loc_8D101:
mov rbx, rax
loc_8D104:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp
call _ZNSt12_Vector_baseINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::_Vector_base<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~_Vector_base()
lea rdi, [rsp+arg_48]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
loc_8D120:
mov rdi, rbx
call __Unwind_Resume
| long long format_literal(long long a1, long long a2)
{
long long *v2; // r14
long long v3; // r12
long long v4; // rax
long long *v5; // rcx
long long v6; // rbx
long long *v8[5]; // [rsp+0h] [rbp-C8h] BYREF
long long v9; // [rsp+28h] [rbp-A0h]
_QWORD v10[2]; // [rsp+30h] [rbp-98h] BYREF
char v11; // [rsp+40h] [rbp-88h] BYREF
__int128 v12; // [rsp+50h] [rbp-78h] BYREF
long long ( *v13)(); // [rsp+60h] [rbp-68h]
long long ( *v14)(); // [rsp+68h] [rbp-60h]
_BYTE v15[80]; // [rsp+78h] [rbp-50h] BYREF
v9 = a1;
v12 = 0LL;
v14 = std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_invoke;
v13 = std::_Function_handler<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&),format_literal(std::string const&)::$_0>::_M_manager;
memset(v8, 0, 32);
v10[0] = &v11;
v10[1] = 0LL;
v11 = 0;
v2 = *(long long **)a2;
v3 = *(_QWORD *)a2 + *(_QWORD *)(a2 + 8);
while ( std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>(
v2,
v3,
v8,
(long long)&GRAMMAR_LITERAL_ESCAPE_RE[abi:cxx11],
0) )
{
v4 = std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::position((long long *)v8, 0LL);
std::string::append<__gnu_cxx::__normal_iterator<char const*,std::string>,void>(v10, v2, (char *)v2 + v4);
std::function<std::string ()(std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)>::operator()(
v15,
&v12,
v8);
std::string::append(v10, v15);
std::string::~string(v15);
v5 = v8[1] - 9;
if ( (unsigned long long)(((char *)v8[1] - (char *)v8[0]) / 24) >= 4 )
v5 = v8[1] - 3;
v2 = (long long *)*v5;
}
std::string::append<__gnu_cxx::__normal_iterator<char const*,std::string>,void>(v10, v2, v3);
std::_Vector_base<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~_Vector_base(v8);
std::_Function_base::~_Function_base((std::_Function_base *)&v12);
std::operator+<char>((long long)v8, (long long)"\"", (long long)v10);
v6 = v9;
std::operator+<char>(v9, (long long)v8, (long long)"\"");
std::string::~string(v8);
std::string::~string(v10);
return v6;
}
| format_literal:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x28],RDI
XORPS XMM0,XMM0
LEA RCX,[RSP + 0x50]
MOVAPS xmmword ptr [RCX],XMM0
LEA RAX,[0x18d128]
MOV qword ptr [RCX + 0x18],RAX
LEA RAX,[0x18d17a]
MOV qword ptr [RCX + 0x10],RAX
MOV R15,RSP
MOVAPS xmmword ptr [R15 + 0x10],XMM0
MOVAPS xmmword ptr [R15],XMM0
LEA RAX,[RSP + 0x40]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
MOV R14,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
ADD R12,R14
LEA R13,[0x200310]
LEA RBP,[RSP + 0x30]
LEA RBX,[RSP + 0x78]
LAB_0018cfdf:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
MOV RCX,R13
XOR R8D,R8D
CALL 0x00150e3a
TEST AL,AL
JZ 0x0018d05e
MOV RDI,R15
XOR ESI,ESI
CALL 0x001628ce
ADD RAX,R14
MOV RDI,RBP
MOV RSI,R14
MOV RDX,RAX
CALL 0x00193446
LAB_0018d012:
MOV RDI,RBX
LEA RSI,[RSP + 0x50]
MOV RDX,R15
CALL 0x0019345c
LAB_0018d022:
MOV RDI,RBP
MOV RSI,RBX
CALL 0x00124130
MOV RDI,RBX
CALL 0x001241c8
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,RCX
SUB RAX,qword ptr [RSP]
CQO
PUSH 0x18
POP RSI
IDIV RSI
LEA RDX,[RCX + -0x18]
ADD RCX,-0x48
CMP RAX,0x4
CMOVNC RCX,RDX
MOV R14,qword ptr [RCX]
JMP 0x0018cfdf
LAB_0018d05e:
LEA RDI,[RSP + 0x30]
MOV RSI,R14
MOV RDX,R12
CALL 0x00193446
MOV RDI,RSP
CALL 0x00151368
LEA RDI,[RSP + 0x50]
CALL 0x00149072
LAB_0018d080:
LEA RSI,[0x1bbba4]
MOV RDI,RSP
LEA RDX,[RSP + 0x30]
CALL 0x0013aa98
LAB_0018d094:
LEA RDX,[0x1bbba4]
MOV RSI,RSP
MOV RBX,qword ptr [RSP + 0x28]
MOV RDI,RBX
CALL 0x0013983c
LAB_0018d0ab:
MOV RDI,RSP
CALL 0x001241c8
LEA RDI,[RSP + 0x30]
CALL 0x001241c8
MOV RAX,RBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* format_literal(std::__cxx11::string const&) */
string * format_literal(string *param_1)
{
string *psVar1;
bool bVar2;
long lVar3;
long *plVar4;
long *in_RSI;
long lVar5;
long lVar6;
long local_c8;
long lStack_c0;
int8 local_b8;
int8 uStack_b0;
string *local_a0;
int1 *local_98;
int8 local_90;
int1 local_88 [16];
int8 local_78;
int8 uStack_70;
code *local_68;
code *local_60;
function<std::__cxx11::string(std::__cxx11::match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>const&)>
local_50 [32];
local_78 = 0;
uStack_70 = 0;
local_60 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>const&),format_literal(std::__cxx11::string_const&)::$_0>
::_M_invoke;
local_68 = std::
_Function_handler<std::__cxx11::string(std::__cxx11::match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>const&),format_literal(std::__cxx11::string_const&)::$_0>
::_M_manager;
local_b8 = 0;
uStack_b0 = 0;
local_c8 = 0;
lStack_c0 = 0;
local_98 = local_88;
local_90 = 0;
local_88[0] = 0;
lVar6 = *in_RSI;
lVar5 = in_RSI[1] + lVar6;
local_a0 = param_1;
while( true ) {
/* try { // try from 0018cfdf to 0018d011 has its CatchHandler @ 0018d101 */
bVar2 = std::__detail::
__regex_algo_impl<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>,char,std::__cxx11::regex_traits<char>,(std::__detail::_RegexExecutorPolicy)0,false>
(lVar6,lVar5,&local_c8,GRAMMAR_LITERAL_ESCAPE_RE_abi_cxx11_,0);
if (!bVar2) break;
lVar3 = std::__cxx11::
match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::position((match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
*)&local_c8,0);
std::__cxx11::string::
append<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,void>
((string *)&local_98,lVar6,lVar3 + lVar6);
/* try { // try from 0018d012 to 0018d021 has its CatchHandler @ 0018d0ff */
std::
function<std::__cxx11::string(std::__cxx11::match_results<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>const&)>
::operator()(local_50,(match_results *)&local_78);
/* try { // try from 0018d022 to 0018d02c has its CatchHandler @ 0018d0f0 */
std::__cxx11::string::append((string *)&local_98);
std::__cxx11::string::~string((string *)local_50);
plVar4 = (long *)(lStack_c0 + -0x48);
if (3 < (ulong)((lStack_c0 - local_c8) / 0x18)) {
plVar4 = (long *)(lStack_c0 + -0x18);
}
lVar6 = *plVar4;
}
/* try { // try from 0018d05e to 0018d06d has its CatchHandler @ 0018d0ee */
std::__cxx11::string::append<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,void>
((string *)&local_98,lVar6,lVar5);
std::
_Vector_base<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
::~_Vector_base((_Vector_base<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>,std::allocator<std::__cxx11::sub_match<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>>
*)&local_c8);
std::_Function_base::~_Function_base((_Function_base *)&local_78);
/* try { // try from 0018d080 to 0018d093 has its CatchHandler @ 0018d0df */
std::operator+((char *)&local_c8,(string *)&DAT_001bbba4);
psVar1 = local_a0;
/* try { // try from 0018d094 to 0018d0aa has its CatchHandler @ 0018d0d2 */
std::operator+(local_a0,(char *)&local_c8);
std::__cxx11::string::~string((string *)&local_c8);
std::__cxx11::string::~string((string *)&local_98);
return psVar1;
}
| |
22,408 | void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest.cc | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the flag
// after the exception is caught and either report or re-throw the
// exception based on the flag's value:
//
// try {
// // Perform the test method.
// } catch (...) {
// if (GTEST_FLAG_GET(catch_exceptions))
// // Report the exception as failure.
// else
// throw; // Re-throws the original exception.
// }
//
// However, the purpose of this flag is to allow the program to drop into
// the debugger when the exception is thrown. On most platforms, once the
// control enters the catch block, the exception origin information is
// lost and the debugger will stop the program at the point of the
// re-throw in this function -- instead of at the point of the original
// throw statement in the code under test. For this reason, we perform
// the check early, sacrificing the ability to affect Google Test's
// exception handling in the method where the exception is thrown.
if (internal::GetUnitTestImpl()->catch_exceptions()) {
#if GTEST_HAS_EXCEPTIONS
try {
return HandleSehExceptionsInMethodIfSupported(object, method, location);
} catch (const AssertionException&) { // NOLINT
// This failure was reported already.
} catch (const internal::GoogleTestFailureException&) { // NOLINT
// This exception type can only be thrown by a failed Google
// Test assertion with the intention of letting another testing
// framework catch it. Therefore we just re-throw it.
throw;
} catch (const std::exception& e) { // NOLINT
internal::ReportFailureInUnknownLocation(
TestPartResult::kFatalFailure,
FormatCxxExceptionMessage(e.what(), location));
} catch (...) { // NOLINT
internal::ReportFailureInUnknownLocation(
TestPartResult::kFatalFailure,
FormatCxxExceptionMessage(nullptr, location));
}
return static_cast<Result>(0);
#else
return HandleSehExceptionsInMethodIfSupported(object, method, location);
#endif // GTEST_HAS_EXCEPTIONS
} else {
return (object->*method)();
}
} | O3 | cpp | void testing::internal::HandleExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x18c24
movq 0x24ed4(%rip), %rax # 0x597b0
addq %r15, %r14
cmpb $0x1, 0x2c8(%rax)
jne 0x34908
testb $0x1, %r12b
je 0x348f6
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
callq *%r12
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testb $0x1, %r12b
movq %r12, %rcx
je 0x34919
movq (%r14), %rax
movq -0x1(%rax,%rcx), %rcx
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x4, %r14d
jne 0x3493c
callq 0x81f0
jmp 0x349b0
cmpl $0x3, %r14d
je 0x349bc
callq 0x81f0
cmpl $0x2, %r14d
jne 0x34977
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x30887
leaq 0x8(%rsp), %rsi
movl $0x2, %edi
callq 0x200e2
jmp 0x34995
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x30887
leaq 0x8(%rsp), %rsi
movl $0x2, %edi
callq 0x200e2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x349b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
callq 0x8910
xorl %eax, %eax
jmp 0x348fc
callq 0x81f0
callq 0x87e0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x349e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x349e9
movq %rax, %rbx
callq 0x8910
jmp 0x34a22
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34a13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x34a13
movq %rax, %rbx
callq 0x8910
jmp 0x34a22
movq %rax, %rbx
callq 0x8910
movq %rbx, %rdi
callq 0x8990
movq %rax, %rdi
callq 0x321df
| _ZN7testing8internal35HandleExceptionsInMethodIfSupportedINS0_12UnitTestImplEbEET0_PT_MS4_FS3_vEPKc:
push r15
push r14
push r12
push rbx
sub rsp, 28h
mov rbx, rcx
mov r15, rdx
mov r12, rsi
mov r14, rdi
call _ZN7testing8UnitTest11GetInstanceEv; testing::UnitTest::GetInstance(void)
mov rax, cs:qword_597B0
add r14, r15
cmp byte ptr [rax+2C8h], 1
jnz short loc_34908
test r12b, 1
jz short loc_348F6
mov rax, [r14]
mov r12, [rax+r12-1]
loc_348F6:
mov rdi, r14
call r12
loc_348FC:
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
retn
loc_34908:
test r12b, 1
mov rcx, r12
jz short loc_34919
mov rax, [r14]
mov rcx, [rax+rcx-1]
loc_34919:
mov rdi, r14
add rsp, 28h
pop rbx
pop r12
pop r14
pop r15
jmp rcx
mov r14, rdx
mov rdi, rax; void *
cmp r14d, 4
jnz short loc_3493C
call ___cxa_begin_catch
jmp short loc_349B0
loc_3493C:
cmp r14d, 3
jz short loc_349BC
call ___cxa_begin_catch
cmp r14d, 2
jnz short loc_34977
mov rcx, [rax]
mov rdi, rax
call qword ptr [rcx+10h]
lea rdi, [rsp+48h+var_40]
mov rsi, rax
mov rdx, rbx
call _ZN7testing8internalL25FormatCxxExceptionMessageB5cxx11EPKcS2_; testing::internal::FormatCxxExceptionMessage(char const*,char const*)
lea rsi, [rsp+48h+var_40]; int
mov edi, 2; int
call _ZN7testing8internal30ReportFailureInUnknownLocationENS_14TestPartResult4TypeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type,std::string const&)
jmp short loc_34995
loc_34977:
lea rdi, [rsp+48h+var_40]
xor esi, esi
mov rdx, rbx
call _ZN7testing8internalL25FormatCxxExceptionMessageB5cxx11EPKcS2_; testing::internal::FormatCxxExceptionMessage(char const*,char const*)
lea rsi, [rsp+48h+var_40]; int
mov edi, 2; int
call _ZN7testing8internal30ReportFailureInUnknownLocationENS_14TestPartResult4TypeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type,std::string const&)
loc_34995:
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_349B0
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_349B0:
call ___cxa_end_catch
xor eax, eax
jmp loc_348FC
loc_349BC:
call ___cxa_begin_catch
call ___cxa_rethrow
mov rbx, rax
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_349E9
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_349E9
mov rbx, rax
loc_349E9:
call ___cxa_end_catch
jmp short loc_34A22
mov rbx, rax
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_34A13
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_34A13
mov rbx, rax
loc_34A13:
call ___cxa_end_catch
jmp short loc_34A22
mov rbx, rax
call ___cxa_end_catch
loc_34A22:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,bool>(
testing::UnitTest *a1,
long long ( *a2)(_QWORD),
long long a3)
{
long long ( *v4)(_QWORD *); // r12
_QWORD *v5; // r14
long long ( *v7)(_QWORD *); // rcx
v4 = (long long ( *)(_QWORD *))a2;
testing::UnitTest::GetInstance(a1);
v5 = (_QWORD *)((char *)a1 + a3);
if ( *((_BYTE *)qword_597B0 + 712) == 1 )
{
if ( ((unsigned __int8)a2 & 1) != 0 )
v4 = *(long long ( **)(_QWORD *))((char *)a2 + *v5 - 1);
return v4(v5);
}
else
{
v7 = (long long ( *)(_QWORD *))a2;
if ( ((unsigned __int8)a2 & 1) != 0 )
v7 = *(long long ( **)(_QWORD *))((char *)a2 + *v5 - 1);
return v7(v5);
}
}
| HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,bool>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RCX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
CALL 0x00118c24
MOV RAX,qword ptr [0x001597b0]
ADD R14,R15
CMP byte ptr [RAX + 0x2c8],0x1
JNZ 0x00134908
TEST R12B,0x1
JZ 0x001348f6
MOV RAX,qword ptr [R14]
MOV R12,qword ptr [RAX + R12*0x1 + -0x1]
LAB_001348f6:
MOV RDI,R14
CALL R12
LAB_001348fc:
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00134908:
TEST R12B,0x1
MOV RCX,R12
JZ 0x00134919
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [RAX + RCX*0x1 + -0x1]
LAB_00134919:
MOV RDI,R14
ADD RSP,0x28
POP RBX
POP R12
POP R14
POP R15
JMP RCX
|
/* bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,
bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*)
*/
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl,bool>
(UnitTestImpl *param_1,_func_bool *param_2,char *param_3)
{
bool bVar1;
UnitTestImpl *pUVar2;
UnitTest::GetInstance();
pUVar2 = param_1 + (long)param_3;
if (*(char *)(UnitTest::GetInstance()::instance._64_8_ + 0x2c8) == '\x01') {
if (((ulong)param_2 & 1) != 0) {
param_2 = *(_func_bool **)(param_2 + *(long *)pUVar2 + -1);
}
/* try { // try from 001348f6 to 001348fb has its CatchHandler @ 00134929 */
bVar1 = (*param_2)(pUVar2);
return bVar1;
}
if (((ulong)param_2 & 1) != 0) {
param_2 = *(_func_bool **)(param_2 + *(long *)pUVar2 + -1);
}
/* WARNING: Could not recover jumptable at 0x00134927. Too many branches */
/* WARNING: Treating indirect jump as call */
bVar1 = (*param_2)(pUVar2);
return bVar1;
}
| |
22,409 | my_charset_is_ascii_compatible | eloqsql/strings/ctype-simple.c | static my_bool
my_charset_is_ascii_compatible(CHARSET_INFO *cs)
{
uint i;
if (!cs->tab_to_uni)
return 1;
for (i= 0; i < 128; i++)
{
if (cs->tab_to_uni[i] != i)
return 0;
}
return 1;
} | O0 | c | my_charset_is_ascii_compatible:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0xa39c9
movb $0x1, -0x1(%rbp)
jmp 0xa3a04
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0xa3a00
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x14(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl -0x14(%rbp), %eax
je 0xa39f3
movb $0x0, -0x1(%rbp)
jmp 0xa3a04
jmp 0xa39f5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa39d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
| my_charset_is_ascii_compatible:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_A39C9
mov [rbp+var_1], 1
jmp short loc_A3A04
loc_A39C9:
mov [rbp+var_14], 0
loc_A39D0:
cmp [rbp+var_14], 80h
jnb short loc_A3A00
mov rax, [rbp+var_10]
mov rax, [rax+68h]
mov ecx, [rbp+var_14]
movzx eax, word ptr [rax+rcx*2]
cmp eax, [rbp+var_14]
jz short loc_A39F3
mov [rbp+var_1], 0
jmp short loc_A3A04
loc_A39F3:
jmp short $+2
loc_A39F5:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_A39D0
loc_A3A00:
mov [rbp+var_1], 1
loc_A3A04:
mov al, [rbp+var_1]
pop rbp
retn
| char my_charset_is_ascii_compatible(long long a1)
{
unsigned int i; // [rsp+0h] [rbp-14h]
if ( !*(_QWORD *)(a1 + 104) )
return 1;
for ( i = 0; i < 0x80; ++i )
{
if ( *(unsigned __int16 *)(*(_QWORD *)(a1 + 104) + 2LL * i) != i )
return 0;
}
return 1;
}
| my_charset_is_ascii_compatible:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x001a39c9
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001a3a04
LAB_001a39c9:
MOV dword ptr [RBP + -0x14],0x0
LAB_001a39d0:
CMP dword ptr [RBP + -0x14],0x80
JNC 0x001a3a00
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX EAX,word ptr [RAX + RCX*0x2]
CMP EAX,dword ptr [RBP + -0x14]
JZ 0x001a39f3
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001a3a04
LAB_001a39f3:
JMP 0x001a39f5
LAB_001a39f5:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001a39d0
LAB_001a3a00:
MOV byte ptr [RBP + -0x1],0x1
LAB_001a3a04:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 my_charset_is_ascii_compatible(long param_1)
{
uint local_1c;
if (*(long *)(param_1 + 0x68) != 0) {
for (local_1c = 0; local_1c < 0x80; local_1c = local_1c + 1) {
if (*(ushort *)(*(long *)(param_1 + 0x68) + (ulong)local_1c * 2) != local_1c) {
return 0;
}
}
}
return 1;
}
| |
22,410 | ma_page_setup | eloqsql/storage/maria/ma_page.c | void _ma_page_setup(MARIA_PAGE *page, MARIA_HA *info,
const MARIA_KEYDEF *keyinfo, my_off_t pos,
uchar *buff)
{
MARIA_SHARE *share= info->s;
page->info= info;
page->keyinfo= keyinfo;
page->buff= buff;
page->pos= pos;
page->size= _ma_get_page_used(share, buff);
page->org_size= page->size;
page->flag= _ma_get_keypage_flag(share, buff);
page->node= ((page->flag & KEYPAGE_FLAG_ISNOD) ?
share->base.key_reflength : 0);
} | O3 | c | ma_page_setup:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r8, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movl 0x744(%rax), %ecx
movzwl -0x2(%r8,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movl %ecx, 0x20(%rdi)
movl %ecx, 0x24(%rdi)
movl 0x744(%rax), %ecx
addl $-0x3, %ecx
movzbl (%r8,%rcx), %edx
movl %edx, 0x2c(%rdi)
xorl %ecx, %ecx
testb $0x1, %dl
je 0x3d841
movl 0x3e4(%rax), %ecx
movl %ecx, 0x28(%rdi)
popq %rbp
retq
| _ma_page_setup:
push rbp
mov rbp, rsp
mov rax, [rsi]
mov [rdi], rsi
mov [rdi+8], rdx
mov [rdi+10h], r8
mov [rdi+18h], rcx
mov ecx, [rax+744h]
movzx ecx, word ptr [r8+rcx-2]
rol cx, 8
movzx ecx, cx
mov [rdi+20h], ecx
mov [rdi+24h], ecx
mov ecx, [rax+744h]
add ecx, 0FFFFFFFDh
movzx edx, byte ptr [r8+rcx]
mov [rdi+2Ch], edx
xor ecx, ecx
test dl, 1
jz short loc_3D841
mov ecx, [rax+3E4h]
loc_3D841:
mov [rdi+28h], ecx
pop rbp
retn
| long long ma_page_setup(long long a1, long long *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned __int16 v6; // cx
int v7; // edx
int v8; // ecx
result = *a2;
*(_QWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a3;
*(_QWORD *)(a1 + 16) = a5;
*(_QWORD *)(a1 + 24) = a4;
v6 = __ROL2__(*(_WORD *)(a5 + *(unsigned int *)(result + 1860) - 2), 8);
*(_DWORD *)(a1 + 32) = v6;
*(_DWORD *)(a1 + 36) = v6;
v7 = *(unsigned __int8 *)(a5 + (unsigned int)(*(_DWORD *)(result + 1860) - 3));
*(_DWORD *)(a1 + 44) = v7;
v8 = 0;
if ( (v7 & 1) != 0 )
v8 = *(_DWORD *)(result + 996);
*(_DWORD *)(a1 + 40) = v8;
return result;
}
| _ma_page_setup:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RDI + 0x10],R8
MOV qword ptr [RDI + 0x18],RCX
MOV ECX,dword ptr [RAX + 0x744]
MOVZX ECX,word ptr [R8 + RCX*0x1 + -0x2]
ROL CX,0x8
MOVZX ECX,CX
MOV dword ptr [RDI + 0x20],ECX
MOV dword ptr [RDI + 0x24],ECX
MOV ECX,dword ptr [RAX + 0x744]
ADD ECX,-0x3
MOVZX EDX,byte ptr [R8 + RCX*0x1]
MOV dword ptr [RDI + 0x2c],EDX
XOR ECX,ECX
TEST DL,0x1
JZ 0x0013d841
MOV ECX,dword ptr [RAX + 0x3e4]
LAB_0013d841:
MOV dword ptr [RDI + 0x28],ECX
POP RBP
RET
|
void _ma_page_setup(int8 *param_1,long *param_2,int8 param_3,int8 param_4,
long param_5)
{
byte bVar1;
ushort uVar2;
long lVar3;
uint uVar4;
int4 uVar5;
lVar3 = *param_2;
*param_1 = param_2;
param_1[1] = param_3;
param_1[2] = param_5;
param_1[3] = param_4;
uVar2 = *(ushort *)(param_5 + -2 + (ulong)*(uint *)(lVar3 + 0x744));
uVar4 = (uint)(ushort)(uVar2 << 8 | uVar2 >> 8);
*(uint *)(param_1 + 4) = uVar4;
*(uint *)((long)param_1 + 0x24) = uVar4;
bVar1 = *(byte *)(param_5 + (ulong)(*(int *)(lVar3 + 0x744) - 3));
*(uint *)((long)param_1 + 0x2c) = (uint)bVar1;
uVar5 = 0;
if ((bVar1 & 1) != 0) {
uVar5 = *(int4 *)(lVar3 + 0x3e4);
}
*(int4 *)(param_1 + 5) = uVar5;
return;
}
| |
22,411 | list_walk | eloqsql/mysys/list.c | int list_walk(LIST *list, list_walk_action action, uchar* argument)
{
int error=0;
while (list)
{
if ((error = (*action)(list->data,argument)))
return error;
list=list_rest(list);
}
return 0;
} | O3 | c | list_walk:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x95e9c
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
jne 0x95e9a
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x95e7f
jmp 0x95e9c
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| list_walk:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
xor ebx, ebx
test rdi, rdi
jz short loc_95E9C
mov r14, rdx
mov r15, rsi
mov r12, rdi
loc_95E7F:
mov rdi, [r12+10h]
mov rsi, r14
call r15
test eax, eax
jnz short loc_95E9A
mov r12, [r12+8]
test r12, r12
jnz short loc_95E7F
jmp short loc_95E9C
loc_95E9A:
mov ebx, eax
loc_95E9C:
mov eax, ebx
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long list_walk(long long a1, long long ( *a2)(_QWORD, long long), long long a3)
{
unsigned int v3; // ebx
long long v5; // r12
unsigned int v6; // eax
v3 = 0;
if ( a1 )
{
v5 = a1;
while ( 1 )
{
v6 = a2(*(_QWORD *)(v5 + 16), a3);
if ( v6 )
break;
v5 = *(_QWORD *)(v5 + 8);
if ( !v5 )
return v3;
}
return v6;
}
return v3;
}
| list_walk:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
XOR EBX,EBX
TEST RDI,RDI
JZ 0x00195e9c
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
LAB_00195e7f:
MOV RDI,qword ptr [R12 + 0x10]
MOV RSI,R14
CALL R15
TEST EAX,EAX
JNZ 0x00195e9a
MOV R12,qword ptr [R12 + 0x8]
TEST R12,R12
JNZ 0x00195e7f
JMP 0x00195e9c
LAB_00195e9a:
MOV EBX,EAX
LAB_00195e9c:
MOV EAX,EBX
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int list_walk(long param_1,code *param_2,int8 param_3)
{
int iVar1;
if (param_1 != 0) {
do {
iVar1 = (*param_2)(*(int8 *)(param_1 + 0x10),param_3);
if (iVar1 != 0) {
return iVar1;
}
param_1 = *(long *)(param_1 + 8);
} while (param_1 != 0);
}
return 0;
}
| |
22,412 | my_exit | eloqsql/storage/maria/aria_chk.c | static void my_exit(int exit_code)
{
free_tmpdir(&maria_chk_tmpdir);
free_defaults(default_argv);
my_error_unregister(HA_ERR_FIRST,
HA_ERR_FIRST+ array_elements(handler_error_messages)-1);
my_end(check_param.testflag & T_INFO ?
MY_CHECK_ERROR | MY_GIVE_INFO : MY_CHECK_ERROR);
exit(exit_code);
} | O3 | c | my_exit:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x419bd4(%rip), %rdi # 0x44fcd0
callq 0xbd93c
movq 0x419c48(%rip), %rdi # 0x44fd50
callq 0xb343b
movl $0x78, %edi
movl $0xc6, %esi
callq 0xbf824
movl 0x3f996e(%rip), %edi # 0x42fa90
shrl $0xc, %edi
andl $0x2, %edi
incl %edi
callq 0xc31f7
movl %ebx, %edi
callq 0x2b5f0
| my_exit:
push rbp
mov rbp, rsp
push rbx
push rax
mov ebx, edi
lea rdi, maria_chk_tmpdir
call free_tmpdir
mov rdi, cs:default_argv
call free_defaults
mov edi, 78h ; 'x'
mov esi, 0C6h
call my_error_unregister
mov edi, dword ptr cs:qword_42FA90
shr edi, 0Ch
and edi, 2
inc edi
call my_end
mov edi, ebx
call _exit
| void __noreturn my_exit(unsigned int a1)
{
free_tmpdir(&maria_chk_tmpdir);
free_defaults(default_argv);
my_error_unregister(120LL, 198LL);
my_end((((unsigned int)qword_42FA90 >> 12) & 2) + 1);
exit(a1);
}
| my_exit:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV EBX,EDI
LEA RDI,[0x54fcd0]
CALL 0x001bd93c
MOV RDI,qword ptr [0x0054fd50]
CALL 0x001b343b
MOV EDI,0x78
MOV ESI,0xc6
CALL 0x001bf824
MOV EDI,dword ptr [0x0052fa90]
SHR EDI,0xc
AND EDI,0x2
INC EDI
CALL 0x001c31f7
MOV EDI,EBX
CALL 0x0012b5f0
|
void my_exit(int param_1)
{
free_tmpdir(maria_chk_tmpdir);
free_defaults(default_argv);
my_error_unregister(0x78,0xc6);
my_end(((uint)DAT_0052fa90 >> 0xc & 2) + 1);
/* WARNING: Subroutine does not return */
exit(param_1);
}
| |
22,413 | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) | llama.cpp/common/minja/minja.hpp | static std::string typeToString(Type t) {
switch (t) {
case Type::Text: return "text";
case Type::Expression: return "expression";
case Type::If: return "if";
case Type::Else: return "else";
case Type::Elif: return "elif";
case Type::EndIf: return "endif";
case Type::For: return "for";
case Type::EndFor: return "endfor";
case Type::Set: return "set";
case Type::EndSet: return "endset";
case Type::Comment: return "comment";
case Type::Macro: return "macro";
case Type::EndMacro: return "endmacro";
case Type::Filter: return "filter";
case Type::EndFilter: return "endfilter";
case Type::Generation: return "generation";
case Type::EndGeneration: return "endgeneration";
case Type::Break: return "break";
case Type::Continue: return "continue";
}
return "Unknown";
} | O3 | cpp | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type):
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x12, %esi
ja 0xf34d5
movl %esi, %eax
leaq 0x2eb05(%rip), %rcx # 0x121e80
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2ec1f(%rip), %rsi # 0x121faa
leaq 0x2ec1c(%rip), %rdx # 0x121fae
jmp 0xf34e3
leaq 0x3109b(%rip), %rsi # 0x124439
leaq 0x3109d(%rip), %rdx # 0x124442
jmp 0xf34e3
leaq 0x3105b(%rip), %rsi # 0x12440c
leaq 0x3105c(%rip), %rdx # 0x124414
jmp 0xf34e3
leaq 0x3101e(%rip), %rsi # 0x1243e2
leaq 0x3101d(%rip), %rdx # 0x1243e8
jmp 0xf34e3
leaq 0x30f21(%rip), %rsi # 0x1242f8
leaq 0x30f1e(%rip), %rdx # 0x1242fc
jmp 0xf34e3
leaq 0x31096(%rip), %rsi # 0x124480
leaq 0x31096(%rip), %rdx # 0x124487
jmp 0xf34e3
leaq 0x30f86(%rip), %rsi # 0x124383
leaq 0x30f8c(%rip), %rdx # 0x124390
jmp 0xf34e3
leaq 0x24232(%rip), %rsi # 0x117642
leaq 0x2422d(%rip), %rdx # 0x117644
jmp 0xf34e3
leaq 0x31019(%rip), %rsi # 0x12443c
leaq 0x31018(%rip), %rdx # 0x124442
jmp 0xf34e3
leaq 0x30ee8(%rip), %rsi # 0x12431e
leaq 0x30ee5(%rip), %rdx # 0x124322
jmp 0xf34e3
leaq 0x30f33(%rip), %rsi # 0x12437c
leaq 0x30f32(%rip), %rdx # 0x124382
jmp 0xf34e3
leaq 0x310c5(%rip), %rsi # 0x124521
leaq 0x310c8(%rip), %rdx # 0x12452b
jmp 0xf34e3
leaq 0x30fd7(%rip), %rsi # 0x124443
leaq 0x30fd5(%rip), %rdx # 0x124448
jmp 0xf34e3
leaq 0x30ea7(%rip), %rsi # 0x124323
leaq 0x30ea5(%rip), %rdx # 0x124328
jmp 0xf34e3
leaq 0x30f83(%rip), %rsi # 0x12440f
leaq 0x30f81(%rip), %rdx # 0x124414
jmp 0xf34e3
leaq 0x30ee3(%rip), %rsi # 0x12437f
leaq 0x30edf(%rip), %rdx # 0x124382
jmp 0xf34e3
leaq 0x30f9d(%rip), %rsi # 0x124449
leaq 0x30f9e(%rip), %rdx # 0x124451
jmp 0xf34e3
leaq 0x35901(%rip), %rsi # 0x128dbd
leaq 0x358fd(%rip), %rdx # 0x128dc0
jmp 0xf34e3
leaq 0x285bd(%rip), %rsi # 0x11ba89
leaq 0x285c0(%rip), %rdx # 0x11ba93
jmp 0xf34e3
leaq 0x31d44(%rip), %rsi # 0x125220
leaq 0x31d44(%rip), %rdx # 0x125227
movq %rbx, %rdi
callq 0x2a262
movq %rbx, %rax
popq %rbx
retq
| _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE:
push rbx
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
cmp esi, 12h; switch 19 cases
ja def_F3382; jumptable 00000000000F3382 default case
mov eax, esi
lea rcx, jpt_F3382
movsxd rax, ds:(jpt_F3382 - 121E80h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_F3384:
lea rsi, aText; jumptable 00000000000F3382 case 0
lea rdx, aText+4; ""
jmp loc_F34E3
loc_F3397:
lea rsi, aEndfilter; jumptable 00000000000F3382 case 16
lea rdx, aEndfilter+9; ""
jmp loc_F34E3
loc_F33AA:
lea rsi, aEndmacro; jumptable 00000000000F3382 case 14
lea rdx, aEndmacro+8; ""
jmp loc_F34E3
loc_F33BD:
lea rsi, aEndset; jumptable 00000000000F3382 case 11
lea rdx, aEndset+6; ""
jmp loc_F34E3
loc_F33D0:
lea rsi, aElif; jumptable 00000000000F3382 case 4
lea rdx, aElif+4; ""
jmp loc_F34E3
loc_F33E3:
lea rsi, aInternalErrorE+1Bh; jumptable 00000000000F3382 case 12
lea rdx, aInternalErrorE+22h; ""
jmp loc_F34E3
loc_F33F6:
lea rsi, aEndgeneration; jumptable 00000000000F3382 case 9
lea rdx, aEndgeneration+0Dh; ""
jmp loc_F34E3
loc_F3409:
lea rsi, aIf+1; jumptable 00000000000F3382 case 2
lea rdx, aIf+3; ""
jmp loc_F34E3
loc_F341C:
lea rsi, aEndfilter+3; jumptable 00000000000F3382 case 15
lea rdx, aEndfilter+9; ""
jmp loc_F34E3
loc_F342F:
lea rsi, aElse; jumptable 00000000000F3382 case 3
lea rdx, aElse+4; ""
jmp loc_F34E3
loc_F3442:
lea rsi, aEndfor; jumptable 00000000000F3382 case 7
lea rdx, aEndfor+6; ""
jmp loc_F34E3
loc_F3455:
lea rsi, aExpectedLeftSi_0+24h; jumptable 00000000000F3382 case 1
lea rdx, aExpectedLeftSi_0+2Eh; ""
jmp short loc_F34E3
loc_F3465:
lea rsi, aBreak; jumptable 00000000000F3382 case 17
lea rdx, aBreak+5; ""
jmp short loc_F34E3
loc_F3475:
lea rsi, aEndif; jumptable 00000000000F3382 case 5
lea rdx, aEndif+5; ""
jmp short loc_F34E3
loc_F3485:
lea rsi, aEndmacro+3; jumptable 00000000000F3382 case 13
lea rdx, aEndmacro+8; ""
jmp short loc_F34E3
loc_F3495:
lea rsi, aEndfor+3; jumptable 00000000000F3382 case 6
lea rdx, aEndfor+6; ""
jmp short loc_F34E3
loc_F34A5:
lea rsi, aContinue; jumptable 00000000000F3382 case 18
lea rdx, aContinue+8; ""
jmp short loc_F34E3
loc_F34B5:
lea rsi, aAtLeastOneOfMi+2Fh; jumptable 00000000000F3382 case 10
lea rdx, aAtLeastOneOfMi+32h; ""
jmp short loc_F34E3
loc_F34C5:
lea rsi, aSpeakerFilePat+1Ch; jumptable 00000000000F3382 case 8
lea rdx, aSpeakerFilePat+26h; ""
jmp short loc_F34E3
def_F3382:
lea rsi, aUnknown; jumptable 00000000000F3382 default case
lea rdx, aUnknown+7; ""
loc_F34E3:
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
pop rbx
retn
| _QWORD * minja::TemplateToken::typeToString[abi:cxx11](_QWORD *a1, int a2)
{
char *v2; // rsi
char *v3; // rdx
*a1 = a1 + 2;
switch ( a2 )
{
case 0:
v2 = "text";
v3 = (char *)"";
break;
case 1:
v2 = (char *)"expression";
v3 = (char *)"";
break;
case 2:
v2 = "if";
v3 = "";
break;
case 3:
v2 = "else";
v3 = "";
break;
case 4:
v2 = "elif";
v3 = "";
break;
case 5:
v2 = "endif";
v3 = "";
break;
case 6:
v2 = "for";
v3 = "";
break;
case 7:
v2 = "endfor";
v3 = "";
break;
case 8:
v2 = "generation";
v3 = "";
break;
case 9:
v2 = "endgeneration";
v3 = "";
break;
case 10:
v2 = (char *)"set";
v3 = (char *)"";
break;
case 11:
v2 = "endset";
v3 = "";
break;
case 12:
v2 = (char *)"comment";
v3 = (char *)"";
break;
case 13:
v2 = "macro";
v3 = "";
break;
case 14:
v2 = "endmacro";
v3 = "";
break;
case 15:
v2 = "filter";
v3 = "";
break;
case 16:
v2 = "endfilter";
v3 = "";
break;
case 17:
v2 = "break";
v3 = "";
break;
case 18:
v2 = "continue";
v3 = "";
break;
default:
v2 = "Unknown";
v3 = "";
break;
}
std::string::_M_construct<char const*>((long long)a1, v2, (long long)v3);
return a1;
}
| typeToString[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
CMP ESI,0x12
JA 0x001f34d5
MOV EAX,ESI
LEA RCX,[0x221e80]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[0x221faa]
LEA RDX,[0x221fae]
JMP 0x001f34e3
caseD_10:
LEA RSI,[0x224439]
LEA RDX,[0x224442]
JMP 0x001f34e3
caseD_e:
LEA RSI,[0x22440c]
LEA RDX,[0x224414]
JMP 0x001f34e3
caseD_b:
LEA RSI,[0x2243e2]
LEA RDX,[0x2243e8]
JMP 0x001f34e3
caseD_4:
LEA RSI,[0x2242f8]
LEA RDX,[0x2242fc]
JMP 0x001f34e3
caseD_c:
LEA RSI,[0x224480]
LEA RDX,[0x224487]
JMP 0x001f34e3
caseD_9:
LEA RSI,[0x224383]
LEA RDX,[0x224390]
JMP 0x001f34e3
caseD_2:
LEA RSI,[0x217642]
LEA RDX,[0x217644]
JMP 0x001f34e3
caseD_f:
LEA RSI,[0x22443c]
LEA RDX,[0x224442]
JMP 0x001f34e3
caseD_3:
LEA RSI,[0x22431e]
LEA RDX,[0x224322]
JMP 0x001f34e3
caseD_7:
LEA RSI,[0x22437c]
LEA RDX,[0x224382]
JMP 0x001f34e3
caseD_1:
LEA RSI,[0x224521]
LEA RDX,[0x22452b]
JMP 0x001f34e3
caseD_11:
LEA RSI,[0x224443]
LEA RDX,[0x224448]
JMP 0x001f34e3
caseD_5:
LEA RSI,[0x224323]
LEA RDX,[0x224328]
JMP 0x001f34e3
caseD_d:
LEA RSI,[0x22440f]
LEA RDX,[0x224414]
JMP 0x001f34e3
caseD_6:
LEA RSI,[0x22437f]
LEA RDX,[0x224382]
JMP 0x001f34e3
caseD_12:
LEA RSI,[0x224449]
LEA RDX,[0x224451]
JMP 0x001f34e3
caseD_a:
LEA RSI,[0x228dbd]
LEA RDX,[0x228dc0]
JMP 0x001f34e3
caseD_8:
LEA RSI,[0x21ba89]
LEA RDX,[0x21ba93]
JMP 0x001f34e3
default:
LEA RSI,[0x225220]
LEA RDX,[0x225227]
LAB_001f34e3:
MOV RDI,RBX
CALL 0x0012a262
MOV RAX,RBX
POP RBX
RET
|
/* minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) */
TemplateToken * __thiscall
minja::TemplateToken::typeToString_abi_cxx11_(TemplateToken *this,int4 param_2)
{
char *pcVar1;
char *pcVar2;
*(TemplateToken **)this = this + 0x10;
switch(param_2) {
case 0:
pcVar2 = "text";
pcVar1 = "";
break;
case 1:
pcVar2 = "expression";
pcVar1 = "";
break;
case 2:
pcVar2 = "if";
pcVar1 = "";
break;
case 3:
pcVar2 = "else";
pcVar1 = "";
break;
case 4:
pcVar2 = "elif";
pcVar1 = "";
break;
case 5:
pcVar2 = "endif";
pcVar1 = "";
break;
case 6:
pcVar2 = "for";
pcVar1 = "";
break;
case 7:
pcVar2 = "endfor";
pcVar1 = "";
break;
case 8:
pcVar2 = "generation";
pcVar1 = "";
break;
case 9:
pcVar2 = "endgeneration";
pcVar1 = "";
break;
case 10:
pcVar2 = "set";
pcVar1 = "";
break;
case 0xb:
pcVar2 = "endset";
pcVar1 = "";
break;
case 0xc:
pcVar2 = "comment";
pcVar1 = "";
break;
case 0xd:
pcVar2 = "macro";
pcVar1 = "";
break;
case 0xe:
pcVar2 = "endmacro";
pcVar1 = "";
break;
case 0xf:
pcVar2 = "filter";
pcVar1 = "";
break;
case 0x10:
pcVar2 = "endfilter";
pcVar1 = "";
break;
case 0x11:
pcVar2 = "break";
pcVar1 = "";
break;
case 0x12:
pcVar2 = "continue";
pcVar1 = "";
break;
default:
pcVar2 = "Unknown";
pcVar1 = "";
}
std::__cxx11::string::_M_construct<char_const*>(this,pcVar2,pcVar1);
return this;
}
| |
22,414 | ma_dispose | eloqsql/storage/maria/ma_page.c | int _ma_dispose(register MARIA_HA *info, my_off_t pos, my_bool page_not_read)
{
my_off_t old_link;
uchar buff[MAX_KEYPAGE_HEADER_SIZE+ 8 + 2];
ulonglong page_no;
MARIA_SHARE *share= info->s;
MARIA_PINNED_PAGE page_link;
uint block_size= share->block_size;
int result= 0;
enum pagecache_page_lock lock_method;
enum pagecache_page_pin pin_method;
DBUG_ENTER("_ma_dispose");
DBUG_PRINT("enter",("page: %lu", (ulong) (pos / block_size)));
DBUG_ASSERT(pos % block_size == 0);
(void) _ma_lock_key_del(info, 0);
old_link= share->key_del_current;
share->key_del_current= pos;
page_no= pos / block_size;
bzero(buff, share->keypage_header);
_ma_store_keynr(share, buff, (uchar) MARIA_DELETE_KEY_NR);
_ma_store_page_used(share, buff, share->keypage_header + 8);
mi_sizestore(buff + share->keypage_header, old_link);
share->state.changed|= STATE_NOT_SORTED_PAGES;
if (share->now_transactional)
{
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE * 2];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 1];
my_off_t page;
/* Store address of deleted page */
page_store(log_data + FILEID_STORE_SIZE, page_no);
/* Store link to next unused page (the link that is written to page) */
page= (old_link == HA_OFFSET_ERROR ? IMPOSSIBLE_PAGE_NO :
old_link / block_size);
page_store(log_data + FILEID_STORE_SIZE + PAGE_STORE_SIZE, page);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
if (translog_write_record(&lsn, LOGREC_REDO_INDEX_FREE_PAGE,
info->trn, info,
(translog_size_t) sizeof(log_data),
TRANSLOG_INTERNAL_PARTS + 1, log_array,
log_data, NULL))
result= 1;
}
if (page_not_read)
{
lock_method= PAGECACHE_LOCK_WRITE;
pin_method= PAGECACHE_PIN;
}
else
{
lock_method= PAGECACHE_LOCK_LEFT_WRITELOCKED;
pin_method= PAGECACHE_PIN_LEFT_PINNED;
}
if (pagecache_write_part(share->pagecache,
&share->kfile, (pgcache_page_no_t) page_no,
PAGECACHE_PRIORITY_LOW, buff,
share->page_type,
lock_method, pin_method,
PAGECACHE_WRITE_DELAY, &page_link.link,
LSN_IMPOSSIBLE,
0, share->keypage_header + 8))
result= 1;
#ifdef IDENTICAL_PAGES_AFTER_RECOVERY
{
uchar *page_buff= pagecache_block_link_to_buffer(page_link.link);
bzero(page_buff + share->keypage_header + 8,
block_size - share->keypage_header - 8 - KEYPAGE_CHECKSUM_SIZE);
}
#endif
if (page_not_read)
{
/* It was not locked before, we have to unlock it when we unpin pages */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
}
DBUG_RETURN(result);
} | O0 | c | ma_dispose:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x160, %rsp # imm = 0x160
movb %dl, %al
movq %fs:0x28, %rcx
movq %rcx, -0x18(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movb %al, -0x61(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x9c(%rbp)
movl $0x0, -0xa0(%rbp)
jmp 0x996df
jmp 0x996e1
jmp 0x996e3
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x44be0
movq -0x80(%rbp), %rax
movq 0x700(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rcx
movq -0x80(%rbp), %rax
movq %rcx, 0x700(%rax)
movq -0x60(%rbp), %rax
movl -0x9c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
subl $0x1, %eax
subl $0x1, %eax
subl $0x2, %eax
movl %eax, %eax
movb $-0x1, -0x40(%rbp,%rax)
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
addl $0x8, %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x41(%rbp,%rax)
movl -0xac(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x42(%rbp,%rax)
movq -0x70(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x70(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x3d(%rbp,%rax)
movq -0xc8(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x3e(%rbp,%rax)
movq -0xc8(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x3f(%rbp,%rax)
movq -0xc8(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x40(%rbp,%rax)
movq -0xb8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x39(%rbp,%rax)
movq -0xd0(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x3a(%rbp,%rax)
movq -0xd0(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x3b(%rbp,%rax)
movq -0xd0(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
movb %cl, -0x3c(%rbp,%rax)
movq -0x80(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x170(%rax)
movq -0x80(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x999d9
jmp 0x998be
leaq -0x4c(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x120(%rbp)
movq -0x78(%rbp), %rax
movl %eax, %ecx
movq -0x120(%rbp), %rax
movl %ecx, (%rax)
movq -0x78(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x120(%rbp), %rax
movb %cl, 0x4(%rax)
cmpq $-0x1, -0x70(%rbp)
jne 0x9990a
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
movq %rax, -0x130(%rbp)
jmp 0x99920
movq -0x70(%rbp), %rax
movl -0x9c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x4c(%rbp), %rax
addq $0x2, %rax
addq $0x5, %rax
movq %rax, -0x128(%rbp)
movq -0x118(%rbp), %rax
movl %eax, %ecx
movq -0x128(%rbp), %rax
movl %ecx, (%rax)
movq -0x118(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x128(%rbp), %rax
movb %cl, 0x4(%rax)
leaq -0x4c(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq $0xc, -0xe8(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x58(%rbp), %rcx
leaq -0x110(%rbp), %r10
leaq -0x4c(%rbp), %rax
leaq -0xd8(%rbp), %rdi
movl $0xe, %esi
movl $0xc, %r8d
movl $0x3, %r9d
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x302c0
cmpb $0x0, %al
je 0x999d7
movl $0x1, -0xa0(%rbp)
jmp 0x999d9
cmpb $0x0, -0x61(%rbp)
je 0x999f5
movl $0x4, -0xa4(%rbp)
movl $0x2, -0xa8(%rbp)
jmp 0x99a09
movl $0x2, -0xa4(%rbp)
movl $0x0, -0xa8(%rbp)
movq -0x80(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x80(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x78(%rbp), %rdx
leaq -0x40(%rbp), %r8
movq -0x80(%rbp), %rax
movl 0x7d4(%rax), %r9d
movl -0xa4(%rbp), %ebx
movl -0xa8(%rbp), %r11d
leaq -0x98(%rbp), %r10
movq -0x80(%rbp), %rax
movl 0x744(%rax), %eax
addl $0x8, %eax
xorl %ecx, %ecx
xorl %r14d, %r14d
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movl %eax, 0x30(%rsp)
callq 0x3cb70
cmpb $0x0, %al
je 0x99a95
movl $0x1, -0xa0(%rbp)
cmpb $0x0, -0x61(%rbp)
je 0x99ac3
movl $0x6, -0x90(%rbp)
movb $0x1, -0x88(%rbp)
movq -0x58(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x98(%rbp), %rsi
callq 0xda300
jmp 0x99ac5
movl -0xa0(%rbp), %eax
movl %eax, -0x134(%rbp)
movq %fs:0x28, %rax
movq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0x99af5
movl -0x134(%rbp), %eax
addq $0x160, %rsp # imm = 0x160
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2a250
nopw (%rax,%rax)
| _ma_dispose:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 160h
mov al, dl
mov rcx, fs:28h
mov [rbp+var_18], rcx
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_61], al
mov rax, [rbp+var_58]
mov rax, [rax]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov eax, [rax+7BCh]
mov [rbp+var_9C], eax
mov [rbp+var_A0], 0
jmp short $+2
loc_996DF:
jmp short $+2
loc_996E1:
jmp short $+2
loc_996E3:
mov rdi, [rbp+var_58]
xor esi, esi
call _ma_lock_key_del
mov rax, [rbp+var_80]
mov rax, [rax+700h]
mov [rbp+var_70], rax
mov rcx, [rbp+var_60]
mov rax, [rbp+var_80]
mov [rax+700h], rcx
mov rax, [rbp+var_60]
mov ecx, [rbp+var_9C]
xor edx, edx
div rcx
mov [rbp+var_78], rax
lea rdi, [rbp+var_40]
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov edx, eax
xor esi, esi
call _memset
mov rax, [rbp+var_80]
mov eax, [rax+744h]
sub eax, 1
sub eax, 1
sub eax, 2
mov eax, eax
mov [rbp+rax+var_40], 0FFh
mov rax, [rbp+var_80]
mov eax, [rax+744h]
add eax, 8
mov [rbp+var_AC], eax
mov eax, [rbp+var_AC]
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_41], cl
mov eax, [rbp+var_AC]
shr eax, 8
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_42], cl
mov rax, [rbp+var_70]
mov [rbp+var_B8], rax
mov rax, [rbp+var_70]
shr rax, 20h
mov [rbp+var_C0], rax
mov rax, [rbp+var_C0]
mov [rbp+var_C8], rax
mov rax, [rbp+var_C8]
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_3D], cl
mov rax, [rbp+var_C8]
shr rax, 8
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_3E], cl
mov rax, [rbp+var_C8]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_3F], cl
mov rax, [rbp+var_C8]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_40], cl
mov rax, [rbp+var_B8]
mov [rbp+var_D0], rax
mov rax, [rbp+var_D0]
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_39], cl
mov rax, [rbp+var_D0]
shr rax, 8
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_3A], cl
mov rax, [rbp+var_D0]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_3B], cl
mov rax, [rbp+var_D0]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_80]
mov eax, [rax+744h]
mov [rbp+rax+var_3C], cl
mov rax, [rbp+var_80]
mov ecx, [rax+170h]
or ecx, 20h
mov [rax+170h], ecx
mov rax, [rbp+var_80]
cmp byte ptr [rax+7E7h], 0
jz loc_999D9
jmp short $+2
loc_998BE:
lea rax, [rbp+var_4C]
add rax, 2
mov [rbp+var_120], rax
mov rax, [rbp+var_78]
mov ecx, eax
mov rax, [rbp+var_120]
mov [rax], ecx
mov rax, [rbp+var_78]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_120]
mov [rax+4], cl
cmp [rbp+var_70], 0FFFFFFFFFFFFFFFFh
jnz short loc_9990A
mov rax, 0FFFFFFFFFFh
mov [rbp+var_130], rax
jmp short loc_99920
loc_9990A:
mov rax, [rbp+var_70]
mov ecx, [rbp+var_9C]
xor edx, edx
div rcx
mov [rbp+var_130], rax
loc_99920:
mov rax, [rbp+var_130]
mov [rbp+var_118], rax
lea rax, [rbp+var_4C]
add rax, 2
add rax, 5
mov [rbp+var_128], rax
mov rax, [rbp+var_118]
mov ecx, eax
mov rax, [rbp+var_128]
mov [rax], ecx
mov rax, [rbp+var_118]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_128]
mov [rax+4], cl
lea rax, [rbp+var_4C]
mov [rbp+var_F0], rax
mov [rbp+var_E8], 0Ch
mov rax, [rbp+var_58]
mov rdx, [rax+8]
mov rcx, [rbp+var_58]
lea r10, [rbp+var_110]
lea rax, [rbp+var_4C]
lea rdi, [rbp+var_D8]
mov esi, 0Eh
mov r8d, 0Ch
mov r9d, 3
xor r11d, r11d
mov [rsp+170h+var_170], r10
mov [rsp+170h+var_168], rax
mov [rsp+170h+var_160], 0
call translog_write_record
cmp al, 0
jz short loc_999D7
mov [rbp+var_A0], 1
loc_999D7:
jmp short $+2
loc_999D9:
cmp [rbp+var_61], 0
jz short loc_999F5
mov [rbp+var_A4], 4
mov [rbp+var_A8], 2
jmp short loc_99A09
loc_999F5:
mov [rbp+var_A4], 2
mov [rbp+var_A8], 0
loc_99A09:
mov rax, [rbp+var_80]
mov rdi, [rax+600h]
mov rsi, [rbp+var_80]
add rsi, 750h
mov rdx, [rbp+var_78]
lea r8, [rbp+var_40]
mov rax, [rbp+var_80]
mov r9d, [rax+7D4h]
mov ebx, [rbp+var_A4]
mov r11d, [rbp+var_A8]
lea r10, [rbp+var_98]
mov rax, [rbp+var_80]
mov eax, [rax+744h]
add eax, 8
xor ecx, ecx
xor r14d, r14d
mov dword ptr [rsp+170h+var_170], ebx
mov dword ptr [rsp+170h+var_168], r11d
mov dword ptr [rsp+170h+var_160], 0
mov [rsp+170h+var_158], r10
mov [rsp+170h+var_150], 0
mov [rsp+170h+var_148], 0
mov [rsp+170h+var_140], eax
call pagecache_write_part
cmp al, 0
jz short loc_99A95
mov [rbp+var_A0], 1
loc_99A95:
cmp [rbp+var_61], 0
jz short loc_99AC3
mov [rbp+var_90], 6
mov [rbp+var_88], 1
mov rdi, [rbp+var_58]
add rdi, 2E8h
lea rsi, [rbp+var_98]
call insert_dynamic
loc_99AC3:
jmp short $+2
loc_99AC5:
mov eax, [rbp+var_A0]
mov [rbp+var_134], eax
mov rax, fs:28h
mov rcx, [rbp+var_18]
cmp rax, rcx
jnz short loc_99AF5
mov eax, [rbp+var_134]
add rsp, 160h
pop rbx
pop r14
pop rbp
retn
loc_99AF5:
call ___stack_chk_fail
| long long ma_dispose(long long *a1, unsigned long long a2, char a3)
{
unsigned long long v4; // [rsp+40h] [rbp-130h]
_QWORD v5[7]; // [rsp+60h] [rbp-110h] BYREF
_BYTE v6[8]; // [rsp+98h] [rbp-D8h] BYREF
unsigned long long v7; // [rsp+A0h] [rbp-D0h]
unsigned long long v8; // [rsp+A8h] [rbp-C8h]
unsigned long long v9; // [rsp+B0h] [rbp-C0h]
unsigned long long v10; // [rsp+B8h] [rbp-B8h]
int v11; // [rsp+C4h] [rbp-ACh]
unsigned int v12; // [rsp+C8h] [rbp-A8h]
unsigned int v13; // [rsp+CCh] [rbp-A4h]
unsigned int v14; // [rsp+D0h] [rbp-A0h]
unsigned int v15; // [rsp+D4h] [rbp-9Ch]
char v16[8]; // [rsp+D8h] [rbp-98h] BYREF
int v17; // [rsp+E0h] [rbp-90h]
char v18; // [rsp+E8h] [rbp-88h]
long long v19; // [rsp+F0h] [rbp-80h]
unsigned long long v20; // [rsp+F8h] [rbp-78h]
unsigned long long v21; // [rsp+100h] [rbp-70h]
char v22; // [rsp+10Fh] [rbp-61h]
unsigned long long v23; // [rsp+110h] [rbp-60h]
long long *v24; // [rsp+118h] [rbp-58h]
__int16 v25; // [rsp+124h] [rbp-4Ch] BYREF
int v26; // [rsp+126h] [rbp-4Ah]
char v27; // [rsp+12Ah] [rbp-46h]
int v28; // [rsp+12Bh] [rbp-45h]
char v29; // [rsp+12Fh] [rbp-41h]
_BYTE v30[40]; // [rsp+130h] [rbp-40h] BYREF
unsigned long long v31; // [rsp+158h] [rbp-18h]
v31 = __readfsqword(0x28u);
v24 = a1;
v23 = a2;
v22 = a3;
v19 = *a1;
v15 = *(_DWORD *)(v19 + 1980);
v14 = 0;
ma_lock_key_del(a1, 0);
v21 = *(_QWORD *)(v19 + 1792);
*(_QWORD *)(v19 + 1792) = a2;
v20 = v23 / v15;
memset(v30, 0LL, *(unsigned int *)(v19 + 1860));
v30[*(_DWORD *)(v19 + 1860) - 4] = -1;
v11 = *(_DWORD *)(v19 + 1860) + 8;
v30[*(unsigned int *)(v19 + 1860) - 1] = v11;
*((_BYTE *)&v28 + *(unsigned int *)(v19 + 1860) + 3) = BYTE1(v11);
v10 = v21;
v9 = HIDWORD(v21);
v8 = HIDWORD(v21);
v30[*(unsigned int *)(v19 + 1860) + 3] = BYTE4(v21);
v30[*(unsigned int *)(v19 + 1860) + 2] = BYTE1(v8);
v30[*(unsigned int *)(v19 + 1860) + 1] = BYTE2(v8);
v30[*(unsigned int *)(v19 + 1860)] = BYTE3(v8);
v7 = v10;
v30[*(unsigned int *)(v19 + 1860) + 7] = v10;
v30[*(unsigned int *)(v19 + 1860) + 6] = BYTE1(v7);
v30[*(unsigned int *)(v19 + 1860) + 5] = BYTE2(v7);
v30[*(unsigned int *)(v19 + 1860) + 4] = BYTE3(v7);
*(_DWORD *)(v19 + 368) |= 0x20u;
if ( *(_BYTE *)(v19 + 2023) )
{
v26 = v20;
v27 = BYTE4(v20);
v4 = v21 == -1LL ? 0xFFFFFFFFFFLL : v21 / v15;
v28 = v4;
v29 = BYTE4(v4);
v5[4] = &v25;
v5[5] = 12LL;
if ( translog_write_record((long long)v6, 0xEu, v24[1], v24, 12, 3u, v5, &v25, 0LL) )
v14 = 1;
}
if ( v22 )
{
v13 = 4;
v12 = 2;
}
else
{
v13 = 2;
v12 = 0;
}
if ( pagecache_write_part(
*(_QWORD **)(v19 + 1536),
v19 + 1872,
v20,
0,
(long long)v30,
*(_DWORD *)(v19 + 2004),
v13,
v12,
0,
v16,
0LL,
0,
*(_DWORD *)(v19 + 1860) + 8) )
{
v14 = 1;
}
if ( v22 )
{
v17 = 6;
v18 = 1;
insert_dynamic(v24 + 93, v16);
}
return v14;
}
| _ma_dispose:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x160
MOV AL,DL
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RCX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV byte ptr [RBP + -0x61],AL
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x9c],EAX
MOV dword ptr [RBP + -0xa0],0x0
JMP 0x001996df
LAB_001996df:
JMP 0x001996e1
LAB_001996e1:
JMP 0x001996e3
LAB_001996e3:
MOV RDI,qword ptr [RBP + -0x58]
XOR ESI,ESI
CALL 0x00144be0
MOV RAX,qword ptr [RBP + -0x80]
MOV RAX,qword ptr [RAX + 0x700]
MOV qword ptr [RBP + -0x70],RAX
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX + 0x700],RCX
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x9c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
SUB EAX,0x1
SUB EAX,0x1
SUB EAX,0x2
MOV EAX,EAX
MOV byte ptr [RBP + RAX*0x1 + -0x40],0xff
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
ADD EAX,0x8
MOV dword ptr [RBP + -0xac],EAX
MOV EAX,dword ptr [RBP + -0xac]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x41],CL
MOV EAX,dword ptr [RBP + -0xac]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x42],CL
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x70]
SHR RAX,0x20
MOV qword ptr [RBP + -0xc0],RAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0xc8],RAX
MOV RAX,qword ptr [RBP + -0xc8]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x3d],CL
MOV RAX,qword ptr [RBP + -0xc8]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x3e],CL
MOV RAX,qword ptr [RBP + -0xc8]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x3f],CL
MOV RAX,qword ptr [RBP + -0xc8]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x40],CL
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0xd0],RAX
MOV RAX,qword ptr [RBP + -0xd0]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x39],CL
MOV RAX,qword ptr [RBP + -0xd0]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x3a],CL
MOV RAX,qword ptr [RBP + -0xd0]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x3b],CL
MOV RAX,qword ptr [RBP + -0xd0]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
MOV byte ptr [RBP + RAX*0x1 + -0x3c],CL
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x20
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x80]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x001999d9
JMP 0x001998be
LAB_001998be:
LEA RAX,[RBP + -0x4c]
ADD RAX,0x2
MOV qword ptr [RBP + -0x120],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x120]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x78]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x120]
MOV byte ptr [RAX + 0x4],CL
CMP qword ptr [RBP + -0x70],-0x1
JNZ 0x0019990a
MOV RAX,0xffffffffff
MOV qword ptr [RBP + -0x130],RAX
JMP 0x00199920
LAB_0019990a:
MOV RAX,qword ptr [RBP + -0x70]
MOV ECX,dword ptr [RBP + -0x9c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x130],RAX
LAB_00199920:
MOV RAX,qword ptr [RBP + -0x130]
MOV qword ptr [RBP + -0x118],RAX
LEA RAX,[RBP + -0x4c]
ADD RAX,0x2
ADD RAX,0x5
MOV qword ptr [RBP + -0x128],RAX
MOV RAX,qword ptr [RBP + -0x118]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x128]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x118]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x128]
MOV byte ptr [RAX + 0x4],CL
LEA RAX,[RBP + -0x4c]
MOV qword ptr [RBP + -0xf0],RAX
MOV qword ptr [RBP + -0xe8],0xc
MOV RAX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x58]
LEA R10,[RBP + -0x110]
LEA RAX,[RBP + -0x4c]
LEA RDI,[RBP + -0xd8]
MOV ESI,0xe
MOV R8D,0xc
MOV R9D,0x3
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x001302c0
CMP AL,0x0
JZ 0x001999d7
MOV dword ptr [RBP + -0xa0],0x1
LAB_001999d7:
JMP 0x001999d9
LAB_001999d9:
CMP byte ptr [RBP + -0x61],0x0
JZ 0x001999f5
MOV dword ptr [RBP + -0xa4],0x4
MOV dword ptr [RBP + -0xa8],0x2
JMP 0x00199a09
LAB_001999f5:
MOV dword ptr [RBP + -0xa4],0x2
MOV dword ptr [RBP + -0xa8],0x0
LAB_00199a09:
MOV RAX,qword ptr [RBP + -0x80]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x80]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x78]
LEA R8,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x80]
MOV R9D,dword ptr [RAX + 0x7d4]
MOV EBX,dword ptr [RBP + -0xa4]
MOV R11D,dword ptr [RBP + -0xa8]
LEA R10,[RBP + -0x98]
MOV RAX,qword ptr [RBP + -0x80]
MOV EAX,dword ptr [RAX + 0x744]
ADD EAX,0x8
XOR ECX,ECX
XOR R14D,R14D
MOV dword ptr [RSP],EBX
MOV dword ptr [RSP + 0x8],R11D
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R10
MOV qword ptr [RSP + 0x20],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x30],EAX
CALL 0x0013cb70
CMP AL,0x0
JZ 0x00199a95
MOV dword ptr [RBP + -0xa0],0x1
LAB_00199a95:
CMP byte ptr [RBP + -0x61],0x0
JZ 0x00199ac3
MOV dword ptr [RBP + -0x90],0x6
MOV byte ptr [RBP + -0x88],0x1
MOV RDI,qword ptr [RBP + -0x58]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x98]
CALL 0x001da300
LAB_00199ac3:
JMP 0x00199ac5
LAB_00199ac5:
MOV EAX,dword ptr [RBP + -0xa0]
MOV dword ptr [RBP + -0x134],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,RCX
JNZ 0x00199af5
MOV EAX,dword ptr [RBP + -0x134]
ADD RSP,0x160
POP RBX
POP R14
POP RBP
RET
LAB_00199af5:
CALL 0x0012a250
|
int4 _ma_dispose(long *param_1,ulong param_2,char param_3)
{
char cVar1;
long in_FS_OFFSET;
ulong in_stack_fffffffffffffe98;
ulong local_138;
int1 local_118 [32];
int1 *local_f8;
int8 local_f0;
int1 local_e0 [8];
ulong local_d8;
ulong local_d0;
ulong local_c8;
ulong local_c0;
int local_b4;
int4 local_b0;
int4 local_ac;
int4 local_a8;
uint local_a4;
int1 local_a0 [8];
int4 local_98;
int1 local_90;
long local_88;
ulong local_80;
ulong local_78;
char local_69;
ulong local_68;
long *local_60;
int1 local_54 [2];
int4 local_52;
int1 local_4e;
int4 local_4d;
int1 local_49 [41];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = *param_1;
local_a4 = *(uint *)(local_88 + 0x7bc);
local_a8 = 0;
local_69 = param_3;
local_68 = param_2;
local_60 = param_1;
_ma_lock_key_del(param_1);
local_78 = *(ulong *)(local_88 + 0x700);
*(ulong *)(local_88 + 0x700) = local_68;
local_80 = local_68 / local_a4;
memset(local_49 + 1,0,(ulong)*(uint *)(local_88 + 0x744));
local_49[(ulong)(*(int *)(local_88 + 0x744) - 4) + 1] = 0xff;
local_b4 = *(int *)(local_88 + 0x744) + 8;
local_49[*(uint *)(local_88 + 0x744)] = (char)local_b4;
local_49[(ulong)*(uint *)(local_88 + 0x744) - 1] = (char)((uint)local_b4 >> 8);
local_c0 = local_78;
local_d0 = local_78 >> 0x20;
local_49[(ulong)*(uint *)(local_88 + 0x744) + 4] = (char)(local_78 >> 0x20);
local_49[(ulong)*(uint *)(local_88 + 0x744) + 3] = (char)(local_78 >> 0x28);
local_49[(ulong)*(uint *)(local_88 + 0x744) + 2] = (char)(local_78 >> 0x30);
local_49[(ulong)*(uint *)(local_88 + 0x744) + 1] = (char)(local_78 >> 0x38);
local_d8 = local_78;
local_49[(ulong)*(uint *)(local_88 + 0x744) + 8] = (char)local_78;
local_49[(ulong)*(uint *)(local_88 + 0x744) + 7] = (char)(local_78 >> 8);
local_49[(ulong)*(uint *)(local_88 + 0x744) + 6] = (char)(local_78 >> 0x10);
local_49[(ulong)*(uint *)(local_88 + 0x744) + 5] = (char)(local_78 >> 0x18);
*(uint *)(local_88 + 0x170) = *(uint *)(local_88 + 0x170) | 0x20;
local_c8 = local_d0;
if (*(char *)(local_88 + 0x7e7) != '\0') {
local_52 = (int4)local_80;
local_4e = (int1)(local_80 >> 0x20);
if (local_78 == 0xffffffffffffffff) {
local_138 = 0xffffffffff;
}
else {
local_138 = local_78 / local_a4;
}
local_4d = (int4)local_138;
local_49[0] = (int1)(local_138 >> 0x20);
local_f8 = local_54;
local_f0 = 0xc;
in_stack_fffffffffffffe98 = 0;
cVar1 = translog_write_record(local_e0,0xe,local_60[1],local_60,0xc,3,local_118,local_54,0);
if (cVar1 != '\0') {
local_a8 = 1;
}
}
if (local_69 == '\0') {
local_ac = 2;
local_b0 = 0;
}
else {
local_ac = 4;
local_b0 = 2;
}
cVar1 = pagecache_write_part
(*(int8 *)(local_88 + 0x600),local_88 + 0x750,local_80,0,local_49 + 1,
*(int4 *)(local_88 + 0x7d4),local_ac,local_b0,
in_stack_fffffffffffffe98 & 0xffffffff00000000,local_a0,0,0,
*(int *)(local_88 + 0x744) + 8);
if (cVar1 != '\0') {
local_a8 = 1;
}
if (local_69 != '\0') {
local_98 = 6;
local_90 = 1;
insert_dynamic(local_60 + 0x5d,local_a0);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_20) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_a8;
}
| |
22,415 | YogaTest_aspect_ratio_width_height_flex_grow_row_Test::~YogaTest_aspect_ratio_width_height_flex_grow_row_Test() | yoga-mod/tests/YGAspectRatioTest.cpp | TEST(YogaTest, aspect_ratio_width_height_flex_grow_row) {
YGNodeRef root = YGNodeNew();
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetAlignItems(root, YGAlignFlexStart);
YGNodeStyleSetWidth(root, 100);
YGNodeStyleSetHeight(root, 200);
YGNodeRef root_child0 = YGNodeNew();
YGNodeStyleSetWidth(root_child0, 50);
YGNodeStyleSetHeight(root_child0, 50);
YGNodeStyleSetFlexGrow(root_child0, 1);
YGNodeStyleSetAspectRatio(root_child0, 1);
YGNodeInsertChild(root, root_child0, 0);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
ASSERT_EQ(0, YGNodeLayoutGetLeft(root_child0));
ASSERT_EQ(0, YGNodeLayoutGetTop(root_child0));
ASSERT_EQ(100, YGNodeLayoutGetWidth(root_child0));
ASSERT_EQ(100, YGNodeLayoutGetHeight(root_child0));
YGNodeFreeRecursive(root);
} | O3 | cpp | YogaTest_aspect_ratio_width_height_flex_grow_row_Test::~YogaTest_aspect_ratio_width_height_flex_grow_row_Test():
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x381548
movl $0x10, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x32440
nop
| _ZN53YogaTest_aspect_ratio_width_height_flex_grow_row_TestD0Ev:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _ZN7testing4TestD2Ev; testing::Test::~Test()
mov esi, 10h; unsigned __int64
mov rdi, rbx; void *
add rsp, 8
pop rbx
pop rbp
jmp __ZdlPvm; operator delete(void *,ulong)
| void YogaTest_aspect_ratio_width_height_flex_grow_row_Test::~YogaTest_aspect_ratio_width_height_flex_grow_row_Test(
YogaTest_aspect_ratio_width_height_flex_grow_row_Test *this)
{
testing::Test::~Test(this);
operator delete(this, 0x10uLL);
}
| ~YogaTest_aspect_ratio_width_height_flex_grow_row_Test:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00481548
MOV ESI,0x10
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x00132440
|
/* YogaTest_aspect_ratio_width_height_flex_grow_row_Test::~YogaTest_aspect_ratio_width_height_flex_grow_row_Test()
*/
void __thiscall
YogaTest_aspect_ratio_width_height_flex_grow_row_Test::
~YogaTest_aspect_ratio_width_height_flex_grow_row_Test
(YogaTest_aspect_ratio_width_height_flex_grow_row_Test *this)
{
testing::Test::~Test((Test *)this);
operator_delete(this,0x10);
return;
}
| |
22,416 | spdlog::details::C_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h | void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {
const size_t field_size = 2;
ScopedPadder p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_year % 100, dest);
} | O3 | c | spdlog::details::C_formatter<spdlog::details::scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movslq 0x14(%rdx), %rax
imulq $0x51eb851f, %rax, %rcx # imm = 0x51EB851F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rcx
addl %edx, %ecx
imull $0x64, %ecx, %ecx
subl %ecx, %eax
cmpl $0x63, %eax
ja 0x38819
movzbl %al, %ebp
imull $0xcd, %ebp, %r14d
shrl $0xb, %r14d
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
orb $0x30, %r14b
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x387dd
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %r14b, (%rcx,%rax)
orb $0x30, %bpl
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x3880b
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rbx), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%rbx), %rcx
movq %rsi, 0x10(%rbx)
movb %bpl, (%rcx,%rax)
jmp 0x3883d
movl %eax, %eax
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x49343(%rip), %rsi # 0x81b6b
movl $0x5, %edx
movl $0x1, %ecx
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x4163d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| _ZN6spdlog7details11C_formatterINS0_18null_scoped_padderEE6formatERKNS0_7log_msgERK2tmRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE:
push rbp
push r14
push rbx
sub rsp, 10h
mov rbx, rcx
movsxd rax, dword ptr [rdx+14h]
imul rcx, rax, 51EB851Fh
mov rdx, rcx
shr rdx, 3Fh
sar rcx, 25h
add ecx, edx
imul ecx, 64h ; 'd'
sub eax, ecx
cmp eax, 63h ; 'c'
ja short loc_38819
movzx ebp, al
imul r14d, ebp, 0CDh
shr r14d, 0Bh
lea eax, [r14+r14]
lea eax, [rax+rax*4]
sub bpl, al
or r14b, 30h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_387DD
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_387DD:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], r14b
or bpl, 30h
mov rax, [rbx+10h]
lea rsi, [rax+1]
cmp [rbx+18h], rsi
jnb short loc_3880B
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
mov rax, [rbx+10h]
lea rsi, [rax+1]
loc_3880B:
mov rcx, [rbx+8]
mov [rbx+10h], rsi
mov [rcx+rax], bpl
jmp short loc_3883D
loc_38819:
mov eax, eax
mov r8, rsp
mov [r8], rax
lea rsi, a02; "{:02}"
mov edx, 5
mov ecx, 1
mov rdi, rbx; int
xor r9d, r9d
call _ZN3fmt3v106detail10vformat_toIcEEvRNS1_6bufferIT_EENS0_17basic_string_viewIS4_EENS1_12vformat_argsIS4_E4typeENS1_10locale_refE; fmt::v10::detail::vformat_to<char>(fmt::v10::detail::buffer<char> &,fmt::v10::basic_string_view<char>,fmt::v10::detail::vformat_args<char>::type,fmt::v10::detail::locale_ref)
loc_3883D:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long spdlog::details::C_formatter<spdlog::details::null_scoped_padder>::format(
long long a1,
long long a2,
long long a3,
long long a4)
{
unsigned int v5; // eax
char v6; // bp
char v7; // r14
long long v8; // rax
long long v9; // rsi
long long v10; // rcx
char v11; // bp
long long result; // rax
long long v13; // rsi
long long v14; // rcx
v5 = *(_DWORD *)(a3 + 20) % 100;
if ( v5 > 0x63 )
return fmt::v10::detail::vformat_to<char>(a4);
v6 = (unsigned __int8)v5 % 0xAu;
v7 = ((unsigned __int8)v5 / 0xAu) | 0x30;
v8 = *(_QWORD *)(a4 + 16);
v9 = v8 + 1;
if ( *(_QWORD *)(a4 + 24) < (unsigned long long)(v8 + 1) )
{
(**(void ( ***)(long long))a4)(a4);
v8 = *(_QWORD *)(a4 + 16);
v9 = v8 + 1;
}
v10 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a4 + 16) = v9;
*(_BYTE *)(v10 + v8) = v7;
v11 = v6 | 0x30;
result = *(_QWORD *)(a4 + 16);
v13 = result + 1;
if ( *(_QWORD *)(a4 + 24) < (unsigned long long)(result + 1) )
{
(**(void ( ***)(long long))a4)(a4);
result = *(_QWORD *)(a4 + 16);
v13 = result + 1;
}
v14 = *(_QWORD *)(a4 + 8);
*(_QWORD *)(a4 + 16) = v13;
*(_BYTE *)(v14 + result) = v11;
return result;
}
| format:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RCX
MOVSXD RAX,dword ptr [RDX + 0x14]
IMUL RCX,RAX,0x51eb851f
MOV RDX,RCX
SHR RDX,0x3f
SAR RCX,0x25
ADD ECX,EDX
IMUL ECX,ECX,0x64
SUB EAX,ECX
CMP EAX,0x63
JA 0x00138819
MOVZX EBP,AL
IMUL R14D,EBP,0xcd
SHR R14D,0xb
LEA EAX,[R14 + R14*0x1]
LEA EAX,[RAX + RAX*0x4]
SUB BPL,AL
OR R14B,0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x001387dd
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_001387dd:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],R14B
OR BPL,0x30
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [RBX + 0x18],RSI
JNC 0x0013880b
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
LAB_0013880b:
MOV RCX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],BPL
JMP 0x0013883d
LAB_00138819:
MOV EAX,EAX
MOV R8,RSP
MOV qword ptr [R8],RAX
LEA RSI,[0x181b6b]
MOV EDX,0x5
MOV ECX,0x1
MOV RDI,RBX
XOR R9D,R9D
CALL 0x0014163d
LAB_0013883d:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* spdlog::details::C_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg
const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::C_formatter<spdlog::details::null_scoped_padder>::format
(C_formatter<spdlog::details::null_scoped_padder> *this,log_msg *param_1,tm *param_2,
basic_memory_buffer *param_3)
{
byte bVar1;
uint uVar2;
long lVar3;
ulong uVar4;
ulong local_28 [2];
uVar2 = param_2->tm_year % 100;
if (uVar2 < 100) {
bVar1 = (byte)((uVar2 & 0xff) / 10);
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
if (*(ulong *)(param_3 + 0x18) < uVar4) {
(*(code *)**(int8 **)param_3)(param_3);
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
}
*(ulong *)(param_3 + 0x10) = uVar4;
*(byte *)(*(long *)(param_3 + 8) + lVar3) = bVar1 | 0x30;
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
if (*(ulong *)(param_3 + 0x18) < uVar4) {
(*(code *)**(int8 **)param_3)(param_3);
lVar3 = *(long *)(param_3 + 0x10);
uVar4 = lVar3 + 1;
}
*(ulong *)(param_3 + 0x10) = uVar4;
*(byte *)(*(long *)(param_3 + 8) + lVar3) = (char)uVar2 + bVar1 * -10 | 0x30;
}
else {
local_28[0] = (ulong)uVar2;
fmt::v10::detail::vformat_to<char>(param_3,"{:02}",5,1,local_28,0);
}
return;
}
| |
22,417 | my_snprintf_8bit | eloqsql/strings/ctype-simple.c | size_t my_snprintf_8bit(CHARSET_INFO *cs __attribute__((unused)),
char* to, size_t n __attribute__((unused)),
const char* fmt, ...)
{
va_list args;
size_t result;
va_start(args,fmt);
result= my_vsnprintf(to, n, fmt, args);
va_end(args);
return result;
} | O3 | c | my_snprintf_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, %rdi
leaq -0xd0(%rbp), %rsi
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x3855d
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rsi, 0x10(%rax)
leaq 0x10(%rbp), %rsi
movq %rsi, 0x8(%rax)
movabsq $0x3000000020, %rsi # imm = 0x3000000020
movq %rsi, (%rax)
movq %rdx, %rsi
movq %rcx, %rdx
movq %rax, %rcx
callq 0x5a1d5
addq $0xd0, %rsp
popq %rbp
retq
| my_snprintf_8bit:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rdi, rsi
lea rsi, [rbp+var_D0]
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_3855D
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_3855D:
lea rax, [rbp+var_20]
mov [rax+10h], rsi
lea rsi, [rbp+arg_0]
mov [rax+8], rsi
mov rsi, 3000000020h
mov [rax], rsi
mov rsi, rdx
mov rdx, rcx
mov rcx, rax
call my_vsnprintf
add rsp, 0D0h
pop rbp
retn
| long long my_snprintf_8bit(
__m128 a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14,
char a15)
{
char v16; // [rsp+0h] [rbp-D0h] BYREF
long long v17; // [rsp+20h] [rbp-B0h]
long long v18; // [rsp+28h] [rbp-A8h]
__m128 v19; // [rsp+30h] [rbp-A0h]
__m128 v20; // [rsp+40h] [rbp-90h]
__m128 v21; // [rsp+50h] [rbp-80h]
__m128 v22; // [rsp+60h] [rbp-70h]
__m128 v23; // [rsp+70h] [rbp-60h]
__m128 v24; // [rsp+80h] [rbp-50h]
__m128 v25; // [rsp+90h] [rbp-40h]
__m128 v26; // [rsp+A0h] [rbp-30h]
long long v27; // [rsp+B0h] [rbp-20h]
char *v28; // [rsp+B8h] [rbp-18h]
char *v29; // [rsp+C0h] [rbp-10h]
v19 = a1;
v20 = a2;
v21 = a3;
v22 = a4;
v23 = a5;
v24 = a6;
v25 = a7;
v26 = a8;
v17 = a13;
v18 = a14;
v29 = &v16;
v28 = &a15;
v27 = 0x3000000020LL;
return my_vsnprintf(a10, a11, a12);
}
| my_snprintf_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RDI,RSI
LEA RSI,[RBP + -0xd0]
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x0013855d
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_0013855d:
LEA RAX,[RBP + -0x20]
MOV qword ptr [RAX + 0x10],RSI
LEA RSI,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RSI
MOV RSI,0x3000000020
MOV qword ptr [RAX],RSI
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,RAX
CALL 0x0015a1d5
ADD RSP,0xd0
POP RBP
RET
|
void my_snprintf_8bit(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
int1 local_d8 [32];
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
int1 *local_20;
int1 *local_18;
local_18 = local_d8;
if (in_AL != '\0') {
local_a8 = param_1;
local_98 = param_2;
local_88 = param_3;
local_78 = param_4;
local_68 = param_5;
local_58 = param_6;
local_48 = param_7;
local_38 = param_8;
}
local_20 = &stack0x00000008;
local_28 = 0x3000000020;
local_b8 = param_13;
local_b0 = param_14;
my_vsnprintf(param_10,param_11,param_12,&local_28);
return;
}
| |
22,418 | my_mb_wc_utf8mb4_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0x52dd0
movzbl (%rsi), %ecx
testb %cl, %cl
js 0x52dc9
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0x52dd0
cmpb $-0x3e, %cl
jae 0x52dd2
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0x52e08
leaq 0x2(%rsi), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %r8
ja 0x52dd0
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
movl $0x0, %eax
cmpb $0x3f, %dl
ja 0x52dd0
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0x52dc4
cmpb $-0x11, %cl
ja 0x52e6a
leaq 0x3(%rsi), %r8
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %r8
ja 0x52dd0
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0x52dce
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0x52dce
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
movl $0x0, %eax
testb %r9b, %r8b
jne 0x52dd0
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0x52dc4
cmpb $-0xc, %cl
ja 0x52dce
leaq 0x4(%rsi), %r8
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %r8
ja 0x52dd0
movzbl 0x1(%rsi), %r8d
cmpb $-0x41, %r8b
jg 0x52dce
movzbl 0x2(%rsi), %edx
cmpb $-0x41, %dl
jg 0x52dce
movzbl 0x3(%rsi), %esi
cmpb $-0x41, %sil
jg 0x52dce
cmpl $0xf0, %ecx
sete %al
cmpb $-0x70, %r8b
setb %r9b
testb %r9b, %al
jne 0x52dce
cmpl $0xf4, %ecx
sete %r9b
cmpb $-0x70, %r8b
setae %r10b
movl $0x0, %eax
testb %r10b, %r9b
jne 0x52dd0
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r8d
shll $0xc, %r8d
orl %ecx, %r8d
andl $0x3f, %edx
shll $0x6, %edx
orl %r8d, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x4, %eax
jmp 0x52e62
| my_mb_wc_utf8mb4_quick_0:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_52DD0
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_52DC9
mov eax, 1
loc_52DC4:
mov [rdi], rcx
jmp short loc_52DD0
loc_52DC9:
cmp cl, 0C2h
jnb short loc_52DD2
loc_52DCE:
xor eax, eax
loc_52DD0:
pop rbp
retn
loc_52DD2:
cmp cl, 0DFh
ja short loc_52E08
lea r8, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp r8, rdx
ja short loc_52DD0
movzx edx, byte ptr [rsi+1]
xor edx, 80h
mov eax, 0
cmp dl, 3Fh ; '?'
ja short loc_52DD0
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_52DC4
loc_52E08:
cmp cl, 0EFh
ja short loc_52E6A
lea r8, [rsi+3]
mov eax, 0FFFFFF99h
cmp r8, rdx
ja short loc_52DD0
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_52DCE
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_52DCE
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
mov eax, 0
test r8b, r9b
jnz short loc_52DD0
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
loc_52E62:
mov rcx, rsi
jmp loc_52DC4
loc_52E6A:
cmp cl, 0F4h
ja loc_52DCE
lea r8, [rsi+4]
mov eax, 0FFFFFF98h
cmp r8, rdx
ja loc_52DD0
movzx r8d, byte ptr [rsi+1]
cmp r8b, 0BFh
jg loc_52DCE
movzx edx, byte ptr [rsi+2]
cmp dl, 0BFh
jg loc_52DCE
movzx esi, byte ptr [rsi+3]
cmp sil, 0BFh
jg loc_52DCE
cmp ecx, 0F0h
setz al
cmp r8b, 90h
setb r9b
test al, r9b
jnz loc_52DCE
cmp ecx, 0F4h
setz r9b
cmp r8b, 90h
setnb r10b
mov eax, 0
test r9b, r10b
jnz loc_52DD0
and ecx, 7
shl ecx, 12h
and r8d, 3Fh
shl r8d, 0Ch
or r8d, ecx
and edx, 3Fh
shl edx, 6
or edx, r8d
and esi, 3Fh
or rsi, rdx
mov eax, 4
jmp loc_52E62
| long long my_mb_wc_utf8mb4_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rcx
char v5; // dl
char v6; // si
unsigned long long v7; // rsi
char v8; // r8
char v9; // dl
char v10; // si
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (v4 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_4:
*a1 = v4;
return result;
}
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
if ( (unsigned __int8)v4 > 0xEFu )
{
if ( (unsigned __int8)v4 <= 0xF4u )
{
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v8 = a2[1];
if ( v8 <= -65 )
{
v9 = a2[2];
if ( v9 <= -65 )
{
v10 = a2[3];
if ( v10 <= -65 && ((unsigned __int8)v8 >= 0x90u || (_DWORD)v4 != 240) )
{
result = 0LL;
if ( (unsigned __int8)v8 >= 0x90u && (_DWORD)v4 == 244 )
return result;
v7 = ((v4 & 7) << 18) | ((unsigned __int8)(v8 & 0x3F) << 12) | ((unsigned __int8)(v9 & 0x3F) << 6) | v10 & 0x3F;
result = 4LL;
LABEL_18:
v4 = v7;
goto LABEL_4;
}
}
}
}
}
else
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v5 = a2[1];
if ( v5 <= -65 )
{
v6 = a2[2];
if ( v6 <= -65 )
{
result = 0LL;
if ( (unsigned __int8)v5 < 0xA0u && (_DWORD)v4 == 224 )
return result;
v7 = (unsigned __int16)((_WORD)v4 << 12) | ((unsigned __int8)(v5 & 0x3F) << 6) | (unsigned long long)(v6 & 0x3F);
result = 3LL;
goto LABEL_18;
}
}
}
return 0LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
{
result = 0LL;
if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v4 = a2[1] ^ 0x80 | ((unsigned __int8)(v4 & 0x1F) << 6);
result = 2LL;
goto LABEL_4;
}
}
return result;
}
| my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x00152dd0
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x00152dc9
MOV EAX,0x1
LAB_00152dc4:
MOV qword ptr [RDI],RCX
JMP 0x00152dd0
LAB_00152dc9:
CMP CL,0xc2
JNC 0x00152dd2
LAB_00152dce:
XOR EAX,EAX
LAB_00152dd0:
POP RBP
RET
LAB_00152dd2:
CMP CL,0xdf
JA 0x00152e08
LEA R8,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP R8,RDX
JA 0x00152dd0
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
MOV EAX,0x0
CMP DL,0x3f
JA 0x00152dd0
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x00152dc4
LAB_00152e08:
CMP CL,0xef
JA 0x00152e6a
LEA R8,[RSI + 0x3]
MOV EAX,0xffffff99
CMP R8,RDX
JA 0x00152dd0
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x00152dce
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x00152dce
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
MOV EAX,0x0
TEST R8B,R9B
JNZ 0x00152dd0
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
LAB_00152e62:
MOV RCX,RSI
JMP 0x00152dc4
LAB_00152e6a:
CMP CL,0xf4
JA 0x00152dce
LEA R8,[RSI + 0x4]
MOV EAX,0xffffff98
CMP R8,RDX
JA 0x00152dd0
MOVZX R8D,byte ptr [RSI + 0x1]
CMP R8B,0xbf
JG 0x00152dce
MOVZX EDX,byte ptr [RSI + 0x2]
CMP DL,0xbf
JG 0x00152dce
MOVZX ESI,byte ptr [RSI + 0x3]
CMP SIL,0xbf
JG 0x00152dce
CMP ECX,0xf0
SETZ AL
CMP R8B,0x90
SETC R9B
TEST AL,R9B
JNZ 0x00152dce
CMP ECX,0xf4
SETZ R9B
CMP R8B,0x90
SETNC R10B
MOV EAX,0x0
TEST R9B,R10B
JNZ 0x00152dd0
AND ECX,0x7
SHL ECX,0x12
AND R8D,0x3f
SHL R8D,0xc
OR R8D,ECX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,R8D
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x4
JMP 0x00152e62
|
int8 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
uVar5 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (0xc1 < bVar1) {
uVar4 = (uint)bVar1;
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar5 = (ulong)((uVar4 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
goto LAB_00152dc4;
}
if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
bVar2 = param_2[1];
if (((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) {
if (uVar4 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc;
uVar3 = 3;
LAB_00152e62:
uVar5 = (ulong)uVar4;
goto LAB_00152dc4;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar1 = param_2[1];
if (((((char)bVar1 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) &&
(uVar4 != 0xf0 || 0x8f < bVar1)) {
if (uVar4 == 0xf4 && 0x8f < bVar1) {
return 0;
}
uVar4 = param_2[3] & 0x3f |
(param_2[2] & 0x3f) << 6 | (bVar1 & 0x3f) << 0xc | (uVar4 & 7) << 0x12;
uVar3 = 4;
goto LAB_00152e62;
}
}
}
uVar3 = 0;
}
else {
uVar3 = 1;
LAB_00152dc4:
*param_1 = uVar5;
}
return uVar3;
}
| |
22,419 | lf_hash_search_using_hash_value | eloqsql/mysys/lf_hash.cc | void *lf_hash_search_using_hash_value(LF_HASH *hash, LF_PINS *pins,
my_hash_value_type hashnr,
const void *key, uint keylen)
{
LF_SLIST **el, *found;
uint bucket;
/* hide OOM errors - if we cannot initialize a bucket, try the previous one */
for (bucket= hashnr % hash->size; ;bucket= my_clear_highest_bit(bucket))
{
el= (LF_SLIST **)lf_dynarray_lvalue(&hash->array, bucket);
if (el && (*el || initialize_bucket(hash, el, bucket, pins) == 0))
break;
if (unlikely(bucket == 0))
return 0; /* if there's no bucket==0, the hash is empty */
}
found= l_search(el, hash->charset, my_reverse_bits(hashnr) | 1,
(uchar *)key, keylen, pins);
return found ? found+1 : 0;
} | O3 | cpp | lf_hash_search_using_hash_value:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, -0x38(%rbp)
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %eax
xorl %edx, %edx
divl 0xc0(%rdi)
movl %edx, %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x30d2e
testq %rax, %rax
jne 0x313f9
testl %r13d, %r13d
je 0x314ad
movl %r13d, %eax
shrl %eax
movl %r13d, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
orl %eax, %ecx
andl %ecx, %r13d
jmp 0x313b2
movq %rax, %r15
cmpq $0x0, (%rax)
jne 0x31417
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x3103c
testl %eax, %eax
jne 0x313c2
movq 0xa8(%r14), %rsi
movl $0xff, %eax
movl %r12d, %ecx
andl %eax, %ecx
leaq 0xb8ee1(%rip), %rdx # 0xea310
movzbl (%rdx,%rcx), %ecx
shll $0x18, %ecx
movl %r12d, %edi
shrl $0x8, %edi
andl %eax, %edi
movzbl (%rdx,%rdi), %edi
shll $0x10, %edi
orl %ecx, %edi
movl %r12d, %ecx
shrl $0x10, %ecx
andl %eax, %ecx
movzbl (%rdx,%rcx), %eax
shll $0x8, %eax
orl %edi, %eax
shrl $0x18, %r12d
movzbl (%rdx,%r12), %edx
orl %eax, %edx
orl $0x1, %edx
movl -0x2c(%rbp), %r8d
leaq -0x50(%rbp), %r9
movq %r15, %rdi
movq -0x38(%rbp), %rcx
pushq $0x0
pushq %rbx
callq 0x3154e
addq $0x10, %rsp
xorl %ecx, %ecx
movl $0x0, %edx
testl %eax, %eax
je 0x31490
movq -0x48(%rbp), %rdx
movq %rdx, %rax
xchgq %rax, 0x10(%rbx)
xorl %eax, %eax
xchgq %rax, 0x8(%rbx)
xchgq %rcx, (%rbx)
leaq 0x20(%rdx), %rax
testq %rdx, %rdx
cmoveq %rdx, %rax
jmp 0x314af
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| lf_hash_search_using_hash_value:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_2C], r8d
mov [rbp+var_38], rcx
mov r12d, edx
mov rbx, rsi
mov r14, rdi
mov eax, edx
xor edx, edx
div dword ptr [rdi+0C0h]
mov r13d, edx
loc_313B2:
mov rdi, r14
mov esi, r13d
call lf_dynarray_lvalue
test rax, rax
jnz short loc_313F9
loc_313C2:
test r13d, r13d
jz loc_314AD
mov eax, r13d
shr eax, 1
mov ecx, r13d
shr ecx, 2
or ecx, eax
mov eax, ecx
shr eax, 2
or eax, ecx
mov ecx, eax
shr ecx, 4
or ecx, eax
mov eax, ecx
shr eax, 8
or eax, ecx
mov ecx, eax
shr ecx, 10h
or ecx, eax
and r13d, ecx
jmp short loc_313B2
loc_313F9:
mov r15, rax
cmp qword ptr [rax], 0
jnz short loc_31417
mov rdi, r14
mov rsi, r15
mov edx, r13d
mov rcx, rbx
call _ZL17initialize_bucketP10st_lf_hashPP8LF_SLISTjP7LF_PINS; initialize_bucket(st_lf_hash *,LF_SLIST **,uint,LF_PINS *)
test eax, eax
jnz short loc_313C2
loc_31417:
mov rsi, [r14+0A8h]
mov eax, 0FFh
mov ecx, r12d
and ecx, eax
lea rdx, _my_bits_reverse_table
movzx ecx, byte ptr [rdx+rcx]
shl ecx, 18h
mov edi, r12d
shr edi, 8
and edi, eax
movzx edi, byte ptr [rdx+rdi]
shl edi, 10h
or edi, ecx
mov ecx, r12d
shr ecx, 10h
and ecx, eax
movzx eax, byte ptr [rdx+rcx]
shl eax, 8
or eax, edi
shr r12d, 18h
movzx edx, byte ptr [rdx+r12]
or edx, eax
or edx, 1
mov r8d, [rbp+var_2C]
lea r9, [rbp+var_50]
mov rdi, r15
mov rcx, [rbp+var_38]
push 0
push rbx
call _ZL6l_findPP8LF_SLISTPK15charset_info_stjPKhmP6CURSORP7LF_PINSPFcPvSB_E; l_find(LF_SLIST **,charset_info_st const*,uint,uchar const*,ulong,CURSOR *,LF_PINS *,char (*)(void *,void *))
add rsp, 10h
xor ecx, ecx
mov edx, 0
test eax, eax
jz short loc_31490
mov rdx, [rbp+var_48]
loc_31490:
mov rax, rdx
xchg rax, [rbx+10h]
xor eax, eax
xchg rax, [rbx+8]
xchg rcx, [rbx]
lea rax, [rdx+20h]
test rdx, rdx
cmovz rax, rdx
jmp short loc_314AF
loc_314AD:
xor eax, eax
loc_314AF:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long lf_hash_search_using_hash_value(
long long a1,
volatile long long *a2,
unsigned int a3,
long long a4,
int a5)
{
unsigned int i; // r13d
volatile signed long long *v7; // rax
int v8; // r15d
int v9; // eax
long long v10; // rdx
long long result; // rax
char v12; // [rsp+0h] [rbp-50h] BYREF
long long v13; // [rsp+8h] [rbp-48h]
long long v14; // [rsp+18h] [rbp-38h]
int v15; // [rsp+24h] [rbp-2Ch]
v15 = a5;
v14 = a4;
for ( i = a3 % *(_DWORD *)(a1 + 192);
;
i &= (i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2)) >> 4) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2)) >> 4)) >> 8) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2)) >> 4) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2) | (((i >> 1) | (i >> 2) | (((i >> 1) | (i >> 2)) >> 2)) >> 4)) >> 8)) >> 16) )
{
v7 = (volatile signed long long *)lf_dynarray_lvalue(a1, i);
if ( v7 )
{
v8 = (int)v7;
if ( *v7 || !(unsigned int)initialize_bucket(a1, v7, i, (long long)a2) )
break;
}
if ( !i )
return 0LL;
}
v9 = l_find(
v8,
*(_QWORD *)(a1 + 168),
(my_bits_reverse_table[(unsigned __int8)a3] << 24) | (my_bits_reverse_table[BYTE1(a3)] << 16) | (my_bits_reverse_table[BYTE2(a3)] << 8) | my_bits_reverse_table[HIBYTE(a3)] | 1u,
v14,
v15,
(unsigned int)&v12,
(long long)a2,
0LL);
v10 = 0LL;
if ( v9 )
v10 = v13;
_InterlockedExchange64(a2 + 2, v10);
_InterlockedExchange64(a2 + 1, 0LL);
_InterlockedExchange64(a2, 0LL);
result = v10 + 32;
if ( !v10 )
return 0LL;
return result;
}
| lf_hash_search_using_hash_value:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],RCX
MOV R12D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV EAX,EDX
XOR EDX,EDX
DIV dword ptr [RDI + 0xc0]
MOV R13D,EDX
LAB_001313b2:
MOV RDI,R14
MOV ESI,R13D
CALL 0x00130d2e
TEST RAX,RAX
JNZ 0x001313f9
LAB_001313c2:
TEST R13D,R13D
JZ 0x001314ad
MOV EAX,R13D
SHR EAX,0x1
MOV ECX,R13D
SHR ECX,0x2
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x2
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x4
OR ECX,EAX
MOV EAX,ECX
SHR EAX,0x8
OR EAX,ECX
MOV ECX,EAX
SHR ECX,0x10
OR ECX,EAX
AND R13D,ECX
JMP 0x001313b2
LAB_001313f9:
MOV R15,RAX
CMP qword ptr [RAX],0x0
JNZ 0x00131417
MOV RDI,R14
MOV RSI,R15
MOV EDX,R13D
MOV RCX,RBX
CALL 0x0013103c
TEST EAX,EAX
JNZ 0x001313c2
LAB_00131417:
MOV RSI,qword ptr [R14 + 0xa8]
MOV EAX,0xff
MOV ECX,R12D
AND ECX,EAX
LEA RDX,[0x1ea310]
MOVZX ECX,byte ptr [RDX + RCX*0x1]
SHL ECX,0x18
MOV EDI,R12D
SHR EDI,0x8
AND EDI,EAX
MOVZX EDI,byte ptr [RDX + RDI*0x1]
SHL EDI,0x10
OR EDI,ECX
MOV ECX,R12D
SHR ECX,0x10
AND ECX,EAX
MOVZX EAX,byte ptr [RDX + RCX*0x1]
SHL EAX,0x8
OR EAX,EDI
SHR R12D,0x18
MOVZX EDX,byte ptr [RDX + R12*0x1]
OR EDX,EAX
OR EDX,0x1
MOV R8D,dword ptr [RBP + -0x2c]
LEA R9,[RBP + -0x50]
MOV RDI,R15
MOV RCX,qword ptr [RBP + -0x38]
PUSH 0x0
PUSH RBX
CALL 0x0013154e
ADD RSP,0x10
XOR ECX,ECX
MOV EDX,0x0
TEST EAX,EAX
JZ 0x00131490
MOV RDX,qword ptr [RBP + -0x48]
LAB_00131490:
MOV RAX,RDX
XCHG qword ptr [RBX + 0x10],RAX
XOR EAX,EAX
XCHG qword ptr [RBX + 0x8],RAX
XCHG qword ptr [RBX],RCX
LEA RAX,[RDX + 0x20]
TEST RDX,RDX
CMOVZ RAX,RDX
JMP 0x001314af
LAB_001314ad:
XOR EAX,EAX
LAB_001314af:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long lf_hash_search_using_hash_value
(st_lf_hash *param_1,LF_PINS *param_2,uint param_3,uchar *param_4,uint param_5)
{
int iVar1;
LF_SLIST **ppLVar2;
uint uVar3;
long lVar4;
uint uVar5;
ulong uVar6;
CURSOR local_58 [8];
long local_50;
uchar *local_40;
uint local_34;
uVar6 = (ulong)param_3 % (ulong)*(uint *)(param_1 + 0xc0);
local_40 = param_4;
local_34 = param_5;
while( true ) {
uVar5 = (uint)uVar6;
ppLVar2 = (LF_SLIST **)lf_dynarray_lvalue(param_1,uVar6);
if ((ppLVar2 != (LF_SLIST **)0x0) &&
((*ppLVar2 != (LF_SLIST *)0x0 ||
(iVar1 = initialize_bucket(param_1,ppLVar2,uVar5,param_2), iVar1 == 0)))) break;
if (uVar5 == 0) {
return 0;
}
uVar3 = (uint)(uVar6 >> 2) | (uint)(uVar6 >> 1);
uVar3 = uVar3 >> 2 | uVar3;
uVar3 = uVar3 >> 4 | uVar3;
uVar3 = uVar3 >> 8 | uVar3;
uVar6 = (ulong)(uVar5 & (uVar3 >> 0x10 | uVar3));
}
iVar1 = l_find(ppLVar2,*(charset_info_st **)(param_1 + 0xa8),
(uint)(byte)_my_bits_reverse_table[param_3 >> 0x18] |
(uint)(byte)_my_bits_reverse_table[param_3 >> 0x10 & 0xff] << 8 |
(uint)(byte)_my_bits_reverse_table[param_3 >> 8 & 0xff] << 0x10 |
(uint)(byte)_my_bits_reverse_table[param_3 & 0xff] << 0x18 | 1,local_40,
(ulong)local_34,local_58,param_2,(_func_char_void_ptr_void_ptr *)0x0);
lVar4 = 0;
if (iVar1 != 0) {
lVar4 = local_50;
}
LOCK();
*(long *)(param_2 + 0x10) = lVar4;
UNLOCK();
LOCK();
*(int8 *)(param_2 + 8) = 0;
UNLOCK();
LOCK();
*(int8 *)param_2 = 0;
UNLOCK();
if (lVar4 != 0) {
return lVar4 + 0x20;
}
return 0;
}
| |
22,420 | get_this_host | eloqsql/libmariadb/unittest/libmariadb/my_test.h | void get_this_host(MYSQL *mysql)
{
MYSQL_RES *res;
MYSQL_ROW row;
if (mysql_query(mysql, "select substr(current_user(), locate('@', current_user())+1)"))
return;
if ((res= mysql_store_result(mysql)))
{
if ((row= mysql_fetch_row(res)))
this_host= strdup(row[0]);
mysql_free_result(res);
}
} | O0 | c | get_this_host:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3863b(%rip), %rsi # 0x4c1d2
callq 0x1ef20
cmpl $0x0, %eax
je 0x13ba3
jmp 0x13be5
movq -0x8(%rbp), %rdi
callq 0x20570
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x13be5
movq -0x10(%rbp), %rdi
callq 0x208b0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13bdc
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x137a0
movq %rax, 0x4d62c(%rip) # 0x61208
movq -0x10(%rbp), %rdi
callq 0x17db0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_this_host:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
lea rsi, aSelectSubstrCu; "select substr(current_user(), locate('@"...
call mysql_query
cmp eax, 0
jz short loc_13BA3
jmp short loc_13BE5
loc_13BA3:
mov rdi, [rbp+var_8]
call mysql_store_result
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_13BE5
mov rdi, [rbp+var_10]
call mysql_fetch_row
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_13BDC
mov rax, [rbp+var_18]
mov rdi, [rax]
call _strdup
mov cs:this_host, rax
loc_13BDC:
mov rdi, [rbp+var_10]
call mysql_free_result
loc_13BE5:
add rsp, 20h
pop rbp
retn
| long long get_this_host(long long a1)
{
long long result; // rax
_QWORD *row; // [rsp+8h] [rbp-18h]
long long v3; // [rsp+10h] [rbp-10h]
result = mysql_query(a1, "select substr(current_user(), locate('@', current_user())+1)");
if ( !(_DWORD)result )
{
result = mysql_store_result(a1);
v3 = result;
if ( result )
{
row = (_QWORD *)mysql_fetch_row(result);
if ( row )
this_host = strdup(*row);
return mysql_free_result(v3);
}
}
return result;
}
| get_this_host:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x14c1d2]
CALL 0x0011ef20
CMP EAX,0x0
JZ 0x00113ba3
JMP 0x00113be5
LAB_00113ba3:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00120570
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x00113be5
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001208b0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x00113bdc
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
CALL 0x001137a0
MOV qword ptr [0x00161208],RAX
LAB_00113bdc:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00117db0
LAB_00113be5:
ADD RSP,0x20
POP RBP
RET
|
void get_this_host(int8 param_1)
{
int iVar1;
long lVar2;
int8 *puVar3;
iVar1 = mysql_query(param_1,"select substr(current_user(), locate(\'@\', current_user())+1)");
if ((iVar1 == 0) && (lVar2 = mysql_store_result(param_1), lVar2 != 0)) {
puVar3 = (int8 *)mysql_fetch_row(lVar2);
if (puVar3 != (int8 *)0x0) {
this_host = strdup((char *)*puVar3);
}
mysql_free_result(lVar2);
}
return;
}
| |
22,421 | my_once_free | eloqsql/mysys/my_once.c | void my_once_free(void)
{
reg1 USED_MEM *next,*old;
DBUG_ENTER("my_once_free");
for (next=my_once_root_block ; next ; )
{
old=next; next= next->next ;
free((uchar*) old);
}
my_once_root_block=0;
DBUG_VOID_RETURN;
} | O3 | c | my_once_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x31d756(%rip), %rbx # 0x36a570
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4ce32
movq (%rdi), %r14
callq 0x25390
movq %r14, %rdi
testq %r14, %r14
jne 0x4ce22
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
| my_once_free:
push rbp
mov rbp, rsp
push r14
push rbx
lea rbx, my_once_root_block
mov rdi, [rbx]
test rdi, rdi
jz short loc_4CE32
loc_4CE22:
mov r14, [rdi]
call _free
mov rdi, r14
test r14, r14
jnz short loc_4CE22
loc_4CE32:
mov qword ptr [rbx], 0
pop rbx
pop r14
pop rbp
retn
| long long my_once_free()
{
_QWORD *v0; // rdi
_QWORD *v1; // r14
long long result; // rax
v0 = (_QWORD *)my_once_root_block;
if ( my_once_root_block )
{
do
{
v1 = (_QWORD *)*v0;
result = free(v0);
v0 = v1;
}
while ( v1 );
}
my_once_root_block = 0LL;
return result;
}
| my_once_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA RBX,[0x46a570]
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x0014ce32
LAB_0014ce22:
MOV R14,qword ptr [RDI]
CALL 0x00125390
MOV RDI,R14
TEST R14,R14
JNZ 0x0014ce22
LAB_0014ce32:
MOV qword ptr [RBX],0x0
POP RBX
POP R14
POP RBP
RET
|
void my_once_free(void)
{
long *plVar1;
long *__ptr;
__ptr = my_once_root_block;
if (my_once_root_block != (long *)0x0) {
do {
plVar1 = (long *)*__ptr;
free(__ptr);
__ptr = plVar1;
} while (plVar1 != (long *)0x0);
}
my_once_root_block = (long *)0x0;
return;
}
| |
22,422 | my_set_error | eloqsql/libmariadb/libmariadb/mariadb_lib.c | void my_set_error(MYSQL *mysql,
unsigned int error_nr,
const char *sqlstate,
const char *format,
...)
{
va_list ap;
const char *errmsg;
if (!format)
{
if (error_nr >= CR_MIN_ERROR && error_nr <= CR_MYSQL_LAST_ERROR)
errmsg= ER(error_nr);
else if (error_nr >= CER_MIN_ERROR && error_nr <= CR_MARIADB_LAST_ERROR)
errmsg= CER(error_nr);
else
errmsg= ER(CR_UNKNOWN_ERROR);
}
mysql->net.last_errno= error_nr;
ma_strmake(mysql->net.sqlstate, sqlstate, SQLSTATE_LENGTH);
va_start(ap, format);
vsnprintf(mysql->net.last_error, MYSQL_ERRMSG_SIZE - 1,
format ? format : errmsg, ap);
va_end(ap);
return;
} | O0 | c | my_set_error:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp # imm = 0x110
testb %al, %al
je 0x1acbe
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ad52
cmpl $0x7d0, -0xc(%rbp) # imm = 0x7D0
jb 0x1ad11
cmpl $0x80d, -0xc(%rbp) # imm = 0x80D
ja 0x1ad11
movl -0xc(%rbp), %eax
subl $0x7d0, %eax # imm = 0x7D0
movl %eax, %eax
movl %eax, %ecx
leaq 0x49449(%rip), %rax # 0x64150
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x1ad50
cmpl $0x1388, -0xc(%rbp) # imm = 0x1388
jb 0x1ad40
cmpl $0x1397, -0xc(%rbp) # imm = 0x1397
ja 0x1ad40
movl -0xc(%rbp), %eax
subl $0x1388, %eax # imm = 0x1388
movl %eax, %eax
movl %eax, %ecx
leaq 0x4961a(%rip), %rax # 0x64350
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x1ad4e
leaq 0x49409(%rip), %rax # 0x64150
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x1ad50
jmp 0x1ad52
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x8(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
movq -0x18(%rbp), %rsi
movl $0x5, %edx
callq 0x36b00
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
movq -0x8(%rbp), %rax
addq $0x97, %rax
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1adc1
movq -0x20(%rbp), %rax
movq %rax, -0x110(%rbp)
jmp 0x1adcc
movq -0x48(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rdi
movq -0x110(%rbp), %rdx
movl $0x1ff, %esi # imm = 0x1FF
leaq -0x40(%rbp), %rcx
callq 0x132a0
addq $0x110, %rsp # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_set_error:
push rbp
mov rbp, rsp
sub rsp, 110h
test al, al
jz short loc_1ACBE
movaps [rbp+var_D0], xmm0
movaps [rbp+var_C0], xmm1
movaps [rbp+var_B0], xmm2
movaps [rbp+var_A0], xmm3
movaps [rbp+var_90], xmm4
movaps [rbp+var_80], xmm5
movaps [rbp+var_70], xmm6
movaps [rbp+var_60], xmm7
loc_1ACBE:
mov [rbp+var_D8], r9
mov [rbp+var_E0], r8
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
cmp [rbp+var_20], 0
jnz short loc_1AD52
cmp [rbp+var_C], 7D0h
jb short loc_1AD11
cmp [rbp+var_C], 80Dh
ja short loc_1AD11
mov eax, [rbp+var_C]
sub eax, 7D0h
mov eax, eax
mov ecx, eax
lea rax, client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
jmp short loc_1AD50
loc_1AD11:
cmp [rbp+var_C], 1388h
jb short loc_1AD40
cmp [rbp+var_C], 1397h
ja short loc_1AD40
mov eax, [rbp+var_C]
sub eax, 1388h
mov eax, eax
mov ecx, eax
lea rax, mariadb_client_errors
mov rax, [rax+rcx*8]
mov [rbp+var_48], rax
jmp short loc_1AD4E
loc_1AD40:
lea rax, client_errors
mov rax, [rax]
mov [rbp+var_48], rax
loc_1AD4E:
jmp short $+2
loc_1AD50:
jmp short $+2
loc_1AD52:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_8]
mov [rax+90h], ecx
mov rdi, [rbp+var_8]
add rdi, 297h
mov rsi, [rbp+var_18]
mov edx, 5
call ma_strmake
lea rax, [rbp+var_40]
lea rcx, [rbp+var_100]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 20h ; ' '
mov rax, [rbp+var_8]
add rax, 97h
mov [rbp+var_108], rax
cmp [rbp+var_20], 0
jz short loc_1ADC1
mov rax, [rbp+var_20]
mov [rbp+var_110], rax
jmp short loc_1ADCC
loc_1ADC1:
mov rax, [rbp+var_48]
mov [rbp+var_110], rax
loc_1ADCC:
mov rdi, [rbp+var_108]
mov rdx, [rbp+var_110]
mov esi, 1FFh
lea rcx, [rbp+var_40]
call _vsnprintf
add rsp, 110h
pop rbp
retn
| long long my_set_error(long long a1, unsigned int a2, long long a3, long long a4, ...)
{
long long v5; // [rsp+8h] [rbp-108h]
char *v6; // [rsp+C8h] [rbp-48h]
va_list va; // [rsp+D0h] [rbp-40h] BYREF
long long v8; // [rsp+F0h] [rbp-20h]
long long v9; // [rsp+F8h] [rbp-18h]
unsigned int v10; // [rsp+104h] [rbp-Ch]
long long v11; // [rsp+108h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
if ( !a4 )
{
if ( v10 < 0x7D0 || v10 > 0x80D )
{
if ( v10 < 0x1388 || v10 > 0x1397 )
v6 = client_errors[0];
else
v6 = mariadb_client_errors[v10 - 5000];
}
else
{
v6 = client_errors[v10 - 2000];
}
}
*(_DWORD *)(v11 + 144) = v10;
ma_strmake(v11 + 663, v9, 5LL);
va_start(va, a4);
v5 = v11 + 151;
if ( v8 )
return vsnprintf(v5, 511LL, v8, va);
else
return vsnprintf(v5, 511LL, v6, va);
}
| my_set_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x110
TEST AL,AL
JZ 0x0011acbe
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
MOVAPS xmmword ptr [RBP + -0xc0],XMM1
MOVAPS xmmword ptr [RBP + -0xb0],XMM2
MOVAPS xmmword ptr [RBP + -0xa0],XMM3
MOVAPS xmmword ptr [RBP + -0x90],XMM4
MOVAPS xmmword ptr [RBP + -0x80],XMM5
MOVAPS xmmword ptr [RBP + -0x70],XMM6
MOVAPS xmmword ptr [RBP + -0x60],XMM7
LAB_0011acbe:
MOV qword ptr [RBP + -0xd8],R9
MOV qword ptr [RBP + -0xe0],R8
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x0011ad52
CMP dword ptr [RBP + -0xc],0x7d0
JC 0x0011ad11
CMP dword ptr [RBP + -0xc],0x80d
JA 0x0011ad11
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x7d0
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x164150]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0011ad50
LAB_0011ad11:
CMP dword ptr [RBP + -0xc],0x1388
JC 0x0011ad40
CMP dword ptr [RBP + -0xc],0x1397
JA 0x0011ad40
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1388
MOV EAX,EAX
MOV ECX,EAX
LEA RAX,[0x164350]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0011ad4e
LAB_0011ad40:
LEA RAX,[0x164150]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_0011ad4e:
JMP 0x0011ad50
LAB_0011ad50:
JMP 0x0011ad52
LAB_0011ad52:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x90],ECX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x297
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x5
CALL 0x00136b00
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x100]
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],0x20
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x97
MOV qword ptr [RBP + -0x108],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0011adc1
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x110],RAX
JMP 0x0011adcc
LAB_0011adc1:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x110],RAX
LAB_0011adcc:
MOV RDI,qword ptr [RBP + -0x108]
MOV RDX,qword ptr [RBP + -0x110]
MOV ESI,0x1ff
LEA RCX,[RBP + -0x40]
CALL 0x001132a0
ADD RSP,0x110
POP RBP
RET
|
void my_set_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,uint param_10,int8 param_11,char *param_12,int8 param_13,
int8 param_14)
{
char in_AL;
char *local_118;
int1 local_108 [32];
int8 local_e8;
int8 local_e0;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
char *local_50;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
char *local_28;
int8 local_20;
uint local_14;
long local_10;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
if (param_12 == (char *)0x0) {
if ((param_10 < 2000) || (0x80d < param_10)) {
if ((param_10 < 5000) || (0x1397 < param_10)) {
local_50 = client_errors;
}
else {
local_50 = *(char **)(mariadb_client_errors + (ulong)(param_10 - 5000) * 8);
}
}
else {
local_50 = (&client_errors)[param_10 - 2000];
}
}
*(uint *)(param_9 + 0x90) = param_10;
local_e8 = param_13;
local_e0 = param_14;
local_28 = param_12;
local_20 = param_11;
local_14 = param_10;
local_10 = param_9;
ma_strmake(param_9 + 0x297,param_11,5);
local_38 = local_108;
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x20;
if (local_28 == (char *)0x0) {
local_118 = local_50;
}
else {
local_118 = local_28;
}
vsnprintf((char *)(local_10 + 0x97),0x1ff,local_118,&local_48);
return;
}
| |
22,423 | js_boolean_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_boolean_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
val = js_bool(JS_ToBool(ctx, argv[0]));
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_BOOLEAN);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O0 | c | js_boolean_constructor:
subq $0x78, %rsp
movq %rsi, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movq %r8, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x38530
movl %eax, %edi
callq 0x57250
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x2e260
cmpl $0x0, %eax
jne 0x57368
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl $0x6, %ecx
callq 0x54e00
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
jne 0x57352
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x55010
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x5737c
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nopl (%rax,%rax)
| js_boolean_constructor:
sub rsp, 78h
mov [rsp+78h+var_20], rsi
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_28], rdi
mov [rsp+78h+var_2C], ecx
mov [rsp+78h+var_38], r8
mov rdi, [rsp+78h+var_28]
mov rax, [rsp+78h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToBool
mov edi, eax
call js_bool
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], rdx
mov rax, [rsp+78h+var_68]
mov [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_40], rax
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_18]
call JS_IsUndefined_0
cmp eax, 0
jnz short loc_57368
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_20]
mov rdx, [rsp+78h+var_18]
mov ecx, 6
call js_create_from_ctor
mov [rsp+78h+var_78], rax
mov [rsp+78h+var_70], rdx
mov rax, [rsp+78h+var_78]
mov [rsp+78h+var_58], rax
mov rax, [rsp+78h+var_70]
mov [rsp+78h+var_50], rax
mov rdi, [rsp+78h+var_58]
mov rsi, [rsp+78h+var_50]
call JS_IsException_1
cmp eax, 0
jnz short loc_57352
mov rdi, [rsp+78h+var_28]
mov rsi, [rsp+78h+var_58]
mov rdx, [rsp+78h+var_50]
mov rcx, [rsp+78h+var_48]
mov r8, [rsp+78h+var_40]
call JS_SetObjectData
loc_57352:
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_50]
mov [rsp+78h+var_8], rax
jmp short loc_5737C
loc_57368:
mov rax, [rsp+78h+var_48]
mov [rsp+78h+var_10], rax
mov rax, [rsp+78h+var_40]
mov [rsp+78h+var_8], rax
loc_5737C:
mov rax, [rsp+78h+var_10]
mov rdx, [rsp+78h+var_8]
add rsp, 78h
retn
| long long js_boolean_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13)
{
int v13; // eax
long long v14; // rdx
int v15; // edx
double v16; // xmm4_8
double v17; // xmm5_8
long long v19; // [rsp+0h] [rbp-78h]
long long v20; // [rsp+10h] [rbp-68h]
int v21; // [rsp+28h] [rbp-50h]
long long v22; // [rsp+38h] [rbp-40h]
v13 = JS_ToBool(a1, *(_DWORD **)a13, *(_QWORD *)(a13 + 8));
v20 = js_bool(v13);
v22 = v14;
if ( JS_IsUndefined_0(a2, a3) )
return v20;
v19 = js_create_from_ctor(a1, a2, a3, 6);
v21 = v15;
if ( !JS_IsException_1(v19, v15) )
JS_SetObjectData(a1, v19, v21, v20, v22, a4, a5, a6, a7, v16, v17, a10, a11);
return v19;
}
| js_boolean_constructor:
SUB RSP,0x78
MOV qword ptr [RSP + 0x58],RSI
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x50],RDI
MOV dword ptr [RSP + 0x4c],ECX
MOV qword ptr [RSP + 0x40],R8
MOV RDI,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00138530
MOV EDI,EAX
CALL 0x00157250
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x0012e260
CMP EAX,0x0
JNZ 0x00157368
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV ECX,0x6
CALL 0x00154e00
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00123cc0
CMP EAX,0x0
JNZ 0x00157352
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x38]
CALL 0x00155010
LAB_00157352:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x70],RAX
JMP 0x0015737c
LAB_00157368:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x70],RAX
LAB_0015737c:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
ADD RSP,0x78
RET
|
int1 [16]
js_boolean_constructor
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int4 uVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
uVar1 = JS_ToBool(param_1,*param_5,param_5[1]);
auVar5 = js_bool(uVar1);
uVar4 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
iVar2 = JS_IsUndefined(param_2,param_3);
if (iVar2 == 0) {
auVar5 = js_create_from_ctor(param_1,param_2,param_3,6);
iVar2 = JS_IsException(auVar5._0_8_,auVar5._8_8_);
if (iVar2 == 0) {
JS_SetObjectData(param_1,auVar5._0_8_,auVar5._8_8_,uVar3,uVar4);
}
}
return auVar5;
}
| |
22,424 | js_boolean_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_boolean_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue val, obj;
val = js_bool(JS_ToBool(ctx, argv[0]));
if (!JS_IsUndefined(new_target)) {
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_BOOLEAN);
if (!JS_IsException(obj))
JS_SetObjectData(ctx, obj, val);
return obj;
} else {
return val;
}
} | O1 | c | js_boolean_constructor:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edx
jb 0x3896c
movq 0x8(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
callq 0x22d0d
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movl $0x1, %r15d
cmpl $0x3, %r12d
jne 0x3898e
movq %r14, %r12
jmp 0x389c4
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movl $0x6, %ecx
callq 0x36d56
movq %rax, %r12
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x389c4
movl $0x1, %r8d
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x36e62
movq %r12, %rax
movq %r15, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_boolean_constructor:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r12, rdx
mov r13, rsi
mov rbx, rdi
mov rsi, [r8]
mov rdx, [r8+8]
mov [rsp+38h+var_30], rsi
cmp edx, 0FFFFFFF7h
jb short loc_3896C
mov rax, [rsp+38h+var_30]
inc dword ptr [rax]
loc_3896C:
mov rdi, rbx
call JS_ToBoolFree
xor r14d, r14d
test eax, eax
setnz r14b
mov r15d, 1
cmp r12d, 3
jnz short loc_3898E
mov r12, r14
jmp short loc_389C4
loc_3898E:
mov rdi, rbx
mov rsi, r13
mov rdx, r12
mov ecx, 6
call js_create_from_ctor
mov r12, rax
mov r15, rdx
cmp r15d, 6
jz short loc_389C4
mov r8d, 1
mov rdi, rbx
mov rsi, r12
mov rdx, r15
mov rcx, r14
call JS_SetObjectData
loc_389C4:
mov rax, r12
mov rdx, r15
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| _BOOL8 js_boolean_constructor(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13)
{
_DWORD *v15; // rsi
long long v16; // rdx
int v17; // eax
_BOOL8 v18; // r14
unsigned long long v19; // r12
unsigned long long v20; // rax
int v21; // edx
long long v22; // r9
double v23; // xmm4_8
double v24; // xmm5_8
char v26; // [rsp+0h] [rbp-38h]
v15 = *(_DWORD **)a13;
v16 = *(_QWORD *)(a13 + 8);
if ( (unsigned int)v16 >= 0xFFFFFFF7 )
++**(_DWORD **)a13;
v17 = JS_ToBoolFree(a1, (long long)v15, v16);
v18 = v17 != 0;
if ( (_DWORD)a3 == 3 )
return v17 != 0;
v20 = js_create_from_ctor(a1, a2, a3, 6);
v19 = v20;
if ( v21 != 6 )
JS_SetObjectData(a1, v20, v21, (_DWORD *)v18, 1LL, a4, a5, a6, a7, v23, v24, a10, a11, v22, v26);
return v19;
}
| js_boolean_constructor:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,RDX
MOV R13,RSI
MOV RBX,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x9
JC 0x0013896c
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_0013896c:
MOV RDI,RBX
CALL 0x00122d0d
XOR R14D,R14D
TEST EAX,EAX
SETNZ R14B
MOV R15D,0x1
CMP R12D,0x3
JNZ 0x0013898e
MOV R12,R14
JMP 0x001389c4
LAB_0013898e:
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R12
MOV ECX,0x6
CALL 0x00136d56
MOV R12,RAX
MOV R15,RDX
CMP R15D,0x6
JZ 0x001389c4
MOV R8D,0x1
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
CALL 0x00136e62
LAB_001389c4:
MOV RAX,R12
MOV RDX,R15
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16]
js_boolean_constructor
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
int1 auVar3 [16];
if (0xfffffff6 < (uint)param_5[1]) {
*(int *)*param_5 = *(int *)*param_5 + 1;
}
iVar1 = JS_ToBoolFree(param_1);
uVar2 = CONCAT71(0,iVar1 != 0);
auVar3._8_8_ = 1;
auVar3._0_8_ = uVar2;
if ((int)param_3 != 3) {
auVar3 = js_create_from_ctor(param_1,param_2,param_3,6);
if (auVar3._8_4_ != 6) {
JS_SetObjectData(param_1,auVar3._0_8_,auVar3._8_8_,uVar2,1);
}
}
return auVar3;
}
| |
22,425 | lunasvg::parseDominantBaseline(std::basic_string_view<char, std::char_traits<char>> const&) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static DominantBaseline parseDominantBaseline(const std::string_view& input)
{
static const SVGEnumerationEntry<DominantBaseline> entries[] = {
{DominantBaseline::Auto, "auto"},
{DominantBaseline::UseScript, "use-script"},
{DominantBaseline::NoChange, "no-change"},
{DominantBaseline::ResetSize, "reset-size"},
{DominantBaseline::Ideographic, "ideographic"},
{DominantBaseline::Alphabetic, "alphabetic"},
{DominantBaseline::Hanging, "hanging"},
{DominantBaseline::Mathematical, "mathematical"},
{DominantBaseline::Central, "central"},
{DominantBaseline::Middle, "middle"},
{DominantBaseline::TextAfterEdge, "text-after-edge"},
{DominantBaseline::TextBeforeEdge, "text-before-edge"}
};
return parseEnumValue(input, entries, DominantBaseline::Auto);
} | O0 | cpp | lunasvg::parseDominantBaseline(std::basic_string_view<char, std::char_traits<char>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x911d9(%rip), %rsi # 0xc2cd0
xorl %edx, %edx
callq 0x32800
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN7lunasvgL21parseDominantBaselineERKSt17basic_string_viewIcSt11char_traitsIcEE:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
lea rsi, _ZZN7lunasvgL21parseDominantBaselineERKSt17basic_string_viewIcSt11char_traitsIcEEE7entries; lunasvg::parseDominantBaseline(std::string_view const&)::entries
xor edx, edx
call _ZN7lunasvgL14parseEnumValueINS_16DominantBaselineELj12EEET_RKSt17basic_string_viewIcSt11char_traitsIcEERAT0__KSt4pairIS2_S6_ES2_; lunasvg::parseEnumValue<lunasvg::DominantBaseline,12u>(std::string_view const&,std::pair<lunasvg::DominantBaseline,std::string_view> const(&)[12u],lunasvg::DominantBaseline)
add rsp, 10h
pop rbp
retn
| long long lunasvg::parseDominantBaseline(long long a1)
{
return lunasvg::parseEnumValue<lunasvg::DominantBaseline,12u>(
a1,
&lunasvg::parseDominantBaseline(std::string_view const&)::entries,
0LL);
}
| parseDominantBaseline:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x1c2cd0]
XOR EDX,EDX
CALL 0x00132800
ADD RSP,0x10
POP RBP
RET
|
/* lunasvg::parseDominantBaseline(std::basic_string_view<char, std::char_traits<char> > const&) */
void lunasvg::parseDominantBaseline(basic_string_view *param_1)
{
parseEnumValue<lunasvg::DominantBaseline,12u>
(param_1,parseDominantBaseline(std::basic_string_view<char,std::char_traits<char>>const&)
::entries,0);
return;
}
| |
22,426 | js_resolve_export1 | bluesky950520[P]quickjs/quickjs.c | static JSResolveResultEnum js_resolve_export1(JSContext *ctx,
JSModuleDef **pmodule,
JSExportEntry **pme,
JSModuleDef *m,
JSAtom export_name,
JSResolveState *s)
{
JSExportEntry *me;
*pmodule = NULL;
*pme = NULL;
if (find_resolve_entry(s, m, export_name) >= 0)
return JS_RESOLVE_RES_CIRCULAR;
if (add_resolve_entry(ctx, s, m, export_name) < 0)
return JS_RESOLVE_RES_EXCEPTION;
me = find_export_entry(ctx, m, export_name);
if (me) {
if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
/* local export */
*pmodule = m;
*pme = me;
return JS_RESOLVE_RES_FOUND;
} else {
/* indirect export */
JSModuleDef *m1;
m1 = m->req_module_entries[me->u.req_module_idx].module;
if (me->local_name == JS_ATOM__star_) {
/* export ns from */
*pmodule = m;
*pme = me;
return JS_RESOLVE_RES_FOUND;
} else {
return js_resolve_export1(ctx, pmodule, pme, m1,
me->local_name, s);
}
}
} else {
if (export_name != JS_ATOM_default) {
/* not found in direct or indirect exports: try star exports */
int i;
for(i = 0; i < m->star_export_entries_count; i++) {
JSStarExportEntry *se = &m->star_export_entries[i];
JSModuleDef *m1, *res_m;
JSExportEntry *res_me;
JSResolveResultEnum ret;
m1 = m->req_module_entries[se->req_module_idx].module;
ret = js_resolve_export1(ctx, &res_m, &res_me, m1,
export_name, s);
if (ret == JS_RESOLVE_RES_AMBIGUOUS ||
ret == JS_RESOLVE_RES_EXCEPTION) {
return ret;
} else if (ret == JS_RESOLVE_RES_FOUND) {
if (*pme != NULL) {
if (*pmodule != res_m ||
res_me->local_name != (*pme)->local_name) {
*pmodule = NULL;
*pme = NULL;
return JS_RESOLVE_RES_AMBIGUOUS;
}
} else {
*pmodule = res_m;
*pme = res_me;
}
}
}
if (*pme != NULL)
return JS_RESOLVE_RES_FOUND;
}
return JS_RESOLVE_RES_NOT_FOUND;
}
} | O0 | c | js_resolve_export1:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movq %r9, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq $0x0, (%rax)
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0x73d00
cmpl $0x0, %eax
jl 0x73a9f
movl $0x2, 0x74(%rsp)
jmp 0x73ced
movq 0x68(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x50(%rsp), %rdx
movl 0x4c(%rsp), %ecx
callq 0x73d80
cmpl $0x0, %eax
jge 0x73ac9
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x73ced
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0x49a80
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x73ba2
movq 0x38(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x73b1f
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x74(%rsp)
jmp 0x73ced
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x38(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x7e, 0x14(%rax)
jne 0x73b72
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x74(%rsp)
jmp 0x73ced
movq 0x68(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movl 0x14(%rax), %r8d
movq 0x40(%rsp), %r9
callq 0x73a40
movl %eax, 0x74(%rsp)
jmp 0x73ced
cmpl $0x16, 0x4c(%rsp)
je 0x73ce5
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x50(%rsp), %rcx
cmpl 0x40(%rcx), %eax
jge 0x73cce
movq 0x50(%rsp), %rax
movq 0x38(%rax), %rax
movslq 0x2c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl 0x4c(%rsp), %r8d
movq 0x40(%rsp), %r9
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x73a40
movl %eax, 0x4(%rsp)
cmpl $0x3, 0x4(%rsp)
je 0x73c37
cmpl $-0x1, 0x4(%rsp)
jne 0x73c44
movl 0x4(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0x73ced
cmpl $0x0, 0x4(%rsp)
jne 0x73cba
movq 0x58(%rsp), %rax
cmpq $0x0, (%rax)
je 0x73c9e
movq 0x60(%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x73c7a
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
movq 0x58(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x14(%rcx), %eax
je 0x73c9c
movq 0x60(%rsp), %rax
movq $0x0, (%rax)
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movl $0x3, 0x74(%rsp)
jmp 0x73ced
jmp 0x73cb8
movq 0x10(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, (%rax)
jmp 0x73cba
jmp 0x73cbc
jmp 0x73cbe
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x73bb5
movq 0x58(%rsp), %rax
cmpq $0x0, (%rax)
je 0x73ce3
movl $0x0, 0x74(%rsp)
jmp 0x73ced
jmp 0x73ce5
movl $0x1, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
| js_resolve_export1:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov [rsp+78h+var_18], rsi
mov [rsp+78h+var_20], rdx
mov [rsp+78h+var_28], rcx
mov [rsp+78h+var_2C], r8d
mov [rsp+78h+var_38], r9
mov rax, [rsp+78h+var_18]
mov qword ptr [rax], 0
mov rax, [rsp+78h+var_20]
mov qword ptr [rax], 0
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_28]
mov edx, [rsp+78h+var_2C]
call find_resolve_entry
cmp eax, 0
jl short loc_73A9F
mov [rsp+78h+var_4], 2
jmp loc_73CED
loc_73A9F:
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_28]
mov ecx, [rsp+78h+var_2C]
call add_resolve_entry
cmp eax, 0
jge short loc_73AC9
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp loc_73CED
loc_73AC9:
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_28]
mov edx, [rsp+78h+var_2C]
call find_export_entry
mov [rsp+78h+var_40], rax
cmp [rsp+78h+var_40], 0
jz loc_73BA2
mov rax, [rsp+78h+var_40]
cmp dword ptr [rax+10h], 0
jnz short loc_73B1F
mov rcx, [rsp+78h+var_28]
mov rax, [rsp+78h+var_18]
mov [rax], rcx
mov rcx, [rsp+78h+var_40]
mov rax, [rsp+78h+var_20]
mov [rax], rcx
mov [rsp+78h+var_4], 0
jmp loc_73CED
loc_73B1F:
mov rax, [rsp+78h+var_28]
mov rax, [rax+18h]
mov rcx, [rsp+78h+var_40]
movsxd rcx, dword ptr [rcx]
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
mov [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_40]
cmp dword ptr [rax+14h], 7Eh ; '~'
jnz short loc_73B72
mov rcx, [rsp+78h+var_28]
mov rax, [rsp+78h+var_18]
mov [rax], rcx
mov rcx, [rsp+78h+var_40]
mov rax, [rsp+78h+var_20]
mov [rax], rcx
mov [rsp+78h+var_4], 0
jmp loc_73CED
loc_73B72:
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_18]
mov rdx, [rsp+78h+var_20]
mov rcx, [rsp+78h+var_48]
mov rax, [rsp+78h+var_40]
mov r8d, [rax+14h]
mov r9, [rsp+78h+var_38]
call js_resolve_export1
mov [rsp+78h+var_4], eax
jmp loc_73CED
loc_73BA2:
cmp [rsp+78h+var_2C], 16h
jz loc_73CE5
mov [rsp+78h+var_4C], 0
loc_73BB5:
mov eax, [rsp+78h+var_4C]
mov rcx, [rsp+78h+var_28]
cmp eax, [rcx+40h]
jge loc_73CCE
mov rax, [rsp+78h+var_28]
mov rax, [rax+38h]
movsxd rcx, [rsp+78h+var_4C]
shl rcx, 2
add rax, rcx
mov [rsp+78h+var_58], rax
mov rax, [rsp+78h+var_28]
mov rax, [rax+18h]
mov rcx, [rsp+78h+var_58]
movsxd rcx, dword ptr [rcx]
shl rcx, 4
add rax, rcx
mov rax, [rax+8]
mov [rsp+78h+var_60], rax
mov rdi, [rsp+78h+var_10]
mov rcx, [rsp+78h+var_60]
mov r8d, [rsp+78h+var_2C]
mov r9, [rsp+78h+var_38]
lea rsi, [rsp+78h+var_68]
lea rdx, [rsp+78h+var_70]
call js_resolve_export1
mov [rsp+78h+var_74], eax
cmp [rsp+78h+var_74], 3
jz short loc_73C37
cmp [rsp+78h+var_74], 0FFFFFFFFh
jnz short loc_73C44
loc_73C37:
mov eax, [rsp+78h+var_74]
mov [rsp+78h+var_4], eax
jmp loc_73CED
loc_73C44:
cmp [rsp+78h+var_74], 0
jnz short loc_73CBA
mov rax, [rsp+78h+var_20]
cmp qword ptr [rax], 0
jz short loc_73C9E
mov rax, [rsp+78h+var_18]
mov rax, [rax]
cmp rax, [rsp+78h+var_68]
jnz short loc_73C7A
mov rax, [rsp+78h+var_70]
mov eax, [rax+14h]
mov rcx, [rsp+78h+var_20]
mov rcx, [rcx]
cmp eax, [rcx+14h]
jz short loc_73C9C
loc_73C7A:
mov rax, [rsp+78h+var_18]
mov qword ptr [rax], 0
mov rax, [rsp+78h+var_20]
mov qword ptr [rax], 0
mov [rsp+78h+var_4], 3
jmp short loc_73CED
loc_73C9C:
jmp short loc_73CB8
loc_73C9E:
mov rcx, [rsp+78h+var_68]
mov rax, [rsp+78h+var_18]
mov [rax], rcx
mov rcx, [rsp+78h+var_70]
mov rax, [rsp+78h+var_20]
mov [rax], rcx
loc_73CB8:
jmp short $+2
loc_73CBA:
jmp short $+2
loc_73CBC:
jmp short $+2
loc_73CBE:
mov eax, [rsp+78h+var_4C]
add eax, 1
mov [rsp+78h+var_4C], eax
jmp loc_73BB5
loc_73CCE:
mov rax, [rsp+78h+var_20]
cmp qword ptr [rax], 0
jz short loc_73CE3
mov [rsp+78h+var_4], 0
jmp short loc_73CED
loc_73CE3:
jmp short $+2
loc_73CE5:
mov [rsp+78h+var_4], 1
loc_73CED:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
| long long js_resolve_export1(long long a1, _QWORD *a2, long long a3, long long a4, unsigned int a5, long long a6)
{
unsigned int v7; // [rsp+4h] [rbp-74h]
long long v8; // [rsp+8h] [rbp-70h] BYREF
long long v9; // [rsp+10h] [rbp-68h] BYREF
long long v10; // [rsp+18h] [rbp-60h]
int *v11; // [rsp+20h] [rbp-58h]
int i; // [rsp+2Ch] [rbp-4Ch]
long long v13; // [rsp+30h] [rbp-48h]
int *export_entry; // [rsp+38h] [rbp-40h]
long long v15; // [rsp+40h] [rbp-38h]
unsigned int v16; // [rsp+4Ch] [rbp-2Ch]
long long v17; // [rsp+50h] [rbp-28h]
long long v18; // [rsp+58h] [rbp-20h]
_QWORD *v19; // [rsp+60h] [rbp-18h]
long long v20; // [rsp+68h] [rbp-10h]
v20 = a1;
v19 = a2;
v18 = a3;
v17 = a4;
v16 = a5;
v15 = a6;
*a2 = 0LL;
*(_QWORD *)v18 = 0LL;
if ( (int)find_resolve_entry(v15, v17, v16) < 0 )
{
if ( (int)add_resolve_entry(v20, v15, v17, v16) >= 0 )
{
export_entry = (int *)find_export_entry(v20, v17, v16);
if ( export_entry )
{
if ( export_entry[4] )
{
v13 = *(_QWORD *)(16LL * *export_entry + *(_QWORD *)(v17 + 24) + 8);
if ( export_entry[5] == 126 )
{
*v19 = v17;
*(_QWORD *)v18 = export_entry;
return 0;
}
else
{
return (unsigned int)js_resolve_export1(v20, v19, v18, v13, (unsigned int)export_entry[5], v15);
}
}
else
{
*v19 = v17;
*(_QWORD *)v18 = export_entry;
return 0;
}
}
else
{
if ( v16 == 22 )
return 1;
for ( i = 0; i < *(_DWORD *)(v17 + 64); ++i )
{
v11 = (int *)(4LL * i + *(_QWORD *)(v17 + 56));
v10 = *(_QWORD *)(16LL * *v11 + *(_QWORD *)(v17 + 24) + 8);
v7 = js_resolve_export1(v20, &v9, &v8, v10, v16, v15);
if ( v7 == 3 || v7 == -1 )
return v7;
if ( !v7 )
{
if ( *(_QWORD *)v18 )
{
if ( *v19 != v9 || *(_DWORD *)(v8 + 20) != *(_DWORD *)(*(_QWORD *)v18 + 20LL) )
{
*v19 = 0LL;
*(_QWORD *)v18 = 0LL;
return 3;
}
}
else
{
*v19 = v9;
*(_QWORD *)v18 = v8;
}
}
}
return !*(_QWORD *)v18;
}
}
else
{
return (unsigned int)-1;
}
}
else
{
return 2;
}
}
| js_resolve_export1:
SUB RSP,0x78
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],R8D
MOV qword ptr [RSP + 0x40],R9
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x4c]
CALL 0x00173d00
CMP EAX,0x0
JL 0x00173a9f
MOV dword ptr [RSP + 0x74],0x2
JMP 0x00173ced
LAB_00173a9f:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x50]
MOV ECX,dword ptr [RSP + 0x4c]
CALL 0x00173d80
CMP EAX,0x0
JGE 0x00173ac9
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x00173ced
LAB_00173ac9:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x4c]
CALL 0x00149a80
MOV qword ptr [RSP + 0x38],RAX
CMP qword ptr [RSP + 0x38],0x0
JZ 0x00173ba2
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x10],0x0
JNZ 0x00173b1f
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],RCX
MOV dword ptr [RSP + 0x74],0x0
JMP 0x00173ced
LAB_00173b1f:
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x38]
MOVSXD RCX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x38]
CMP dword ptr [RAX + 0x14],0x7e
JNZ 0x00173b72
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],RCX
MOV dword ptr [RSP + 0x74],0x0
JMP 0x00173ced
LAB_00173b72:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x38]
MOV R8D,dword ptr [RAX + 0x14]
MOV R9,qword ptr [RSP + 0x40]
CALL 0x00173a40
MOV dword ptr [RSP + 0x74],EAX
JMP 0x00173ced
LAB_00173ba2:
CMP dword ptr [RSP + 0x4c],0x16
JZ 0x00173ce5
MOV dword ptr [RSP + 0x2c],0x0
LAB_00173bb5:
MOV EAX,dword ptr [RSP + 0x2c]
MOV RCX,qword ptr [RSP + 0x50]
CMP EAX,dword ptr [RCX + 0x40]
JGE 0x00173cce
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x38]
MOVSXD RCX,dword ptr [RSP + 0x2c]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
MOVSXD RCX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x68]
MOV RCX,qword ptr [RSP + 0x18]
MOV R8D,dword ptr [RSP + 0x4c]
MOV R9,qword ptr [RSP + 0x40]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0x8]
CALL 0x00173a40
MOV dword ptr [RSP + 0x4],EAX
CMP dword ptr [RSP + 0x4],0x3
JZ 0x00173c37
CMP dword ptr [RSP + 0x4],-0x1
JNZ 0x00173c44
LAB_00173c37:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RSP + 0x74],EAX
JMP 0x00173ced
LAB_00173c44:
CMP dword ptr [RSP + 0x4],0x0
JNZ 0x00173cba
MOV RAX,qword ptr [RSP + 0x58]
CMP qword ptr [RAX],0x0
JZ 0x00173c9e
MOV RAX,qword ptr [RSP + 0x60]
MOV RAX,qword ptr [RAX]
CMP RAX,qword ptr [RSP + 0x10]
JNZ 0x00173c7a
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV RCX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x14]
JZ 0x00173c9c
LAB_00173c7a:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],0x0
MOV dword ptr [RSP + 0x74],0x3
JMP 0x00173ced
LAB_00173c9c:
JMP 0x00173cb8
LAB_00173c9e:
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],RCX
LAB_00173cb8:
JMP 0x00173cba
LAB_00173cba:
JMP 0x00173cbc
LAB_00173cbc:
JMP 0x00173cbe
LAB_00173cbe:
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00173bb5
LAB_00173cce:
MOV RAX,qword ptr [RSP + 0x58]
CMP qword ptr [RAX],0x0
JZ 0x00173ce3
MOV dword ptr [RSP + 0x74],0x0
JMP 0x00173ced
LAB_00173ce3:
JMP 0x00173ce5
LAB_00173ce5:
MOV dword ptr [RSP + 0x74],0x1
LAB_00173ced:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4
js_resolve_export1(int8 param_1,long *param_2,long *param_3,long param_4,int param_5,
int8 param_6)
{
int iVar1;
long local_70;
long local_68;
int8 local_60;
int *local_58;
int local_4c;
int8 local_48;
int *local_40;
int8 local_38;
int local_2c;
long local_28;
long *local_20;
long *local_18;
int8 local_10;
int4 local_4;
*param_2 = 0;
*param_3 = 0;
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
iVar1 = find_resolve_entry(param_6,param_4,param_5);
if (iVar1 < 0) {
iVar1 = add_resolve_entry(local_10,local_38,local_28,local_2c);
if (iVar1 < 0) {
local_4 = 0xffffffff;
}
else {
local_40 = (int *)find_export_entry(local_10,local_28,local_2c);
if (local_40 == (int *)0x0) {
if (local_2c != 0x16) {
local_40 = (int *)0x0;
for (local_4c = 0; local_4c < *(int *)(local_28 + 0x40); local_4c = local_4c + 1) {
local_58 = (int *)(*(long *)(local_28 + 0x38) + (long)local_4c * 4);
local_60 = *(int8 *)(*(long *)(local_28 + 0x18) + (long)*local_58 * 0x10 + 8);
iVar1 = js_resolve_export1(local_10,&local_68,&local_70,local_60,local_2c,local_38);
if (iVar1 == 3) {
return 3;
}
if (iVar1 == -1) {
return 0xffffffff;
}
if (iVar1 == 0) {
if (*local_20 == 0) {
*local_18 = local_68;
*local_20 = local_70;
}
else if ((*local_18 != local_68) ||
(*(int *)(local_70 + 0x14) != *(int *)(*local_20 + 0x14))) {
*local_18 = 0;
*local_20 = 0;
return 3;
}
}
}
if (*local_20 != 0) {
return 0;
}
}
local_4 = 1;
}
else if (local_40[4] == 0) {
*local_18 = local_28;
*local_20 = (long)local_40;
local_4 = 0;
}
else {
local_48 = *(int8 *)(*(long *)(local_28 + 0x18) + (long)*local_40 * 0x10 + 8);
if (local_40[5] == 0x7e) {
*local_18 = local_28;
*local_20 = (long)local_40;
local_4 = 0;
}
else {
local_4 = js_resolve_export1(local_10,local_18,local_20,local_48,local_40[5],local_38);
}
}
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
22,427 | js_resolve_export1 | bluesky950520[P]quickjs/quickjs.c | static JSResolveResultEnum js_resolve_export1(JSContext *ctx,
JSModuleDef **pmodule,
JSExportEntry **pme,
JSModuleDef *m,
JSAtom export_name,
JSResolveState *s)
{
JSExportEntry *me;
*pmodule = NULL;
*pme = NULL;
if (find_resolve_entry(s, m, export_name) >= 0)
return JS_RESOLVE_RES_CIRCULAR;
if (add_resolve_entry(ctx, s, m, export_name) < 0)
return JS_RESOLVE_RES_EXCEPTION;
me = find_export_entry(ctx, m, export_name);
if (me) {
if (me->export_type == JS_EXPORT_TYPE_LOCAL) {
/* local export */
*pmodule = m;
*pme = me;
return JS_RESOLVE_RES_FOUND;
} else {
/* indirect export */
JSModuleDef *m1;
m1 = m->req_module_entries[me->u.req_module_idx].module;
if (me->local_name == JS_ATOM__star_) {
/* export ns from */
*pmodule = m;
*pme = me;
return JS_RESOLVE_RES_FOUND;
} else {
return js_resolve_export1(ctx, pmodule, pme, m1,
me->local_name, s);
}
}
} else {
if (export_name != JS_ATOM_default) {
/* not found in direct or indirect exports: try star exports */
int i;
for(i = 0; i < m->star_export_entries_count; i++) {
JSStarExportEntry *se = &m->star_export_entries[i];
JSModuleDef *m1, *res_m;
JSExportEntry *res_me;
JSResolveResultEnum ret;
m1 = m->req_module_entries[se->req_module_idx].module;
ret = js_resolve_export1(ctx, &res_m, &res_me, m1,
export_name, s);
if (ret == JS_RESOLVE_RES_AMBIGUOUS ||
ret == JS_RESOLVE_RES_EXCEPTION) {
return ret;
} else if (ret == JS_RESOLVE_RES_FOUND) {
if (*pme != NULL) {
if (*pmodule != res_m ||
res_me->local_name != (*pme)->local_name) {
*pmodule = NULL;
*pme = NULL;
return JS_RESOLVE_RES_AMBIGUOUS;
}
} else {
*pmodule = res_m;
*pme = res_me;
}
}
}
if (*pme != NULL)
return JS_RESOLVE_RES_FOUND;
}
return JS_RESOLVE_RES_NOT_FOUND;
}
} | O2 | c | js_resolve_export1:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movl %r8d, %ebp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x8(%r9), %rax
movq %rax, 0x20(%rsp)
movl 0xc(%r9), %ebx
andq $0x0, (%r15)
andq $0x0, (%r13)
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x3b509
movq (%r14), %rdi
cmpq %r12, (%rdi,%rcx)
jne 0x3b503
cmpl %ebp, 0x8(%rdi,%rcx)
je 0x3b597
addq $0x10, %rcx
jmp 0x3b4eb
incl %ebx
movq 0x8(%rsp), %rdi
movq %r14, %rsi
pushq $0x10
popq %rdx
movq 0x20(%rsp), %rcx
movl %ebx, %r8d
callq 0x3b0ef
testl %eax, %eax
jne 0x3b5b4
movq (%r14), %rax
movslq 0xc(%r14), %rcx
leal 0x1(%rcx), %ebx
movl %ebx, 0xc(%r14)
shlq $0x4, %rcx
movq %r12, (%rax,%rcx)
cmpl $0xe0, %ebp
jl 0x3b55e
movq 0x8(%rsp), %rdx
movq 0x18(%rdx), %rdx
movq 0x68(%rdx), %rdx
movl %ebp, %esi
movq (%rdx,%rsi,8), %rdx
incl (%rdx)
addq %rcx, %rax
movl %ebp, 0x8(%rax)
movq %r12, %rdi
movl %ebp, %esi
callq 0x2910e
testq %rax, %rax
je 0x3b5b8
cmpl $0x0, 0x10(%rax)
je 0x3b5a9
movl 0x14(%rax), %ebp
cmpl $0x7e, %ebp
je 0x3b5a9
movq 0x18(%r12), %rcx
movslq (%rax), %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %r12
jmp 0x3b4d2
pushq $0x2
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, (%r15)
movq %rax, (%r13)
xorl %eax, %eax
jmp 0x3b59a
pushq $-0x1
jmp 0x3b599
cmpl $0x16, %ebp
jne 0x3b5c1
pushq $0x1
jmp 0x3b599
movq %r13, %rdx
xorl %ebx, %ebx
movslq 0x40(%r12), %rax
cmpq %rax, %rbx
jge 0x3b655
movq 0x38(%r12), %rax
movq 0x18(%r12), %rcx
movslq (%rax,%rbx,4), %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rcx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movl %ebp, %r8d
movq %r14, %r9
callq 0x3b4a3
testl %eax, %eax
je 0x3b618
cmpl $-0x1, %eax
je 0x3b59a
movq %r13, %rdx
cmpl $0x3, %eax
jne 0x3b64d
jmp 0x3b59a
movq %r13, %rdx
movq (%r13), %rax
testq %rax, %rax
je 0x3b63d
movq (%r15), %rcx
cmpq 0x18(%rsp), %rcx
jne 0x3b666
movq 0x10(%rsp), %rcx
movl 0x14(%rcx), %ecx
cmpl 0x14(%rax), %ecx
je 0x3b64d
jmp 0x3b666
movq 0x18(%rsp), %rax
movq %rax, (%r15)
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
incq %rbx
jmp 0x3b5c6
xorl %eax, %eax
cmpq $0x0, (%rdx)
jne 0x3b59a
jmp 0x3b5bd
andq $0x0, (%r15)
andq $0x0, (%rdx)
pushq $0x3
jmp 0x3b599
| js_resolve_export1:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, r9
mov ebp, r8d
mov r12, rcx
mov r13, rdx
mov r15, rsi
mov [rsp+58h+var_50], rdi
lea rax, [r9+8]
mov [rsp+58h+var_38], rax
mov ebx, [r9+0Ch]
loc_3B4D2:
and qword ptr [r15], 0
and qword ptr [r13+0], 0
test ebx, ebx
mov eax, 0
cmovg eax, ebx
shl rax, 4
xor ecx, ecx
loc_3B4EB:
cmp rax, rcx
jz short loc_3B509
mov rdi, [r14]
cmp [rdi+rcx], r12
jnz short loc_3B503
cmp [rdi+rcx+8], ebp
jz loc_3B597
loc_3B503:
add rcx, 10h
jmp short loc_3B4EB
loc_3B509:
inc ebx
mov rdi, [rsp+58h+var_50]
mov rsi, r14
push 10h
pop rdx
mov rcx, [rsp+58h+var_38]
mov r8d, ebx
call js_resize_array
test eax, eax
jnz loc_3B5B4
mov rax, [r14]
movsxd rcx, dword ptr [r14+0Ch]
lea ebx, [rcx+1]
mov [r14+0Ch], ebx
shl rcx, 4
mov [rax+rcx], r12
cmp ebp, 0E0h
jl short loc_3B55E
mov rdx, [rsp+58h+var_50]
mov rdx, [rdx+18h]
mov rdx, [rdx+68h]
mov esi, ebp
mov rdx, [rdx+rsi*8]
inc dword ptr [rdx]
loc_3B55E:
add rax, rcx
mov [rax+8], ebp
mov rdi, r12
mov esi, ebp
call find_export_entry
test rax, rax
jz short loc_3B5B8
cmp dword ptr [rax+10h], 0
jz short loc_3B5A9
mov ebp, [rax+14h]
cmp ebp, 7Eh ; '~'
jz short loc_3B5A9
mov rcx, [r12+18h]
movsxd rax, dword ptr [rax]
shl rax, 4
mov r12, [rcx+rax+8]
jmp loc_3B4D2
loc_3B597:
push 2
loc_3B599:
pop rax
loc_3B59A:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3B5A9:
mov [r15], r12
mov [r13+0], rax
xor eax, eax
jmp short loc_3B59A
loc_3B5B4:
push 0FFFFFFFFFFFFFFFFh
jmp short loc_3B599
loc_3B5B8:
cmp ebp, 16h
jnz short loc_3B5C1
loc_3B5BD:
push 1
jmp short loc_3B599
loc_3B5C1:
mov rdx, r13
xor ebx, ebx
loc_3B5C6:
movsxd rax, dword ptr [r12+40h]
cmp rbx, rax
jge loc_3B655
mov rax, [r12+38h]
mov rcx, [r12+18h]
movsxd rax, dword ptr [rax+rbx*4]
shl rax, 4
mov rcx, [rcx+rax+8]
mov rdi, [rsp+58h+var_50]
lea rsi, [rsp+58h+var_40]
lea rdx, [rsp+58h+var_48]
mov r8d, ebp
mov r9, r14
call js_resolve_export1
test eax, eax
jz short loc_3B618
cmp eax, 0FFFFFFFFh
jz short loc_3B59A
mov rdx, r13
cmp eax, 3
jnz short loc_3B64D
jmp short loc_3B59A
loc_3B618:
mov rdx, r13
mov rax, [r13+0]
test rax, rax
jz short loc_3B63D
mov rcx, [r15]
cmp rcx, [rsp+58h+var_40]
jnz short loc_3B666
mov rcx, [rsp+58h+var_48]
mov ecx, [rcx+14h]
cmp ecx, [rax+14h]
jz short loc_3B64D
jmp short loc_3B666
loc_3B63D:
mov rax, [rsp+58h+var_40]
mov [r15], rax
mov rax, [rsp+58h+var_48]
mov [rdx], rax
loc_3B64D:
inc rbx
jmp loc_3B5C6
loc_3B655:
xor eax, eax
cmp qword ptr [rdx], 0
jnz loc_3B59A
jmp loc_3B5BD
loc_3B666:
and qword ptr [r15], 0
and qword ptr [rdx], 0
push 3
jmp loc_3B599
| long long js_resolve_export1(long long a1, long long *a2, _QWORD *a3, long long a4, int a5, long long a6)
{
int v10; // ebx
long long v11; // rax
long long v12; // rax
long long i; // rcx
long long v14; // rax
long long v15; // rcx
long long v16; // rcx
_DWORD *v17; // rdx
int *export_entry; // rax
long long result; // rax
_QWORD *v20; // rdx
long long j; // rbx
long long v23; // [rsp+10h] [rbp-48h] BYREF
long long v24; // [rsp+18h] [rbp-40h] BYREF
_DWORD *v25; // [rsp+20h] [rbp-38h]
v25 = (_DWORD *)(a6 + 8);
v10 = *(_DWORD *)(a6 + 12);
while ( 2 )
{
*a2 = 0LL;
*a3 = 0LL;
v11 = 0LL;
if ( v10 > 0 )
v11 = (unsigned int)v10;
v12 = 16 * v11;
for ( i = 0LL; v12 != i; i += 16LL )
{
if ( *(_QWORD *)(*(_QWORD *)a6 + i) == a4 && *(_DWORD *)(*(_QWORD *)a6 + i + 8) == a5 )
return 2LL;
}
if ( (unsigned int)js_resize_array(a1, a6, 16LL, v25, v10 + 1) )
return -1LL;
v14 = *(_QWORD *)a6;
v15 = *(int *)(a6 + 12);
v10 = v15 + 1;
*(_DWORD *)(a6 + 12) = v15 + 1;
v16 = 16 * v15;
*(_QWORD *)(v14 + v16) = a4;
if ( a5 >= 224 )
{
v17 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a5);
++*v17;
}
*(_DWORD *)(v16 + v14 + 8) = a5;
export_entry = (int *)find_export_entry(a4, a5);
if ( !export_entry )
{
if ( a5 != 22 )
{
v20 = a3;
for ( j = 0LL; j < *(int *)(a4 + 64); ++j )
{
result = js_resolve_export1(
a1,
&v24,
&v23,
*(_QWORD *)(*(_QWORD *)(a4 + 24) + 16LL * *(int *)(*(_QWORD *)(a4 + 56) + 4 * j) + 8),
(unsigned int)a5,
a6);
if ( (_DWORD)result )
{
if ( (_DWORD)result == -1 )
return result;
v20 = a3;
if ( (_DWORD)result == 3 )
return result;
}
else
{
v20 = a3;
if ( *a3 )
{
if ( *a2 != v24 || *(_DWORD *)(v23 + 20) != *(_DWORD *)(*a3 + 20LL) )
{
*a2 = 0LL;
*a3 = 0LL;
return 3LL;
}
}
else
{
*a2 = v24;
*a3 = v23;
}
}
}
result = 0LL;
if ( *v20 )
return result;
}
return 1LL;
}
if ( export_entry[4] )
{
a5 = export_entry[5];
if ( a5 != 126 )
{
a4 = *(_QWORD *)(*(_QWORD *)(a4 + 24) + 16LL * *export_entry + 8);
continue;
}
}
break;
}
*a2 = a4;
*a3 = export_entry;
return 0LL;
}
| js_resolve_export1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,R9
MOV EBP,R8D
MOV R12,RCX
MOV R13,RDX
MOV R15,RSI
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[R9 + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV EBX,dword ptr [R9 + 0xc]
LAB_0013b4d2:
AND qword ptr [R15],0x0
AND qword ptr [R13],0x0
TEST EBX,EBX
MOV EAX,0x0
CMOVG EAX,EBX
SHL RAX,0x4
XOR ECX,ECX
LAB_0013b4eb:
CMP RAX,RCX
JZ 0x0013b509
MOV RDI,qword ptr [R14]
CMP qword ptr [RDI + RCX*0x1],R12
JNZ 0x0013b503
CMP dword ptr [RDI + RCX*0x1 + 0x8],EBP
JZ 0x0013b597
LAB_0013b503:
ADD RCX,0x10
JMP 0x0013b4eb
LAB_0013b509:
INC EBX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R14
PUSH 0x10
POP RDX
MOV RCX,qword ptr [RSP + 0x20]
MOV R8D,EBX
CALL 0x0013b0ef
TEST EAX,EAX
JNZ 0x0013b5b4
MOV RAX,qword ptr [R14]
MOVSXD RCX,dword ptr [R14 + 0xc]
LEA EBX,[RCX + 0x1]
MOV dword ptr [R14 + 0xc],EBX
SHL RCX,0x4
MOV qword ptr [RAX + RCX*0x1],R12
CMP EBP,0xe0
JL 0x0013b55e
MOV RDX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RDX + 0x18]
MOV RDX,qword ptr [RDX + 0x68]
MOV ESI,EBP
MOV RDX,qword ptr [RDX + RSI*0x8]
INC dword ptr [RDX]
LAB_0013b55e:
ADD RAX,RCX
MOV dword ptr [RAX + 0x8],EBP
MOV RDI,R12
MOV ESI,EBP
CALL 0x0012910e
TEST RAX,RAX
JZ 0x0013b5b8
CMP dword ptr [RAX + 0x10],0x0
JZ 0x0013b5a9
MOV EBP,dword ptr [RAX + 0x14]
CMP EBP,0x7e
JZ 0x0013b5a9
MOV RCX,qword ptr [R12 + 0x18]
MOVSXD RAX,dword ptr [RAX]
SHL RAX,0x4
MOV R12,qword ptr [RCX + RAX*0x1 + 0x8]
JMP 0x0013b4d2
LAB_0013b597:
PUSH 0x2
LAB_0013b599:
POP RAX
LAB_0013b59a:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013b5a9:
MOV qword ptr [R15],R12
MOV qword ptr [R13],RAX
XOR EAX,EAX
JMP 0x0013b59a
LAB_0013b5b4:
PUSH -0x1
JMP 0x0013b599
LAB_0013b5b8:
CMP EBP,0x16
JNZ 0x0013b5c1
LAB_0013b5bd:
PUSH 0x1
JMP 0x0013b599
LAB_0013b5c1:
MOV RDX,R13
XOR EBX,EBX
LAB_0013b5c6:
MOVSXD RAX,dword ptr [R12 + 0x40]
CMP RBX,RAX
JGE 0x0013b655
MOV RAX,qword ptr [R12 + 0x38]
MOV RCX,qword ptr [R12 + 0x18]
MOVSXD RAX,dword ptr [RAX + RBX*0x4]
SHL RAX,0x4
MOV RCX,qword ptr [RCX + RAX*0x1 + 0x8]
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x10]
MOV R8D,EBP
MOV R9,R14
CALL 0x0013b4a3
TEST EAX,EAX
JZ 0x0013b618
CMP EAX,-0x1
JZ 0x0013b59a
MOV RDX,R13
CMP EAX,0x3
JNZ 0x0013b64d
JMP 0x0013b59a
LAB_0013b618:
MOV RDX,R13
MOV RAX,qword ptr [R13]
TEST RAX,RAX
JZ 0x0013b63d
MOV RCX,qword ptr [R15]
CMP RCX,qword ptr [RSP + 0x18]
JNZ 0x0013b666
MOV RCX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RCX + 0x14]
CMP ECX,dword ptr [RAX + 0x14]
JZ 0x0013b64d
JMP 0x0013b666
LAB_0013b63d:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [R15],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RDX],RAX
LAB_0013b64d:
INC RBX
JMP 0x0013b5c6
LAB_0013b655:
XOR EAX,EAX
CMP qword ptr [RDX],0x0
JNZ 0x0013b59a
JMP 0x0013b5bd
LAB_0013b666:
AND qword ptr [R15],0x0
AND qword ptr [RDX],0x0
PUSH 0x3
JMP 0x0013b599
|
int8
js_resolve_export1(long param_1,long *param_2,long *param_3,long param_4,uint param_5,long *param_6)
{
int iVar1;
ulong uVar2;
int *piVar3;
int8 uVar4;
long lVar5;
long lVar6;
uint uVar7;
long local_48;
long local_40;
long *local_38;
local_38 = param_6 + 1;
uVar7 = *(uint *)((long)param_6 + 0xc);
while( true ) {
*param_2 = 0;
*param_3 = 0;
uVar2 = 0;
if (0 < (int)uVar7) {
uVar2 = (ulong)uVar7;
}
for (lVar5 = 0; uVar2 * 0x10 != lVar5; lVar5 = lVar5 + 0x10) {
if ((*(long *)(*param_6 + lVar5) == param_4) && (*(uint *)(*param_6 + 8 + lVar5) == param_5))
{
return 2;
}
}
iVar1 = js_resize_array(param_1,param_6,0x10,local_38,uVar7 + 1);
if (iVar1 != 0) {
return 0xffffffffffffffff;
}
lVar5 = *param_6;
iVar1 = *(int *)((long)param_6 + 0xc);
uVar7 = iVar1 + 1;
*(uint *)((long)param_6 + 0xc) = uVar7;
lVar6 = (long)iVar1 * 0x10;
*(long *)(lVar5 + lVar6) = param_4;
if (0xdf < (int)param_5) {
piVar3 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_5 * 8);
*piVar3 = *piVar3 + 1;
}
*(uint *)(lVar5 + lVar6 + 8) = param_5;
piVar3 = (int *)find_export_entry(param_4,param_5);
if (piVar3 == (int *)0x0) break;
if ((piVar3[4] == 0) || (param_5 = piVar3[5], param_5 == 0x7e)) {
*param_2 = param_4;
*param_3 = (long)piVar3;
return 0;
}
param_4 = *(long *)(*(long *)(param_4 + 0x18) + 8 + (long)*piVar3 * 0x10);
}
if (param_5 != 0x16) {
for (lVar5 = 0; lVar5 < *(int *)(param_4 + 0x40); lVar5 = lVar5 + 1) {
uVar4 = js_resolve_export1(param_1,&local_40,&local_48,
*(int8 *)
(*(long *)(param_4 + 0x18) + 8 +
(long)*(int *)(*(long *)(param_4 + 0x38) + lVar5 * 4) * 0x10),
param_5,param_6);
iVar1 = (int)uVar4;
if (iVar1 == 0) {
if (*param_3 == 0) {
*param_2 = local_40;
*param_3 = local_48;
}
else if ((*param_2 != local_40) || (*(int *)(local_48 + 0x14) != *(int *)(*param_3 + 0x14)))
{
*param_2 = 0;
*param_3 = 0;
return 3;
}
}
else {
if (iVar1 == -1) {
return uVar4;
}
if (iVar1 == 3) {
return uVar4;
}
}
}
if (*param_3 != 0) {
return 0;
}
}
return 1;
}
| |
22,428 | js_ecvt1 | bluesky950520[P]quickjs/quickjs.c | static int js_ecvt1(double d, int n_digits,
char dest[minimum_length(JS_ECVT_BUF_SIZE)],
size_t size, int *decpt)
{
/* d is positive, ensure decimal point is always present */
snprintf(dest, size, "%#.*e", n_digits - 1, d);
/* dest contents:
0: first digit
1: '.' decimal point (locale specific)
2..n_digits: (n_digits-1) additional digits
n_digits+1: 'e' exponent mark
n_digits+2..: exponent sign, value and null terminator
*/
/* extract the exponent (actually the position of the decimal point) */
*decpt = 1 + atoi(dest + n_digits + 2);
return n_digits;
} | O0 | c | js_ecvt1:
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movsd 0x20(%rsp), %xmm0
leaq 0xab9a8(%rip), %rdx # 0x10e232
movb $0x1, %al
callq 0xe2d0
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
addq $0x2, %rdi
callq 0xe880
movl %eax, %ecx
addl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| js_ecvt1:
sub rsp, 28h
movsd [rsp+28h+var_8], xmm0
mov [rsp+28h+var_C], edi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov [rsp+28h+var_28], rcx
mov rdi, [rsp+28h+var_18]
mov rsi, [rsp+28h+var_20]
mov ecx, [rsp+28h+var_C]
sub ecx, 1
movsd xmm0, [rsp+28h+var_8]
lea rdx, aE; "%#.*e"
mov al, 1
call _snprintf
mov rdi, [rsp+28h+var_18]
movsxd rax, [rsp+28h+var_C]
add rdi, rax
add rdi, 2
call _atoi
mov ecx, eax
add ecx, 1
mov rax, [rsp+28h+var_28]
mov [rax], ecx
mov eax, [rsp+28h+var_C]
add rsp, 28h
retn
| long long js_ecvt1(unsigned int a1, long long a2, long long a3, _DWORD *a4, double a5)
{
snprintf(a2, a3, "%#.*e", a1 - 1, a5);
*a4 = atoi((int)a1 + a2 + 2) + 1;
return a1;
}
| js_ecvt1:
SUB RSP,0x28
MOVSD qword ptr [RSP + 0x20],XMM0
MOV dword ptr [RSP + 0x1c],EDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSP],RCX
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x1c]
SUB ECX,0x1
MOVSD XMM0,qword ptr [RSP + 0x20]
LEA RDX,[0x20e232]
MOV AL,0x1
CALL 0x0010e2d0
MOV RDI,qword ptr [RSP + 0x10]
MOVSXD RAX,dword ptr [RSP + 0x1c]
ADD RDI,RAX
ADD RDI,0x2
CALL 0x0010e880
MOV ECX,EAX
ADD ECX,0x1
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RSP + 0x1c]
ADD RSP,0x28
RET
|
int js_ecvt1(int8 param_1,int param_2,char *param_3,size_t param_4,int *param_5)
{
int iVar1;
snprintf(param_3,param_4,"%#.*e",param_1,(ulong)(param_2 - 1));
iVar1 = atoi(param_3 + (long)param_2 + 2);
*param_5 = iVar1 + 1;
return param_2;
}
| |
22,429 | js_ecvt1 | bluesky950520[P]quickjs/quickjs.c | static int js_ecvt1(double d, int n_digits,
char dest[minimum_length(JS_ECVT_BUF_SIZE)],
size_t size, int *decpt)
{
/* d is positive, ensure decimal point is always present */
snprintf(dest, size, "%#.*e", n_digits - 1, d);
/* dest contents:
0: first digit
1: '.' decimal point (locale specific)
2..n_digits: (n_digits-1) additional digits
n_digits+1: 'e' exponent mark
n_digits+2..: exponent sign, value and null terminator
*/
/* extract the exponent (actually the position of the decimal point) */
*decpt = 1 + atoi(dest + n_digits + 2);
return n_digits;
} | O2 | c | js_ecvt1:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
leal -0x1(%r15), %ecx
leaq 0x4f7cc(%rip), %rdx # 0x8611e
pushq $0x7d
popq %rsi
movq %r14, %rdi
movb $0x1, %al
callq 0xe2e0
movslq %r15d, %r15
leaq (%r14,%r15), %rdi
addq $0x2, %rdi
callq 0xe8b0
incl %eax
movl %eax, (%rbx)
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
| js_ecvt1:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15d, edi
lea ecx, [r15-1]
lea rdx, aE; "%#.*e"
push 7Dh ; '}'
pop rsi
mov rdi, r14
mov al, 1
call _snprintf
movsxd r15, r15d
lea rdi, [r14+r15]
add rdi, 2
call _atoi
inc eax
mov [rbx], eax
mov eax, r15d
pop rbx
pop r14
pop r15
retn
| long long js_ecvt1(unsigned int a1, long long a2, _DWORD *a3, double a4)
{
snprintf(a2, 125LL, "%#.*e", a1 - 1, a4);
*a3 = atoi(a2 + (int)a1 + 2) + 1;
return a1;
}
| js_ecvt1:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15D,EDI
LEA ECX,[R15 + -0x1]
LEA RDX,[0x18611e]
PUSH 0x7d
POP RSI
MOV RDI,R14
MOV AL,0x1
CALL 0x0010e2e0
MOVSXD R15,R15D
LEA RDI,[R14 + R15*0x1]
ADD RDI,0x2
CALL 0x0010e8b0
INC EAX
MOV dword ptr [RBX],EAX
MOV EAX,R15D
POP RBX
POP R14
POP R15
RET
|
int js_ecvt1(int param_1,char *param_2,int *param_3)
{
int iVar1;
snprintf(param_2,0x7d,"%#.*e",(ulong)(param_1 - 1));
iVar1 = atoi(param_2 + (long)param_1 + 2);
*param_3 = iVar1 + 1;
return param_1;
}
| |
22,430 | mi_init_bulk_insert | eloqsql/storage/myisam/mi_write.c | int mi_init_bulk_insert(MI_INFO *info, size_t cache_size, ha_rows rows)
{
MYISAM_SHARE *share=info->s;
MI_KEYDEF *key=share->keyinfo;
bulk_insert_param *params;
uint i, num_keys, total_keylength;
ulonglong key_map;
DBUG_ENTER("_mi_init_bulk_insert");
DBUG_PRINT("enter",("cache_size: %lu", (ulong) cache_size));
DBUG_ASSERT(!info->bulk_insert &&
(!rows || rows >= MI_MIN_ROWS_TO_USE_BULK_INSERT));
mi_clear_all_keys_active(key_map);
for (i=total_keylength=num_keys=0 ; i < share->base.keys ; i++)
{
if (! (key[i].flag & HA_NOSAME) && (share->base.auto_key != i + 1) &&
mi_is_key_active(share->state.key_map, i))
{
num_keys++;
mi_set_key_active(key_map, i);
total_keylength+=key[i].maxlength+TREE_ELEMENT_EXTRA_SIZE;
}
}
if (num_keys==0 ||
num_keys * (size_t) MI_MIN_SIZE_BULK_INSERT_TREE > cache_size)
DBUG_RETURN(0);
if (rows && rows*total_keylength < cache_size)
cache_size= (size_t) rows;
else
cache_size/=total_keylength*16;
info->bulk_insert=(TREE *)
my_malloc(mi_key_memory_MI_INFO_bulk_insert,
(sizeof(TREE)*share->base.keys+
sizeof(bulk_insert_param)*num_keys),MYF(0));
if (!info->bulk_insert)
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
params=(bulk_insert_param *)(info->bulk_insert+share->base.keys);
for (i=0 ; i < share->base.keys ; i++)
{
if (mi_is_key_active(key_map, i))
{
params->info=info;
params->keynr=i;
/* Only allocate a 16'th of the buffer at a time */
init_tree(&info->bulk_insert[i],
cache_size * key[i].maxlength,
cache_size * key[i].maxlength, 0,
(qsort_cmp2)keys_compare, keys_free, (void *)params++, MYF(0));
}
else
info->bulk_insert[i].root=0;
}
DBUG_RETURN(0);
} | O3 | c | mi_init_bulk_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x30(%rbp)
movq (%rdi), %r13
movl 0x180(%r13), %r8d
testq %r8, %r8
je 0x8ea0a
movq %rdx, %rbx
movq 0x218(%r13), %r14
xorl %ecx, %ecx
xorl %r15d, %r15d
xorl %edi, %edi
xorl %eax, %eax
imulq $0x70, %rcx, %r9
testb $0x1, 0xa(%r14,%r9)
jne 0x8e8e0
movl 0x184(%r13), %r10d
leaq 0x1(%rcx), %rdx
cmpq %r10, %rdx
je 0x8e8e6
movq 0xc0(%r13), %r11
movl $0x1, %r10d
shlq %cl, %r10
btq %rcx, %r11
jae 0x8e8e6
addq %r14, %r9
incl %eax
orq %r10, %r15
movzwl 0x16(%r9), %ecx
addl %ecx, %edi
addl $0x20, %edi
jmp 0x8e8e6
incq %rcx
movq %rcx, %rdx
movq %rdx, %rcx
cmpq %r8, %rdx
jne 0x8e89a
xorl %r12d, %r12d
testl %eax, %eax
je 0x8ea0d
movq %r15, -0x40(%rbp)
movl %eax, %ecx
movq %rcx, %rax
shlq $0xe, %rax
cmpq %rsi, %rax
ja 0x8ea0d
testq %rbx, %rbx
je 0x8e91f
movl %edi, %eax
imulq %rbx, %rax
cmpq %rsi, %rax
jb 0x8e92d
shll $0x4, %edi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rax, %rbx
leaq 0xb7d1e0(%rip), %rax # 0xc0bb14
movl (%rax), %edi
imulq $0x298, %r8, %rax # imm = 0x298
shlq $0x4, %rcx
addq %rax, %rcx
xorl %r12d, %r12d
movq %rcx, %rsi
xorl %edx, %edx
callq 0xa6f99
movq %rax, %r15
movq -0x30(%rbp), %rax
movq %r15, 0x80(%rax)
testq %r15, %r15
je 0x8ea1f
movl 0x180(%r13), %eax
testq %rax, %rax
je 0x8ea0d
movq %rbx, -0x38(%rbp)
imulq $0x298, %rax, %rax # imm = 0x298
addq %rax, %r15
addq $0x16, %r14
xorl %r12d, %r12d
xorl %ebx, %ebx
movq -0x40(%rbp), %rax
btq %rbx, %rax
jae 0x8e9dd
movq -0x30(%rbp), %rax
movq %rax, (%r15)
movl %ebx, 0x8(%r15)
movq 0x80(%rax), %rdi
addq %r12, %rdi
movzwl (%r14), %edx
imulq -0x38(%rbp), %rdx
movq %rdx, %rsi
xorl %ecx, %ecx
leaq 0x64(%rip), %r8 # 0x8ea27
leaq 0x98(%rip), %r9 # 0x8ea62
pushq $0x0
pushq %r15
addq $0x10, %r15
callq 0xab8f8
addq $0x10, %rsp
jmp 0x8e9f0
movq -0x30(%rbp), %rax
movq 0x80(%rax), %rax
movq $0x0, (%rax,%r12)
incq %rbx
movl 0x180(%r13), %eax
addq $0x298, %r12 # imm = 0x298
addq $0x70, %r14
cmpq %rax, %rbx
jb 0x8e98f
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x80, %r12d
jmp 0x8ea0d
| mi_init_bulk_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_30], rdi
mov r13, [rdi]
mov r8d, [r13+180h]
test r8, r8
jz loc_8EA0A
mov rbx, rdx
mov r14, [r13+218h]
xor ecx, ecx
xor r15d, r15d
xor edi, edi
xor eax, eax
loc_8E89A:
imul r9, rcx, 70h ; 'p'
test byte ptr [r14+r9+0Ah], 1
jnz short loc_8E8E0
mov r10d, [r13+184h]
lea rdx, [rcx+1]
cmp rdx, r10
jz short loc_8E8E6
mov r11, [r13+0C0h]
mov r10d, 1
shl r10, cl
bt r11, rcx
jnb short loc_8E8E6
add r9, r14
inc eax
or r15, r10
movzx ecx, word ptr [r9+16h]
add edi, ecx
add edi, 20h ; ' '
jmp short loc_8E8E6
loc_8E8E0:
inc rcx
mov rdx, rcx
loc_8E8E6:
mov rcx, rdx
cmp rdx, r8
jnz short loc_8E89A
xor r12d, r12d
test eax, eax
jz loc_8EA0D
mov [rbp+var_40], r15
mov ecx, eax
mov rax, rcx
shl rax, 0Eh
cmp rax, rsi
ja loc_8EA0D
test rbx, rbx
jz short loc_8E91F
mov eax, edi
imul rax, rbx
cmp rax, rsi
jb short loc_8E92D
loc_8E91F:
shl edi, 4
mov rax, rsi
xor edx, edx
div rdi
mov rbx, rax
loc_8E92D:
lea rax, mi_key_memory_MI_INFO_bulk_insert
mov edi, [rax]
imul rax, r8, 298h
shl rcx, 4
add rcx, rax
xor r12d, r12d
mov rsi, rcx
xor edx, edx
call my_malloc
mov r15, rax
mov rax, [rbp+var_30]
mov [rax+80h], r15
test r15, r15
jz loc_8EA1F
mov eax, [r13+180h]
test rax, rax
jz loc_8EA0D
mov [rbp+var_38], rbx
imul rax, 298h
add r15, rax
add r14, 16h
xor r12d, r12d
xor ebx, ebx
loc_8E98F:
mov rax, [rbp+var_40]
bt rax, rbx
jnb short loc_8E9DD
mov rax, [rbp+var_30]
mov [r15], rax
mov [r15+8], ebx
mov rdi, [rax+80h]
add rdi, r12
movzx edx, word ptr [r14]
imul rdx, [rbp+var_38]
mov rsi, rdx
xor ecx, ecx
lea r8, keys_compare_0
lea r9, keys_free_0
push 0
push r15
add r15, 10h
call init_tree
add rsp, 10h
jmp short loc_8E9F0
loc_8E9DD:
mov rax, [rbp+var_30]
mov rax, [rax+80h]
mov qword ptr [rax+r12], 0
loc_8E9F0:
inc rbx
mov eax, [r13+180h]
add r12, 298h
add r14, 70h ; 'p'
cmp rbx, rax
jb short loc_8E98F
loc_8EA0A:
xor r12d, r12d
loc_8EA0D:
mov eax, r12d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8EA1F:
mov r12d, 80h
jmp short loc_8EA0D
| long long mi_init_bulk_insert(_QWORD *a1, unsigned long long a2, unsigned long long a3)
{
long long v3; // r13
long long v4; // r8
long long v6; // r14
unsigned long long v7; // rcx
long long v8; // r15
unsigned int v9; // edi
unsigned int v10; // eax
unsigned long long v11; // rdx
long long v12; // r11
unsigned int v13; // r12d
long long v14; // r15
long long v15; // r15
unsigned __int16 *v16; // r14
long long v17; // r12
unsigned long long v18; // rbx
long long v19; // rax
long long v21; // [rsp-10h] [rbp-50h]
long long v22; // [rsp+0h] [rbp-40h]
int v23; // [rsp+8h] [rbp-38h]
v3 = *a1;
v4 = *(unsigned int *)(*a1 + 384LL);
if ( !*(_DWORD *)(*a1 + 384LL) )
return 0;
v6 = *(_QWORD *)(v3 + 536);
v7 = 0LL;
v8 = 0LL;
v9 = 0;
v10 = 0;
do
{
if ( (*(_BYTE *)(v6 + 112 * v7 + 10) & 1) != 0 )
{
v11 = v7 + 1;
}
else
{
v11 = v7 + 1;
if ( v7 + 1 != *(_DWORD *)(v3 + 388) )
{
v12 = *(_QWORD *)(v3 + 192);
if ( _bittest64(&v12, v7) )
{
++v10;
v8 |= 1LL << v7;
v9 += *(unsigned __int16 *)(v6 + 112 * v7 + 22) + 32;
}
}
}
v7 = v11;
}
while ( v11 != v4 );
v13 = 0;
if ( v10 )
{
v22 = v8;
if ( (unsigned long long)v10 << 14 <= a2 )
{
if ( !a3 || a3 * v9 >= a2 )
a3 = a2 / (16 * v9);
v13 = 0;
v14 = my_malloc(mi_key_memory_MI_INFO_bulk_insert, 664 * v4 + 16LL * v10, 0LL);
a1[16] = v14;
if ( !v14 )
return 128;
if ( *(_DWORD *)(v3 + 384) )
{
v23 = a3;
v15 = 664LL * *(unsigned int *)(v3 + 384) + v14;
v16 = (unsigned __int16 *)(v6 + 22);
v17 = 0LL;
v18 = 0LL;
do
{
v19 = v22;
if ( _bittest64(&v19, v18) )
{
*(_QWORD *)v15 = a1;
*(_DWORD *)(v15 + 8) = v18;
v21 = v15;
v15 += 16LL;
init_tree(
v17 + *((_DWORD *)a1 + 32),
v23 * *v16,
v23 * *v16,
0,
(unsigned int)keys_compare_0,
(unsigned int)keys_free_0,
v21,
0LL);
}
else
{
*(_QWORD *)(a1[16] + v17) = 0LL;
}
++v18;
v17 += 664LL;
v16 += 56;
}
while ( v18 < *(unsigned int *)(v3 + 384) );
return 0;
}
}
}
return v13;
}
| mi_init_bulk_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x30],RDI
MOV R13,qword ptr [RDI]
MOV R8D,dword ptr [R13 + 0x180]
TEST R8,R8
JZ 0x0018ea0a
MOV RBX,RDX
MOV R14,qword ptr [R13 + 0x218]
XOR ECX,ECX
XOR R15D,R15D
XOR EDI,EDI
XOR EAX,EAX
LAB_0018e89a:
IMUL R9,RCX,0x70
TEST byte ptr [R14 + R9*0x1 + 0xa],0x1
JNZ 0x0018e8e0
MOV R10D,dword ptr [R13 + 0x184]
LEA RDX,[RCX + 0x1]
CMP RDX,R10
JZ 0x0018e8e6
MOV R11,qword ptr [R13 + 0xc0]
MOV R10D,0x1
SHL R10,CL
BT R11,RCX
JNC 0x0018e8e6
ADD R9,R14
INC EAX
OR R15,R10
MOVZX ECX,word ptr [R9 + 0x16]
ADD EDI,ECX
ADD EDI,0x20
JMP 0x0018e8e6
LAB_0018e8e0:
INC RCX
MOV RDX,RCX
LAB_0018e8e6:
MOV RCX,RDX
CMP RDX,R8
JNZ 0x0018e89a
XOR R12D,R12D
TEST EAX,EAX
JZ 0x0018ea0d
MOV qword ptr [RBP + -0x40],R15
MOV ECX,EAX
MOV RAX,RCX
SHL RAX,0xe
CMP RAX,RSI
JA 0x0018ea0d
TEST RBX,RBX
JZ 0x0018e91f
MOV EAX,EDI
IMUL RAX,RBX
CMP RAX,RSI
JC 0x0018e92d
LAB_0018e91f:
SHL EDI,0x4
MOV RAX,RSI
XOR EDX,EDX
DIV RDI
MOV RBX,RAX
LAB_0018e92d:
LEA RAX,[0xd0bb14]
MOV EDI,dword ptr [RAX]
IMUL RAX,R8,0x298
SHL RCX,0x4
ADD RCX,RAX
XOR R12D,R12D
MOV RSI,RCX
XOR EDX,EDX
CALL 0x001a6f99
MOV R15,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x80],R15
TEST R15,R15
JZ 0x0018ea1f
MOV EAX,dword ptr [R13 + 0x180]
TEST RAX,RAX
JZ 0x0018ea0d
MOV qword ptr [RBP + -0x38],RBX
IMUL RAX,RAX,0x298
ADD R15,RAX
ADD R14,0x16
XOR R12D,R12D
XOR EBX,EBX
LAB_0018e98f:
MOV RAX,qword ptr [RBP + -0x40]
BT RAX,RBX
JNC 0x0018e9dd
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [R15],RAX
MOV dword ptr [R15 + 0x8],EBX
MOV RDI,qword ptr [RAX + 0x80]
ADD RDI,R12
MOVZX EDX,word ptr [R14]
IMUL RDX,qword ptr [RBP + -0x38]
MOV RSI,RDX
XOR ECX,ECX
LEA R8,[0x18ea27]
LEA R9,[0x18ea62]
PUSH 0x0
PUSH R15
ADD R15,0x10
CALL 0x001ab8f8
ADD RSP,0x10
JMP 0x0018e9f0
LAB_0018e9dd:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RAX + R12*0x1],0x0
LAB_0018e9f0:
INC RBX
MOV EAX,dword ptr [R13 + 0x180]
ADD R12,0x298
ADD R14,0x70
CMP RBX,RAX
JC 0x0018e98f
LAB_0018ea0a:
XOR R12D,R12D
LAB_0018ea0d:
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018ea1f:
MOV R12D,0x80
JMP 0x0018ea0d
|
int8 mi_init_bulk_insert(long *param_1,ulong param_2,ulong param_3)
{
long lVar1;
uint uVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
uint uVar6;
long lVar7;
ushort *puVar8;
ulong uVar9;
int8 *puVar10;
lVar1 = *param_1;
uVar5 = (ulong)*(uint *)(lVar1 + 0x180);
if (uVar5 != 0) {
lVar7 = *(long *)(lVar1 + 0x218);
uVar4 = 0;
uVar9 = 0;
uVar6 = 0;
uVar2 = 0;
do {
if ((((*(byte *)(lVar7 + 10 + uVar4 * 0x70) & 1) == 0) &&
(uVar4 + 1 != (ulong)*(uint *)(lVar1 + 0x184))) &&
((*(ulong *)(lVar1 + 0xc0) >> (uVar4 & 0x3f) & 1) != 0)) {
uVar2 = uVar2 + 1;
uVar9 = uVar9 | 1L << ((byte)uVar4 & 0x3f);
uVar6 = uVar6 + *(ushort *)(uVar4 * 0x70 + lVar7 + 0x16) + 0x20;
}
uVar4 = uVar4 + 1;
} while (uVar4 != uVar5);
if (uVar2 == 0) {
return 0;
}
if (param_2 < (ulong)uVar2 << 0xe) {
return 0;
}
if ((param_3 == 0) || (param_2 <= uVar6 * param_3)) {
param_3 = param_2 / (uVar6 << 4);
}
lVar3 = my_malloc(mi_key_memory_MI_INFO_bulk_insert,(ulong)uVar2 * 0x10 + uVar5 * 0x298,0);
param_1[0x10] = lVar3;
if (lVar3 == 0) {
return 0x80;
}
if ((ulong)*(uint *)(lVar1 + 0x180) == 0) {
return 0;
}
puVar10 = (int8 *)(lVar3 + (ulong)*(uint *)(lVar1 + 0x180) * 0x298);
puVar8 = (ushort *)(lVar7 + 0x16);
lVar7 = 0;
uVar5 = 0;
do {
if ((uVar9 >> (uVar5 & 0x3f) & 1) == 0) {
*(int8 *)(param_1[0x10] + lVar7) = 0;
}
else {
*puVar10 = param_1;
*(int *)(puVar10 + 1) = (int)uVar5;
init_tree(param_1[0x10] + lVar7,*puVar8 * param_3,*puVar8 * param_3,0,keys_compare,keys_free
,puVar10,0,uVar9,param_3);
puVar10 = puVar10 + 2;
}
uVar5 = uVar5 + 1;
lVar7 = lVar7 + 0x298;
puVar8 = puVar8 + 0x38;
} while (uVar5 < *(uint *)(lVar1 + 0x180));
}
return 0;
}
| |
22,431 | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned int>(char*, unsigned int, int) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/format.h | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
out -= 2;
copy2(out, digits2(static_cast<size_t>(value % 100)));
value /= 100;
}
if (value < 10) {
*--out = static_cast<Char>('0' + value);
return {out, end};
}
out -= 2;
copy2(out, digits2(static_cast<size_t>(value)));
return {out, end};
} | O0 | c | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned int>(char*, unsigned int, int):
subq $0xb8, %rsp
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rdx
movq %rdi, 0x68(%rsp)
movq %rdx, 0x58(%rsp)
movq %rax, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xa1380
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movb %al, 0x4b(%rsp)
leaq 0x4b(%rsp), %rdi
leaq 0x33c2ba(%rip), %rsi # 0x3dd700
callq 0xa0470
movl 0x4c(%rsp), %ecx
movq 0x68(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %rax
subq $0x64, %rcx
sbbq $0x0, %rax
jb 0xa1518
jmp 0xa1483
movq 0x68(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
movl $0x64, %edx
movq %rdx, 0x10(%rsp)
callq 0x96150
movq %rax, %rdi
callq 0xa0480
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rsi, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rsi
movw (%rsi), %si
movw %si, (%rax)
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x90350
movq %rdx, 0x58(%rsp)
movq %rax, 0x50(%rsp)
jmp 0xa1469
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rcx
xorl %eax, %eax
movl $0x9, %edx
subq %rsi, %rdx
sbbq %rcx, %rax
jb 0xa156a
jmp 0xa1533
movb 0x50(%rsp), %cl
addb $0x30, %cl
movq 0x68(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x68(%rsp)
movb %cl, -0x1(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0xa15cf
movq 0x68(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0xa0480
movq (%rsp), %rcx
movq %rcx, 0xa0(%rsp)
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq 0x90(%rsp), %rdx
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
| _ZN3fmt3v106detail14format_decimalIcoEENS1_21format_decimal_resultIPT_EES5_T0_i:
sub rsp, 0B8h
mov [rsp+0B8h+var_48], rsi
mov [rsp+0B8h+var_40], rdx
mov rax, [rsp+0B8h+var_48]
mov rdx, [rsp+0B8h+var_40]
mov [rsp+0B8h+var_50], rdi
mov [rsp+0B8h+var_60], rdx
mov [rsp+0B8h+var_68], rax
mov [rsp+0B8h+var_6C], ecx
mov eax, [rsp+0B8h+var_6C]
mov [rsp+0B8h+var_94], eax
mov rax, [rsp+0B8h+var_68]
mov rcx, [rsp+0B8h+var_60]
mov qword ptr [rsp+0B8h+var_80], rcx
mov [rsp+0B8h+var_88], rax
mov rdi, [rsp+0B8h+var_88]; this
mov rsi, qword ptr [rsp+0B8h+var_80]; unsigned __int128
call _ZN3fmt3v106detail12count_digitsEo; fmt::v10::detail::count_digits(unsigned __int128)
mov ecx, eax
mov eax, [rsp+0B8h+var_94]
cmp eax, ecx
setnl al
and al, 1
mov [rsp+0B8h+var_6D], al
lea rdi, [rsp+0B8h+var_6D]
lea rsi, aInvalidDigitCo; "invalid digit count"
call _ZN3fmt3v106detail13ignore_unusedIJbA20_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [20]>(bool,char [20] const&)
mov ecx, [rsp+0B8h+var_6C]
mov rax, [rsp+0B8h+var_50]
movsxd rcx, ecx
add rax, rcx
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_90], rax
loc_A1469:
mov rcx, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_60]
sub rcx, 64h ; 'd'
sbb rax, 0
jb loc_A1518
jmp short $+2
loc_A1483:
mov rax, [rsp+0B8h+var_50]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_B0], rax
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_60]; unsigned __int64
xor eax, eax
mov ecx, eax
mov [rsp+0B8h+var_A0], rcx
mov edx, 64h ; 'd'
mov [rsp+0B8h+var_A8], rdx
call ___umodti3
mov rdi, rax; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rsi, [rsp+0B8h+var_B0]
mov rdx, [rsp+0B8h+var_A8]
mov rcx, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_8], rsi
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_8]
mov rsi, [rsp+0B8h+var_10]
mov si, [rsi]
mov [rax], si
mov rdi, [rsp+0B8h+var_68]
mov rsi, [rsp+0B8h+var_60]
call ___udivti3
mov [rsp+0B8h+var_60], rdx
mov [rsp+0B8h+var_68], rax
jmp loc_A1469
loc_A1518:
mov rsi, [rsp+0B8h+var_68]; unsigned __int64
mov rcx, [rsp+0B8h+var_60]
xor eax, eax
mov edx, 9
sub rdx, rsi
sbb rax, rcx
jb short loc_A156A
jmp short $+2
loc_A1533:
mov cl, byte ptr [rsp+0B8h+var_68]
add cl, 30h ; '0'
mov rax, [rsp+0B8h+var_50]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+0B8h+var_50], rdx
mov [rax-1], cl
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_30], rax
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_28], rax
jmp short loc_A15CF
loc_A156A:
mov rax, [rsp+0B8h+var_50]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+0B8h+var_50], rax
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_B8], rax
mov rdi, [rsp+0B8h+var_68]; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rcx, [rsp+0B8h+var_B8]
mov [rsp+0B8h+var_18], rcx
mov [rsp+0B8h+var_20], rax
mov rax, [rsp+0B8h+var_18]
mov rcx, [rsp+0B8h+var_20]
mov cx, [rcx]
mov [rax], cx
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_30], rax
mov rax, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_28], rax
loc_A15CF:
mov rax, [rsp+0B8h+var_30]
mov rdx, [rsp+0B8h+var_28]
add rsp, 0B8h
retn
| _WORD * fmt::v10::detail::format_decimal<char,unsigned __int128>(
long long a1,
fmt::v10::detail *a2,
long long a3,
int a4,
long long a5,
long long a6)
{
fmt::v10::detail *v6; // rax
unsigned __int128 v7; // rax
unsigned __int128 v10; // [rsp+50h] [rbp-68h]
_WORD *v11; // [rsp+68h] [rbp-50h]
*((_QWORD *)&v10 + 1) = a3;
*(_QWORD *)&v10 = a2;
fmt::v10::detail::count_digits(a2, a3, a3, a3, a5, a6);
fmt::v10::detail::ignore_unused<bool,char [20]>();
v11 = (_WORD *)(a4 + a1);
while ( v10 >= 0x64 )
{
--v11;
v6 = (fmt::v10::detail *)__umodti3(v10, *((_QWORD *)&v10 + 1));
*v11 = *(_WORD *)fmt::v10::detail::digits2(v6);
*(_QWORD *)&v7 = __udivti3(v10, *((_QWORD *)&v10 + 1), 100LL, 0LL);
v10 = v7;
}
if ( 9 < v10 )
{
*(v11 - 1) = *(_WORD *)fmt::v10::detail::digits2((fmt::v10::detail *)v10);
return v11 - 1;
}
else
{
*((_BYTE *)v11 - 1) = v10 + 48;
return (_WORD *)((char *)v11 - 1);
}
}
| format_decimal<char,unsigned__int128>:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x70],RSI
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RAX
MOV dword ptr [RSP + 0x4c],ECX
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x24],EAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001a1380
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,ECX
SETGE AL
AND AL,0x1
MOV byte ptr [RSP + 0x4b],AL
LEA RDI,[RSP + 0x4b]
LEA RSI,[0x4dd700]
CALL 0x001a0470
MOV ECX,dword ptr [RSP + 0x4c]
MOV RAX,qword ptr [RSP + 0x68]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x28],RAX
LAB_001a1469:
MOV RCX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RSP + 0x58]
SUB RCX,0x64
SBB RAX,0x0
JC 0x001a1518
JMP 0x001a1483
LAB_001a1483:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,-0x2
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
XOR EAX,EAX
MOV ECX,EAX
MOV qword ptr [RSP + 0x18],RCX
MOV EDX,0x64
MOV qword ptr [RSP + 0x10],RDX
CALL 0x00196150
MOV RDI,RAX
CALL 0x001a0480
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xb0],RSI
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV SI,word ptr [RSI]
MOV word ptr [RAX],SI
MOV RDI,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x58]
CALL 0x00190350
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001a1469
LAB_001a1518:
MOV RSI,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x58]
XOR EAX,EAX
MOV EDX,0x9
SUB RDX,RSI
SBB RAX,RCX
JC 0x001a156a
JMP 0x001a1533
LAB_001a1533:
MOV CL,byte ptr [RSP + 0x50]
ADD CL,0x30
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x68],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001a15cf
LAB_001a156a:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,-0x2
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001a0480
MOV RCX,qword ptr [RSP]
MOV qword ptr [RSP + 0xa0],RCX
MOV qword ptr [RSP + 0x98],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0x98]
MOV CX,word ptr [RCX]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x90],RAX
LAB_001a15cf:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
ADD RSP,0xb8
RET
|
/* fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned
__int128>(char*, unsigned __int128, int) */
int1 [16] __thiscall
fmt::v10::detail::format_decimal<char,unsigned__int128>
(detail *this,char *param_1,uint param_2,int param_3)
{
int1 auVar1 [16];
int iVar2;
detail *pdVar3;
detail *pdVar4;
ulong uVar5;
int2 *puVar6;
int4 in_register_00000014;
int1 auVar7 [16];
bool local_6d;
int local_6c;
int1 local_68 [16];
detail *local_50;
char *local_48;
int8 local_40;
detail *local_30;
int2 *local_10;
detail *local_8;
local_68._8_8_ = CONCAT44(in_register_00000014,param_2);
local_6c = param_3;
local_68._0_8_ = param_1;
local_50 = this;
local_48 = param_1;
local_40 = local_68._8_8_;
iVar2 = count_digits((detail *)param_1,param_2);
local_6d = iVar2 <= param_3;
ignore_unused<bool,char[20]>(&local_6d,"invalid digit count");
auVar7._8_8_ = local_68._8_8_;
auVar7._0_8_ = local_68._0_8_;
pdVar3 = local_50 + local_6c;
local_50 = pdVar3;
while (local_68._8_8_ = auVar7._8_8_, local_68._0_8_ = auVar7._0_8_,
(ulong)((ulong)local_68._0_8_ < 100) <= (ulong)local_68._8_8_) {
pdVar4 = local_50 + -2;
local_50 = pdVar4;
uVar5 = __umodti3(local_68._0_8_,local_68._8_8_);
local_68 = auVar7;
local_10 = (int2 *)digits2(uVar5);
*(int2 *)pdVar4 = *local_10;
local_8 = pdVar4;
auVar7 = __udivti3(local_68._0_8_,local_68._8_8_,100,0);
}
if (local_68._8_8_ == 0 && (ulong)(9 < (ulong)local_68._0_8_) <= (ulong)-local_68._8_8_) {
local_68[0] = auVar7[0];
local_30 = local_50 + -1;
local_50[-1] = (detail)(local_68[0] + '0');
}
else {
pdVar4 = local_50 + -2;
local_50 = pdVar4;
puVar6 = (int2 *)digits2(local_68._0_8_);
local_68 = auVar7;
*(int2 *)pdVar4 = *puVar6;
local_30 = local_50;
}
auVar1._8_8_ = pdVar3;
auVar1._0_8_ = local_30;
return auVar1;
}
| |
22,432 | getopt_ull_limit_value | eloqsql/mysys/my_getopt.c | ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp,
my_bool *fix)
{
my_bool adjusted= FALSE;
ulonglong old= num;
char buf1[255], buf2[255];
DBUG_ENTER("getopt_ull_limit_value");
if ((ulonglong) num > (ulonglong) optp->max_value &&
optp->max_value) /* if max value is not set -> no upper limit */
{
num= (ulonglong) optp->max_value;
adjusted= TRUE;
}
switch ((optp->var_type & GET_TYPE_MASK)) {
case GET_UINT:
if (num > (ulonglong) UINT_MAX)
{
num= ((ulonglong) UINT_MAX);
adjusted= TRUE;
}
break;
case GET_ULONG:
#if SIZEOF_LONG < SIZEOF_LONG_LONG
if (num > (ulonglong) ULONG_MAX)
{
num= ((ulonglong) ULONG_MAX);
adjusted= TRUE;
}
#endif
break;
default:
DBUG_ASSERT((optp->var_type & GET_TYPE_MASK) == GET_ULL);
break;
}
if (optp->block_size > 1)
{
num/= (ulonglong) optp->block_size;
num*= (ulonglong) optp->block_size;
}
if (num < (ulonglong) optp->min_value)
{
num= (ulonglong) optp->min_value;
if (old < (ulonglong) optp->min_value)
adjusted= TRUE;
}
if (fix)
*fix= old != num;
else if (adjusted)
my_getopt_error_reporter(WARNING_LEVEL,
"option '%s': unsigned value %s adjusted to %s",
optp->name, ullstr(old, buf1), ullstr(num, buf2));
DBUG_RETURN(num);
} | O3 | c | getopt_ull_limit_value:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdx, %rcx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq 0x50(%rsi), %rax
cmpq %rdi, %rax
setb %dl
testq %rax, %rax
setne %r9b
andb %dl, %r9b
cmoveq %rdi, %rax
movl 0x30(%rsi), %edx
andl $0x3f, %edx
cmpl $0x4, %edx
sete %dl
movq %rax, %r8
shrq $0x20, %r8
setne %r10b
andb %dl, %r10b
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
cmoveq %rax, %r8
movq 0x60(%rsi), %r11
cmpq $0x2, %r11
jl 0x5f553
movq %r8, %rax
xorl %edx, %edx
divq %r11
subq %rdx, %r8
movq 0x48(%rsi), %rax
cmpq %rax, %r8
movq %rax, %rbx
cmovaq %r8, %rbx
testq %rcx, %rcx
je 0x5f56e
cmpq %rdi, %rbx
setne (%rcx)
jmp 0x5f5cd
cmpq %rax, %r8
setb %cl
cmpq %rdi, %rax
seta %al
andb %cl, %al
orb %r9b, %r10b
orb %al, %r10b
testb $0x1, %r10b
je 0x5f5cd
leaq 0x2dafa9(%rip), %rax # 0x33a538
movq (%rax), %r12
movq (%rsi), %r14
leaq -0x130(%rbp), %rsi
callq 0x8f5b9
movq %rax, %r15
leaq -0x230(%rbp), %rsi
movq %rbx, %rdi
callq 0x8f5b9
leaq 0x38288(%rip), %rsi # 0x97842
movl $0x1, %edi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
xorl %eax, %eax
callq *%r12
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x5f5ef
movq %rbx, %rax
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x36290
| getopt_ull_limit_value:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 210h
mov rcx, rdx
mov rax, fs:28h
mov [rbp+var_28], rax
mov rax, [rsi+50h]
cmp rax, rdi
setb dl
test rax, rax
setnz r9b
and r9b, dl
cmovz rax, rdi
mov edx, [rsi+30h]
and edx, 3Fh
cmp edx, 4
setz dl
mov r8, rax
shr r8, 20h
setnz r10b
and r10b, dl
mov r8d, 0FFFFFFFFh
cmovz r8, rax
mov r11, [rsi+60h]
cmp r11, 2
jl short loc_5F553
mov rax, r8
xor edx, edx
div r11
sub r8, rdx
loc_5F553:
mov rax, [rsi+48h]
cmp r8, rax
mov rbx, rax
cmova rbx, r8
test rcx, rcx
jz short loc_5F56E
cmp rbx, rdi
setnz byte ptr [rcx]
jmp short loc_5F5CD
loc_5F56E:
cmp r8, rax
setb cl
cmp rax, rdi
setnbe al
and al, cl
or r10b, r9b
or r10b, al
test r10b, 1
jz short loc_5F5CD
lea rax, my_getopt_error_reporter
mov r12, [rax]
mov r14, [rsi]
lea rsi, [rbp+var_130]
call ullstr
mov r15, rax
lea rsi, [rbp+var_230]
mov rdi, rbx
call ullstr
lea rsi, aOptionSUnsigne; "option '%s': unsigned value %s adjusted"...
mov edi, 1
mov rdx, r14
mov rcx, r15
mov r8, rax
xor eax, eax
call r12
loc_5F5CD:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_5F5EF
mov rax, rbx
add rsp, 210h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_5F5EF:
call ___stack_chk_fail
| unsigned long long getopt_ull_limit_value(unsigned long long a1, long long a2, bool *a3)
{
unsigned long long v3; // rax
bool v4; // r9
bool v5; // r10
unsigned long long v6; // r8
long long v7; // r11
unsigned long long v8; // rax
unsigned long long v9; // rbx
long long (*v10)(int, const char *, ...); // r12
const char *v11; // r14
const char *v12; // r15
const char *v13; // rax
char v15[256]; // [rsp+0h] [rbp-230h] BYREF
char v16[264]; // [rsp+100h] [rbp-130h] BYREF
unsigned long long v17; // [rsp+208h] [rbp-28h]
v17 = __readfsqword(0x28u);
v3 = *(_QWORD *)(a2 + 80);
v4 = v3 < a1 && v3 != 0;
if ( !v4 )
v3 = a1;
v5 = (*(_DWORD *)(a2 + 48) & 0x3F) == 4 && HIDWORD(v3) != 0;
v6 = 0xFFFFFFFFLL;
if ( !v5 )
v6 = v3;
v7 = *(_QWORD *)(a2 + 96);
if ( v7 >= 2 )
v6 -= v6 % v7;
v8 = *(_QWORD *)(a2 + 72);
v9 = v8;
if ( v6 > v8 )
v9 = v6;
if ( a3 )
{
*a3 = v9 != a1;
}
else if ( v6 < v8 && v8 > a1 || v4 || v5 )
{
v10 = my_getopt_error_reporter;
v11 = *(const char **)a2;
v12 = (const char *)ullstr(a1, v16);
v13 = (const char *)ullstr(v9, v15);
v10(1, "option '%s': unsigned value %s adjusted to %s", v11, v12, v13);
}
return v9;
}
| getopt_ull_limit_value:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x210
MOV RCX,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RSI + 0x50]
CMP RAX,RDI
SETC DL
TEST RAX,RAX
SETNZ R9B
AND R9B,DL
CMOVZ RAX,RDI
MOV EDX,dword ptr [RSI + 0x30]
AND EDX,0x3f
CMP EDX,0x4
SETZ DL
MOV R8,RAX
SHR R8,0x20
SETNZ R10B
AND R10B,DL
MOV R8D,0xffffffff
CMOVZ R8,RAX
MOV R11,qword ptr [RSI + 0x60]
CMP R11,0x2
JL 0x0015f553
MOV RAX,R8
XOR EDX,EDX
DIV R11
SUB R8,RDX
LAB_0015f553:
MOV RAX,qword ptr [RSI + 0x48]
CMP R8,RAX
MOV RBX,RAX
CMOVA RBX,R8
TEST RCX,RCX
JZ 0x0015f56e
CMP RBX,RDI
SETNZ byte ptr [RCX]
JMP 0x0015f5cd
LAB_0015f56e:
CMP R8,RAX
SETC CL
CMP RAX,RDI
SETA AL
AND AL,CL
OR R10B,R9B
OR R10B,AL
TEST R10B,0x1
JZ 0x0015f5cd
LEA RAX,[0x43a538]
MOV R12,qword ptr [RAX]
MOV R14,qword ptr [RSI]
LEA RSI,[RBP + -0x130]
CALL 0x0018f5b9
MOV R15,RAX
LEA RSI,[RBP + -0x230]
MOV RDI,RBX
CALL 0x0018f5b9
LEA RSI,[0x197842]
MOV EDI,0x1
MOV RDX,R14
MOV RCX,R15
MOV R8,RAX
XOR EAX,EAX
CALL R12
LAB_0015f5cd:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x0015f5ef
MOV RAX,RBX
ADD RSP,0x210
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0015f5ef:
CALL 0x00136290
|
ulong getopt_ull_limit_value(ulong param_1,int8 *param_2,long param_3)
{
ulong uVar1;
int8 uVar2;
bool bVar3;
int *puVar4;
ulong uVar5;
int8 uVar6;
int8 uVar7;
ulong uVar8;
ulong uVar9;
long in_FS_OFFSET;
bool bVar10;
int1 local_238 [256];
int1 local_138 [264];
long local_30;
puVar4 = my_getopt_error_reporter;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar1 = param_2[10];
uVar5 = uVar1;
if (uVar1 == 0 || param_1 <= uVar1) {
uVar5 = param_1;
}
bVar10 = (*(uint *)(param_2 + 6) & 0x3f) != 4;
bVar3 = uVar5 >> 0x20 == 0;
uVar9 = 0xffffffff;
if (bVar3 || bVar10) {
uVar9 = uVar5;
}
if (1 < (long)param_2[0xc]) {
uVar9 = uVar9 - uVar9 % (ulong)param_2[0xc];
}
uVar5 = param_2[9];
uVar8 = uVar5;
if (uVar5 < uVar9) {
uVar8 = uVar9;
}
if (param_3 == 0) {
if ((!bVar3 && !bVar10 || uVar1 != 0 && param_1 > uVar1) || param_1 < uVar5 && uVar9 < uVar5) {
uVar2 = *param_2;
uVar6 = ullstr(param_1,local_138);
uVar7 = ullstr(uVar8,local_238);
(*(code *)puVar4)(1,"option \'%s\': unsigned value %s adjusted to %s",uVar2,uVar6,uVar7);
}
}
else {
*(bool *)param_3 = uVar8 != param_1;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return uVar8;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,433 | inline_mysql_file_sync(char const*, unsigned int, int, unsigned long) | eloqsql/include/mysql/psi/mysql_file.h | static inline int
inline_mysql_file_sync(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File fd, myf flags)
{
int result= 0;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, fd, PSI_FILE_SYNC);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, (size_t) 0, src_file, src_line);
result= my_sync(fd, flags);
PSI_FILE_CALL(end_file_wait)(locker, (size_t) 0);
return result;
}
#endif
result= my_sync(fd, flags);
return result;
} | O0 | c | inline_mysql_file_sync(char const*, unsigned int, int, unsigned long):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
leaq 0xcb56b9(%rip), %rax # 0x1b0e4d0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x10, %edx
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xe58ea5
leaq 0xcb5676(%rip), %rax # 0x1b0e4d0
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %esi, %esi
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x12c9a90
movl %eax, -0x24(%rbp)
leaq 0xcb5647(%rip), %rax # 0x1b0e4d0
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x30(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe58eba
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x12c9a90
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_sync_2:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 10h
call rax
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_E58EA5
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
xor esi, esi
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_sync
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_30]
xor ecx, ecx
mov esi, ecx
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_E58EBA
loc_E58EA5:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_sync
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_E58EBA:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
| long long inline_mysql_file_sync_2(long long a1, unsigned int a2, unsigned int a3, long long a4)
{
_BYTE v5[72]; // [rsp+8h] [rbp-78h] BYREF
long long v6; // [rsp+50h] [rbp-30h]
unsigned int v7; // [rsp+5Ch] [rbp-24h]
long long v8; // [rsp+60h] [rbp-20h]
unsigned int v9; // [rsp+68h] [rbp-18h]
unsigned int v10; // [rsp+6Ch] [rbp-14h]
long long v11; // [rsp+70h] [rbp-10h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7 = 0;
v6 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v5, a3, 16LL);
if ( v6 )
{
((void ( *)(long long, _QWORD, long long, _QWORD))PSI_server[66])(v6, 0LL, v11, v10);
v7 = my_sync(v9, v8);
((void ( *)(long long, _QWORD))PSI_server[67])(v6, 0LL);
}
else
{
return (unsigned int)my_sync(v9, v8);
}
return v7;
}
| inline_mysql_set_statement_text:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
CMP qword ptr [RBP + -0x8],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00e58e33
LEA RAX,[0x1c0e4d0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x268]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
LAB_00e58e33:
ADD RSP,0x20
POP RBP
RET
|
/* inline_mysql_set_statement_text(PSI_statement_locker*, char const*, unsigned int) */
void inline_mysql_set_statement_text(PSI_statement_locker *param_1,char *param_2,uint param_3)
{
if (param_1 != (PSI_statement_locker *)0x0) {
(**(code **)(PSI_server + 0x268))(param_1,param_2,param_3);
}
return;
}
| |
22,434 | common_chat_params_init_hermes_2_pro(minja::chat_template const&, common_chat_inputs const&) | monkey531[P]llama/common/chat.cpp | static common_chat_params common_chat_params_init_hermes_2_pro(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
common_chat_params data;
// (content)?(<tool_call>{"name": "foo", "arguments": {"a": 1}}</tool_call>)*
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
std::string name = function["name"];
auto parameters = function["parameters"];
builder.resolve_refs(parameters);
tool_rules.push_back(builder.add_schema(name + "-call", {
{"type", "object"},
{"properties", json {
{"name", json {{"const", name}}},
{"arguments", parameters},
}},
{"required", json::array({"name", "arguments"})},
}));
});
auto tool_call = "\"<tool_call>\" space " + builder.add_rule("tool_call", string_join(tool_rules, " | ")) + " \"</tool_call>\" space";
builder.add_rule("root", inputs.parallel_tool_calls ? "(" + tool_call + ")+" : tool_call);
data.grammar_triggers.push_back({"<tool_call>", /* .at_start = */ false});
data.preserved_tokens = { "</tool_call>" };
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
data.format = COMMON_CHAT_FORMAT_HERMES_2_PRO;
return data;
} | O0 | cpp | common_chat_params_init_hermes_2_pro(minja::chat_template const&, common_chat_inputs const&):
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movb $0x0, 0xff(%rsp)
callq 0x205200
movq 0x100(%rsp), %rdi
addq $0x20, %rdi
leaq 0x44420(%rip), %rsi # 0x218f4c
callq 0x1642c0
movq 0x38(%rsp), %rdi
movb %al, 0x38(%rdi)
movq 0x100(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq %rdi, 0xb0(%rsp)
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0xa8(%rsp), %rsi
callq 0x1e4bf0
movq 0x40(%rsp), %rsi
leaq 0x4b4ad(%rip), %rdx # 0x220024
leaq 0xd8(%rsp), %rdi
callq 0x19f260
jmp 0x1d4b86
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
leaq 0xd8(%rsp), %rsi
callq 0x5d950
leaq 0xd8(%rsp), %rdi
callq 0x5e548
leaq 0xb8(%rsp), %rdi
callq 0x1a4230
movq 0x108(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rdi
addq $0x10, %rdi
callq 0x116e20
testb $0x1, %al
jne 0x1d4be7
jmp 0x1d4bf7
leaq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa1500
jmp 0x1d4c11
movq 0x100(%rsp), %rsi
addq $0x10, %rsi
leaq 0x58(%rsp), %rdi
callq 0xb1e80
jmp 0x1d4c0f
jmp 0x1d4c11
movq 0x100(%rsp), %rax
movzbl 0x68(%rax), %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xa1500
movl 0x14(%rsp), %r8d
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %r9
movq %rsp, %rax
movl $0x1, (%rax)
andl $0x1, %r8d
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rcx
callq 0x15eeb0
jmp 0x1d4c66
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x107280
jmp 0x1d4c7a
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
leaq 0x88(%rsp), %rsi
callq 0xaa700
leaq 0x88(%rsp), %rdi
callq 0xa14c0
leaq 0x68(%rsp), %rdi
callq 0x5e548
leaq 0x48(%rsp), %rdi
callq 0xa14c0
leaq 0x58(%rsp), %rdi
callq 0xa14c0
movq 0x38(%rsp), %rax
movl $0x9, (%rax)
movb $0x1, 0xff(%rsp)
testb $0x1, 0xff(%rsp)
jne 0x1d4d6e
jmp 0x1d4d64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x1a4230
jmp 0x1d4d7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1d4d7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1d4d4e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5e548
leaq 0x48(%rsp), %rdi
callq 0xa14c0
leaq 0x58(%rsp), %rdi
callq 0xa14c0
jmp 0x1d4d7b
movq 0x38(%rsp), %rdi
callq 0x103770
movq 0x30(%rsp), %rax
addq $0x118, %rsp # imm = 0x118
retq
movq 0x38(%rsp), %rdi
callq 0x103770
movq 0xa0(%rsp), %rdi
callq 0x5dbc0
nopw %cs:(%rax,%rax)
| _ZL36common_chat_params_init_hermes_2_proRKN5minja13chat_templateERK18common_chat_inputs:
sub rsp, 118h
mov [rsp+118h+var_E0], rdi
mov rax, rdi
mov [rsp+118h+var_E8], rax
mov [rsp+118h+var_8], rdi
mov [rsp+118h+var_10], rsi
mov [rsp+118h+var_18], rdx
mov [rsp+118h+var_19], 0
call _ZN18common_chat_paramsC2Ev; common_chat_params::common_chat_params(void)
mov rdi, [rsp+118h+var_18]
add rdi, 20h ; ' '
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov rdi, [rsp+118h+var_E0]
mov [rdi+38h], al
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_70], rax
mov [rsp+118h+var_68], rdi
lea rdi, [rsp+118h+var_60]
mov [rsp+118h+var_D8], rdi
lea rsi, [rsp+118h+var_70]
call _ZNSt8functionIFvRK22common_grammar_builderEEC2IZL36common_chat_params_init_hermes_2_proRKN5minja13chat_templateERK18common_chat_inputsE3$_0vEEOT_; std::function<void ()(common_grammar_builder const&)>::function<common_chat_params_init_hermes_2_pro(minja::chat_template const&,common_chat_inputs const&)::$_0,void>(common_chat_params_init_hermes_2_pro(minja::chat_template const&,common_chat_inputs const&)::$_0 &&)
mov rsi, [rsp+118h+var_D8]
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+118h+var_40]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
jmp short $+2
loc_1D4B86:
mov rdi, [rsp+118h+var_E0]
add rdi, 18h
lea rsi, [rsp+118h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+118h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_60]
call _ZNSt8functionIFvRK22common_grammar_builderEED2Ev; std::function<void ()(common_grammar_builder const&)>::~function()
mov rax, [rsp+118h+var_10]
mov [rsp+118h+var_F8], rax
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_F0], rax
mov rdi, [rsp+118h+var_18]
add rdi, 10h
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::empty(void)
test al, 1
jnz short loc_1D4BE7
jmp short loc_1D4BF7
loc_1D4BE7:
lea rdi, [rsp+118h+var_C0]
xor eax, eax
mov esi, eax
call _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))
jmp short loc_1D4C11
loc_1D4BF7:
mov rsi, [rsp+118h+var_18]
add rsi, 10h
lea rdi, [rsp+118h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short $+2
loc_1D4C0F:
jmp short $+2
loc_1D4C11:
mov rax, [rsp+118h+var_18]
movzx eax, byte ptr [rax+68h]
mov [rsp+118h+var_104], eax
xor eax, eax
mov esi, eax
lea rdi, [rsp+118h+var_D0]
mov [rsp+118h+var_100], rdi
call _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 r8d, [rsp+118h+var_104]
mov rsi, [rsp+118h+var_F8]
mov rdx, [rsp+118h+var_F0]
mov r9, [rsp+118h+var_100]
mov rax, rsp
mov dword ptr [rax], 1
and r8d, 1
lea rdi, [rsp+118h+var_B0]
lea rcx, [rsp+118h+var_C0]
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
jmp short $+2
loc_1D4C66:
lea rdi, [rsp+118h+var_90]
lea rsi, [rsp+118h+var_B0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
jmp short $+2
loc_1D4C7A:
mov rdi, [rsp+118h+var_E0]
add rdi, 8
lea rsi, [rsp+118h+var_90]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
lea rdi, [rsp+118h+var_90]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
lea rdi, [rsp+118h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_D0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
lea rdi, [rsp+118h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rax, [rsp+118h+var_E0]
mov dword ptr [rax], 9
mov [rsp+118h+var_19], 1
test [rsp+118h+var_19], 1
jnz loc_1D4D6E
jmp loc_1D4D64
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_B0]
call _ZNSt8functionIFvRK22common_grammar_builderEED2Ev; std::function<void ()(common_grammar_builder const&)>::~function()
jmp short loc_1D4D7B
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_1D4D7B
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_1D4D4E
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1D4D4E:
lea rdi, [rsp+arg_40]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
lea rdi, [rsp+arg_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_1D4D7B
loc_1D4D64:
mov rdi, [rsp+118h+var_E0]; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
loc_1D4D6E:
mov rax, [rsp+118h+var_E8]
add rsp, 118h
retn
loc_1D4D7B:
mov rdi, [rsp+arg_30]; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, [rsp+arg_98]
call __Unwind_Resume
| const minja::chat_template * common_chat_params_init_hermes_2_pro(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
char v8; // [rsp+14h] [rbp-104h]
const common_chat_inputs *v9; // [rsp+20h] [rbp-F8h]
long long v10; // [rsp+28h] [rbp-F0h]
_BYTE v11[16]; // [rsp+48h] [rbp-D0h] BYREF
_BYTE v12[16]; // [rsp+58h] [rbp-C0h] BYREF
_BYTE v13[32]; // [rsp+68h] [rbp-B0h] BYREF
_BYTE v14[32]; // [rsp+88h] [rbp-90h] BYREF
_QWORD v15[2]; // [rsp+A8h] [rbp-70h] BYREF
_BYTE v16[32]; // [rsp+B8h] [rbp-60h] BYREF
_BYTE v17[40]; // [rsp+D8h] [rbp-40h] BYREF
long long v18; // [rsp+100h] [rbp-18h]
const common_chat_inputs *v19; // [rsp+108h] [rbp-10h]
const minja::chat_template *v20; // [rsp+110h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17[39] = 0;
common_chat_params::common_chat_params(a1);
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
v18 + 32,
(long long)"required",
v3,
v4,
v5,
v6);
v15[0] = v18;
v15[1] = a1;
std::function<void ()(common_grammar_builder const&)>::function<common_chat_params_init_hermes_2_pro(minja::chat_template const&,common_chat_inputs const&)::$_0,void>(
v16,
v15);
build_grammar[abi:cxx11]((long long)v17, (long long)v16, grammar_options);
std::string::operator=((char *)a1 + 24, v17);
std::string::~string(v17);
std::function<void ()(common_grammar_builder const&)>::~function((std::_Function_base *)v16);
v9 = v19;
v10 = v18;
if ( (nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::empty(v18 + 16) & 1) != 0 )
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json((long long)v12);
else
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v12,
v18 + 16);
v8 = *(_BYTE *)(v18 + 104);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json((long long)v11);
minja::chat_template::apply((long long)v13, v9, v10, (long long)v12, v8 & 1, v11, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(
v14,
(long long)v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
(long long)a1 + 8,
(long long)v14);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v14);
std::string::~string(v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)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>::~basic_json((long long)v12);
*(_DWORD *)a1 = 9;
return a1;
}
| _M_construct_aux<char*>:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x001d4b10
ADD RSP,0x28
RET
|
/* void std::__cxx11::string::_M_construct_aux<char*>(char*, char*, std::__false_type) */
void std::__cxx11::string::_M_construct_aux<char*>
(int8 param_1,int8 param_2,int8 param_3)
{
_M_construct<char*>(param_1,param_2,param_3);
return;
}
| |
22,435 | nglog::tools::SafeAppendString(char const*, char*, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | static void SafeAppendString(const char* source, char* dest, size_t dest_size) {
size_t dest_string_length = strlen(dest);
NGLOG_SAFE_ASSERT(dest_string_length < dest_size);
dest += dest_string_length;
dest_size -= dest_string_length;
strncpy(dest, source, dest_size);
// Making sure |dest| is always null-terminated.
dest[dest_size - 1] = '\0';
} | O1 | cpp | nglog::tools::SafeAppendString(char const*, char*, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7200
movq %rbx, %rdx
subq %rax, %rdx
jbe 0x217ee
addq %r14, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x7250
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72c0
| _ZN5nglog5toolsL16SafeAppendStringEPKcPcm:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
call _strlen
mov rdx, rbx
sub rdx, rax
jbe short loc_217EE
add rax, r14
mov rdi, rax
mov rsi, r15
call _strncpy
mov byte ptr [r14+rbx-1], 0
pop rbx
pop r14
pop r15
retn
loc_217EE:
call _abort
| long long nglog::tools::SafeAppendString(nglog::tools *this, const char *a2, char *a3)
{
unsigned long long v4; // rax
long long result; // rax
v4 = strlen(a2);
if ( (unsigned long long)a3 <= v4 )
abort(a2);
result = strncpy(&a2[v4], this, &a3[-v4]);
a3[(_QWORD)a2 - 1] = 0;
return result;
}
| SafeAppendString:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x00107200
MOV RDX,RBX
SUB RDX,RAX
JBE 0x001217ee
ADD RAX,R14
MOV RDI,RAX
MOV RSI,R15
CALL 0x00107250
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
POP RBX
POP R14
POP R15
RET
LAB_001217ee:
CALL 0x001072c0
|
/* nglog::tools::SafeAppendString(char const*, char*, unsigned long) */
void nglog::tools::SafeAppendString(char *param_1,char *param_2,ulong param_3)
{
size_t sVar1;
sVar1 = strlen(param_2);
if (sVar1 <= param_3 && param_3 - sVar1 != 0) {
strncpy(param_2 + sVar1,param_1,param_3 - sVar1);
param_2[param_3 - 1] = '\0';
return;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
22,436 | nglog::tools::SafeAppendString(char const*, char*, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | static void SafeAppendString(const char* source, char* dest, size_t dest_size) {
size_t dest_string_length = strlen(dest);
NGLOG_SAFE_ASSERT(dest_string_length < dest_size);
dest += dest_string_length;
dest_size -= dest_string_length;
strncpy(dest, source, dest_size);
// Making sure |dest| is always null-terminated.
dest[dest_size - 1] = '\0';
} | O3 | cpp | nglog::tools::SafeAppendString(char const*, char*, unsigned long):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7200
movq %rbx, %rdx
subq %rax, %rdx
jbe 0x21208
addq %r14, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x7250
movb $0x0, -0x1(%r14,%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x72c0
| _ZN5nglog5toolsL16SafeAppendStringEPKcPcm:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
call _strlen
mov rdx, rbx
sub rdx, rax
jbe short loc_21208
add rax, r14
mov rdi, rax
mov rsi, r15
call _strncpy
mov byte ptr [r14+rbx-1], 0
pop rbx
pop r14
pop r15
retn
loc_21208:
call _abort
| long long nglog::tools::SafeAppendString(nglog::tools *this, const char *a2, char *a3)
{
unsigned long long v4; // rax
long long result; // rax
v4 = strlen(a2);
if ( (unsigned long long)a3 <= v4 )
abort(a2);
result = strncpy(&a2[v4], this, &a3[-v4]);
a3[(_QWORD)a2 - 1] = 0;
return result;
}
| SafeAppendString:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
CALL 0x00107200
MOV RDX,RBX
SUB RDX,RAX
JBE 0x00121208
ADD RAX,R14
MOV RDI,RAX
MOV RSI,R15
CALL 0x00107250
MOV byte ptr [R14 + RBX*0x1 + -0x1],0x0
POP RBX
POP R14
POP R15
RET
LAB_00121208:
CALL 0x001072c0
|
/* nglog::tools::SafeAppendString(char const*, char*, unsigned long) */
void nglog::tools::SafeAppendString(char *param_1,char *param_2,ulong param_3)
{
size_t sVar1;
sVar1 = strlen(param_2);
if (sVar1 <= param_3 && param_3 - sVar1 != 0) {
strncpy(param_2 + sVar1,param_1,param_3 - sVar1);
param_2[param_3 - 1] = '\0';
return;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
22,437 | mariadb_read_options | eloqsql/libmariadb/libmariadb/ma_default.c | my_bool _mariadb_read_options(MYSQL *mysql,
const char *config_dir,
const char *config_file,
const char *group,
unsigned int recursion)
{
int i= 0,
exts,
errors= 0;
char filename[FN_REFLEN + 1];
unsigned int recursion_stop= 64;
#ifndef _WIN32
char *env;
#endif
if (recursion >= recursion_stop)
return 1;
if (config_file && config_file[0])
return _mariadb_read_options_from_file(mysql, config_file, group, recursion);
if (config_dir && config_dir[0])
{
for (exts= 0; ini_exts[exts]; exts++)
{
snprintf(filename, FN_REFLEN,
"%s%cmy.%s", config_dir, FN_LIBCHAR, ini_exts[exts]);
if (!access(filename, R_OK))
errors+= _mariadb_read_options_from_file(mysql, filename, group, recursion);
}
return errors;
}
for (i=0; i < MAX_CONFIG_DIRS && configuration_dirs[i]; i++)
{
for (exts= 0; ini_exts[exts]; exts++)
{
snprintf(filename, FN_REFLEN,
"%s%cmy.%s", configuration_dirs[i], FN_LIBCHAR, ini_exts[exts]);
if (!access(filename, R_OK))
errors+= _mariadb_read_options_from_file(mysql, filename, group, recursion);
}
}
#ifndef _WIN32
/* special case: .my.cnf in Home directory */
if ((env= getenv("HOME")))
{
for (exts= 0; ini_exts[exts]; exts++)
{
snprintf(filename, FN_REFLEN,
"%s%c.my.%s", env, FN_LIBCHAR, ini_exts[exts]);
if (!access(filename, R_OK))
errors+= _mariadb_read_options_from_file(mysql, filename, group, recursion);
}
}
#endif
return errors;
} | O3 | c | mariadb_read_options:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rcx, -0x258(%rbp)
movq %rdi, -0x250(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movb $0x1, %r12b
movl %r8d, -0x244(%rbp)
cmpl $0x3f, %r8d
jbe 0x434a0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x43683
movl %r12d, %eax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r9
testq %rdx, %rdx
je 0x434ed
cmpb $0x0, (%rdx)
je 0x434ed
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x43683
movq -0x250(%rbp), %rdi
movq %rdx, %rsi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x43688
testq %r9, %r9
je 0x4356b
cmpb $0x0, (%r9)
je 0x4356b
leaq 0xad21(%rip), %r10 # 0x4e220
leaq 0xacd5(%rip), %r8 # 0x4e1db
xorl %r12d, %r12d
leaq -0x240(%rbp), %r14
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movq %r14, %rdi
movl $0x1, %edx
xorl %eax, %eax
pushq %r10
pushq $0x2f
callq 0x142d0
addq $0x10, %rsp
movq %r14, %rdi
movl $0x4, %esi
callq 0x14780
testl %eax, %eax
jne 0x43478
leaq -0x240(%rbp), %rsi
movq -0x250(%rbp), %rdi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
callq 0x43688
jmp 0x4367b
xorl %r12d, %r12d
leaq 0x212fb(%rip), %r15 # 0x64870
leaq 0xac5f(%rip), %r13 # 0x4e1db
leaq -0x240(%rbp), %r14
xorl %ebx, %ebx
movq (%r15), %rax
movq (%rax,%rbx,8), %r9
testq %r9, %r9
je 0x435f5
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movq %r14, %rdi
movl $0x1, %edx
movq %r13, %r8
xorl %eax, %eax
leaq 0xac71(%rip), %r10 # 0x4e220
pushq %r10
pushq $0x2f
callq 0x142d0
addq $0x10, %rsp
movq %r14, %rdi
movl $0x4, %esi
callq 0x14780
testl %eax, %eax
jne 0x435ec
movq -0x250(%rbp), %rdi
movq %r14, %rsi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
callq 0x43688
addb %al, %r12b
incq %rbx
cmpq $0x6, %rbx
jne 0x43585
leaq 0xabcf(%rip), %rdi # 0x4e1cb
callq 0x145b0
testq %rax, %rax
je 0x43478
leaq 0xabd4(%rip), %r8 # 0x4e1e5
leaq -0x240(%rbp), %r14
movl $0x200, %esi # imm = 0x200
movl $0x201, %ecx # imm = 0x201
movq %r14, %rdi
movl $0x1, %edx
movq %rax, %r9
xorl %eax, %eax
leaq 0xabea(%rip), %r10 # 0x4e220
pushq %r10
pushq $0x2f
callq 0x142d0
addq $0x10, %rsp
movq %r14, %rdi
movl $0x4, %esi
callq 0x14780
testl %eax, %eax
jne 0x43478
leaq -0x240(%rbp), %rsi
movq -0x250(%rbp), %rdi
movq -0x258(%rbp), %rdx
movl -0x244(%rbp), %ecx
callq 0x43688
addb %r12b, %al
movl %eax, %r12d
jmp 0x43478
callq 0x14520
| _mariadb_read_options:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 238h
mov [rbp+var_258], rcx
mov [rbp+var_250], rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r12b, 1
mov [rbp+var_244], r8d
cmp r8d, 3Fh ; '?'
jbe short loc_434A0
loc_43478:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_43683
mov eax, r12d
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_434A0:
mov r9, rsi
test rdx, rdx
jz short loc_434ED
cmp byte ptr [rdx], 0
jz short loc_434ED
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_43683
mov rdi, [rbp+var_250]
mov rsi, rdx
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
add rsp, 238h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _mariadb_read_options_from_file
loc_434ED:
test r9, r9
jz short loc_4356B
cmp byte ptr [r9], 0
jz short loc_4356B
lea r10, aCnf; "cnf"
lea r8, aSCmyS; "%s%cmy.%s"
xor r12d, r12d
lea r14, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov rdi, r14
mov edx, 1
xor eax, eax
push r10
push 2Fh ; '/'
call ___snprintf_chk
add rsp, 10h
mov rdi, r14
mov esi, 4
call _access
test eax, eax
jnz loc_43478
lea rsi, [rbp+var_240]
mov rdi, [rbp+var_250]
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
call _mariadb_read_options_from_file
jmp loc_4367B
loc_4356B:
xor r12d, r12d
lea r15, configuration_dirs
lea r13, aSCmyS; "%s%cmy.%s"
lea r14, [rbp+var_240]
xor ebx, ebx
loc_43585:
mov rax, [r15]
mov r9, [rax+rbx*8]
test r9, r9
jz short loc_435F5
mov esi, 200h
mov ecx, 201h
mov rdi, r14
mov edx, 1
mov r8, r13
xor eax, eax
lea r10, aCnf; "cnf"
push r10
push 2Fh ; '/'
call ___snprintf_chk
add rsp, 10h
mov rdi, r14
mov esi, 4
call _access
test eax, eax
jnz short loc_435EC
mov rdi, [rbp+var_250]
mov rsi, r14
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
call _mariadb_read_options_from_file
add r12b, al
loc_435EC:
inc rbx
cmp rbx, 6
jnz short loc_43585
loc_435F5:
lea rdi, aMariadbHome+8; "HOME"
call _getenv
test rax, rax
jz loc_43478
lea r8, aSCMyS; "%s%c.my.%s"
lea r14, [rbp+var_240]
mov esi, 200h
mov ecx, 201h
mov rdi, r14
mov edx, 1
mov r9, rax
xor eax, eax
lea r10, aCnf; "cnf"
push r10
push 2Fh ; '/'
call ___snprintf_chk
add rsp, 10h
mov rdi, r14
mov esi, 4
call _access
test eax, eax
jnz loc_43478
lea rsi, [rbp+var_240]
mov rdi, [rbp+var_250]
mov rdx, [rbp+var_258]
mov ecx, [rbp+var_244]
call _mariadb_read_options_from_file
add al, r12b
loc_4367B:
mov r12d, eax
jmp loc_43478
loc_43683:
call ___stack_chk_fail
| long long mariadb_read_options(long long a1, const char *a2, _BYTE *a3, long long a4, unsigned int a5)
{
unsigned int v5; // r12d
double v7; // xmm0_8
unsigned int options_from_file; // eax
long long i; // rbx
const char *v10; // r9
double v11; // xmm0_8
const char *v12; // rax
double v13; // xmm0_8
_BYTE v16[528]; // [rsp+20h] [rbp-240h] BYREF
unsigned long long v17; // [rsp+230h] [rbp-30h]
v17 = __readfsqword(0x28u);
LOBYTE(v5) = 1;
if ( a5 > 0x3F )
return v5;
if ( !a3 || !*a3 )
{
if ( a2 && *a2 )
{
v5 = 0;
v7 = __snprintf_chk(v16, 512LL, 1LL, 513LL, "%s%cmy.%s", a2, 47LL, "cnf");
if ( (unsigned int)access(v16, 4LL, v7) )
return v5;
return (unsigned int)mariadb_read_options_from_file(a1, v16, a4, a5);
}
else
{
v5 = 0;
for ( i = 0LL; i != 6; ++i )
{
v10 = *(const char **)(configuration_dirs + 8 * i);
if ( !v10 )
break;
v11 = __snprintf_chk(v16, 512LL, 1LL, 513LL, "%s%cmy.%s", v10, 47LL, "cnf");
if ( !(unsigned int)access(v16, 4LL, v11) )
LOBYTE(v5) = mariadb_read_options_from_file(a1, v16, a4, a5) + v5;
}
v12 = (const char *)getenv("HOME");
if ( !v12 )
return v5;
v13 = __snprintf_chk(v16, 512LL, 1LL, 513LL, "%s%c.my.%s", v12, 47LL, "cnf");
if ( (unsigned int)access(v16, 4LL, v13) )
return v5;
options_from_file = mariadb_read_options_from_file(a1, v16, a4, a5);
LOBYTE(options_from_file) = v5 + options_from_file;
}
return options_from_file;
}
return mariadb_read_options_from_file(a1, a3, a4, a5);
}
| _mariadb_read_options:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x238
MOV qword ptr [RBP + -0x258],RCX
MOV qword ptr [RBP + -0x250],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R12B,0x1
MOV dword ptr [RBP + -0x244],R8D
CMP R8D,0x3f
JBE 0x001434a0
LAB_00143478:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00143683
MOV EAX,R12D
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001434a0:
MOV R9,RSI
TEST RDX,RDX
JZ 0x001434ed
CMP byte ptr [RDX],0x0
JZ 0x001434ed
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00143683
MOV RDI,qword ptr [RBP + -0x250]
MOV RSI,RDX
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
ADD RSP,0x238
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00143688
LAB_001434ed:
TEST R9,R9
JZ 0x0014356b
CMP byte ptr [R9],0x0
JZ 0x0014356b
LEA R10,[0x14e220]
LEA R8,[0x14e1db]
XOR R12D,R12D
LEA R14,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV RDI,R14
MOV EDX,0x1
XOR EAX,EAX
PUSH R10
PUSH 0x2f
CALL 0x001142d0
ADD RSP,0x10
MOV RDI,R14
MOV ESI,0x4
CALL 0x00114780
TEST EAX,EAX
JNZ 0x00143478
LEA RSI,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x250]
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
CALL 0x00143688
JMP 0x0014367b
LAB_0014356b:
XOR R12D,R12D
LEA R15,[0x164870]
LEA R13,[0x14e1db]
LEA R14,[RBP + -0x240]
XOR EBX,EBX
LAB_00143585:
MOV RAX,qword ptr [R15]
MOV R9,qword ptr [RAX + RBX*0x8]
TEST R9,R9
JZ 0x001435f5
MOV ESI,0x200
MOV ECX,0x201
MOV RDI,R14
MOV EDX,0x1
MOV R8,R13
XOR EAX,EAX
LEA R10,[0x14e220]
PUSH R10
PUSH 0x2f
CALL 0x001142d0
ADD RSP,0x10
MOV RDI,R14
MOV ESI,0x4
CALL 0x00114780
TEST EAX,EAX
JNZ 0x001435ec
MOV RDI,qword ptr [RBP + -0x250]
MOV RSI,R14
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
CALL 0x00143688
ADD R12B,AL
LAB_001435ec:
INC RBX
CMP RBX,0x6
JNZ 0x00143585
LAB_001435f5:
LEA RDI,[0x14e1cb]
CALL 0x001145b0
TEST RAX,RAX
JZ 0x00143478
LEA R8,[0x14e1e5]
LEA R14,[RBP + -0x240]
MOV ESI,0x200
MOV ECX,0x201
MOV RDI,R14
MOV EDX,0x1
MOV R9,RAX
XOR EAX,EAX
LEA R10,[0x14e220]
PUSH R10
PUSH 0x2f
CALL 0x001142d0
ADD RSP,0x10
MOV RDI,R14
MOV ESI,0x4
CALL 0x00114780
TEST EAX,EAX
JNZ 0x00143478
LEA RSI,[RBP + -0x240]
MOV RDI,qword ptr [RBP + -0x250]
MOV RDX,qword ptr [RBP + -0x258]
MOV ECX,dword ptr [RBP + -0x244]
CALL 0x00143688
ADD AL,R12B
LAB_0014367b:
MOV R12D,EAX
JMP 0x00143478
LAB_00143683:
CALL 0x00114520
|
ulong _mariadb_read_options
(int8 param_1,char *param_2,char *param_3,int8 param_4,uint param_5)
{
long lVar1;
char cVar2;
int iVar3;
uint uVar4;
ulong uVar5;
char *pcVar6;
int8 uVar7;
long lVar8;
int8 unaff_R12;
long in_FS_OFFSET;
char local_248 [528];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = CONCAT71((int7)((ulong)unaff_R12 >> 8),1);
if (param_5 < 0x40) {
if ((param_3 != (char *)0x0) && (*param_3 != '\0')) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
uVar5 = _mariadb_read_options_from_file(param_1,param_3,param_4,param_5);
return uVar5;
}
goto LAB_00143683;
}
if ((param_2 == (char *)0x0) || (*param_2 == '\0')) {
uVar5 = 0;
lVar8 = 0;
do {
lVar1 = *(long *)(configuration_dirs + lVar8 * 8);
if (lVar1 == 0) break;
__snprintf_chk(local_248,0x200,1,0x201,"%s%cmy.%s",lVar1,0x2f,&DAT_0014e220);
iVar3 = access(local_248,4);
if (iVar3 == 0) {
cVar2 = _mariadb_read_options_from_file(param_1,local_248,param_4,param_5);
uVar5 = (ulong)(byte)((char)uVar5 + cVar2);
}
lVar8 = lVar8 + 1;
} while (lVar8 != 6);
pcVar6 = getenv("HOME");
if (pcVar6 != (char *)0x0) {
__snprintf_chk(local_248,0x200,1,0x201,"%s%c.my.%s",pcVar6,0x2f,&DAT_0014e220);
iVar3 = access(local_248,4);
if (iVar3 == 0) {
uVar7 = _mariadb_read_options_from_file(param_1,local_248,param_4,param_5);
uVar4 = (uint)CONCAT71((int7)((ulong)uVar7 >> 8),(char)uVar7 + (char)uVar5);
goto LAB_0014367b;
}
}
}
else {
uVar5 = 0;
__snprintf_chk(local_248,0x200,1,0x201,"%s%cmy.%s",param_2,0x2f,&DAT_0014e220);
iVar3 = access(local_248,4);
if (iVar3 == 0) {
uVar4 = _mariadb_read_options_from_file(param_1,local_248,param_4,param_5);
LAB_0014367b:
uVar5 = (ulong)uVar4;
}
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5 & 0xffffffff;
}
LAB_00143683:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,438 | cxxopts::values::abstract_value<bool>::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | shubhamoy[P]dir2txt/include/cxxopts.hpp | void
parse(const std::string& text) const override
{
parse_value(text, *m_store);
} | O1 | cpp | cxxopts::values::abstract_value<bool>::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %r14
movq %rsi, %rdi
callq 0x252ac
testb %al, %al
je 0x24f13
movb $0x1, (%r14)
jmp 0x24f23
movq %rbx, %rdi
callq 0x253ad
testb %al, %al
je 0x24f2b
movb $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x254ae
| _ZNK7cxxopts6values14abstract_valueIbE5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, [rdi+28h]
mov rdi, rsi
call _ZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::values::parser_tool::IsTrueText(std::string const&)
test al, al
jz short loc_24F13
mov byte ptr [r14], 1
jmp short loc_24F23
loc_24F13:
mov rdi, rbx
call _ZN7cxxopts6values11parser_tool11IsFalseTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::values::parser_tool::IsFalseText(std::string const&)
test al, al
jz short loc_24F2B
mov byte ptr [r14], 0
loc_24F23:
add rsp, 8
pop rbx
pop r14
retn
loc_24F2B:
mov rdi, rbx; int
add rsp, 8
pop rbx
pop r14
jmp _ZN7cxxopts14throw_or_mimicINS_10exceptions23incorrect_argument_typeEEEvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::throw_or_mimic<cxxopts::exceptions::incorrect_argument_type>(std::string const&)
| long long cxxopts::values::abstract_value<bool>::parse(long long a1, int a2, int a3, int a4, int a5, int a6)
{
int v6; // eax
_BYTE *v7; // r14
long long result; // rax
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
int v13; // [rsp-8h] [rbp-18h]
v7 = *(_BYTE **)(a1 + 40);
result = cxxopts::values::parser_tool::IsTrueText(a2, a2, a3, a4, a5, a6, v6);
if ( (_BYTE)result )
{
*v7 = 1;
}
else
{
result = cxxopts::values::parser_tool::IsFalseText(a2, a2, v9, v10, v11, v12, v13);
if ( !(_BYTE)result )
cxxopts::throw_or_mimic<cxxopts::exceptions::incorrect_argument_type>(a2);
*v7 = 0;
}
return result;
}
| parse:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,qword ptr [RDI + 0x28]
MOV RDI,RSI
CALL 0x001252ac
TEST AL,AL
JZ 0x00124f13
MOV byte ptr [R14],0x1
JMP 0x00124f23
LAB_00124f13:
MOV RDI,RBX
CALL 0x001253ad
TEST AL,AL
JZ 0x00124f2b
MOV byte ptr [R14],0x0
LAB_00124f23:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00124f2b:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001254ae
|
/* cxxopts::values::abstract_value<bool>::parse(std::__cxx11::string const&) const */
void __thiscall
cxxopts::values::abstract_value<bool>::parse(abstract_value<bool> *this,string *param_1)
{
int1 *puVar1;
char cVar2;
puVar1 = *(int1 **)(this + 0x28);
cVar2 = parser_tool::IsTrueText(param_1);
if (cVar2 == '\0') {
cVar2 = parser_tool::IsFalseText(param_1);
if (cVar2 == '\0') {
throw_or_mimic<cxxopts::exceptions::incorrect_argument_type>(param_1);
return;
}
*puVar1 = 0;
}
else {
*puVar1 = 1;
}
return;
}
| |
22,439 | cxxopts::values::abstract_value<bool>::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | shubhamoy[P]dir2txt/include/cxxopts.hpp | void
parse(const std::string& text) const override
{
parse_value(text, *m_store);
} | O3 | cpp | cxxopts::values::abstract_value<bool>::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x28(%rdi), %r14
movq %rsi, %rdi
callq 0x24f90
testb %al, %al
je 0x24ba3
movb $0x1, (%r14)
jmp 0x24bb3
movq %rbx, %rdi
callq 0x25091
testb %al, %al
je 0x24bbb
movb $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x25192
| _ZNK7cxxopts6values14abstract_valueIbE5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, [rdi+28h]
mov rdi, rsi
call _ZN7cxxopts6values11parser_tool10IsTrueTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::values::parser_tool::IsTrueText(std::string const&)
test al, al
jz short loc_24BA3
mov byte ptr [r14], 1
jmp short loc_24BB3
loc_24BA3:
mov rdi, rbx
call _ZN7cxxopts6values11parser_tool11IsFalseTextERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::values::parser_tool::IsFalseText(std::string const&)
test al, al
jz short loc_24BBB
mov byte ptr [r14], 0
loc_24BB3:
add rsp, 8
pop rbx
pop r14
retn
loc_24BBB:
mov rdi, rbx; int
add rsp, 8
pop rbx
pop r14
jmp _ZN7cxxopts14throw_or_mimicINS_10exceptions23incorrect_argument_typeEEEvRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; cxxopts::throw_or_mimic<cxxopts::exceptions::incorrect_argument_type>(std::string const&)
| long long cxxopts::values::abstract_value<bool>::parse(long long a1, int a2, int a3, int a4, int a5, int a6)
{
int v6; // eax
_BYTE *v7; // r14
long long result; // rax
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
int v13; // [rsp-8h] [rbp-18h]
v7 = *(_BYTE **)(a1 + 40);
result = cxxopts::values::parser_tool::IsTrueText(a2, a2, a3, a4, a5, a6, v6);
if ( (_BYTE)result )
{
*v7 = 1;
}
else
{
result = cxxopts::values::parser_tool::IsFalseText(a2, a2, v9, v10, v11, v12, v13);
if ( !(_BYTE)result )
cxxopts::throw_or_mimic<cxxopts::exceptions::incorrect_argument_type>(a2);
*v7 = 0;
}
return result;
}
| parse:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,qword ptr [RDI + 0x28]
MOV RDI,RSI
CALL 0x00124f90
TEST AL,AL
JZ 0x00124ba3
MOV byte ptr [R14],0x1
JMP 0x00124bb3
LAB_00124ba3:
MOV RDI,RBX
CALL 0x00125091
TEST AL,AL
JZ 0x00124bbb
MOV byte ptr [R14],0x0
LAB_00124bb3:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00124bbb:
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00125192
|
/* cxxopts::values::abstract_value<bool>::parse(std::__cxx11::string const&) const */
void __thiscall
cxxopts::values::abstract_value<bool>::parse(abstract_value<bool> *this,string *param_1)
{
int1 *puVar1;
char cVar2;
puVar1 = *(int1 **)(this + 0x28);
cVar2 = parser_tool::IsTrueText(param_1);
if (cVar2 == '\0') {
cVar2 = parser_tool::IsFalseText(param_1);
if (cVar2 == '\0') {
throw_or_mimic<cxxopts::exceptions::incorrect_argument_type>(param_1);
return;
}
*puVar1 = 0;
}
else {
*puVar1 = 1;
}
return;
}
| |
22,440 | my_rnd_init | eloqsql/mysys/my_rnd.c | void my_rnd_init(struct my_rnd_struct *rand_st, ulong seed1, ulong seed2)
{
#ifdef HAVE_valgrind
bzero((char*) rand_st,sizeof(*rand_st)); /* Avoid UMC varnings */
#endif
rand_st->max_value= 0x3FFFFFFFL;
rand_st->max_value_dbl=(double) rand_st->max_value;
rand_st->seed1=seed1%rand_st->max_value ;
rand_st->seed2=seed2%rand_st->max_value;
} | O0 | c | my_rnd_init:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x3fffffff, 0x10(%rax) # imm = 0x3FFFFFFF
movq -0x8(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0x51db4(%rip), %xmm1 # 0x110b40
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x51db8(%rip), %xmm1 # 0x110b50
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x8(%rbp), %rax
movq %rdx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
| my_rnd_init:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 3FFFFFFFh
mov rax, [rbp+var_8]
movq xmm0, qword ptr [rax+10h]
movaps xmm1, xmmword ptr cs:_ZL17two_digit_numbers+200h; ""
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_110B50
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
mov rax, [rbp+var_8]
movsd qword ptr [rax+18h], xmm0
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
xor edx, edx
div qword ptr [rcx+10h]
mov rax, [rbp+var_8]
mov [rax], rdx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
xor edx, edx
div qword ptr [rcx+10h]
mov rax, [rbp+var_8]
mov [rax+8], rdx
pop rbp
retn
| long long my_rnd_init(long long a1, unsigned long long a2, unsigned long long a3)
{
__m128d v3; // xmm1
long long result; // rax
*(_QWORD *)(a1 + 16) = 0x3FFFFFFFLL;
v3 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64((const __m128i *)(a1 + 16)), *(__m128i *)""),
(__m128d)xmmword_110B50);
*(double *)(a1 + 24) = _mm_unpackhi_pd(v3, v3).m128d_f64[0] + v3.m128d_f64[0];
*(_QWORD *)a1 = a2 % *(_QWORD *)(a1 + 16);
result = a1;
*(_QWORD *)(a1 + 8) = a3 % *(_QWORD *)(a1 + 16);
return result;
}
| my_rnd_init:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x10],0x3fffffff
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,qword ptr [RAX + 0x10]
MOVAPS XMM1,xmmword ptr [0x00210b40]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM1,xmmword ptr [0x00210b50]
SUBPD XMM0,XMM1
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX + 0x18],XMM0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
XOR EDX,EDX
DIV qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
XOR EDX,EDX
DIV qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],RDX
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void my_rnd_init(ulong *param_1,ulong param_2,ulong param_3)
{
ulong uVar1;
int1 auVar2 [16];
param_1[2] = 0x3fffffff;
uVar1 = param_1[2];
auVar2._8_4_ = (int)(uVar1 >> 0x20);
auVar2._0_8_ = uVar1;
auVar2._12_4_ = _UNK_00210b44;
param_1[3] = (ulong)((auVar2._8_8_ - _UNK_00210b58) +
((double)CONCAT44(ram0x00210b40,(int)uVar1) - _DAT_00210b50));
*param_1 = param_2 % param_1[2];
param_1[1] = param_3 % param_1[2];
return;
}
| |
22,441 | my_rnd_init | eloqsql/mysys/my_rnd.c | void my_rnd_init(struct my_rnd_struct *rand_st, ulong seed1, ulong seed2)
{
#ifdef HAVE_valgrind
bzero((char*) rand_st,sizeof(*rand_st)); /* Avoid UMC varnings */
#endif
rand_st->max_value= 0x3FFFFFFFL;
rand_st->max_value_dbl=(double) rand_st->max_value;
rand_st->seed1=seed1%rand_st->max_value ;
rand_st->seed2=seed2%rand_st->max_value;
} | O3 | c | my_rnd_init:
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rcx
movq $0x3fffffff, 0x10(%rdi) # imm = 0x3FFFFFFF
movabsq $0x41cfffffff800000, %rax # imm = 0x41CFFFFFFF800000
movq %rax, 0x18(%rdi)
movabsq $0x400000011, %r8 # imm = 0x400000011
movq %rsi, %rax
mulq %r8
movq %rsi, %r9
subq %rdx, %r9
shrq %r9
addq %rdx, %r9
shrq $0x1d, %r9
movq %r9, %rax
shlq $0x1e, %rax
subq %rax, %r9
addq %rsi, %r9
movq %rcx, %rax
mulq %r8
movq %r9, (%rdi)
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x1d, %rax
movq %rax, %rdx
shlq $0x1e, %rdx
subq %rdx, %rax
addq %rcx, %rax
movq %rax, 0x8(%rdi)
popq %rbp
retq
| my_rnd_init:
push rbp
mov rbp, rsp
mov rcx, rdx
mov qword ptr [rdi+10h], 3FFFFFFFh
mov rax, 41CFFFFFFF800000h
mov [rdi+18h], rax
mov r8, 400000011h
mov rax, rsi
mul r8
mov r9, rsi
sub r9, rdx
shr r9, 1
add r9, rdx
shr r9, 1Dh
mov rax, r9
shl rax, 1Eh
sub r9, rax
add r9, rsi
mov rax, rcx
mul r8
mov [rdi], r9
mov rax, rcx
sub rax, rdx
shr rax, 1
add rax, rdx
shr rax, 1Dh
mov rdx, rax
shl rdx, 1Eh
sub rax, rdx
add rax, rcx
mov [rdi+8], rax
pop rbp
retn
| unsigned long long my_rnd_init(unsigned long long *a1, unsigned long long a2, unsigned long long a3)
{
unsigned long long result; // rax
a1[2] = 0x3FFFFFFFLL;
a1[3] = 0x41CFFFFFFF800000LL;
*a1 = a2 % 0x3FFFFFFF;
result = a3 % 0x3FFFFFFF;
a1[1] = a3 % 0x3FFFFFFF;
return result;
}
| my_rnd_init:
PUSH RBP
MOV RBP,RSP
MOV RCX,RDX
MOV qword ptr [RDI + 0x10],0x3fffffff
MOV RAX,0x41cfffffff800000
MOV qword ptr [RDI + 0x18],RAX
MOV R8,0x400000011
MOV RAX,RSI
MUL R8
MOV R9,RSI
SUB R9,RDX
SHR R9,0x1
ADD R9,RDX
SHR R9,0x1d
MOV RAX,R9
SHL RAX,0x1e
SUB R9,RAX
ADD R9,RSI
MOV RAX,RCX
MUL R8
MOV qword ptr [RDI],R9
MOV RAX,RCX
SUB RAX,RDX
SHR RAX,0x1
ADD RAX,RDX
SHR RAX,0x1d
MOV RDX,RAX
SHL RDX,0x1e
SUB RAX,RDX
ADD RAX,RCX
MOV qword ptr [RDI + 0x8],RAX
POP RBP
RET
|
void my_rnd_init(ulong *param_1,ulong param_2,ulong param_3)
{
param_1[2] = 0x3fffffff;
param_1[3] = 0x41cfffffff800000;
*param_1 = param_2 % 0x3fffffff;
param_1[1] = param_3 % 0x3fffffff;
return;
}
| |
22,442 | google::protobuf::BytesValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/wrappers.pb.cc | void BytesValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) {
auto* const _this = static_cast<BytesValue*>(&to_msg);
auto& from = static_cast<const BytesValue&>(from_msg);
// @@protoc_insertion_point(class_specific_merge_from_start:google.protobuf.BytesValue)
GOOGLE_DCHECK_NE(&from, _this);
uint32_t cached_has_bits = 0;
(void) cached_has_bits;
if (!from._internal_value().empty()) {
_this->_internal_set_value(from._internal_value());
}
_this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
} | O3 | cpp | google::protobuf::BytesValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rsi
andq $-0x4, %rsi
cmpq $0x0, 0x8(%rsi)
je 0xb25d7
leaq 0x10(%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
andq $-0x4, %rdx
testb $0x1, %al
jne 0xb2604
callq 0x786ce
movq 0x8(%r14), %rsi
testb $0x1, %sil
jne 0xb25e9
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x8, %rbx
andq $-0x4, %rsi
addq $0x8, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x734be
movq (%rdx), %rdx
jmp 0xb25d2
nop
| _ZN6google8protobuf10BytesValue9MergeImplERNS0_7MessageERKS2_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rsi, [rsi+10h]
and rsi, 0FFFFFFFFFFFFFFFCh
cmp qword ptr [rsi+8], 0
jz short loc_B25D7
lea rdi, [rbx+10h]
mov rax, [rbx+8]
mov rdx, rax
and rdx, 0FFFFFFFFFFFFFFFCh
test al, 1
jnz short loc_B2604
loc_B25D2:
call _ZN6google8protobuf8internal14ArenaStringPtr3SetERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPNS0_5ArenaE; google::protobuf::internal::ArenaStringPtr::Set(std::string const&,google::protobuf::Arena *)
loc_B25D7:
mov rsi, [r14+8]
test sil, 1
jnz short loc_B25E9
add rsp, 8
pop rbx
pop r14
retn
loc_B25E9:
add rbx, 8
and rsi, 0FFFFFFFFFFFFFFFCh
add rsi, 8
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZN6google8protobuf8internal16InternalMetadata11DoMergeFromINS0_15UnknownFieldSetEEEvRKT_; google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(google::protobuf::UnknownFieldSet const&)
loc_B2604:
mov rdx, [rdx]
jmp short loc_B25D2
| long long google::protobuf::BytesValue::MergeImpl(
google::protobuf::BytesValue *this,
google::protobuf::Message *a2,
const google::protobuf::Message *a3)
{
unsigned long long v5; // rsi
long long *v6; // rdi
google::protobuf::Arena *v7; // rdx
long long result; // rax
long long v9; // rsi
v5 = *((_QWORD *)a2 + 2) & 0xFFFFFFFFFFFFFFFCLL;
if ( *(_QWORD *)(v5 + 8) )
{
v6 = (long long *)((char *)this + 16);
v7 = (google::protobuf::Arena *)(*((_QWORD *)this + 1) & 0xFFFFFFFFFFFFFFFCLL);
if ( (*((_QWORD *)this + 1) & 1) != 0 )
v7 = *(google::protobuf::Arena **)v7;
result = google::protobuf::internal::ArenaStringPtr::Set(v6, v5, v7);
}
v9 = *((_QWORD *)a2 + 1);
if ( (v9 & 1) != 0 )
return google::protobuf::internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>(
(long long *)this + 1,
(const google::protobuf::UnknownFieldSet *)((v9 & 0xFFFFFFFFFFFFFFFCLL) + 8));
return result;
}
| MergeImpl:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x10]
AND RSI,-0x4
CMP qword ptr [RSI + 0x8],0x0
JZ 0x001b25d7
LEA RDI,[RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x8]
MOV RDX,RAX
AND RDX,-0x4
TEST AL,0x1
JNZ 0x001b2604
LAB_001b25d2:
CALL 0x001786ce
LAB_001b25d7:
MOV RSI,qword ptr [R14 + 0x8]
TEST SIL,0x1
JNZ 0x001b25e9
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001b25e9:
ADD RBX,0x8
AND RSI,-0x4
ADD RSI,0x8
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001734be
LAB_001b2604:
MOV RDX,qword ptr [RDX]
JMP 0x001b25d2
|
/* google::protobuf::BytesValue::MergeImpl(google::protobuf::Message&, google::protobuf::Message
const&) */
void google::protobuf::BytesValue::MergeImpl(Message *param_1,Message *param_2)
{
Arena *pAVar1;
if (*(long *)((string *)(*(ulong *)(param_2 + 0x10) & 0xfffffffffffffffc) + 8) != 0) {
pAVar1 = (Arena *)(*(ulong *)(param_1 + 8) & 0xfffffffffffffffc);
if ((*(ulong *)(param_1 + 8) & 1) != 0) {
pAVar1 = *(Arena **)pAVar1;
}
internal::ArenaStringPtr::Set
((ArenaStringPtr *)(param_1 + 0x10),
(string *)(*(ulong *)(param_2 + 0x10) & 0xfffffffffffffffc),pAVar1);
}
if ((*(ulong *)(param_2 + 8) & 1) == 0) {
return;
}
internal::InternalMetadata::DoMergeFrom<google::protobuf::UnknownFieldSet>
((InternalMetadata *)(param_1 + 8),
(UnknownFieldSet *)((*(ulong *)(param_2 + 8) & 0xfffffffffffffffc) + 8));
return;
}
| |
22,443 | psi_rwlock_trywrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_trywrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_TRYWRITELOCK, file, line);
int result= rw_trywrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_trywrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1b80ee(%rip), %rax # 0x1ea0d8
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x3, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x32650
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x32043
leaq 0x1b80a8(%rip), %rax # 0x1ea0d8
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_trywrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 3
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_trywrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_32043
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_32043:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_trywrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[0] + 54))(
v6,
*(_QWORD *)(a1 + 144),
3LL,
a2,
a3);
v4 = my_rw_trywrlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server[0] + 55))(v5, v4);
return v4;
}
| psi_rwlock_trywrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x2ea0d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x3
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00132650
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x00132043
LEA RAX,[0x2ea0d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_00132043:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_trywrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),3,param_2,param_3);
uVar1 = my_rw_trywrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
22,444 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O0 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x220(%rbp)
movq %rsi, -0x228(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0x79d30
movq %rax, -0x240(%rbp)
movl $0xffffffff, -0x248(%rbp) # imm = 0xFFFFFFFF
movq -0x240(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2b316
callq 0x24040
movl $0x24, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0x2b4ca
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x2b340
callq 0x24040
movl $0x2, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0x2b4ca
jmp 0x2b342
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x2b361
callq 0x24040
movl $0x2, (%rax)
jmp 0x2b4ab
jmp 0x2b363
movq -0x238(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x249(%rbp)
je 0x2b390
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x249(%rbp)
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x2b39c
jmp 0x2b3b0
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
jmp 0x2b363
movq -0x238(%rbp), %rax
movb $0x0, (%rax)
movq -0x230(%rbp), %rax
movw (%rax), %ax
subw $0x2e, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x2b3f0
movq -0x230(%rbp), %rdi
leaq 0x5111b(%rip), %rsi # 0x7c4fc
movl $0x3, %edx
callq 0x24130
cmpl $0x0, %eax
jne 0x2b400
callq 0x24040
movl $0x2, (%rax)
jmp 0x2b4ab
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
cmpq -0x240(%rbp), %rax
jb 0x2b44e
movl -0x248(%rbp), %ecx
movq -0x228(%rbp), %rax
movl %ecx, (%rax)
movq -0x220(%rbp), %rax
movq -0x230(%rbp), %rcx
leaq -0x210(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x218(%rbp)
jmp 0x2b4ca
movl -0x248(%rbp), %edi
movq -0x230(%rbp), %rsi
movl $0x2a0000, %edx # imm = 0x2A0000
movb $0x0, %al
callq 0x24300
movl %eax, -0x244(%rbp)
cmpl $0x0, -0x244(%rbp)
jge 0x2b478
jmp 0x2b4ab
cmpl $0x0, -0x248(%rbp)
jl 0x2b48c
movl -0x248(%rbp), %edi
callq 0x24650
movl -0x244(%rbp), %eax
movl %eax, -0x248(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0x2b342
cmpl $0x0, -0x248(%rbp)
jl 0x2b4bf
movl -0x248(%rbp), %edi
callq 0x24650
movq $0x0, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2b4fa
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x24370
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_220], rdi
mov [rbp+var_228], rsi
lea rax, [rbp+var_210]
mov [rbp+var_230], rax
lea rax, [rbp+var_210]
add rax, 1
mov [rbp+var_238], rax
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 201h
call strnmov
mov [rbp+var_240], rax
mov [rbp+var_248], 0FFFFFFFFh
mov rax, [rbp+var_240]
cmp byte ptr [rax], 0
jz short loc_2B316
call ___errno_location
mov dword ptr [rax], 24h ; '$'
mov [rbp+var_218], 0
jmp loc_2B4CA
loc_2B316:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jz short loc_2B340
call ___errno_location
mov dword ptr [rax], 2
mov [rbp+var_218], 0
jmp loc_2B4CA
loc_2B340:
jmp short $+2
loc_2B342:
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_2B361
call ___errno_location
mov dword ptr [rax], 2
jmp loc_2B4AB
loc_2B361:
jmp short $+2
loc_2B363:
mov rax, [rbp+var_238]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_249], al
jz short loc_2B390
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_249], al
loc_2B390:
mov al, [rbp+var_249]
test al, 1
jnz short loc_2B39C
jmp short loc_2B3B0
loc_2B39C:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
jmp short loc_2B363
loc_2B3B0:
mov rax, [rbp+var_238]
mov byte ptr [rax], 0
mov rax, [rbp+var_230]
mov ax, [rax]
sub ax, 2Eh ; '.'
setnz al
movzx eax, al
cmp eax, 0
jz short loc_2B3F0
mov rdi, [rbp+var_230]
lea rsi, asc_7C4FC; ".."
mov edx, 3
call _memcmp
cmp eax, 0
jnz short loc_2B400
loc_2B3F0:
call ___errno_location
mov dword ptr [rax], 2
jmp loc_2B4AB
loc_2B400:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
cmp rax, [rbp+var_240]
jb short loc_2B44E
mov ecx, [rbp+var_248]
mov rax, [rbp+var_228]
mov [rax], ecx
mov rax, [rbp+var_220]
mov rcx, [rbp+var_230]
lea rdx, [rbp+var_210]
sub rcx, rdx
add rax, rcx
mov [rbp+var_218], rax
jmp short loc_2B4CA
loc_2B44E:
mov edi, [rbp+var_248]
mov rsi, [rbp+var_230]
mov edx, offset unk_2A0000
mov al, 0
call _openat64
mov [rbp+var_244], eax
cmp [rbp+var_244], 0
jge short loc_2B478
jmp short loc_2B4AB
loc_2B478:
cmp [rbp+var_248], 0
jl short loc_2B48C
mov edi, [rbp+var_248]
call _close
loc_2B48C:
mov eax, [rbp+var_244]
mov [rbp+var_248], eax
mov rax, [rbp+var_238]
mov [rbp+var_230], rax
jmp loc_2B342
loc_2B4AB:
cmp [rbp+var_248], 0
jl short loc_2B4BF
mov edi, [rbp+var_248]
call _close
loc_2B4BF:
mov [rbp+var_218], 0
loc_2B4CA:
mov rax, [rbp+var_218]
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2B4FA
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_2B4FA:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, int *a2)
{
long long v2; // rcx
bool v4; // [rsp+17h] [rbp-249h]
int v5; // [rsp+18h] [rbp-248h]
int v6; // [rsp+1Ch] [rbp-244h]
const char *v7; // [rsp+20h] [rbp-240h]
const char *v8; // [rsp+28h] [rbp-238h]
const char *v9; // [rsp+30h] [rbp-230h]
char v11; // [rsp+50h] [rbp-210h] BYREF
_BYTE v12[527]; // [rsp+51h] [rbp-20Fh] BYREF
*(_QWORD *)&v12[519] = __readfsqword(0x28u);
v9 = &v11;
v8 = v12;
v7 = (const char *)strnmov(&v11, a1, 513LL);
v5 = -1;
if ( *v7 )
{
*(_DWORD *)__errno_location() = 36;
return 0LL;
}
else if ( v11 == 47 )
{
while ( *v8 != 47 )
{
while ( 1 )
{
v2 = (unsigned int)*v8;
v4 = 0;
if ( *v8 )
v4 = *v8 != 47;
if ( !v4 )
break;
++v8;
}
*v8 = 0;
if ( *(_WORD *)v9 == 46 || !(unsigned int)strcmp(v9, "..") )
break;
if ( ++v8 >= v7 )
{
*a2 = v5;
return v9 - &v11 + a1;
}
v6 = openat64((unsigned int)v5, v9, &unk_2A0000, v2);
if ( v6 < 0 )
goto LABEL_20;
if ( v5 >= 0 )
close((unsigned int)v5);
v5 = v6;
v9 = v8;
}
*(_DWORD *)__errno_location() = 2;
LABEL_20:
if ( v5 >= 0 )
close((unsigned int)v5);
return 0LL;
}
else
{
*(_DWORD *)__errno_location() = 2;
return 0LL;
}
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x220],RDI
MOV qword ptr [RBP + -0x228],RSI
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x230],RAX
LEA RAX,[RBP + -0x210]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x201
CALL 0x00179d30
MOV qword ptr [RBP + -0x240],RAX
MOV dword ptr [RBP + -0x248],0xffffffff
MOV RAX,qword ptr [RBP + -0x240]
CMP byte ptr [RAX],0x0
JZ 0x0012b316
CALL 0x00124040
MOV dword ptr [RAX],0x24
MOV qword ptr [RBP + -0x218],0x0
JMP 0x0012b4ca
LAB_0012b316:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JZ 0x0012b340
CALL 0x00124040
MOV dword ptr [RAX],0x2
MOV qword ptr [RBP + -0x218],0x0
JMP 0x0012b4ca
LAB_0012b340:
JMP 0x0012b342
LAB_0012b342:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x0012b361
CALL 0x00124040
MOV dword ptr [RAX],0x2
JMP 0x0012b4ab
LAB_0012b361:
JMP 0x0012b363
LAB_0012b363:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x249],AL
JZ 0x0012b390
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x249],AL
LAB_0012b390:
MOV AL,byte ptr [RBP + -0x249]
TEST AL,0x1
JNZ 0x0012b39c
JMP 0x0012b3b0
LAB_0012b39c:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
JMP 0x0012b363
LAB_0012b3b0:
MOV RAX,qword ptr [RBP + -0x238]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x230]
MOV AX,word ptr [RAX]
SUB AX,0x2e
SETNZ AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0012b3f0
MOV RDI,qword ptr [RBP + -0x230]
LEA RSI,[0x17c4fc]
MOV EDX,0x3
CALL 0x00124130
CMP EAX,0x0
JNZ 0x0012b400
LAB_0012b3f0:
CALL 0x00124040
MOV dword ptr [RAX],0x2
JMP 0x0012b4ab
LAB_0012b400:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
CMP RAX,qword ptr [RBP + -0x240]
JC 0x0012b44e
MOV ECX,dword ptr [RBP + -0x248]
MOV RAX,qword ptr [RBP + -0x228]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
LEA RDX,[RBP + -0x210]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x218],RAX
JMP 0x0012b4ca
LAB_0012b44e:
MOV EDI,dword ptr [RBP + -0x248]
MOV RSI,qword ptr [RBP + -0x230]
MOV EDX,0x2a0000
MOV AL,0x0
CALL 0x00124300
MOV dword ptr [RBP + -0x244],EAX
CMP dword ptr [RBP + -0x244],0x0
JGE 0x0012b478
JMP 0x0012b4ab
LAB_0012b478:
CMP dword ptr [RBP + -0x248],0x0
JL 0x0012b48c
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x00124650
LAB_0012b48c:
MOV EAX,dword ptr [RBP + -0x244]
MOV dword ptr [RBP + -0x248],EAX
MOV RAX,qword ptr [RBP + -0x238]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x0012b342
LAB_0012b4ab:
CMP dword ptr [RBP + -0x248],0x0
JL 0x0012b4bf
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x00124650
LAB_0012b4bf:
MOV qword ptr [RBP + -0x218],0x0
LAB_0012b4ca:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012b4fa
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_0012b4fa:
CALL 0x00124370
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
int iVar1;
short *psVar2;
int *piVar3;
long in_FS_OFFSET;
bool bVar4;
int local_250;
short *local_240;
short *local_238;
long local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_238 = (short *)local_218;
local_240 = (short *)(local_218 + 1);
psVar2 = (short *)strnmov(local_218,param_1,0x201);
local_250 = -1;
if ((char)*psVar2 == '\0') {
iVar1 = local_250;
if (local_218[0] == '/') {
while (local_250 = iVar1, (char)*local_240 != '/') {
while( true ) {
bVar4 = false;
if ((char)*local_240 != '\0') {
bVar4 = (char)*local_240 != '/';
}
if (!bVar4) break;
local_240 = (short *)((long)local_240 + 1);
}
*(char *)local_240 = '\0';
if ((*local_238 == 0x2e) || (iVar1 = memcmp(local_238,&DAT_0017c4fc,3), iVar1 == 0)) {
piVar3 = __errno_location();
*piVar3 = 2;
goto LAB_0012b4ab;
}
local_240 = (short *)((long)local_240 + 1);
if (psVar2 <= local_240) {
*param_2 = local_250;
local_220 = (long)local_238 + (param_1 - (long)local_218);
goto LAB_0012b4ca;
}
iVar1 = openat64(local_250,(char *)local_238,0x2a0000);
if (iVar1 < 0) goto LAB_0012b4ab;
local_238 = local_240;
if (-1 < local_250) {
close(local_250);
}
}
piVar3 = __errno_location();
*piVar3 = 2;
LAB_0012b4ab:
if (-1 < local_250) {
close(local_250);
}
local_220 = 0;
}
else {
piVar3 = __errno_location();
*piVar3 = 2;
local_220 = 0;
}
}
else {
piVar3 = __errno_location();
*piVar3 = 0x24;
local_220 = 0;
}
LAB_0012b4ca:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_220;
}
| |
22,445 | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::boolean_t&) | llama.cpp/common/json.hpp | inline void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
{
JSON_THROW(type_error::create(302, concat("type must be boolean, but is ", j.type_name()), &j));
}
b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::boolean_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x4, (%rdi)
jne 0x76056
movb 0x8(%r14), %al
movb %al, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1c460
movq %rax, %rbx
movq %r14, %rdi
callq 0x30fda
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x55ec5(%rip), %rsi # 0xcbf3f
leaq 0x10(%rsp), %rdi
callq 0x760ec
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x72d1c
xorl %ebp, %ebp
leaq 0x87e3b(%rip), %rsi # 0xfdee0
leaq -0x488a6(%rip), %rdx # 0x2d806
movq %rbx, %rdi
callq 0x1c7b0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x760d2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x760dc
jmp 0x760e4
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
movq %r14, %rdi
callq 0x1c7d0
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_9boolean_tE:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 4
jnz short loc_76056
mov al, [r14+8]
mov [rsi], al
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_76056:
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, aTypeMustBeBool; "type must be boolean, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA30_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(char const(&)[30],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; 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_760D2
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_760D2:
test bpl, bpl
jnz short loc_760DC
jmp short loc_760E4
mov r14, rax
loc_760DC:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_760E4:
mov rdi, r14
call __Unwind_Resume
| unsigned __int8 nlohmann::json_abi_v3_11_3::detail::from_json<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>>(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
unsigned __int8 result; // al
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *a1 != 4 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[30],char const*>(
v4,
"type must be boolean, but is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
result = a1[8];
*a2 = result;
return result;
}
| from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x4
JNZ 0x00176056
MOV AL,byte ptr [R14 + 0x8]
MOV byte ptr [RSI],AL
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00176056:
MOV EDI,0x20
CALL 0x0011c460
MOV RBX,RAX
MOV RDI,R14
CALL 0x00130fda
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00176073:
LEA RSI,[0x1cbf3f]
LEA RDI,[RSP + 0x10]
CALL 0x001760ec
MOV BPL,0x1
LAB_00176087:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00172d1c
XOR EBP,EBP
LEA RSI,[0x1fdee0]
LEA RDX,[0x12d806]
MOV RDI,RBX
CALL 0x0011c7b0
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::boolean_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 *param_1,boolean_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == (basic_json)0x4) {
*param_2 = param_1[8];
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
/* try { // try from 00176073 to 00176083 has its CatchHandler @ 001760d9 */
concat<std::__cxx11::string,char_const(&)[30],char_const*>
(local_38,"type must be boolean, but is ",&local_40);
/* try { // try from 00176087 to 001760b3 has its CatchHandler @ 001760b4 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
| |
22,446 | json_at | corpus-core[P]colibri-stateless/src/util/json.c | json_t json_at(json_t parent, size_t index) {
if (parent.type != JSON_TYPE_ARRAY) return json(JSON_TYPE_INVALID, parent.start, 0);
size_t i = 0;
json_for_each_value(parent, val) {
if (index == i++) return val;
}
return json(JSON_TYPE_NOT_FOUND, parent.start, 0);
} | O0 | c | json_at:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
cmpl $0x4, 0x10(%rax)
je 0x206a4
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
jmp 0x20786
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdi
movq $0x0, -0x10(%rbp)
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20290
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpl $-0x1, 0x10(%rcx)
movb %al, -0x41(%rbp)
je 0x206f5
movq -0x40(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x206fe
jmp 0x20769
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
cmpq %rcx, %rax
jne 0x20718
jmp 0x20786
jmp 0x2071a
movq -0x40(%rbp), %rax
leaq -0x28(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl $0x2, %edx
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x20290
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x206d8
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
| json_at:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_40], rdi
mov [rbp+var_38], rdi
lea rax, [rbp+arg_0]
mov [rbp+var_30], rax
mov [rbp+var_8], rsi
cmp dword ptr [rax+10h], 4
jz short loc_206A4
mov rax, [rbp+var_40]
mov rcx, [rbp+var_30]
mov rcx, [rcx]
mov [rax], rcx
mov qword ptr [rax+8], 0
mov dword ptr [rax+10h], 0
jmp loc_20786
loc_206A4:
mov rax, [rbp+var_30]
mov rdi, [rbp+var_40]
mov [rbp+var_10], 0
xor ecx, ecx
mov esi, ecx
xor edx, edx
mov rcx, [rax]
mov [rsp+60h+var_60], rcx
mov rcx, [rax+8]
mov [rsp+60h+var_58], rcx
mov rax, [rax+10h]
mov [rsp+60h+var_50], rax
call json_next_value
loc_206D8:
mov rcx, [rbp+var_40]
xor eax, eax
cmp dword ptr [rcx+10h], 0FFFFFFFFh
mov [rbp+var_41], al
jz short loc_206F5
mov rax, [rbp+var_40]
cmp dword ptr [rax+10h], 0
setnz al
mov [rbp+var_41], al
loc_206F5:
mov al, [rbp+var_41]
test al, 1
jnz short loc_206FE
jmp short loc_20769
loc_206FE:
mov rax, [rbp+var_8]
mov rcx, [rbp+var_10]
mov rdx, rcx
add rdx, 1
mov [rbp+var_10], rdx
cmp rax, rcx
jnz short loc_20718
jmp short loc_20786
loc_20718:
jmp short $+2
loc_2071A:
mov rax, [rbp+var_40]
lea rdi, [rbp+var_28]
xor ecx, ecx
mov esi, ecx
mov edx, 2
mov rcx, [rax]
mov [rsp+60h+var_60], rcx
mov rcx, [rax+8]
mov [rsp+60h+var_58], rcx
mov rax, [rax+10h]
mov [rsp+60h+var_50], rax
call json_next_value
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov [rax+8], rcx
mov rcx, [rbp+var_18]
mov [rax+10h], rcx
jmp loc_206D8
loc_20769:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_30]
mov rcx, [rcx]
mov [rax], rcx
mov qword ptr [rax+8], 0
mov dword ptr [rax+10h], 0FFFFFFFFh
loc_20786:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
| long long * json_at(
long long *a1,
long long a2,
_DWORD a3,
_DWORD a4,
int a5,
int a6,
long long a7,
long long a8,
long long a9)
{
int v9; // r8d
int v10; // r9d
long long v11; // rcx
bool v13; // [rsp+1Fh] [rbp-41h]
_QWORD v14[3]; // [rsp+38h] [rbp-28h] BYREF
long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a2;
if ( (_DWORD)a9 == 4 )
{
v15 = 0LL;
json_next_value((long long)a1, 0LL, 0, a8, a5, a6, a7, a8, a9);
while ( 1 )
{
v13 = 0;
if ( *((_DWORD *)a1 + 4) != -1 )
v13 = *((_DWORD *)a1 + 4) != 0;
if ( !v13 )
break;
v11 = v15++;
if ( v16 == v11 )
return a1;
json_next_value((long long)v14, 0LL, 2, a1[1], v9, v10, *a1, a1[1], a1[2]);
*a1 = v14[0];
a1[1] = v14[1];
a1[2] = v14[2];
}
*a1 = a7;
a1[1] = 0LL;
*((_DWORD *)a1 + 4) = -1;
}
else
{
*a1 = a7;
a1[1] = 0LL;
*((_DWORD *)a1 + 4) = 0;
}
return a1;
}
| json_at:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x40],RDI
MOV qword ptr [RBP + -0x38],RDI
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x8],RSI
CMP dword ptr [RAX + 0x10],0x4
JZ 0x001206a4
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0x10],0x0
JMP 0x00120786
LAB_001206a4:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x10],0x0
XOR ECX,ECX
MOV ESI,ECX
XOR EDX,EDX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120290
LAB_001206d8:
MOV RCX,qword ptr [RBP + -0x40]
XOR EAX,EAX
CMP dword ptr [RCX + 0x10],-0x1
MOV byte ptr [RBP + -0x41],AL
JZ 0x001206f5
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x10],0x0
SETNZ AL
MOV byte ptr [RBP + -0x41],AL
LAB_001206f5:
MOV AL,byte ptr [RBP + -0x41]
TEST AL,0x1
JNZ 0x001206fe
JMP 0x00120769
LAB_001206fe:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
CMP RAX,RCX
JNZ 0x00120718
JMP 0x00120786
LAB_00120718:
JMP 0x0012071a
LAB_0012071a:
MOV RAX,qword ptr [RBP + -0x40]
LEA RDI,[RBP + -0x28]
XOR ECX,ECX
MOV ESI,ECX
MOV EDX,0x2
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00120290
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],RCX
JMP 0x001206d8
LAB_00120769:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV dword ptr [RAX + 0x10],0xffffffff
LAB_00120786:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
int8 * json_at(int8 *param_1,long param_2)
{
bool bVar1;
int8 in_stack_00000008;
int in_stack_00000018;
int8 local_30;
int8 local_28;
int8 local_20;
long local_18;
long local_10;
if (in_stack_00000018 == 4) {
local_18 = 0;
local_10 = param_2;
json_next_value(param_1,0,0);
while( true ) {
bVar1 = false;
if (*(int *)(param_1 + 2) != -1) {
bVar1 = *(int *)(param_1 + 2) != 0;
}
if (!bVar1) break;
if (local_10 == local_18) {
return param_1;
}
local_18 = local_18 + 1;
json_next_value(&local_30,0,2);
*param_1 = local_30;
param_1[1] = local_28;
param_1[2] = local_20;
}
*param_1 = in_stack_00000008;
param_1[1] = 0;
*(int4 *)(param_1 + 2) = 0xffffffff;
}
else {
*param_1 = in_stack_00000008;
param_1[1] = 0;
*(int4 *)(param_1 + 2) = 0;
}
return param_1;
}
| |
22,447 | json_at | corpus-core[P]colibri-stateless/src/util/json.c | json_t json_at(json_t parent, size_t index) {
if (parent.type != JSON_TYPE_ARRAY) return json(JSON_TYPE_INVALID, parent.start, 0);
size_t i = 0;
json_for_each_value(parent, val) {
if (index == i++) return val;
}
return json(JSON_TYPE_NOT_FOUND, parent.start, 0);
} | O1 | c | json_at:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %r12
cmpl $0x4, 0x10(%r12)
jne 0x1767c
movq %rsi, %r14
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x17358
movl 0x10(%rbx), %eax
decl %eax
cmpl $-0x3, %eax
ja 0x17664
incq %r14
leaq 0x20(%rsp), %r15
decq %r14
je 0x17692
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x17358
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movl 0x10(%rbx), %eax
decl %eax
cmpl $-0x2, %eax
jb 0x17625
movq (%r12), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
jmp 0x17692
movq (%r12), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| json_at:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
lea r12, [rsp+58h+arg_0]
cmp dword ptr [r12+10h], 4
jnz loc_1767C
mov r14, rsi
mov rax, [r12+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+58h+var_58], xmm0
mov rdi, rbx
xor esi, esi
xor edx, edx
call json_next_value
mov eax, [rbx+10h]
dec eax
cmp eax, 0FFFFFFFDh
ja short loc_17664
inc r14
lea r15, [rsp+58h+var_38]
loc_17625:
dec r14
jz short loc_17692
mov rax, [rbx+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [rbx]
movups [rsp+58h+var_58], xmm0
mov rdi, r15
xor esi, esi
mov edx, 2
call json_next_value
mov rax, [rsp+58h+var_28]
mov [rbx+10h], rax
movups xmm0, [rsp+58h+var_38]
movups xmmword ptr [rbx], xmm0
mov eax, [rbx+10h]
dec eax
cmp eax, 0FFFFFFFEh
jb short loc_17625
loc_17664:
mov rax, [r12]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov dword ptr [rbx+10h], 0FFFFFFFFh
jmp short loc_17692
loc_1767C:
mov rax, [r12]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov dword ptr [rbx+10h], 0
loc_17692:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
| long long json_at(long long a1, long long a2, _DWORD a3, int a4, int a5, int a6, __int128 a7, long long a8)
{
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // r14
__int128 v13; // [rsp+20h] [rbp-38h] BYREF
long long v14; // [rsp+30h] [rbp-28h]
if ( (_DWORD)a8 == 4 )
{
json_next_value(a1, 0LL, 0, a4, a5, a6, a7, a8);
if ( (unsigned int)(*(_DWORD *)(a1 + 16) - 1) > 0xFFFFFFFD )
{
LABEL_6:
*(_QWORD *)a1 = a7;
*(_QWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 16) = -1;
}
else
{
v11 = a2 + 1;
while ( --v11 )
{
json_next_value((long long)&v13, 0LL, 2, v8, v9, v10, *(_OWORD *)a1, *(_QWORD *)(a1 + 16));
*(_QWORD *)(a1 + 16) = v14;
*(_OWORD *)a1 = v13;
if ( (unsigned int)(*(_DWORD *)(a1 + 16) - 1) >= 0xFFFFFFFE )
goto LABEL_6;
}
}
}
else
{
*(_QWORD *)a1 = a7;
*(_QWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 16) = 0;
}
return a1;
}
| json_at:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
LEA R12,[RSP + 0x60]
CMP dword ptr [R12 + 0x10],0x4
JNZ 0x0011767c
MOV R14,RSI
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00117358
MOV EAX,dword ptr [RBX + 0x10]
DEC EAX
CMP EAX,-0x3
JA 0x00117664
INC R14
LEA R15,[RSP + 0x20]
LAB_00117625:
DEC R14
JZ 0x00117692
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
XOR ESI,ESI
MOV EDX,0x2
CALL 0x00117358
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RBX + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RBX],XMM0
MOV EAX,dword ptr [RBX + 0x10]
DEC EAX
CMP EAX,-0x2
JC 0x00117625
LAB_00117664:
MOV RAX,qword ptr [R12]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0x10],0xffffffff
JMP 0x00117692
LAB_0011767c:
MOV RAX,qword ptr [R12]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0x10],0x0
LAB_00117692:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
|
int8 * json_at(int8 *param_1,long param_2)
{
int8 in_stack_00000008;
int in_stack_00000018;
int8 local_38;
int8 uStack_30;
int8 local_28;
if (in_stack_00000018 == 4) {
json_next_value(param_1,0,0);
if (*(int *)(param_1 + 2) - 1U < 0xfffffffe) {
param_2 = param_2 + 1;
do {
param_2 = param_2 + -1;
if (param_2 == 0) {
return param_1;
}
json_next_value(&local_38,0,2);
param_1[2] = local_28;
*param_1 = local_38;
param_1[1] = uStack_30;
} while (*(int *)(param_1 + 2) - 1U < 0xfffffffe);
}
*param_1 = in_stack_00000008;
param_1[1] = 0;
*(int4 *)(param_1 + 2) = 0xffffffff;
}
else {
*param_1 = in_stack_00000008;
param_1[1] = 0;
*(int4 *)(param_1 + 2) = 0;
}
return param_1;
}
| |
22,448 | json_at | corpus-core[P]colibri-stateless/src/util/json.c | json_t json_at(json_t parent, size_t index) {
if (parent.type != JSON_TYPE_ARRAY) return json(JSON_TYPE_INVALID, parent.start, 0);
size_t i = 0;
json_for_each_value(parent, val) {
if (index == i++) return val;
}
return json(JSON_TYPE_NOT_FOUND, parent.start, 0);
} | O3 | c | json_at:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x60(%rsp), %r12
cmpl $0x4, 0x10(%r12)
jne 0x16f19
movq %rsi, %r14
movq 0x10(%r12), %rax
movq %rax, 0x10(%rsp)
movups (%r12), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x16c13
movl 0x10(%rbx), %eax
decl %eax
cmpl $-0x3, %eax
ja 0x16f01
incq %r14
leaq 0x20(%rsp), %r15
decq %r14
je 0x16f2f
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x16c13
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
movl 0x10(%rbx), %eax
decl %eax
cmpl $-0x2, %eax
jb 0x16ec2
movq (%r12), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
jmp 0x16f2f
movq (%r12), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| json_at:
push r15
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
lea r12, [rsp+58h+arg_0]
cmp dword ptr [r12+10h], 4
jnz loc_16F19
mov r14, rsi
mov rax, [r12+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [r12]
movups [rsp+58h+var_58], xmm0
mov rdi, rbx
xor esi, esi
xor edx, edx
call json_next_value
mov eax, [rbx+10h]
dec eax
cmp eax, 0FFFFFFFDh
ja short loc_16F01
inc r14
lea r15, [rsp+58h+var_38]
loc_16EC2:
dec r14
jz short loc_16F2F
mov rax, [rbx+10h]
mov [rsp+58h+var_48], rax
movups xmm0, xmmword ptr [rbx]
movups [rsp+58h+var_58], xmm0
mov rdi, r15
xor esi, esi
mov edx, 2
call json_next_value
mov rax, [rsp+58h+var_28]
mov [rbx+10h], rax
movups xmm0, [rsp+58h+var_38]
movups xmmword ptr [rbx], xmm0
mov eax, [rbx+10h]
dec eax
cmp eax, 0FFFFFFFEh
jb short loc_16EC2
loc_16F01:
mov rax, [r12]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov dword ptr [rbx+10h], 0FFFFFFFFh
jmp short loc_16F2F
loc_16F19:
mov rax, [r12]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov dword ptr [rbx+10h], 0
loc_16F2F:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r14
pop r15
retn
| long long json_at(long long a1, long long a2, _DWORD a3, int a4, int a5, int a6, __int128 a7, long long a8)
{
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // r14
__int128 v13; // [rsp+20h] [rbp-38h] BYREF
long long v14; // [rsp+30h] [rbp-28h]
if ( (_DWORD)a8 == 4 )
{
json_next_value(a1, 0LL, 0, a4, a5, a6, a7, a8);
if ( (unsigned int)(*(_DWORD *)(a1 + 16) - 1) > 0xFFFFFFFD )
{
LABEL_6:
*(_QWORD *)a1 = a7;
*(_QWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 16) = -1;
}
else
{
v11 = a2 + 1;
while ( --v11 )
{
json_next_value((long long)&v13, 0LL, 2, v8, v9, v10, *(_OWORD *)a1, *(_QWORD *)(a1 + 16));
*(_QWORD *)(a1 + 16) = v14;
*(_OWORD *)a1 = v13;
if ( (unsigned int)(*(_DWORD *)(a1 + 16) - 1) >= 0xFFFFFFFE )
goto LABEL_6;
}
}
}
else
{
*(_QWORD *)a1 = a7;
*(_QWORD *)(a1 + 8) = 0LL;
*(_DWORD *)(a1 + 16) = 0;
}
return a1;
}
| json_at:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
LEA R12,[RSP + 0x60]
CMP dword ptr [R12 + 0x10],0x4
JNZ 0x00116f19
MOV R14,RSI
MOV RAX,qword ptr [R12 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x00116c13
MOV EAX,dword ptr [RBX + 0x10]
DEC EAX
CMP EAX,-0x3
JA 0x00116f01
INC R14
LEA R15,[RSP + 0x20]
LAB_00116ec2:
DEC R14
JZ 0x00116f2f
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
XOR ESI,ESI
MOV EDX,0x2
CALL 0x00116c13
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RBX + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x20]
MOVUPS xmmword ptr [RBX],XMM0
MOV EAX,dword ptr [RBX + 0x10]
DEC EAX
CMP EAX,-0x2
JC 0x00116ec2
LAB_00116f01:
MOV RAX,qword ptr [R12]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0x10],0xffffffff
JMP 0x00116f2f
LAB_00116f19:
MOV RAX,qword ptr [R12]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV dword ptr [RBX + 0x10],0x0
LAB_00116f2f:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R14
POP R15
RET
|
int8 * json_at(int8 *param_1,long param_2)
{
int8 in_stack_00000008;
int in_stack_00000018;
int8 local_38;
int8 uStack_30;
int8 local_28;
if (in_stack_00000018 == 4) {
json_next_value(param_1,0,0);
if (*(int *)(param_1 + 2) - 1U < 0xfffffffe) {
param_2 = param_2 + 1;
do {
param_2 = param_2 + -1;
if (param_2 == 0) {
return param_1;
}
json_next_value(&local_38,0,2);
param_1[2] = local_28;
*param_1 = local_38;
param_1[1] = uStack_30;
} while (*(int *)(param_1 + 2) - 1U < 0xfffffffe);
}
*param_1 = in_stack_00000008;
param_1[1] = 0;
*(int4 *)(param_1 + 2) = 0xffffffff;
}
else {
*param_1 = in_stack_00000008;
param_1[1] = 0;
*(int4 *)(param_1 + 2) = 0;
}
return param_1;
}
| |
22,449 | ggml_unary_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_unary_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
enum ggml_unary_op op,
bool inplace) {
bool is_node = false;
if (!inplace && (a->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
ggml_set_op_params_i32(result, 0, (int32_t) op);
result->op = GGML_OP_UNARY;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
} | O0 | c | ggml_unary_impl:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
andb $0x1, %al
movb %al, 0x23(%rsp)
movb $0x0, 0x22(%rsp)
testb $0x1, 0x23(%rsp)
jne 0x127d6a
movq 0x28(%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x127d6a
movb $0x1, 0x22(%rsp)
testb $0x1, 0x23(%rsp)
je 0x127d87
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x11e7e0
movq %rax, 0x10(%rsp)
jmp 0x127d9b
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x11cfc0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %edx
xorl %esi, %esi
callq 0x121430
movq 0x18(%rsp), %rax
movl $0x3d, 0x50(%rax)
testb $0x1, 0x22(%rsp)
je 0x127dde
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11cfc0
movq %rax, 0x8(%rsp)
jmp 0x127de7
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x127de7
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| ggml_unary_impl:
sub rsp, 38h
mov al, cl
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_14], edx
and al, 1
mov [rsp+38h+var_15], al
mov [rsp+38h+var_16], 0
test [rsp+38h+var_15], 1
jnz short loc_127D6A
mov rax, [rsp+38h+var_10]
cmp qword ptr [rax+98h], 0
jz short loc_127D6A
mov [rsp+38h+var_16], 1
loc_127D6A:
test [rsp+38h+var_15], 1
jz short loc_127D87
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_10]
call ggml_view_tensor
mov [rsp+38h+var_28], rax
jmp short loc_127D9B
loc_127D87:
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_10]
call ggml_dup_tensor
mov [rsp+38h+var_28], rax
loc_127D9B:
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_20], rax
mov rdi, [rsp+38h+var_20]
mov edx, [rsp+38h+var_14]
xor esi, esi
call ggml_set_op_params_i32
mov rax, [rsp+38h+var_20]
mov dword ptr [rax+50h], 3Dh ; '='
test [rsp+38h+var_16], 1
jz short loc_127DDE
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_20]
call ggml_dup_tensor
mov [rsp+38h+var_30], rax
jmp short loc_127DE7
loc_127DDE:
xor eax, eax
mov [rsp+38h+var_30], rax
jmp short $+2
loc_127DE7:
mov rcx, [rsp+38h+var_30]
mov rax, [rsp+38h+var_20]
mov [rax+98h], rcx
mov rcx, [rsp+38h+var_10]
mov rax, [rsp+38h+var_20]
mov [rax+0A0h], rcx
mov rax, [rsp+38h+var_20]
add rsp, 38h
retn
| long long ggml_unary_impl(
long long a1,
long long a2,
int a3,
char a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v13; // [rsp+8h] [rbp-30h]
long long v14; // [rsp+10h] [rbp-28h]
bool v15; // [rsp+22h] [rbp-16h]
v15 = 0;
if ( (a4 & 1) != 0 )
{
v14 = (long long)ggml_view_tensor(a1, a2, a5, a6, a7, a8, a9, a10, a11, a12);
}
else
{
v15 = *(_QWORD *)(a2 + 152) != 0LL;
v14 = ggml_dup_tensor(a1, (unsigned int *)a2);
}
ggml_set_op_params_i32(v14, 0, a3);
*(_DWORD *)(v14 + 80) = 61;
if ( v15 )
v13 = ggml_dup_tensor(a1, (unsigned int *)v14);
else
v13 = 0LL;
*(_QWORD *)(v14 + 152) = v13;
*(_QWORD *)(v14 + 160) = a2;
return v14;
}
| |||
22,450 | ggml_unary_impl | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static struct ggml_tensor * ggml_unary_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
enum ggml_unary_op op,
bool inplace) {
bool is_node = false;
if (!inplace && (a->grad)) {
is_node = true;
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
ggml_set_op_params_i32(result, 0, (int32_t) op);
result->op = GGML_OP_UNARY;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
return result;
} | O2 | c | ggml_unary_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testl %ecx, %ecx
je 0x6ee5a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x69922
movq %rax, %r14
movl %ebp, 0x54(%rax)
movl $0x3d, 0x50(%rax)
jmp 0x6ee8b
movq 0x98(%rbx), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68a65
movq %rax, %r14
movl %ebp, 0x54(%rax)
movl $0x3d, 0x50(%rax)
testq %r12, %r12
je 0x6ee8b
movq %r15, %rdi
movq %r14, %rsi
callq 0x68a65
jmp 0x6ee8d
xorl %eax, %eax
movq %rax, 0x98(%r14)
movq %rbx, 0xa0(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| ggml_unary_impl:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, edx
mov rbx, rsi
mov r15, rdi
test ecx, ecx
jz short loc_6EE5A
mov rdi, r15
mov rsi, rbx
call ggml_view_tensor
mov r14, rax
mov [rax+54h], ebp
mov dword ptr [rax+50h], 3Dh ; '='
jmp short loc_6EE8B
loc_6EE5A:
mov r12, [rbx+98h]
mov rdi, r15
mov rsi, rbx
call ggml_dup_tensor
mov r14, rax
mov [rax+54h], ebp
mov dword ptr [rax+50h], 3Dh ; '='
test r12, r12
jz short loc_6EE8B
mov rdi, r15
mov rsi, r14
call ggml_dup_tensor
jmp short loc_6EE8D
loc_6EE8B:
xor eax, eax
loc_6EE8D:
mov [r14+98h], rax
mov [r14+0A0h], rbx
mov rax, r14
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long ggml_unary_impl(
long long a1,
long long a2,
unsigned int a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long v13; // r14
long long v14; // r12
unsigned int *v15; // rax
long long v16; // rax
if ( a4 )
{
v13 = ggml_view_tensor(a1, a2, a5, a6, a7, a8, a9, a10, a11, a12);
*(_DWORD *)(v13 + 84) = a3;
*(_DWORD *)(v13 + 80) = 61;
LABEL_5:
v16 = 0LL;
goto LABEL_6;
}
v14 = *(_QWORD *)(a2 + 152);
v15 = (unsigned int *)ggml_dup_tensor(a1, (unsigned int *)a2);
v13 = (long long)v15;
v15[21] = a3;
v15[20] = 61;
if ( !v14 )
goto LABEL_5;
v16 = ggml_dup_tensor(a1, v15);
LABEL_6:
*(_QWORD *)(v13 + 152) = v16;
*(_QWORD *)(v13 + 160) = a2;
return v13;
}
| ggml_unary_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,EDX
MOV RBX,RSI
MOV R15,RDI
TEST ECX,ECX
JZ 0x0016ee5a
MOV RDI,R15
MOV RSI,RBX
CALL 0x00169922
MOV R14,RAX
MOV dword ptr [RAX + 0x54],EBP
MOV dword ptr [RAX + 0x50],0x3d
JMP 0x0016ee8b
LAB_0016ee5a:
MOV R12,qword ptr [RBX + 0x98]
MOV RDI,R15
MOV RSI,RBX
CALL 0x00168a65
MOV R14,RAX
MOV dword ptr [RAX + 0x54],EBP
MOV dword ptr [RAX + 0x50],0x3d
TEST R12,R12
JZ 0x0016ee8b
MOV RDI,R15
MOV RSI,R14
CALL 0x00168a65
JMP 0x0016ee8d
LAB_0016ee8b:
XOR EAX,EAX
LAB_0016ee8d:
MOV qword ptr [R14 + 0x98],RAX
MOV qword ptr [R14 + 0xa0],RBX
MOV RAX,R14
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long ggml_unary_impl(int8 param_1,long param_2,int4 param_3,int param_4)
{
long lVar1;
long lVar2;
int8 uVar3;
if (param_4 == 0) {
lVar1 = *(long *)(param_2 + 0x98);
lVar2 = ggml_dup_tensor(param_1,param_2);
*(int4 *)(lVar2 + 0x54) = param_3;
*(int4 *)(lVar2 + 0x50) = 0x3d;
if (lVar1 != 0) {
uVar3 = ggml_dup_tensor(param_1,lVar2);
goto LAB_0016ee8d;
}
}
else {
lVar2 = ggml_view_tensor(param_1,param_2);
*(int4 *)(lVar2 + 0x54) = param_3;
*(int4 *)(lVar2 + 0x50) = 0x3d;
}
uVar3 = 0;
LAB_0016ee8d:
*(int8 *)(lVar2 + 0x98) = uVar3;
*(long *)(lVar2 + 0xa0) = param_2;
return lVar2;
}
| |
22,451 | ma_tls_get_finger_print | eloqsql/libmariadb/libmariadb/secure/openssl.c | unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, char *fp, unsigned int len)
{
X509 *cert= NULL;
MYSQL *mysql;
unsigned int fp_len;
if (!ctls || !ctls->ssl)
return 0;
mysql= SSL_get_app_data(ctls->ssl);
if (!(cert= SSL_get_peer_certificate(ctls->ssl)))
{
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR),
"Unable to get server certificate");
goto end;
}
if (len < EVP_MAX_MD_SIZE)
{
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR),
"Finger print buffer too small");
goto end;
}
if (!X509_digest(cert, EVP_sha1(), (unsigned char *)fp, &fp_len))
{
my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
ER(CR_SSL_CONNECTION_ERROR),
"invalid finger print of server certificate");
goto end;
}
X509_free(cert);
return (fp_len);
end:
X509_free(cert);
return 0;
} | O0 | c | ma_tls_get_finger_print:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b9cd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3b9d9
movl $0x0, -0x4(%rbp)
jmp 0x3bae6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
callq 0x13150
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x137d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x3ba37
movq -0x30(%rbp), %rdi
leaq 0x29822(%rip), %rax # 0x65230
movq (%rax), %rdx
leaq 0x29828(%rip), %rax # 0x65240
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x155ba(%rip), %r8 # 0x50fe5
movb $0x0, %al
callq 0x1a0d0
jmp 0x3bad6
cmpl $0x40, -0x1c(%rbp)
jae 0x3ba6e
movq -0x30(%rbp), %rdi
leaq 0x297e8(%rip), %rax # 0x65230
movq (%rax), %rdx
leaq 0x297ee(%rip), %rax # 0x65240
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x155cd(%rip), %r8 # 0x51032
movb $0x0, %al
callq 0x1a0d0
jmp 0x3bad6
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x13490
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x13590
cmpl $0x0, %eax
jne 0x3bac5
movq -0x30(%rbp), %rdi
leaq 0x29791(%rip), %rax # 0x65230
movq (%rax), %rdx
leaq 0x29797(%rip), %rax # 0x65240
movq 0xd0(%rax), %rcx
movl $0x7ea, %esi # imm = 0x7EA
leaq 0x15594(%rip), %r8 # 0x51050
movb $0x0, %al
callq 0x1a0d0
jmp 0x3bad6
movq -0x28(%rbp), %rdi
callq 0x13230
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3bae6
movq -0x28(%rbp), %rdi
callq 0x13230
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
| ma_tls_get_finger_print:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], 0
cmp [rbp+var_10], 0
jz short loc_3B9CD
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jnz short loc_3B9D9
loc_3B9CD:
mov [rbp+var_4], 0
jmp loc_3BAE6
loc_3B9D9:
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
xor esi, esi
call _SSL_get_ex_data
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rdi, [rax+10h]
call _SSL_get1_peer_certificate
mov [rbp+var_28], rax
cmp rax, 0
jnz short loc_3BA37
mov rdi, [rbp+var_30]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aUnableToGetSer; "Unable to get server certificate"
mov al, 0
call my_set_error
jmp loc_3BAD6
loc_3BA37:
cmp [rbp+var_1C], 40h ; '@'
jnb short loc_3BA6E
mov rdi, [rbp+var_30]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aFingerPrintBuf; "Finger print buffer too small"
mov al, 0
call my_set_error
jmp short loc_3BAD6
loc_3BA6E:
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
call _EVP_sha1
mov rdi, [rbp+var_40]
mov rsi, rax
mov rdx, [rbp+var_18]
lea rcx, [rbp+var_34]
call _X509_digest
cmp eax, 0
jnz short loc_3BAC5
mov rdi, [rbp+var_30]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+0D0h]
mov esi, 7EAh
lea r8, aInvalidFingerP; "invalid finger print of server certific"...
mov al, 0
call my_set_error
jmp short loc_3BAD6
loc_3BAC5:
mov rdi, [rbp+var_28]
call _X509_free
mov eax, [rbp+var_34]
mov [rbp+var_4], eax
jmp short loc_3BAE6
loc_3BAD6:
mov rdi, [rbp+var_28]
call _X509_free
mov [rbp+var_4], 0
loc_3BAE6:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long ma_tls_get_finger_print(long long a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int v5; // [rsp+Ch] [rbp-34h] BYREF
long long v6; // [rsp+10h] [rbp-30h]
long long v7; // [rsp+18h] [rbp-28h]
unsigned int v8; // [rsp+24h] [rbp-1Ch]
long long v9; // [rsp+28h] [rbp-18h]
long long v10; // [rsp+30h] [rbp-10h]
v10 = a1;
v9 = a2;
v8 = a3;
v7 = 0LL;
if ( a1 && *(_QWORD *)(v10 + 16) )
{
v6 = SSL_get_ex_data(*(_QWORD *)(v10 + 16), 0LL);
v7 = SSL_get1_peer_certificate(*(_QWORD *)(v10 + 16));
if ( v7 )
{
if ( v8 >= 0x40 )
{
v3 = EVP_sha1();
if ( (unsigned int)X509_digest(v7, v3, v9, &v5) )
{
X509_free(v7);
return v5;
}
my_set_error(
v6,
0x7EAu,
(long long)SQLSTATE_UNKNOWN,
(long long)client_errors[26],
"invalid finger print of server certificate");
}
else
{
my_set_error(v6, 0x7EAu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[26], "Finger print buffer too small");
}
}
else
{
my_set_error(
v6,
0x7EAu,
(long long)SQLSTATE_UNKNOWN,
(long long)client_errors[26],
"Unable to get server certificate");
}
X509_free(v7);
return 0;
}
return 0;
}
| ma_tls_get_finger_print:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0013b9cd
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JNZ 0x0013b9d9
LAB_0013b9cd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013bae6
LAB_0013b9d9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
XOR ESI,ESI
CALL 0x00113150
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x001137d0
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JNZ 0x0013ba37
MOV RDI,qword ptr [RBP + -0x30]
LEA RAX,[0x165230]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x165240]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x150fe5]
MOV AL,0x0
CALL 0x0011a0d0
JMP 0x0013bad6
LAB_0013ba37:
CMP dword ptr [RBP + -0x1c],0x40
JNC 0x0013ba6e
MOV RDI,qword ptr [RBP + -0x30]
LEA RAX,[0x165230]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x165240]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x151032]
MOV AL,0x0
CALL 0x0011a0d0
JMP 0x0013bad6
LAB_0013ba6e:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00113490
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RAX
MOV RDX,qword ptr [RBP + -0x18]
LEA RCX,[RBP + -0x34]
CALL 0x00113590
CMP EAX,0x0
JNZ 0x0013bac5
MOV RDI,qword ptr [RBP + -0x30]
LEA RAX,[0x165230]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x165240]
MOV RCX,qword ptr [RAX + 0xd0]
MOV ESI,0x7ea
LEA R8,[0x151050]
MOV AL,0x0
CALL 0x0011a0d0
JMP 0x0013bad6
LAB_0013bac5:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00113230
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013bae6
LAB_0013bad6:
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00113230
MOV dword ptr [RBP + -0x4],0x0
LAB_0013bae6:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 ma_tls_get_finger_print(long param_1,uchar *param_2,uint param_3)
{
int iVar1;
X509 *data;
EVP_MD *type;
uint local_3c;
void *local_38;
X509 *local_30;
uint local_24;
uchar *local_20;
long local_18;
local_30 = (X509 *)0x0;
if ((param_1 != 0) && (*(long *)(param_1 + 0x10) != 0)) {
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
local_38 = SSL_get_ex_data(*(SSL **)(param_1 + 0x10),0);
data = (X509 *)SSL_get1_peer_certificate(*(int8 *)(local_18 + 0x10));
local_30 = data;
if (data == (X509 *)0x0) {
my_set_error(local_38,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_00165310,
"Unable to get server certificate");
}
else if (local_24 < 0x40) {
my_set_error(local_38,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_00165310,
"Finger print buffer too small");
}
else {
type = EVP_sha1();
iVar1 = X509_digest(data,type,local_20,&local_3c);
if (iVar1 != 0) {
X509_free(local_30);
return local_3c;
}
my_set_error(local_38,0x7ea,SQLSTATE_UNKNOWN,PTR_s_TLS_SSL_error_____100s_00165310,
"invalid finger print of server certificate");
}
X509_free(local_30);
}
return 0;
}
| |
22,452 | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::string_t&) | llama.cpp/common/json.hpp | inline void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
{
if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
{
JSON_THROW(type_error::create(302, concat("type must be string, but is ", j.type_name()), &j));
}
s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::string_t&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x3, (%rdi)
jne 0x4870a
movq 0x8(%r14), %rax
movq %rsi, %rdi
movq %rax, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x17c20
movl $0x20, %edi
callq 0x17400
movq %rax, %rbx
movq %r14, %rdi
callq 0x2c462
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x185c9(%rip), %rsi # 0x60cf7
leaq 0x10(%rsp), %rdi
callq 0x487a0
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x48436
xorl %ebp, %ebp
leaq 0x2f017(%rip), %rsi # 0x77770
leaq -0x201a4(%rip), %rdx # 0x285bc
movq %rbx, %rdi
callq 0x176f0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48786
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x17100
testb %bpl, %bpl
jne 0x48790
jmp 0x48798
movq %rax, %r14
movq %rbx, %rdi
callq 0x179b0
movq %r14, %rdi
callq 0x17710
| _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEEvRKT_RNSG_8string_tE:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 3
jnz short loc_4870A
mov rax, [r14+8]
mov rdi, rsi
mov rsi, rax
add rsp, 30h
pop rbx
pop r14
pop rbp
jmp __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_; std::string::_M_assign(std::string const&)
loc_4870A:
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, aTypeMustBeStri; "type must be string, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; 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_48786
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48786:
test bpl, bpl
jnz short loc_48790
jmp short loc_48798
mov r14, rax
loc_48790:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_48798:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
long long a1,
long long a2)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 3 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
v4,
"type must be string, but is ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return std::string::_M_assign(a2, *(_QWORD *)(a1 + 8));
}
| from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x3
JNZ 0x0014870a
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,RSI
MOV RSI,RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
JMP 0x00117c20
LAB_0014870a:
MOV EDI,0x20
CALL 0x00117400
MOV RBX,RAX
MOV RDI,R14
CALL 0x0012c462
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00148727:
LEA RSI,[0x160cf7]
LEA RDI,[RSP + 0x10]
CALL 0x001487a0
MOV BPL,0x1
LAB_0014873b:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00148436
XOR EBP,EBP
LEA RSI,[0x177770]
LEA RDX,[0x1285bc]
MOV RDI,RBX
CALL 0x001176f0
|
/* void
nlohmann::json_abi_v3_11_3::detail::from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::string_t&) */
void nlohmann::json_abi_v3_11_3::detail::
from_json<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 *param_1,string_t *param_2)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*param_1 == (basic_json)0x3) {
std::__cxx11::string::_M_assign((string *)param_2);
return;
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_1);
/* try { // try from 00148727 to 00148737 has its CatchHandler @ 0014878d */
concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be string, but is ",&local_40);
/* try { // try from 0014873b to 00148767 has its CatchHandler @ 00148768 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&type_error::typeinfo,exception::~exception);
}
| |
22,453 | partitioned_key_cache_write | eloqsql/mysys/mf_keycache.c | static
int partitioned_key_cache_write(PARTITIONED_KEY_CACHE_CB *keycache,
File file, void *file_extra,
my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length __attribute__((unused)),
int dont_write)
{
uint w_length;
ulonglong *part_map= (ulonglong *) file_extra;
uint offset= (uint) (filepos % keycache->key_cache_block_size);
DBUG_ENTER("partitioned_key_cache_write");
DBUG_PRINT("enter",
("fd: %u pos: %lu length: %u block_length: %u"
" key_block_length: %u",
(uint) file, (ulong) filepos, length, block_length,
keycache ? keycache->key_cache_block_size : 0));
/* Write data in key_cache_block_size increments */
do
{
SIMPLE_KEY_CACHE_CB *partition= get_key_cache_partition_for_write(keycache,
file,
filepos,
part_map);
w_length = length;
set_if_smaller(w_length, keycache->key_cache_block_size - offset );
if (simple_key_cache_write(partition,
file, 0, filepos, level,
buff, w_length, block_length,
dont_write))
DBUG_RETURN(1);
filepos+= w_length;
buff+= w_length;
offset= 0;
} while ((length-= w_length));
DBUG_RETURN(0);
} | O3 | c | partitioned_key_cache_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %r8d, -0x2c(%rbp)
movq %rcx, %r15
movq %rdx, -0x40(%rbp)
movq %rdi, %r13
movl 0x10(%rbp), %r12d
movl 0x18(%rdi), %ecx
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %r8
movslq %esi, %rax
movq %rax, -0x38(%rbp)
movl 0x18(%r13), %ecx
movl 0x1c(%r13), %edi
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq -0x38(%rbp), %rsi
addq %rsi, %rax
xorl %edx, %edx
divq %rdi
movq %rdx, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x40(%rbp), %rdx
orq %rax, (%rdx)
movq 0x8(%r13), %rax
movq (%rax,%rcx,8), %rdi
movl 0x18(%r13), %r14d
subl %r8d, %r14d
cmpl %r14d, %r12d
cmovbl %r12d, %r14d
movl 0x20(%rbp), %eax
movl %eax, 0x10(%rsp)
movl %r14d, (%rsp)
movq %r15, %rcx
movl -0x2c(%rbp), %r8d
movq %rbx, %r9
callq 0x55016
testl %eax, %eax
jne 0x56740
movl %r14d, %eax
addq %rax, %rbx
addq %rax, %r15
xorl %r8d, %r8d
subl %r14d, %r12d
jne 0x566cb
jmp 0x56746
movl $0x1, %r8d
movl %r8d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| partitioned_key_cache_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, r9
mov [rbp+var_2C], r8d
mov r15, rcx
mov [rbp+var_40], rdx
mov r13, rdi
mov r12d, [rbp+arg_0]
mov ecx, [rdi+18h]
mov rax, r15
xor edx, edx
div rcx
mov r8, rdx
movsxd rax, esi
mov [rbp+var_38], rax
loc_566CB:
mov ecx, [r13+18h]
mov edi, [r13+1Ch]
mov rax, r15
xor edx, edx
div rcx
mov rsi, [rbp+var_38]
add rax, rsi
xor edx, edx
div rdi
mov rcx, rdx
mov eax, 1
shl rax, cl
mov rdx, [rbp+var_40]
or [rdx], rax
mov rax, [r13+8]
mov rdi, [rax+rcx*8]
mov r14d, [r13+18h]
sub r14d, r8d
cmp r12d, r14d
cmovb r14d, r12d
mov eax, [rbp+arg_10]
mov [rsp+60h+var_50], eax
mov [rsp+60h+var_60], r14d
mov rcx, r15
mov r8d, [rbp+var_2C]
mov r9, rbx
call simple_key_cache_write
test eax, eax
jnz short loc_56740
mov eax, r14d
add rbx, rax
add r15, rax
xor r8d, r8d
sub r12d, r14d
jnz short loc_566CB
jmp short loc_56746
loc_56740:
mov r8d, 1
loc_56746:
mov eax, r8d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long partitioned_key_cache_write(
long long a1,
signed int a2,
_QWORD *a3,
unsigned long long a4,
int a5,
long long a6,
unsigned int a7,
int a8,
int a9)
{
unsigned long long v10; // r15
unsigned long long v12; // r8
unsigned long long v13; // rcx
unsigned int v14; // r14d
int v16; // [rsp+8h] [rbp-58h]
v10 = a4;
v12 = a4 % *(unsigned int *)(a1 + 24);
while ( 1 )
{
v13 = (a2 + v10 / *(unsigned int *)(a1 + 24)) % *(unsigned int *)(a1 + 28);
*a3 |= 1LL << v13;
v14 = *(_DWORD *)(a1 + 24) - v12;
if ( a7 < v14 )
v14 = a7;
if ( (unsigned int)simple_key_cache_write(
*(const __m128i **)(*(_QWORD *)(a1 + 8) + 8 * v13),
a2,
(long long)a3,
v10,
a5,
a6,
v14,
v16,
a9) )
break;
a6 += v14;
v10 += v14;
LODWORD(v12) = 0;
a7 -= v14;
if ( !a7 )
return (unsigned int)v12;
}
LODWORD(v12) = 1;
return (unsigned int)v12;
}
| partitioned_key_cache_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,R9
MOV dword ptr [RBP + -0x2c],R8D
MOV R15,RCX
MOV qword ptr [RBP + -0x40],RDX
MOV R13,RDI
MOV R12D,dword ptr [RBP + 0x10]
MOV ECX,dword ptr [RDI + 0x18]
MOV RAX,R15
XOR EDX,EDX
DIV RCX
MOV R8,RDX
MOVSXD RAX,ESI
MOV qword ptr [RBP + -0x38],RAX
LAB_001566cb:
MOV ECX,dword ptr [R13 + 0x18]
MOV EDI,dword ptr [R13 + 0x1c]
MOV RAX,R15
XOR EDX,EDX
DIV RCX
MOV RSI,qword ptr [RBP + -0x38]
ADD RAX,RSI
XOR EDX,EDX
DIV RDI
MOV RCX,RDX
MOV EAX,0x1
SHL RAX,CL
MOV RDX,qword ptr [RBP + -0x40]
OR qword ptr [RDX],RAX
MOV RAX,qword ptr [R13 + 0x8]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOV R14D,dword ptr [R13 + 0x18]
SUB R14D,R8D
CMP R12D,R14D
CMOVC R14D,R12D
MOV EAX,dword ptr [RBP + 0x20]
MOV dword ptr [RSP + 0x10],EAX
MOV dword ptr [RSP],R14D
MOV RCX,R15
MOV R8D,dword ptr [RBP + -0x2c]
MOV R9,RBX
CALL 0x00155016
TEST EAX,EAX
JNZ 0x00156740
MOV EAX,R14D
ADD RBX,RAX
ADD R15,RAX
XOR R8D,R8D
SUB R12D,R14D
JNZ 0x001566cb
JMP 0x00156746
LAB_00156740:
MOV R8D,0x1
LAB_00156746:
MOV EAX,R8D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
partitioned_key_cache_write
(long param_1,int param_2,ulong *param_3,ulong param_4,int4 param_5,long param_6,
uint param_7)
{
int1 auVar1 [16];
int iVar2;
ulong uVar3;
uint uVar4;
uVar3 = param_4 % (ulong)*(uint *)(param_1 + 0x18);
while( true ) {
auVar1._8_8_ = 0;
auVar1._0_8_ = param_4 / *(uint *)(param_1 + 0x18) + (long)param_2;
auVar1 = auVar1 % ZEXT416(*(uint *)(param_1 + 0x1c));
*param_3 = *param_3 | 1L << (auVar1[0] & 0x3f);
uVar4 = *(int *)(param_1 + 0x18) - (int)uVar3;
if (param_7 < uVar4) {
uVar4 = param_7;
}
iVar2 = simple_key_cache_write
(*(int8 *)(*(long *)(param_1 + 8) + auVar1._0_8_ * 8),(long)param_2,
param_3,param_4,param_5,param_6,uVar4);
if (iVar2 != 0) break;
param_6 = param_6 + (ulong)uVar4;
param_4 = param_4 + uVar4;
uVar3 = 0;
param_7 = param_7 - uVar4;
if (param_7 == 0) {
return 0;
}
}
return 1;
}
| |
22,454 | JS_EnqueueJob | bluesky950520[P]quickjs/quickjs.c | int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func,
int argc, JSValue *argv)
{
JSRuntime *rt = ctx->rt;
JSJobEntry *e;
int i;
assert(!rt->in_free);
e = js_malloc(ctx, sizeof(*e) + argc * sizeof(JSValue));
if (!e)
return -1;
e->ctx = ctx;
e->job_func = job_func;
e->argc = argc;
for(i = 0; i < argc; i++) {
e->argv[i] = js_dup(argv[i]);
}
list_add_tail(&e->link, &rt->job_list);
return 0;
} | O0 | c | JS_EnqueueJob:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
shlq $0x4, %rsi
addq $0x28, %rsi
callq 0x21cb0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x23986
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x23a43
movq 0x48(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x3c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x23a25
movq 0x20(%rsp), %rax
addq $0x28, %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x216d0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x239b6
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x130, %rsi # imm = 0x130
callq 0x23a50
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
| JS_EnqueueJob:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_1C], edx
mov [rsp+58h+var_28], rcx
mov rax, [rsp+58h+var_10]
mov rax, [rax+18h]
mov [rsp+58h+var_30], rax
mov rdi, [rsp+58h+var_10]
movsxd rsi, [rsp+58h+var_1C]
shl rsi, 4
add rsi, 28h ; '('
call js_malloc
mov [rsp+58h+var_38], rax
cmp [rsp+58h+var_38], 0
jnz short loc_23986
mov [rsp+58h+var_4], 0FFFFFFFFh
jmp loc_23A43
loc_23986:
mov rcx, [rsp+58h+var_10]
mov rax, [rsp+58h+var_38]
mov [rax+10h], rcx
mov rcx, [rsp+58h+var_18]
mov rax, [rsp+58h+var_38]
mov [rax+18h], rcx
mov ecx, [rsp+58h+var_1C]
mov rax, [rsp+58h+var_38]
mov [rax+20h], ecx
mov [rsp+58h+var_3C], 0
loc_239B6:
mov eax, [rsp+58h+var_3C]
cmp eax, [rsp+58h+var_1C]
jge short loc_23A25
mov rax, [rsp+58h+var_38]
add rax, 28h ; '('
movsxd rcx, [rsp+58h+var_3C]
shl rcx, 4
add rax, rcx
mov [rsp+58h+var_58], rax
mov rax, [rsp+58h+var_28]
movsxd rcx, [rsp+58h+var_3C]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rcx, rax
mov rax, [rsp+58h+var_58]
mov [rsp+58h+var_50], rcx
mov [rsp+58h+var_48], rdx
mov rcx, [rsp+58h+var_50]
mov [rax], rcx
mov rcx, [rsp+58h+var_48]
mov [rax+8], rcx
mov eax, [rsp+58h+var_3C]
add eax, 1
mov [rsp+58h+var_3C], eax
jmp short loc_239B6
loc_23A25:
mov rdi, [rsp+58h+var_38]
mov rsi, [rsp+58h+var_30]
add rsi, 130h
call list_add_tail_0
mov [rsp+58h+var_4], 0
loc_23A43:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long JS_EnqueueJob(long long a1, long long a2, int a3, long long a4)
{
long long v4; // rdx
_QWORD *v6; // [rsp+0h] [rbp-58h]
int i; // [rsp+1Ch] [rbp-3Ch]
long long v8; // [rsp+20h] [rbp-38h]
long long v9; // [rsp+28h] [rbp-30h]
v9 = *(_QWORD *)(a1 + 24);
v8 = js_malloc(a1, 16LL * a3 + 40);
if ( v8 )
{
*(_QWORD *)(v8 + 16) = a1;
*(_QWORD *)(v8 + 24) = a2;
*(_DWORD *)(v8 + 32) = a3;
for ( i = 0; i < a3; ++i )
{
v6 = (_QWORD *)(16LL * i + v8 + 40);
*v6 = js_dup(*(_DWORD **)(16LL * i + a4), *(_QWORD *)(16LL * i + a4 + 8));
v6[1] = v4;
}
list_add_tail_0(v8, v9 + 304);
return 0;
}
else
{
return (unsigned int)-1;
}
}
| JS_EnqueueJob:
SUB RSP,0x58
MOV qword ptr [RSP + 0x48],RDI
MOV qword ptr [RSP + 0x40],RSI
MOV dword ptr [RSP + 0x3c],EDX
MOV qword ptr [RSP + 0x30],RCX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x48]
MOVSXD RSI,dword ptr [RSP + 0x3c]
SHL RSI,0x4
ADD RSI,0x28
CALL 0x00121cb0
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x00123986
MOV dword ptr [RSP + 0x54],0xffffffff
JMP 0x00123a43
LAB_00123986:
MOV RCX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x18],RCX
MOV ECX,dword ptr [RSP + 0x3c]
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x20],ECX
MOV dword ptr [RSP + 0x1c],0x0
LAB_001239b6:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x3c]
JGE 0x00123a25
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x28
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,dword ptr [RSP + 0x1c]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001216d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x001239b6
LAB_00123a25:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
ADD RSI,0x130
CALL 0x00123a50
MOV dword ptr [RSP + 0x54],0x0
LAB_00123a43:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 JS_EnqueueJob(long param_1,int8 param_2,int param_3,long param_4)
{
long lVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
int8 uVar5;
int4 extraout_EDX;
int4 extraout_var;
int local_3c;
int4 local_4;
lVar1 = *(long *)(param_1 + 0x18);
lVar2 = js_malloc(param_1,(long)param_3 * 0x10 + 0x28);
if (lVar2 == 0) {
local_4 = 0xffffffff;
}
else {
*(long *)(lVar2 + 0x10) = param_1;
*(int8 *)(lVar2 + 0x18) = param_2;
*(int *)(lVar2 + 0x20) = param_3;
for (local_3c = 0; local_3c < param_3; local_3c = local_3c + 1) {
puVar3 = (int8 *)(lVar2 + 0x28 + (long)local_3c * 0x10);
puVar4 = (int8 *)(param_4 + (long)local_3c * 0x10);
uVar5 = js_dup(*puVar4,puVar4[1]);
*puVar3 = uVar5;
puVar3[1] = CONCAT44(extraout_var,extraout_EDX);
}
list_add_tail(lVar2,lVar1 + 0x130);
local_4 = 0;
}
return local_4;
}
| |
22,455 | JS_EnqueueJob | bluesky950520[P]quickjs/quickjs.c | int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func,
int argc, JSValue *argv)
{
JSRuntime *rt = ctx->rt;
JSJobEntry *e;
int i;
assert(!rt->in_free);
e = js_malloc(ctx, sizeof(*e) + argc * sizeof(JSValue));
if (!e)
return -1;
e->ctx = ctx;
e->job_func = job_func;
e->argc = argc;
for(i = 0; i < argc; i++) {
e->argv[i] = js_dup(argv[i]);
}
list_add_tail(&e->link, &rt->job_list);
return 0;
} | O1 | c | JS_EnqueueJob:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rdi), %r12
movslq %edx, %rsi
shlq $0x4, %rsi
addq $0x28, %rsi
callq 0xede6
testq %rax, %rax
je 0xf0b8
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movl %ebp, 0x20(%rax)
testl %ebp, %ebp
jle 0xf091
movl %ebp, %ecx
shlq $0x4, %rcx
xorl %edx, %edx
movq (%rbx,%rdx), %rsi
movq 0x8(%rbx,%rdx), %rdi
movq %rsi, 0x8(%rsp)
cmpl $-0x9, %edi
jb 0xf07e
movq 0x8(%rsp), %r8
incl (%r8)
movq %rsi, 0x28(%rax,%rdx)
movq %rdi, 0x30(%rax,%rdx)
addq $0x10, %rdx
cmpq %rdx, %rcx
jne 0xf063
leaq 0x130(%r12), %rcx
movq 0x130(%r12), %rdx
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x130(%r12)
xorl %eax, %eax
jmp 0xf0bb
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| JS_EnqueueJob:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov rbx, rcx
mov ebp, edx
mov r14, rsi
mov r15, rdi
mov r12, [rdi+18h]
movsxd rsi, edx
shl rsi, 4
add rsi, 28h ; '('
call js_malloc
test rax, rax
jz short loc_F0B8
mov [rax+10h], r15
mov [rax+18h], r14
mov [rax+20h], ebp
test ebp, ebp
jle short loc_F091
mov ecx, ebp
shl rcx, 4
xor edx, edx
loc_F063:
mov rsi, [rbx+rdx]
mov rdi, [rbx+rdx+8]
mov [rsp+38h+var_30], rsi
cmp edi, 0FFFFFFF7h
jb short loc_F07E
mov r8, [rsp+38h+var_30]
inc dword ptr [r8]
loc_F07E:
mov [rax+rdx+28h], rsi
mov [rax+rdx+30h], rdi
add rdx, 10h
cmp rcx, rdx
jnz short loc_F063
loc_F091:
lea rcx, [r12+130h]
mov rdx, [r12+130h]
mov [rdx+8], rax
mov [rax], rdx
mov [rax+8], rcx
mov [r12+130h], rax
xor eax, eax
jmp short loc_F0BB
loc_F0B8:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_F0BB:
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long JS_EnqueueJob(long long a1, long long a2, int a3, long long a4)
{
long long v6; // r12
long long v7; // rax
long long v8; // rdx
long long v9; // rsi
long long v10; // rdi
long long v11; // rdx
v6 = *(_QWORD *)(a1 + 24);
v7 = js_malloc(a1, 16LL * a3 + 40);
if ( !v7 )
return -1LL;
*(_QWORD *)(v7 + 16) = a1;
*(_QWORD *)(v7 + 24) = a2;
*(_DWORD *)(v7 + 32) = a3;
if ( a3 > 0 )
{
v8 = 0LL;
do
{
v9 = *(_QWORD *)(a4 + v8);
v10 = *(_QWORD *)(a4 + v8 + 8);
if ( (unsigned int)v10 >= 0xFFFFFFF7 )
++**(_DWORD **)(a4 + v8);
*(_QWORD *)(v7 + v8 + 40) = v9;
*(_QWORD *)(v7 + v8 + 48) = v10;
v8 += 16LL;
}
while ( 16LL * (unsigned int)a3 != v8 );
}
v11 = *(_QWORD *)(v6 + 304);
*(_QWORD *)(v11 + 8) = v7;
*(_QWORD *)v7 = v11;
*(_QWORD *)(v7 + 8) = v6 + 304;
*(_QWORD *)(v6 + 304) = v7;
return 0LL;
}
| |||
22,456 | JS_EnqueueJob | bluesky950520[P]quickjs/quickjs.c | int JS_EnqueueJob(JSContext *ctx, JSJobFunc *job_func,
int argc, JSValue *argv)
{
JSRuntime *rt = ctx->rt;
JSJobEntry *e;
int i;
assert(!rt->in_free);
e = js_malloc(ctx, sizeof(*e) + argc * sizeof(JSValue));
if (!e)
return -1;
e->ctx = ctx;
e->job_func = job_func;
e->argc = argc;
for(i = 0; i < argc; i++) {
e->argv[i] = js_dup(argv[i]);
}
list_add_tail(&e->link, &rt->job_list);
return 0;
} | O2 | c | JS_EnqueueJob:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rdi), %r13
movslq %edx, %rsi
shlq $0x4, %rsi
addq $0x28, %rsi
callq 0x17214
testq %rax, %rax
je 0x17f39
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movl %r14d, 0x20(%rax)
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
shlq $0x4, %r14
cmpq %rcx, %r14
je 0x17f15
movq (%rbx,%rcx), %rdx
movq 0x8(%rbx,%rcx), %rsi
cmpl $-0x9, %esi
jb 0x17f05
incl (%rdx)
movq %rdx, 0x28(%rax,%rcx)
movq %rsi, 0x30(%rax,%rcx)
addq $0x10, %rcx
jmp 0x17ef0
leaq 0x130(%r13), %rcx
movq 0x130(%r13), %rdx
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x130(%r13)
xorl %eax, %eax
jmp 0x17f3c
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| JS_EnqueueJob:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rcx
mov r14d, edx
mov r15, rsi
mov r12, rdi
mov r13, [rdi+18h]
movsxd rsi, edx
shl rsi, 4
add rsi, 28h ; '('
call js_malloc
test rax, rax
jz short loc_17F39
mov [rax+10h], r12
mov [rax+18h], r15
mov [rax+20h], r14d
xor ecx, ecx
test r14d, r14d
cmovle r14d, ecx
shl r14, 4
loc_17EF0:
cmp r14, rcx
jz short loc_17F15
mov rdx, [rbx+rcx]
mov rsi, [rbx+rcx+8]
cmp esi, 0FFFFFFF7h
jb short loc_17F05
inc dword ptr [rdx]
loc_17F05:
mov [rax+rcx+28h], rdx
mov [rax+rcx+30h], rsi
add rcx, 10h
jmp short loc_17EF0
loc_17F15:
lea rcx, [r13+130h]
mov rdx, [r13+130h]
mov [rdx+8], rax
mov [rax], rdx
mov [rax+8], rcx
mov [r13+130h], rax
xor eax, eax
jmp short loc_17F3C
loc_17F39:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_17F3C:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long JS_EnqueueJob(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v5; // r14
long long v6; // r13
long long v7; // rax
long long v8; // rcx
long long v9; // r14
_DWORD *v10; // rdx
long long v11; // rsi
long long v12; // rdx
v5 = a3;
v6 = *(_QWORD *)(a1 + 24);
v7 = js_malloc(a1, 16LL * (int)a3 + 40);
if ( !v7 )
return -1LL;
*(_QWORD *)(v7 + 16) = a1;
*(_QWORD *)(v7 + 24) = a2;
*(_DWORD *)(v7 + 32) = v5;
v8 = 0LL;
if ( (int)v5 <= 0 )
v5 = 0LL;
v9 = 16 * v5;
while ( v9 != v8 )
{
v10 = *(_DWORD **)(a4 + v8);
v11 = *(_QWORD *)(a4 + v8 + 8);
if ( (unsigned int)v11 >= 0xFFFFFFF7 )
++*v10;
*(_QWORD *)(v7 + v8 + 40) = v10;
*(_QWORD *)(v7 + v8 + 48) = v11;
v8 += 16LL;
}
v12 = *(_QWORD *)(v6 + 304);
*(_QWORD *)(v12 + 8) = v7;
*(_QWORD *)v7 = v12;
*(_QWORD *)(v7 + 8) = v6 + 304;
*(_QWORD *)(v6 + 304) = v7;
return 0LL;
}
| JS_EnqueueJob:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14D,EDX
MOV R15,RSI
MOV R12,RDI
MOV R13,qword ptr [RDI + 0x18]
MOVSXD RSI,EDX
SHL RSI,0x4
ADD RSI,0x28
CALL 0x00117214
TEST RAX,RAX
JZ 0x00117f39
MOV qword ptr [RAX + 0x10],R12
MOV qword ptr [RAX + 0x18],R15
MOV dword ptr [RAX + 0x20],R14D
XOR ECX,ECX
TEST R14D,R14D
CMOVLE R14D,ECX
SHL R14,0x4
LAB_00117ef0:
CMP R14,RCX
JZ 0x00117f15
MOV RDX,qword ptr [RBX + RCX*0x1]
MOV RSI,qword ptr [RBX + RCX*0x1 + 0x8]
CMP ESI,-0x9
JC 0x00117f05
INC dword ptr [RDX]
LAB_00117f05:
MOV qword ptr [RAX + RCX*0x1 + 0x28],RDX
MOV qword ptr [RAX + RCX*0x1 + 0x30],RSI
ADD RCX,0x10
JMP 0x00117ef0
LAB_00117f15:
LEA RCX,[R13 + 0x130]
MOV RDX,qword ptr [R13 + 0x130]
MOV qword ptr [RDX + 0x8],RAX
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [R13 + 0x130],RAX
XOR EAX,EAX
JMP 0x00117f3c
LAB_00117f39:
PUSH -0x1
POP RAX
LAB_00117f3c:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8 JS_EnqueueJob(long param_1,long param_2,uint param_3,long param_4)
{
long lVar1;
int *piVar2;
long lVar3;
long *plVar4;
int8 uVar5;
ulong uVar6;
ulong uVar7;
lVar1 = *(long *)(param_1 + 0x18);
plVar4 = (long *)js_malloc(param_1,(long)(int)param_3 * 0x10 + 0x28);
if (plVar4 == (long *)0x0) {
uVar5 = 0xffffffffffffffff;
}
else {
plVar4[2] = param_1;
plVar4[3] = param_2;
*(uint *)(plVar4 + 4) = param_3;
uVar6 = 0;
uVar7 = (ulong)param_3;
if ((int)param_3 < 1) {
uVar7 = uVar6;
}
for (; uVar7 * 0x10 != uVar6; uVar6 = uVar6 + 0x10) {
piVar2 = *(int **)(param_4 + uVar6);
uVar5 = *(int8 *)(param_4 + 8 + uVar6);
if (0xfffffff6 < (uint)uVar5) {
*piVar2 = *piVar2 + 1;
}
*(int **)((long)plVar4 + uVar6 + 0x28) = piVar2;
*(int8 *)((long)plVar4 + uVar6 + 0x30) = uVar5;
}
lVar3 = *(long *)(lVar1 + 0x130);
*(long **)(lVar3 + 8) = plVar4;
*plVar4 = lVar3;
plVar4[1] = lVar1 + 0x130;
*(long **)(lVar1 + 0x130) = plVar4;
uVar5 = 0;
}
return uVar5;
}
| |
22,457 | js_add_slow | bluesky950520[P]quickjs/quickjs.c | int js_add_slow(JSContext *ctx, JSValue *sp)
{
JSValue op1, op2;
uint32_t tag1, tag2;
op1 = sp[-2];
op2 = sp[-1];
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
/* fast path for float64 */
if (tag1 == JS_TAG_FLOAT64 && tag2 == JS_TAG_FLOAT64) {
double d1, d2;
d1 = JS_VALUE_GET_FLOAT64(op1);
d2 = JS_VALUE_GET_FLOAT64(op2);
sp[-2] = js_float64(d1 + d2);
return 0;
}
if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
goto exception;
}
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
}
if (tag1 == JS_TAG_STRING || tag2 == JS_TAG_STRING) {
sp[-2] = JS_ConcatString(ctx, op1, op2);
if (JS_IsException(sp[-2]))
goto exception;
return 0;
}
op1 = JS_ToNumericFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
op2 = JS_ToNumericFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
goto exception;
}
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
if (tag1 == JS_TAG_INT && tag2 == JS_TAG_INT) {
int32_t v1, v2;
int64_t v;
v1 = JS_VALUE_GET_INT(op1);
v2 = JS_VALUE_GET_INT(op2);
v = (int64_t)v1 + (int64_t)v2;
sp[-2] = js_int64(v);
} else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
if (js_binary_arith_bigint(ctx, OP_add, sp - 2, op1, op2))
goto exception;
} else {
double d1, d2;
/* float64 result */
if (JS_ToFloat64Free(ctx, &d1, op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
if (JS_ToFloat64Free(ctx, &d2, op2))
goto exception;
sp[-2] = js_float64(d1 + d2);
}
return 0;
exception:
sp[-2] = JS_UNDEFINED;
sp[-1] = JS_UNDEFINED;
return -1;
} | O0 | c | js_add_slow:
subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq -0x20(%rax), %rcx
movq %rcx, 0x120(%rsp)
movq -0x18(%rax), %rax
movq %rax, 0x128(%rsp)
movq 0x130(%rsp), %rax
movq -0x10(%rax), %rcx
movq %rcx, 0x110(%rsp)
movq -0x8(%rax), %rax
movq %rax, 0x118(%rsp)
movq 0x128(%rsp), %rax
movl %eax, 0x10c(%rsp)
movq 0x118(%rsp), %rax
movl %eax, 0x108(%rsp)
cmpl $0x7, 0x10c(%rsp)
jne 0x69359
cmpl $0x7, 0x108(%rsp)
jne 0x69359
movsd 0x120(%rsp), %xmm0
movsd %xmm0, 0x100(%rsp)
movsd 0x110(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x30(%rsp)
movsd 0x100(%rsp), %xmm0
addsd 0xf8(%rsp), %xmm0
callq 0x4c3a0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0xe8(%rsp), %rcx
movq %rcx, -0x20(%rax)
movq 0xf0(%rsp), %rcx
movq %rcx, -0x18(%rax)
movl $0x0, 0x144(%rsp)
jmp 0x698b2
cmpl $-0x1, 0x10c(%rsp)
je 0x69371
cmpl $-0x1, 0x108(%rsp)
jne 0x694ab
movq 0x138(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
movl $0x2, %ecx
callq 0x60b50
movq %rax, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x120(%rsp), %rdi
movq 0x128(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x693ff
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x229d0
jmp 0x69851
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
movl $0x2, %ecx
callq 0x60b50
movq %rax, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x6948d
movq 0x138(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
callq 0x229d0
jmp 0x69851
movq 0x128(%rsp), %rax
movl %eax, 0x10c(%rsp)
movq 0x118(%rsp), %rax
movl %eax, 0x108(%rsp)
cmpl $-0x7, 0x10c(%rsp)
je 0x694c3
cmpl $-0x7, 0x108(%rsp)
jne 0x6955c
movq 0x130(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x138(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq 0x110(%rsp), %rcx
movq 0x118(%rsp), %r8
callq 0x698d0
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xb8(%rsp), %rcx
movq %rcx, -0x20(%rax)
movq 0xc0(%rsp), %rcx
movq %rcx, -0x18(%rax)
movq 0x130(%rsp), %rax
movq -0x20(%rax), %rdi
movq -0x18(%rax), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x6954c
jmp 0x69851
movl $0x0, 0x144(%rsp)
jmp 0x698b2
movq 0x138(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
callq 0x6f770
movq %rax, 0xa8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x120(%rsp), %rdi
movq 0x128(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x695e5
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x229d0
jmp 0x69851
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x6f770
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x6966e
movq 0x138(%rsp), %rdi
movq 0x120(%rsp), %rsi
movq 0x128(%rsp), %rdx
callq 0x229d0
jmp 0x69851
movq 0x128(%rsp), %rax
movl %eax, 0x10c(%rsp)
movq 0x118(%rsp), %rax
movl %eax, 0x108(%rsp)
cmpl $0x0, 0x10c(%rsp)
jne 0x69728
cmpl $0x0, 0x108(%rsp)
jne 0x69728
movl 0x120(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x110(%rsp), %eax
movl %eax, 0x90(%rsp)
movslq 0x94(%rsp), %rax
movslq 0x90(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x88(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rdi
callq 0x361c0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x78(%rsp), %rcx
movq %rcx, -0x20(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, -0x18(%rax)
jmp 0x69844
cmpl $-0x9, 0x10c(%rsp)
je 0x6973c
cmpl $-0x9, 0x108(%rsp)
jne 0x69791
movq 0x138(%rsp), %rdi
movq 0x130(%rsp), %rdx
addq $-0x20, %rdx
movq 0x120(%rsp), %rcx
movq 0x128(%rsp), %r8
movl $0x9d, %esi
leaq 0x110(%rsp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x6f7c0
cmpl $0x0, %eax
je 0x6978c
jmp 0x69851
jmp 0x69842
movq 0x138(%rsp), %rdi
movq 0x120(%rsp), %rdx
movq 0x128(%rsp), %rcx
leaq 0x70(%rsp), %rsi
callq 0x37330
cmpl $0x0, %eax
je 0x697d7
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
callq 0x229d0
jmp 0x69851
movq 0x138(%rsp), %rdi
movq 0x110(%rsp), %rdx
movq 0x118(%rsp), %rcx
leaq 0x68(%rsp), %rsi
callq 0x37330
cmpl $0x0, %eax
je 0x69800
jmp 0x69851
movq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x70(%rsp), %xmm0
addsd 0x68(%rsp), %xmm0
callq 0x4c3a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, -0x20(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, -0x18(%rax)
jmp 0x69844
movl $0x0, 0x144(%rsp)
jmp 0x698b2
movq 0x130(%rsp), %rax
movl $0x0, 0x48(%rsp)
movq $0x3, 0x50(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, -0x20(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, -0x18(%rax)
movq 0x130(%rsp), %rax
movl $0x0, 0x38(%rsp)
movq $0x3, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, -0x8(%rax)
movl $0xffffffff, 0x144(%rsp) # imm = 0xFFFFFFFF
movl 0x144(%rsp), %eax
addq $0x148, %rsp # imm = 0x148
retq
nopw %cs:(%rax,%rax)
| js_add_slow:
sub rsp, 148h
mov [rsp+148h+var_10], rdi
mov [rsp+148h+var_18], rsi
mov rax, [rsp+148h+var_18]
mov rcx, [rax-20h]
mov [rsp+148h+var_28], rcx
mov rax, [rax-18h]
mov [rsp+148h+var_20], rax
mov rax, [rsp+148h+var_18]
mov rcx, [rax-10h]
mov [rsp+148h+var_38], rcx
mov rax, [rax-8]
mov [rsp+148h+var_30], rax
mov rax, [rsp+148h+var_20]
mov [rsp+148h+var_3C], eax
mov rax, [rsp+148h+var_30]
mov [rsp+148h+var_40], eax
cmp [rsp+148h+var_3C], 7
jnz loc_69359
cmp [rsp+148h+var_40], 7
jnz loc_69359
movsd xmm0, [rsp+148h+var_28]
movsd [rsp+148h+var_48], xmm0
movsd xmm0, [rsp+148h+var_38]
movsd [rsp+148h+var_50], xmm0
mov rax, [rsp+148h+var_18]
mov [rsp+148h+var_118], rax
movsd xmm0, [rsp+148h+var_48]
addsd xmm0, [rsp+148h+var_50]
call js_float64
mov rcx, rax
mov rax, [rsp+148h+var_118]
mov [rsp+148h+var_60], rcx
mov [rsp+148h+var_58], rdx
mov rcx, [rsp+148h+var_60]
mov [rax-20h], rcx
mov rcx, [rsp+148h+var_58]
mov [rax-18h], rcx
mov [rsp+148h+var_4], 0
jmp loc_698B2
loc_69359:
cmp [rsp+148h+var_3C], 0FFFFFFFFh
jz short loc_69371
cmp [rsp+148h+var_40], 0FFFFFFFFh
jnz loc_694AB
loc_69371:
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_28]
mov rdx, [rsp+148h+var_20]
mov ecx, 2
call JS_ToPrimitiveFree
mov [rsp+148h+var_70], rax
mov [rsp+148h+var_68], rdx
mov rax, [rsp+148h+var_70]
mov [rsp+148h+var_28], rax
mov rax, [rsp+148h+var_68]
mov [rsp+148h+var_20], rax
mov rdi, [rsp+148h+var_28]
mov rsi, [rsp+148h+var_20]
call JS_IsException_1
cmp eax, 0
jz short loc_693FF
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_38]
mov rdx, [rsp+148h+var_30]
call JS_FreeValue
jmp loc_69851
loc_693FF:
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_38]
mov rdx, [rsp+148h+var_30]
mov ecx, 2
call JS_ToPrimitiveFree
mov [rsp+148h+var_80], rax
mov [rsp+148h+var_78], rdx
mov rax, [rsp+148h+var_80]
mov [rsp+148h+var_38], rax
mov rax, [rsp+148h+var_78]
mov [rsp+148h+var_30], rax
mov rdi, [rsp+148h+var_38]
mov rsi, [rsp+148h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_6948D
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_28]
mov rdx, [rsp+148h+var_20]
call JS_FreeValue
jmp loc_69851
loc_6948D:
mov rax, [rsp+148h+var_20]
mov [rsp+148h+var_3C], eax
mov rax, [rsp+148h+var_30]
mov [rsp+148h+var_40], eax
loc_694AB:
cmp [rsp+148h+var_3C], 0FFFFFFF9h
jz short loc_694C3
cmp [rsp+148h+var_40], 0FFFFFFF9h
jnz loc_6955C
loc_694C3:
mov rax, [rsp+148h+var_18]
mov [rsp+148h+var_120], rax
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_28]
mov rdx, [rsp+148h+var_20]
mov rcx, [rsp+148h+var_38]
mov r8, [rsp+148h+var_30]
call JS_ConcatString
mov rcx, rax
mov rax, [rsp+148h+var_120]
mov [rsp+148h+var_90], rcx
mov [rsp+148h+var_88], rdx
mov rcx, [rsp+148h+var_90]
mov [rax-20h], rcx
mov rcx, [rsp+148h+var_88]
mov [rax-18h], rcx
mov rax, [rsp+148h+var_18]
mov rdi, [rax-20h]
mov rsi, [rax-18h]
call JS_IsException_1
cmp eax, 0
jz short loc_6954C
jmp loc_69851
loc_6954C:
mov [rsp+148h+var_4], 0
jmp loc_698B2
loc_6955C:
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_28]
mov rdx, [rsp+148h+var_20]
call JS_ToNumericFree
mov [rsp+148h+var_A0], rax
mov [rsp+148h+var_98], rdx
mov rax, [rsp+148h+var_A0]
mov [rsp+148h+var_28], rax
mov rax, [rsp+148h+var_98]
mov [rsp+148h+var_20], rax
mov rdi, [rsp+148h+var_28]
mov rsi, [rsp+148h+var_20]
call JS_IsException_1
cmp eax, 0
jz short loc_695E5
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_38]
mov rdx, [rsp+148h+var_30]
call JS_FreeValue
jmp loc_69851
loc_695E5:
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_38]
mov rdx, [rsp+148h+var_30]
call JS_ToNumericFree
mov [rsp+148h+var_B0], rax
mov [rsp+148h+var_A8], rdx
mov rax, [rsp+148h+var_B0]
mov [rsp+148h+var_38], rax
mov rax, [rsp+148h+var_A8]
mov [rsp+148h+var_30], rax
mov rdi, [rsp+148h+var_38]
mov rsi, [rsp+148h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_6966E
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_28]
mov rdx, [rsp+148h+var_20]
call JS_FreeValue
jmp loc_69851
loc_6966E:
mov rax, [rsp+148h+var_20]
mov [rsp+148h+var_3C], eax
mov rax, [rsp+148h+var_30]
mov [rsp+148h+var_40], eax
cmp [rsp+148h+var_3C], 0
jnz loc_69728
cmp [rsp+148h+var_40], 0
jnz loc_69728
mov eax, dword ptr [rsp+148h+var_28]
mov [rsp+148h+var_B4], eax
mov eax, dword ptr [rsp+148h+var_38]
mov [rsp+148h+var_B8], eax
movsxd rax, [rsp+148h+var_B4]
movsxd rcx, [rsp+148h+var_B8]
add rax, rcx
mov [rsp+148h+var_C0], rax
mov rax, [rsp+148h+var_18]
mov [rsp+148h+var_128], rax
mov rdi, [rsp+148h+var_C0]
call js_int64
mov rcx, rax
mov rax, [rsp+148h+var_128]
mov [rsp+148h+var_D0], rcx
mov [rsp+148h+var_C8], rdx
mov rcx, [rsp+148h+var_D0]
mov [rax-20h], rcx
mov rcx, [rsp+148h+var_C8]
mov [rax-18h], rcx
jmp loc_69844
loc_69728:
cmp [rsp+148h+var_3C], 0FFFFFFF7h
jz short loc_6973C
cmp [rsp+148h+var_40], 0FFFFFFF7h
jnz short loc_69791
loc_6973C:
mov rdi, [rsp+148h+var_10]
mov rdx, [rsp+148h+var_18]
add rdx, 0FFFFFFFFFFFFFFE0h
mov rcx, [rsp+148h+var_28]
mov r8, [rsp+148h+var_20]
mov esi, 9Dh
lea rax, [rsp+148h+var_38]
mov r9, [rax]
mov [rsp+148h+var_148], r9
mov rax, [rax+8]
mov [rsp+148h+var_140], rax
call js_binary_arith_bigint
cmp eax, 0
jz short loc_6978C
jmp loc_69851
loc_6978C:
jmp loc_69842
loc_69791:
mov rdi, [rsp+148h+var_10]
mov rdx, [rsp+148h+var_28]
mov rcx, [rsp+148h+var_20]
lea rsi, [rsp+148h+var_D8]
call JS_ToFloat64Free
cmp eax, 0
jz short loc_697D7
mov rdi, [rsp+148h+var_10]
mov rsi, [rsp+148h+var_38]
mov rdx, [rsp+148h+var_30]
call JS_FreeValue
jmp short loc_69851
loc_697D7:
mov rdi, [rsp+148h+var_10]
mov rdx, [rsp+148h+var_38]
mov rcx, [rsp+148h+var_30]
lea rsi, [rsp+148h+var_E0]
call JS_ToFloat64Free
cmp eax, 0
jz short loc_69800
jmp short loc_69851
loc_69800:
mov rax, [rsp+148h+var_18]
mov [rsp+148h+var_130], rax
movsd xmm0, [rsp+148h+var_D8]
addsd xmm0, [rsp+148h+var_E0]
call js_float64
mov rcx, rax
mov rax, [rsp+148h+var_130]
mov [rsp+148h+var_F0], rcx
mov [rsp+148h+var_E8], rdx
mov rcx, [rsp+148h+var_F0]
mov [rax-20h], rcx
mov rcx, [rsp+148h+var_E8]
mov [rax-18h], rcx
loc_69842:
jmp short $+2
loc_69844:
mov [rsp+148h+var_4], 0
jmp short loc_698B2
loc_69851:
mov rax, [rsp+148h+var_18]
mov dword ptr [rsp+148h+var_100], 0
mov [rsp+148h+var_F8], 3
mov rcx, [rsp+148h+var_100]
mov [rax-20h], rcx
mov rcx, [rsp+148h+var_F8]
mov [rax-18h], rcx
mov rax, [rsp+148h+var_18]
mov dword ptr [rsp+148h+var_110], 0
mov [rsp+148h+var_108], 3
mov rcx, [rsp+148h+var_110]
mov [rax-10h], rcx
mov rcx, [rsp+148h+var_108]
mov [rax-8], rcx
mov [rsp+148h+var_4], 0FFFFFFFFh
loc_698B2:
mov eax, [rsp+148h+var_4]
add rsp, 148h
retn
| long long js_add_slow(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rax
long long v15; // rdx
long long v16; // rdx
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; // rdx
long long v27; // rdx
long long v28; // rax
long long v29; // rax
long long v31; // [rsp+18h] [rbp-130h]
long long v32; // [rsp+20h] [rbp-128h]
long long v33; // [rsp+28h] [rbp-120h]
long long v34; // [rsp+30h] [rbp-118h]
long long v35; // [rsp+38h] [rbp-110h]
long long v36; // [rsp+48h] [rbp-100h]
double v37; // [rsp+68h] [rbp-E0h] BYREF
double v38; // [rsp+70h] [rbp-D8h] BYREF
long long v39; // [rsp+80h] [rbp-C8h]
long long v40; // [rsp+88h] [rbp-C0h]
int v41; // [rsp+90h] [rbp-B8h]
int v42; // [rsp+94h] [rbp-B4h]
long long v43; // [rsp+98h] [rbp-B0h]
long long v44; // [rsp+A0h] [rbp-A8h]
long long v45; // [rsp+A8h] [rbp-A0h]
long long v46; // [rsp+B0h] [rbp-98h]
long long v47; // [rsp+B8h] [rbp-90h]
long long v48; // [rsp+C0h] [rbp-88h]
long long v49; // [rsp+C8h] [rbp-80h]
long long v50; // [rsp+D0h] [rbp-78h]
long long v51; // [rsp+D8h] [rbp-70h]
long long v52; // [rsp+E0h] [rbp-68h]
long long v53; // [rsp+F0h] [rbp-58h]
long long v54; // [rsp+F8h] [rbp-50h]
long long v55; // [rsp+100h] [rbp-48h]
int v56; // [rsp+108h] [rbp-40h]
int v57; // [rsp+10Ch] [rbp-3Ch]
long long v58; // [rsp+110h] [rbp-38h]
long long v59; // [rsp+118h] [rbp-30h]
long long v60; // [rsp+120h] [rbp-28h]
long long v61; // [rsp+128h] [rbp-20h]
long long v62; // [rsp+130h] [rbp-18h]
long long v63; // [rsp+138h] [rbp-10h]
v63 = a1;
v62 = a2;
v60 = *(long long *)(a2 - 32);
v61 = *(_QWORD *)(a2 - 24);
v58 = *(long long *)(a2 - 16);
v59 = *(_QWORD *)(a2 - 8);
v57 = v61;
v56 = v59;
if ( __PAIR64__(v61, v59) != 0x700000007LL )
{
if ( v57 == -1 || v56 == -1 )
{
v51 = JS_ToPrimitiveFree(v63, v60, v61, 2LL, a13, a14, a3, a4, a5, a6, a7, a8, a9, a10);
v52 = v16;
v60 = v51;
v61 = v16;
if ( JS_IsException_1(v51, v16) )
goto LABEL_6;
v49 = JS_ToPrimitiveFree(v63, v58, v59, 2LL, v17, v18, a3, a4, a5, a6, v19, v20, a9, a10);
v50 = v21;
v58 = v49;
v59 = v21;
if ( JS_IsException_1(v49, v21) )
goto LABEL_8;
v57 = v61;
v56 = v59;
}
if ( v57 == -7 || v56 == -7 )
{
v33 = v62;
v47 = JS_ConcatString(v63, v60, v61, v58, v59);
v48 = v22;
*(_QWORD *)(v62 - 32) = v47;
*(_QWORD *)(v33 - 24) = v48;
if ( !JS_IsException_1(*(_QWORD *)(v62 - 32), *(_QWORD *)(v62 - 24)) )
return 0;
LABEL_28:
v28 = v62;
LODWORD(v36) = 0;
*(_QWORD *)(v62 - 32) = v36;
*(_QWORD *)(v28 - 24) = 3LL;
v29 = v62;
LODWORD(v35) = 0;
*(_QWORD *)(v62 - 16) = v35;
*(_QWORD *)(v29 - 8) = 3LL;
return (unsigned int)-1;
}
v45 = JS_ToNumericFree(v63, v60, v61);
v46 = v23;
v60 = v45;
v61 = v23;
if ( JS_IsException_1(v45, v23) )
{
LABEL_6:
JS_FreeValue(v63, v58, v59);
goto LABEL_28;
}
v43 = JS_ToNumericFree(v63, v58, v59);
v44 = v24;
v58 = v43;
v59 = v24;
if ( !JS_IsException_1(v43, v24) )
{
v57 = v61;
v56 = v59;
if ( (_DWORD)v61 || v56 )
{
if ( v57 == -9 || v56 == -9 )
{
if ( (unsigned int)js_binary_arith_bigint(v63, 157, (int)v62 - 32, v60, v61, v58, v58, v59) )
goto LABEL_28;
}
else
{
if ( (unsigned int)JS_ToFloat64Free(v63, &v38, v60, v61) )
{
JS_FreeValue(v63, v58, v59);
goto LABEL_28;
}
if ( (unsigned int)JS_ToFloat64Free(v63, &v37, v58, v59) )
goto LABEL_28;
v31 = v62;
*(_QWORD *)(v31 - 32) = js_float64(v38 + v37);
*(_QWORD *)(v31 - 24) = v27;
}
}
else
{
v42 = v60;
v41 = v58;
v40 = (int)v58 + (long long)(int)v60;
v32 = v62;
v25 = js_int64(v40);
v39 = v26;
*(_QWORD *)(v62 - 32) = v25;
*(_QWORD *)(v32 - 24) = v39;
}
return 0;
}
LABEL_8:
JS_FreeValue(v63, v60, v61);
goto LABEL_28;
}
v55 = v60;
v54 = v58;
v34 = v62;
v14 = js_float64(*(double *)&v60 + *(double *)&v58);
v53 = v15;
*(_QWORD *)(v62 - 32) = v14;
*(_QWORD *)(v34 - 24) = v53;
return 0;
}
| js_add_slow:
SUB RSP,0x148
MOV qword ptr [RSP + 0x138],RDI
MOV qword ptr [RSP + 0x130],RSI
MOV RAX,qword ptr [RSP + 0x130]
MOV RCX,qword ptr [RAX + -0x20]
MOV qword ptr [RSP + 0x120],RCX
MOV RAX,qword ptr [RAX + -0x18]
MOV qword ptr [RSP + 0x128],RAX
MOV RAX,qword ptr [RSP + 0x130]
MOV RCX,qword ptr [RAX + -0x10]
MOV qword ptr [RSP + 0x110],RCX
MOV RAX,qword ptr [RAX + -0x8]
MOV qword ptr [RSP + 0x118],RAX
MOV RAX,qword ptr [RSP + 0x128]
MOV dword ptr [RSP + 0x10c],EAX
MOV RAX,qword ptr [RSP + 0x118]
MOV dword ptr [RSP + 0x108],EAX
CMP dword ptr [RSP + 0x10c],0x7
JNZ 0x00169359
CMP dword ptr [RSP + 0x108],0x7
JNZ 0x00169359
MOVSD XMM0,qword ptr [RSP + 0x120]
MOVSD qword ptr [RSP + 0x100],XMM0
MOVSD XMM0,qword ptr [RSP + 0x110]
MOVSD qword ptr [RSP + 0xf8],XMM0
MOV RAX,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x30],RAX
MOVSD XMM0,qword ptr [RSP + 0x100]
ADDSD XMM0,qword ptr [RSP + 0xf8]
CALL 0x0014c3a0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xe8],RCX
MOV qword ptr [RSP + 0xf0],RDX
MOV RCX,qword ptr [RSP + 0xe8]
MOV qword ptr [RAX + -0x20],RCX
MOV RCX,qword ptr [RSP + 0xf0]
MOV qword ptr [RAX + -0x18],RCX
MOV dword ptr [RSP + 0x144],0x0
JMP 0x001698b2
LAB_00169359:
CMP dword ptr [RSP + 0x10c],-0x1
JZ 0x00169371
CMP dword ptr [RSP + 0x108],-0x1
JNZ 0x001694ab
LAB_00169371:
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x120]
MOV RDX,qword ptr [RSP + 0x128]
MOV ECX,0x2
CALL 0x00160b50
MOV qword ptr [RSP + 0xd8],RAX
MOV qword ptr [RSP + 0xe0],RDX
MOV RAX,qword ptr [RSP + 0xd8]
MOV qword ptr [RSP + 0x120],RAX
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x128],RAX
MOV RDI,qword ptr [RSP + 0x120]
MOV RSI,qword ptr [RSP + 0x128]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x001693ff
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
CALL 0x001229d0
JMP 0x00169851
LAB_001693ff:
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
MOV ECX,0x2
CALL 0x00160b50
MOV qword ptr [RSP + 0xc8],RAX
MOV qword ptr [RSP + 0xd0],RDX
MOV RAX,qword ptr [RSP + 0xc8]
MOV qword ptr [RSP + 0x110],RAX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x118],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x118]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0016948d
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x120]
MOV RDX,qword ptr [RSP + 0x128]
CALL 0x001229d0
JMP 0x00169851
LAB_0016948d:
MOV RAX,qword ptr [RSP + 0x128]
MOV dword ptr [RSP + 0x10c],EAX
MOV RAX,qword ptr [RSP + 0x118]
MOV dword ptr [RSP + 0x108],EAX
LAB_001694ab:
CMP dword ptr [RSP + 0x10c],-0x7
JZ 0x001694c3
CMP dword ptr [RSP + 0x108],-0x7
JNZ 0x0016955c
LAB_001694c3:
MOV RAX,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x120]
MOV RDX,qword ptr [RSP + 0x128]
MOV RCX,qword ptr [RSP + 0x110]
MOV R8,qword ptr [RSP + 0x118]
CALL 0x001698d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xb8],RCX
MOV qword ptr [RSP + 0xc0],RDX
MOV RCX,qword ptr [RSP + 0xb8]
MOV qword ptr [RAX + -0x20],RCX
MOV RCX,qword ptr [RSP + 0xc0]
MOV qword ptr [RAX + -0x18],RCX
MOV RAX,qword ptr [RSP + 0x130]
MOV RDI,qword ptr [RAX + -0x20]
MOV RSI,qword ptr [RAX + -0x18]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0016954c
JMP 0x00169851
LAB_0016954c:
MOV dword ptr [RSP + 0x144],0x0
JMP 0x001698b2
LAB_0016955c:
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x120]
MOV RDX,qword ptr [RSP + 0x128]
CALL 0x0016f770
MOV qword ptr [RSP + 0xa8],RAX
MOV qword ptr [RSP + 0xb0],RDX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x120],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x128],RAX
MOV RDI,qword ptr [RSP + 0x120]
MOV RSI,qword ptr [RSP + 0x128]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x001695e5
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
CALL 0x001229d0
JMP 0x00169851
LAB_001695e5:
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
CALL 0x0016f770
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xa0],RDX
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x110],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x118],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x118]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0016966e
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x120]
MOV RDX,qword ptr [RSP + 0x128]
CALL 0x001229d0
JMP 0x00169851
LAB_0016966e:
MOV RAX,qword ptr [RSP + 0x128]
MOV dword ptr [RSP + 0x10c],EAX
MOV RAX,qword ptr [RSP + 0x118]
MOV dword ptr [RSP + 0x108],EAX
CMP dword ptr [RSP + 0x10c],0x0
JNZ 0x00169728
CMP dword ptr [RSP + 0x108],0x0
JNZ 0x00169728
MOV EAX,dword ptr [RSP + 0x120]
MOV dword ptr [RSP + 0x94],EAX
MOV EAX,dword ptr [RSP + 0x110]
MOV dword ptr [RSP + 0x90],EAX
MOVSXD RAX,dword ptr [RSP + 0x94]
MOVSXD RCX,dword ptr [RSP + 0x90]
ADD RAX,RCX
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x88]
CALL 0x001361c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x80],RDX
MOV RCX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX + -0x20],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RAX + -0x18],RCX
JMP 0x00169844
LAB_00169728:
CMP dword ptr [RSP + 0x10c],-0x9
JZ 0x0016973c
CMP dword ptr [RSP + 0x108],-0x9
JNZ 0x00169791
LAB_0016973c:
MOV RDI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x130]
ADD RDX,-0x20
MOV RCX,qword ptr [RSP + 0x120]
MOV R8,qword ptr [RSP + 0x128]
MOV ESI,0x9d
LEA RAX,[RSP + 0x110]
MOV R9,qword ptr [RAX]
MOV qword ptr [RSP],R9
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0016f7c0
CMP EAX,0x0
JZ 0x0016978c
JMP 0x00169851
LAB_0016978c:
JMP 0x00169842
LAB_00169791:
MOV RDI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x120]
MOV RCX,qword ptr [RSP + 0x128]
LEA RSI,[RSP + 0x70]
CALL 0x00137330
CMP EAX,0x0
JZ 0x001697d7
MOV RDI,qword ptr [RSP + 0x138]
MOV RSI,qword ptr [RSP + 0x110]
MOV RDX,qword ptr [RSP + 0x118]
CALL 0x001229d0
JMP 0x00169851
LAB_001697d7:
MOV RDI,qword ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x110]
MOV RCX,qword ptr [RSP + 0x118]
LEA RSI,[RSP + 0x68]
CALL 0x00137330
CMP EAX,0x0
JZ 0x00169800
JMP 0x00169851
LAB_00169800:
MOV RAX,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x18],RAX
MOVSD XMM0,qword ptr [RSP + 0x70]
ADDSD XMM0,qword ptr [RSP + 0x68]
CALL 0x0014c3a0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x60],RDX
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX + -0x20],RCX
MOV RCX,qword ptr [RSP + 0x60]
MOV qword ptr [RAX + -0x18],RCX
LAB_00169842:
JMP 0x00169844
LAB_00169844:
MOV dword ptr [RSP + 0x144],0x0
JMP 0x001698b2
LAB_00169851:
MOV RAX,qword ptr [RSP + 0x130]
MOV dword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x3
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + -0x20],RCX
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + -0x18],RCX
MOV RAX,qword ptr [RSP + 0x130]
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x3
MOV RCX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + -0x10],RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX + -0x8],RCX
MOV dword ptr [RSP + 0x144],0xffffffff
LAB_001698b2:
MOV EAX,dword ptr [RSP + 0x144]
ADD RSP,0x148
RET
|
int4 js_add_slow(int8 param_1,long param_2)
{
int1 auVar1 [16];
long lVar2;
int iVar3;
int1 auVar4 [16];
uint uStack_10c;
uint uStack_fc;
double local_e0;
double local_d8 [3];
long local_c0;
int local_b8;
int local_b4;
int1 local_b0 [16];
int1 local_a0 [16];
int1 local_90 [16];
int1 local_80 [16];
int1 local_70 [16];
double local_50;
double local_48;
int local_40;
int local_3c;
int1 local_38 [16];
int1 local_28 [16];
long local_18;
int8 local_10;
local_48 = *(double *)*(int1 (*) [16])(param_2 + -0x20);
local_28._8_8_ = *(int8 *)(param_2 + -0x18);
local_50 = *(double *)*(int1 (*) [16])(param_2 + -0x10);
local_38._8_8_ = *(int8 *)(param_2 + -8);
local_3c = (int)local_28._8_8_;
local_40 = (int)local_38._8_8_;
local_38._0_8_ = local_50;
local_28._0_8_ = local_48;
local_18 = param_2;
local_10 = param_1;
if ((local_3c == 7) && (local_40 == 7)) {
auVar4 = js_float64(local_48 + local_50);
*(int1 (*) [16])(param_2 + -0x20) = auVar4;
return 0;
}
if ((local_3c == -1) ||
(auVar4 = *(int1 (*) [16])(param_2 + -0x10),
auVar1 = *(int1 (*) [16])(param_2 + -0x20), local_40 == -1)) {
local_70 = JS_ToPrimitiveFree(param_1,local_48,local_28._8_8_,2);
local_28 = local_70;
iVar3 = JS_IsException(local_70._0_8_,local_70._8_8_);
if (iVar3 != 0) {
JS_FreeValue(local_10,local_38._0_8_,local_38._8_8_);
goto LAB_00169851;
}
local_80 = JS_ToPrimitiveFree(local_10,local_38._0_8_,local_38._8_8_,2);
local_38 = local_80;
iVar3 = JS_IsException(local_80._0_8_,local_80._8_8_);
if (iVar3 != 0) {
JS_FreeValue(local_10,local_28._0_8_,local_28._8_8_);
goto LAB_00169851;
}
local_3c = local_28._8_4_;
local_40 = local_38._8_4_;
auVar4 = local_38;
auVar1 = local_28;
}
lVar2 = local_18;
local_28._8_8_ = auVar1._8_8_;
local_28._0_8_ = auVar1._0_8_;
local_38._8_8_ = auVar4._8_8_;
local_38._0_8_ = auVar4._0_8_;
if ((local_3c == -7) || (local_40 == -7)) {
local_90 = JS_ConcatString(local_10,local_28._0_8_,local_28._8_8_,local_38._0_8_,local_38._8_8_)
;
local_28 = auVar1;
local_38 = auVar4;
*(int1 (*) [16])(lVar2 + -0x20) = local_90;
iVar3 = JS_IsException(*(int8 *)(local_18 + -0x20),*(int8 *)(local_18 + -0x18));
if (iVar3 == 0) {
return 0;
}
}
else {
local_38 = auVar4;
local_a0 = JS_ToNumericFree(local_10,local_28._0_8_,local_28._8_8_);
local_28 = auVar1;
local_28 = local_a0;
iVar3 = JS_IsException(local_a0._0_8_,local_a0._8_8_);
if (iVar3 == 0) {
local_b0 = JS_ToNumericFree(local_10,local_38._0_8_,local_38._8_8_);
local_38 = local_b0;
iVar3 = JS_IsException(local_b0._0_8_,local_b0._8_8_);
lVar2 = local_18;
if (iVar3 == 0) {
local_3c = local_28._8_4_;
local_40 = local_38._8_4_;
if ((local_3c == 0) && (local_40 == 0)) {
local_b4 = local_28._0_4_;
local_b8 = local_38._0_4_;
local_c0 = (long)(int)local_28._0_4_ + (long)(int)local_38._0_4_;
auVar4 = js_int64(local_c0);
*(int1 (*) [16])(lVar2 + -0x20) = auVar4;
return 0;
}
if ((local_3c == -9) || (local_40 == -9)) {
iVar3 = js_binary_arith_bigint
(local_10,0x9d,local_18 + -0x20,local_28._0_8_,local_28._8_8_,
local_38._0_8_,local_38);
if (iVar3 == 0) {
return 0;
}
}
else {
iVar3 = JS_ToFloat64Free(local_10,local_d8,local_28._0_8_,local_28._8_8_);
if (iVar3 == 0) {
iVar3 = JS_ToFloat64Free(local_10,&local_e0,local_38._0_8_,local_38._8_8_);
lVar2 = local_18;
if (iVar3 == 0) {
auVar4 = js_float64(local_d8[0] + local_e0);
*(int1 (*) [16])(lVar2 + -0x20) = auVar4;
return 0;
}
}
else {
JS_FreeValue(local_10,local_38._0_8_,local_38._8_8_);
}
}
}
else {
JS_FreeValue(local_10,local_28._0_8_,local_28._8_8_);
}
}
else {
JS_FreeValue(local_10,local_38._0_8_,local_38._8_8_);
}
}
LAB_00169851:
*(ulong *)(local_18 + -0x20) = (ulong)uStack_fc << 0x20;
*(int8 *)(local_18 + -0x18) = 3;
*(ulong *)(local_18 + -0x10) = (ulong)uStack_10c << 0x20;
*(int8 *)(local_18 + -8) = 3;
return 0xffffffff;
}
| |
22,458 | js_add_slow | bluesky950520[P]quickjs/quickjs.c | int js_add_slow(JSContext *ctx, JSValue *sp)
{
JSValue op1, op2;
uint32_t tag1, tag2;
op1 = sp[-2];
op2 = sp[-1];
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
/* fast path for float64 */
if (tag1 == JS_TAG_FLOAT64 && tag2 == JS_TAG_FLOAT64) {
double d1, d2;
d1 = JS_VALUE_GET_FLOAT64(op1);
d2 = JS_VALUE_GET_FLOAT64(op2);
sp[-2] = js_float64(d1 + d2);
return 0;
}
if (tag1 == JS_TAG_OBJECT || tag2 == JS_TAG_OBJECT) {
op1 = JS_ToPrimitiveFree(ctx, op1, HINT_NONE);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
op2 = JS_ToPrimitiveFree(ctx, op2, HINT_NONE);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
goto exception;
}
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
}
if (tag1 == JS_TAG_STRING || tag2 == JS_TAG_STRING) {
sp[-2] = JS_ConcatString(ctx, op1, op2);
if (JS_IsException(sp[-2]))
goto exception;
return 0;
}
op1 = JS_ToNumericFree(ctx, op1);
if (JS_IsException(op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
op2 = JS_ToNumericFree(ctx, op2);
if (JS_IsException(op2)) {
JS_FreeValue(ctx, op1);
goto exception;
}
tag1 = JS_VALUE_GET_NORM_TAG(op1);
tag2 = JS_VALUE_GET_NORM_TAG(op2);
if (tag1 == JS_TAG_INT && tag2 == JS_TAG_INT) {
int32_t v1, v2;
int64_t v;
v1 = JS_VALUE_GET_INT(op1);
v2 = JS_VALUE_GET_INT(op2);
v = (int64_t)v1 + (int64_t)v2;
sp[-2] = js_int64(v);
} else if (tag1 == JS_TAG_BIG_INT || tag2 == JS_TAG_BIG_INT) {
if (js_binary_arith_bigint(ctx, OP_add, sp - 2, op1, op2))
goto exception;
} else {
double d1, d2;
/* float64 result */
if (JS_ToFloat64Free(ctx, &d1, op1)) {
JS_FreeValue(ctx, op2);
goto exception;
}
if (JS_ToFloat64Free(ctx, &d2, op2))
goto exception;
sp[-2] = js_float64(d1 + d2);
}
return 0;
exception:
sp[-2] = JS_UNDEFINED;
sp[-1] = JS_UNDEFINED;
return -1;
} | O3 | c | js_add_slow:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq -0x20(%rsi), %xmm0
movq -0x18(%rsi), %r12
movq -0x10(%rsi), %xmm1
movq -0x8(%rsi), %r15
movl %r12d, %eax
xorl $0x7, %eax
movl %r15d, %ecx
xorl $0x7, %ecx
orl %eax, %ecx
jne 0x40e52
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbx)
movq $0x7, -0x18(%rbx)
xorl %eax, %eax
jmp 0x40f89
movq %rdi, %r14
cmpl $-0x1, %r12d
sete %al
cmpl $-0x1, %r15d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x40ef1
movq %xmm0, %rsi
movq %r14, %rdi
movq %r12, %rdx
movl $0x2, %ecx
movq %xmm1, 0x10(%rsp)
callq 0x3e9e9
movq %rdx, %r12
movq 0x10(%rsp), %xmm0
movq %xmm0, %rsi
cmpl $0x6, %r12d
je 0x40f2b
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rdx
movl $0x2, %ecx
callq 0x3e9e9
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x40ee7
cmpl $-0x9, %r12d
jb 0x40f6f
movq 0x18(%r14), %rdi
movl (%r13), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r13)
cmpl $0x1, %eax
jg 0x40f6f
movq %r13, %rsi
movq %r12, %rdx
jmp 0x40f44
movq %r13, %xmm0
movq %rax, %xmm1
movq %xmm0, %rsi
cmpl $-0x7, %r12d
je 0x40f4b
cmpl $-0x7, %r15d
je 0x40f4b
movq %r14, %rdi
movq %r12, %rdx
movl $0x1, %ecx
movq %xmm1, 0x10(%rsp)
callq 0x43a59
movq %rdx, %rbp
movq 0x10(%rsp), %xmm0
movq %xmm0, %rsi
cmpl $0x6, %ebp
jne 0x40f98
cmpl $-0x9, %r15d
jb 0x40f6f
movq 0x18(%r14), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x40f6f
movq %r15, %rdx
callq 0x20d90
jmp 0x40f6f
movq %xmm1, %rcx
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %r8
callq 0x410fe
movq %rax, -0x20(%rbx)
movq %rdx, -0x18(%rbx)
cmpl $0x6, %edx
jne 0x40e4b
xorl %eax, %eax
movl %eax, -0x20(%rbx)
movl $0x3, %ecx
movq %rcx, -0x18(%rbx)
movl %eax, -0x10(%rbx)
movq %rcx, -0x8(%rbx)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rdx
movl $0x1, %ecx
callq 0x43a59
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x40fd8
cmpl $-0x9, %ebp
jb 0x40f6f
movq 0x18(%r14), %rdi
movl (%r13), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r13)
cmpl $0x1, %eax
jg 0x40f6f
movq %r13, %rsi
movq %rbp, %rdx
jmp 0x40f44
movq %rax, %r15
movl %r12d, %eax
orl %ebp, %eax
je 0x41005
cmpl $-0x9, %ebp
je 0x4103f
cmpl $-0x9, %r12d
je 0x4103f
cmpl $0x2, %ebp
ja 0x4106a
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x410b5
movslq %r13d, %rax
movslq %r15d, %rcx
addq %rax, %rcx
movslq %ecx, %rdx
xorl %eax, %eax
cmpq %rcx, %rdx
movl %edx, %edx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movq %xmm0, %rcx
cmoveq %rdx, %rcx
movl $0x7, %edx
cmoveq %rax, %rdx
movq %rcx, -0x20(%rbx)
movq %rdx, -0x18(%rbx)
jmp 0x40f89
leaq -0x20(%rbx), %rdx
movq %r12, (%rsp)
movq %r14, %rdi
movl $0x9d, %esi
movq %r13, %rcx
movq %rbp, %r8
movq %r15, %r9
callq 0x4358b
testl %eax, %eax
jne 0x40f6f
jmp 0x40e4b
cmpl $0x7, %ebp
jne 0x41076
movq %r13, 0x18(%rsp)
jmp 0x410b5
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x3e93d
testl %eax, %eax
je 0x410b5
cmpl $-0x9, %r12d
jb 0x40f6f
movq 0x18(%r14), %rdi
movl (%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r15)
cmpl $0x1, %eax
jg 0x40f6f
movq %r15, %rsi
jmp 0x40ee2
cmpl $0x2, %r12d
ja 0x410c5
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
jmp 0x410f3
cmpl $0x7, %r12d
jne 0x410d2
movq %r15, %xmm0
jmp 0x410f3
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3e93d
testl %eax, %eax
jne 0x40f6f
movq 0x20(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
jmp 0x40e3e
| js_add_slow:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rsi
movq xmm0, qword ptr [rsi-20h]
mov r12, [rsi-18h]
movq xmm1, qword ptr [rsi-10h]
mov r15, [rsi-8]
mov eax, r12d
xor eax, 7
mov ecx, r15d
xor ecx, 7
or ecx, eax
jnz short loc_40E52
addsd xmm0, xmm1
loc_40E3E:
movsd qword ptr [rbx-20h], xmm0
mov qword ptr [rbx-18h], 7
loc_40E4B:
xor eax, eax
jmp loc_40F89
loc_40E52:
mov r14, rdi
cmp r12d, 0FFFFFFFFh
setz al
cmp r15d, 0FFFFFFFFh
setz cl
or cl, al
cmp cl, 1
jnz loc_40EF1
movq rsi, xmm0
mov rdi, r14
mov rdx, r12
mov ecx, 2
movq [rsp+58h+var_48], xmm1
call JS_ToPrimitiveFree
mov r12, rdx
movq xmm0, [rsp+58h+var_48]
movq rsi, xmm0
cmp r12d, 6
jz loc_40F2B
mov r13, rax
mov rdi, r14
mov rdx, r15
mov ecx, 2
call JS_ToPrimitiveFree
mov r15, rdx
cmp r15d, 6
jnz short loc_40EE7
cmp r12d, 0FFFFFFF7h
jb loc_40F6F
mov rdi, [r14+18h]
mov eax, [r13+0]
lea ecx, [rax-1]
mov [r13+0], ecx
cmp eax, 1
jg loc_40F6F
mov rsi, r13
loc_40EE2:
mov rdx, r12
jmp short loc_40F44
loc_40EE7:
movq xmm0, r13
movq xmm1, rax
loc_40EF1:
movq rsi, xmm0
cmp r12d, 0FFFFFFF9h
jz short loc_40F4B
cmp r15d, 0FFFFFFF9h
jz short loc_40F4B
mov rdi, r14
mov rdx, r12
mov ecx, 1
movq [rsp+58h+var_48], xmm1
call JS_ToNumberHintFree
mov rbp, rdx
movq xmm0, [rsp+58h+var_48]
movq rsi, xmm0
cmp ebp, 6
jnz short loc_40F98
loc_40F2B:
cmp r15d, 0FFFFFFF7h
jb short loc_40F6F
mov rdi, [r14+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_40F6F
mov rdx, r15
loc_40F44:
call js_free_value_rt
jmp short loc_40F6F
loc_40F4B:
movq rcx, xmm1
mov rdi, r14
mov rdx, r12
mov r8, r15
call JS_ConcatString
mov [rbx-20h], rax
mov [rbx-18h], rdx
cmp edx, 6
jnz loc_40E4B
loc_40F6F:
xor eax, eax
mov [rbx-20h], eax
mov ecx, 3
mov [rbx-18h], rcx
mov [rbx-10h], eax
mov [rbx-8], rcx
mov eax, 0FFFFFFFFh
loc_40F89:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_40F98:
mov r13, rax
mov rdi, r14
mov rdx, r15
mov ecx, 1
call JS_ToNumberHintFree
mov r12, rdx
cmp r12d, 6
jnz short loc_40FD8
cmp ebp, 0FFFFFFF7h
jb short loc_40F6F
mov rdi, [r14+18h]
mov eax, [r13+0]
lea ecx, [rax-1]
mov [r13+0], ecx
cmp eax, 1
jg short loc_40F6F
mov rsi, r13
mov rdx, rbp
jmp loc_40F44
loc_40FD8:
mov r15, rax
mov eax, r12d
or eax, ebp
jz short loc_41005
cmp ebp, 0FFFFFFF7h
jz short loc_4103F
cmp r12d, 0FFFFFFF7h
jz short loc_4103F
cmp ebp, 2
ja short loc_4106A
xorps xmm0, xmm0
cvtsi2sd xmm0, r13d
movsd [rsp+58h+var_40], xmm0
jmp loc_410B5
loc_41005:
movsxd rax, r13d
movsxd rcx, r15d
add rcx, rax
movsxd rdx, ecx
xor eax, eax
cmp rdx, rcx
mov edx, edx
xorps xmm0, xmm0
cvtsi2sd xmm0, rcx
movq rcx, xmm0
cmovz rcx, rdx
mov edx, 7
cmovz rdx, rax
mov [rbx-20h], rcx
mov [rbx-18h], rdx
jmp loc_40F89
loc_4103F:
lea rdx, [rbx-20h]
mov [rsp+58h+var_58], r12
mov rdi, r14
mov esi, 9Dh
mov rcx, r13
mov r8, rbp
mov r9, r15
call js_binary_arith_bigint
test eax, eax
jnz loc_40F6F
jmp loc_40E4B
loc_4106A:
cmp ebp, 7
jnz short loc_41076
mov [rsp+58h+var_40], r13
jmp short loc_410B5
loc_41076:
lea rsi, [rsp+58h+var_40]
mov rdi, r14
mov rdx, r13
mov rcx, rbp
call __JS_ToFloat64Free
test eax, eax
jz short loc_410B5
cmp r12d, 0FFFFFFF7h
jb loc_40F6F
mov rdi, [r14+18h]
mov eax, [r15]
lea ecx, [rax-1]
mov [r15], ecx
cmp eax, 1
jg loc_40F6F
mov rsi, r15
jmp loc_40EE2
loc_410B5:
cmp r12d, 2
ja short loc_410C5
xorps xmm0, xmm0
cvtsi2sd xmm0, r15d
jmp short loc_410F3
loc_410C5:
cmp r12d, 7
jnz short loc_410D2
movq xmm0, r15
jmp short loc_410F3
loc_410D2:
lea rsi, [rsp+58h+var_38]
mov rdi, r14
mov rdx, r15
mov rcx, r12
call __JS_ToFloat64Free
test eax, eax
jnz loc_40F6F
movq xmm0, [rsp+58h+var_38]
loc_410F3:
addsd xmm0, [rsp+58h+var_40]
jmp loc_40E3E
| long long js_add_slow(
long long a1,
long long a2,
double a3,
double a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
__m128 v11; // xmm0
long long v12; // r12
__m128 v13; // xmm1
long long v14; // r15
double v15; // xmm0_8
long long result; // rax
unsigned long long v17; // rax
long long v18; // r8
long long v19; // r9
double v20; // xmm4_8
double v21; // xmm5_8
long long v22; // rdx
__m128 v23; // xmm0
int *v24; // rsi
int *v25; // r13
unsigned long long v26; // rax
long long v27; // rdx
long long v28; // rdi
int v29; // eax
long long v30; // rcx
long long v31; // rdx
long long v32; // rax
long long v33; // rdx
long long v34; // rbp
int v35; // eax
long long v36; // rdx
int *v37; // r13
long long v38; // rax
long long v39; // rdx
int v40; // eax
int *v41; // r15
long long v42; // rcx
bool v43; // zf
double v44; // rdx
double v45; // rcx
long long v46; // rdx
int v47; // eax
double v48; // xmm0_8
__m128i v49; // [rsp+10h] [rbp-48h] BYREF
double v50[7]; // [rsp+20h] [rbp-38h] BYREF
v11 = (__m128)_mm_loadl_epi64((const __m128i *)(a2 - 32));
v12 = *(_QWORD *)(a2 - 24);
v13 = (__m128)_mm_loadl_epi64((const __m128i *)(a2 - 16));
v14 = *(_QWORD *)(a2 - 8);
if ( !((unsigned int)v12 ^ 7 | (unsigned int)v14 ^ 7) )
{
v15 = *(double *)v11.m128_u64 + *(double *)v13.m128_u64;
LABEL_3:
*(double *)(a2 - 32) = v15;
*(_QWORD *)(a2 - 24) = 7LL;
return 0LL;
}
if ( (_DWORD)v12 == -1 || (_DWORD)v14 == -1 )
{
v49.m128i_i64[0] = v13.m128_u64[0];
v17 = JS_ToPrimitiveFree(a1, v11.m128_i64[0], v12, 2, v11, v13, a5, a6, a7, a8, a9, a10);
v12 = v22;
v23 = (__m128)_mm_loadl_epi64(&v49);
v24 = (int *)v23.m128_u64[0];
if ( (_DWORD)v22 == 6 )
{
LABEL_16:
if ( (unsigned int)v14 < 0xFFFFFFF7 )
goto LABEL_21;
v28 = *(_QWORD *)(a1 + 24);
v35 = *v24;
v30 = (unsigned int)(*v24 - 1);
*v24 = v30;
if ( v35 > 1 )
goto LABEL_21;
v31 = v14;
goto LABEL_19;
}
v25 = (int *)v17;
v26 = JS_ToPrimitiveFree(a1, v23.m128_i64[0], v14, 2, v23, v13, a5, a6, v20, v21, a9, a10);
v14 = v27;
if ( (_DWORD)v27 == 6 )
{
if ( (unsigned int)v12 < 0xFFFFFFF7 )
goto LABEL_21;
v28 = *(_QWORD *)(a1 + 24);
v29 = *v25;
v30 = (unsigned int)(*v25 - 1);
*v25 = v30;
if ( v29 > 1 )
goto LABEL_21;
v24 = v25;
goto LABEL_11;
}
v11.m128_u64[0] = (unsigned long long)v25;
v13.m128_u64[0] = v26;
}
if ( (_DWORD)v12 == -7 || (_DWORD)v14 == -7 )
{
*(_QWORD *)(a2 - 32) = JS_ConcatString(a1, v11.m128_u64[0], v12, v13.m128_u64[0]);
*(_QWORD *)(a2 - 24) = v36;
if ( (_DWORD)v36 != 6 )
return 0LL;
goto LABEL_21;
}
v49.m128i_i64[0] = v13.m128_u64[0];
v32 = JS_ToNumberHintFree(a1, v11.m128_u64[0], v12, 1LL);
v34 = v33;
v24 = (int *)v49.m128i_i64[0];
if ( (_DWORD)v33 == 6 )
goto LABEL_16;
v37 = (int *)v32;
v38 = JS_ToNumberHintFree(a1, v49.m128i_i64[0], v14, 1LL);
v12 = v39;
if ( (_DWORD)v39 == 6 )
{
if ( (unsigned int)v34 < 0xFFFFFFF7 )
goto LABEL_21;
v28 = *(_QWORD *)(a1 + 24);
v40 = *v37;
v30 = (unsigned int)(*v37 - 1);
*v37 = v30;
if ( v40 > 1 )
goto LABEL_21;
v24 = v37;
v31 = v34;
goto LABEL_19;
}
v41 = (int *)v38;
if ( (unsigned int)v34 | (unsigned int)v39 )
{
if ( (_DWORD)v34 == -9 || (_DWORD)v39 == -9 )
{
if ( !(unsigned int)js_binary_arith_bigint(a1, 157, (int)a2 - 32, (_DWORD)v37, v34, v38, v39) )
return 0LL;
goto LABEL_21;
}
if ( (unsigned int)v34 > 2 )
{
if ( (_DWORD)v34 == 7 )
{
v49.m128i_i64[1] = (long long)v37;
}
else if ( (unsigned int)_JS_ToFloat64Free(a1, (double *)&v49.m128i_i64[1], (long long)v37, v34) )
{
if ( (unsigned int)v12 < 0xFFFFFFF7 )
goto LABEL_21;
v28 = *(_QWORD *)(a1 + 24);
v47 = *v41;
v30 = (unsigned int)(*v41 - 1);
*v41 = v30;
if ( v47 > 1 )
goto LABEL_21;
v24 = v41;
LABEL_11:
v31 = v12;
LABEL_19:
js_free_value_rt(v28, v24, v31, v30, v18, v19);
LABEL_21:
*(_DWORD *)(a2 - 32) = 0;
*(_QWORD *)(a2 - 24) = 3LL;
*(_DWORD *)(a2 - 16) = 0;
*(_QWORD *)(a2 - 8) = 3LL;
return 0xFFFFFFFFLL;
}
}
else
{
*(double *)&v49.m128i_i64[1] = (double)(int)v37;
}
if ( (unsigned int)v12 > 2 )
{
if ( (_DWORD)v12 == 7 )
{
v48 = *(double *)&v41;
}
else
{
if ( (unsigned int)_JS_ToFloat64Free(a1, v50, (long long)v41, v12) )
goto LABEL_21;
v48 = v50[0];
}
}
else
{
v48 = (double)(int)v41;
}
v15 = v48 + *(double *)&v49.m128i_i64[1];
goto LABEL_3;
}
v42 = (int)v37 + (long long)(int)v38;
result = 0LL;
v43 = (int)v42 == v42;
*(_QWORD *)&v44 = (unsigned int)v42;
v45 = (double)(int)v42;
if ( v43 )
v45 = v44;
v46 = 7LL;
if ( v43 )
v46 = 0LL;
*(double *)(a2 - 32) = v45;
*(_QWORD *)(a2 - 24) = v46;
return result;
}
| js_add_slow:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOVQ XMM0,qword ptr [RSI + -0x20]
MOV R12,qword ptr [RSI + -0x18]
MOVQ XMM1,qword ptr [RSI + -0x10]
MOV R15,qword ptr [RSI + -0x8]
MOV EAX,R12D
XOR EAX,0x7
MOV ECX,R15D
XOR ECX,0x7
OR ECX,EAX
JNZ 0x00140e52
ADDSD XMM0,XMM1
LAB_00140e3e:
MOVSD qword ptr [RBX + -0x20],XMM0
MOV qword ptr [RBX + -0x18],0x7
LAB_00140e4b:
XOR EAX,EAX
JMP 0x00140f89
LAB_00140e52:
MOV R14,RDI
CMP R12D,-0x1
SETZ AL
CMP R15D,-0x1
SETZ CL
OR CL,AL
CMP CL,0x1
JNZ 0x00140ef1
MOVQ RSI,XMM0
MOV RDI,R14
MOV RDX,R12
MOV ECX,0x2
MOVQ qword ptr [RSP + 0x10],XMM1
CALL 0x0013e9e9
MOV R12,RDX
MOVQ XMM0,qword ptr [RSP + 0x10]
MOVQ RSI,XMM0
CMP R12D,0x6
JZ 0x00140f2b
MOV R13,RAX
MOV RDI,R14
MOV RDX,R15
MOV ECX,0x2
CALL 0x0013e9e9
MOV R15,RDX
CMP R15D,0x6
JNZ 0x00140ee7
CMP R12D,-0x9
JC 0x00140f6f
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [R13]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R13],ECX
CMP EAX,0x1
JG 0x00140f6f
MOV RSI,R13
LAB_00140ee2:
MOV RDX,R12
JMP 0x00140f44
LAB_00140ee7:
MOVQ XMM0,R13
MOVQ XMM1,RAX
LAB_00140ef1:
MOVQ RSI,XMM0
CMP R12D,-0x7
JZ 0x00140f4b
CMP R15D,-0x7
JZ 0x00140f4b
MOV RDI,R14
MOV RDX,R12
MOV ECX,0x1
MOVQ qword ptr [RSP + 0x10],XMM1
CALL 0x00143a59
MOV RBP,RDX
MOVQ XMM0,qword ptr [RSP + 0x10]
MOVQ RSI,XMM0
CMP EBP,0x6
JNZ 0x00140f98
LAB_00140f2b:
CMP R15D,-0x9
JC 0x00140f6f
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00140f6f
MOV RDX,R15
LAB_00140f44:
CALL 0x00120d90
JMP 0x00140f6f
LAB_00140f4b:
MOVQ RCX,XMM1
MOV RDI,R14
MOV RDX,R12
MOV R8,R15
CALL 0x001410fe
MOV qword ptr [RBX + -0x20],RAX
MOV qword ptr [RBX + -0x18],RDX
CMP EDX,0x6
JNZ 0x00140e4b
LAB_00140f6f:
XOR EAX,EAX
MOV dword ptr [RBX + -0x20],EAX
MOV ECX,0x3
MOV qword ptr [RBX + -0x18],RCX
MOV dword ptr [RBX + -0x10],EAX
MOV qword ptr [RBX + -0x8],RCX
MOV EAX,0xffffffff
LAB_00140f89:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00140f98:
MOV R13,RAX
MOV RDI,R14
MOV RDX,R15
MOV ECX,0x1
CALL 0x00143a59
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00140fd8
CMP EBP,-0x9
JC 0x00140f6f
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [R13]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R13],ECX
CMP EAX,0x1
JG 0x00140f6f
MOV RSI,R13
MOV RDX,RBP
JMP 0x00140f44
LAB_00140fd8:
MOV R15,RAX
MOV EAX,R12D
OR EAX,EBP
JZ 0x00141005
CMP EBP,-0x9
JZ 0x0014103f
CMP R12D,-0x9
JZ 0x0014103f
CMP EBP,0x2
JA 0x0014106a
XORPS XMM0,XMM0
CVTSI2SD XMM0,R13D
MOVSD qword ptr [RSP + 0x18],XMM0
JMP 0x001410b5
LAB_00141005:
MOVSXD RAX,R13D
MOVSXD RCX,R15D
ADD RCX,RAX
MOVSXD RDX,ECX
XOR EAX,EAX
CMP RDX,RCX
MOV EDX,EDX
XORPS XMM0,XMM0
CVTSI2SD XMM0,RCX
MOVQ RCX,XMM0
CMOVZ RCX,RDX
MOV EDX,0x7
CMOVZ RDX,RAX
MOV qword ptr [RBX + -0x20],RCX
MOV qword ptr [RBX + -0x18],RDX
JMP 0x00140f89
LAB_0014103f:
LEA RDX,[RBX + -0x20]
MOV qword ptr [RSP],R12
MOV RDI,R14
MOV ESI,0x9d
MOV RCX,R13
MOV R8,RBP
MOV R9,R15
CALL 0x0014358b
TEST EAX,EAX
JNZ 0x00140f6f
JMP 0x00140e4b
LAB_0014106a:
CMP EBP,0x7
JNZ 0x00141076
MOV qword ptr [RSP + 0x18],R13
JMP 0x001410b5
LAB_00141076:
LEA RSI,[RSP + 0x18]
MOV RDI,R14
MOV RDX,R13
MOV RCX,RBP
CALL 0x0013e93d
TEST EAX,EAX
JZ 0x001410b5
CMP R12D,-0x9
JC 0x00140f6f
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [R15]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R15],ECX
CMP EAX,0x1
JG 0x00140f6f
MOV RSI,R15
JMP 0x00140ee2
LAB_001410b5:
CMP R12D,0x2
JA 0x001410c5
XORPS XMM0,XMM0
CVTSI2SD XMM0,R15D
JMP 0x001410f3
LAB_001410c5:
CMP R12D,0x7
JNZ 0x001410d2
MOVQ XMM0,R15
JMP 0x001410f3
LAB_001410d2:
LEA RSI,[RSP + 0x20]
MOV RDI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x0013e93d
TEST EAX,EAX
JNZ 0x00140f6f
MOVQ XMM0,qword ptr [RSP + 0x20]
LAB_001410f3:
ADDSD XMM0,qword ptr [RSP + 0x18]
JMP 0x00140e3e
|
int8 js_add_slow(long param_1,long param_2)
{
double dVar1;
int iVar2;
int *piVar3;
int8 uVar4;
ulong uVar5;
uint uVar6;
uint uVar7;
int iVar8;
bool bVar9;
double dVar10;
int *piVar11;
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
int *local_40;
int *local_38;
dVar10 = *(double *)*(int1 (*) [16])(param_2 + -0x20);
auVar12 = *(int1 (*) [16])(param_2 + -0x20);
dVar1 = *(double *)*(int1 (*) [16])(param_2 + -0x10);
uVar4 = *(int8 *)(param_2 + -8);
auVar13 = *(int1 (*) [16])(param_2 + -0x10);
iVar2 = (int)*(int8 *)(param_2 + -0x18);
iVar8 = (int)uVar4;
if (iVar8 == 7 && iVar2 == 7) {
dVar10 = dVar10 + dVar1;
LAB_00140e3e:
*(double *)(param_2 + -0x20) = dVar10;
*(int8 *)(param_2 + -0x18) = 7;
LAB_00140e4b:
uVar4 = 0;
}
else {
if (iVar8 == -1 || iVar2 == -1) {
auVar12 = JS_ToPrimitiveFree(param_1,dVar10,*(int8 *)(param_2 + -0x18),2);
if (auVar12._8_4_ == 6) {
LAB_00140f2b:
if (0xfffffff6 < auVar13._8_4_) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar2 = *auVar13._0_8_;
*auVar13._0_8_ = iVar2 + -1;
auVar12 = auVar13;
joined_r0x00140f3f:
if (iVar2 < 2) {
js_free_value_rt(uVar4,auVar12._0_8_,auVar12._8_8_);
}
}
}
else {
auVar13 = JS_ToPrimitiveFree(param_1,dVar1,uVar4,2);
if (auVar13._8_4_ != 6) goto LAB_00140ef1;
if (0xfffffff6 < auVar12._8_4_) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar2 = *auVar12._0_8_;
*auVar12._0_8_ = iVar2 + -1;
goto joined_r0x00140f3f;
}
}
}
else {
LAB_00140ef1:
if ((auVar12._8_4_ == -7) || (auVar13._8_4_ == -7)) {
auVar12 = JS_ConcatString(param_1,auVar12._0_8_,auVar12._8_8_,auVar13._0_8_,auVar13._8_8_);
*(int1 (*) [16])(param_2 + -0x20) = auVar12;
if (auVar12._8_4_ != 6) goto LAB_00140e4b;
}
else {
auVar14 = JS_ToNumberHintFree(param_1,auVar12._0_8_,auVar12._8_8_,1);
piVar3 = auVar14._0_8_;
uVar6 = auVar14._8_4_;
if (uVar6 == 6) goto LAB_00140f2b;
auVar12 = JS_ToNumberHintFree(param_1,auVar13._0_8_,auVar13._8_8_,1);
piVar11 = auVar12._0_8_;
uVar7 = auVar12._8_4_;
if (uVar7 == 6) {
if (0xfffffff6 < uVar6) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar3;
*piVar3 = iVar2 + -1;
auVar12 = auVar14;
goto joined_r0x00140f3f;
}
}
else {
if (uVar7 == 0 && uVar6 == 0) {
uVar5 = (long)auVar12._0_4_ + (long)auVar14._0_4_;
bVar9 = (long)(int)uVar5 == uVar5;
dVar10 = (double)(long)uVar5;
if (bVar9) {
dVar10 = (double)(uVar5 & 0xffffffff);
}
uVar4 = 7;
if (bVar9) {
uVar4 = 0;
}
*(double *)(param_2 + -0x20) = dVar10;
*(int8 *)(param_2 + -0x18) = uVar4;
return 0;
}
if ((uVar6 != 0xfffffff7) && (uVar7 != 0xfffffff7)) {
if (uVar6 < 3) {
piVar3 = (int *)(double)auVar14._0_4_;
}
else if ((uVar6 != 7) &&
(iVar2 = __JS_ToFloat64Free(param_1,&local_40,piVar3,auVar14._8_8_),
piVar3 = local_40, iVar2 != 0)) {
if (0xfffffff6 < uVar7) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar11;
*piVar11 = iVar2 + -1;
goto joined_r0x00140f3f;
}
goto LAB_00140f6f;
}
local_40 = piVar3;
if (uVar7 < 3) {
piVar11 = (int *)(double)auVar12._0_4_;
}
else if ((uVar7 != 7) &&
(iVar2 = __JS_ToFloat64Free(param_1,&local_38,piVar11,auVar12._8_8_),
piVar11 = local_38, iVar2 != 0)) goto LAB_00140f6f;
dVar10 = (double)piVar11 + (double)local_40;
goto LAB_00140e3e;
}
iVar2 = js_binary_arith_bigint
(param_1,0x9d,param_2 + -0x20,piVar3,auVar14._8_8_,piVar11,auVar12._8_8_
);
if (iVar2 == 0) goto LAB_00140e4b;
}
}
}
LAB_00140f6f:
*(int4 *)(param_2 + -0x20) = 0;
*(int8 *)(param_2 + -0x18) = 3;
*(int4 *)(param_2 + -0x10) = 0;
*(int8 *)(param_2 + -8) = 3;
uVar4 = 0xffffffff;
}
return uVar4;
}
| |
22,459 | minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) const | llama.cpp/common/minja/chat-template.hpp | std::string try_raw_render(
const nlohmann::ordered_json & messages,
const nlohmann::ordered_json & tools,
bool add_generation_prompt,
const nlohmann::ordered_json & extra_context = nlohmann::ordered_json()) const
{
try {
chat_template_inputs inputs;
inputs.messages = messages;
inputs.tools = tools;
inputs.add_generation_prompt = add_generation_prompt;
inputs.extra_context = extra_context;
// Use fixed date for tests
inputs.now = std::chrono::system_clock::from_time_t(0);
chat_template_options opts;
opts.apply_polyfills = false;
auto prompt = apply(inputs, opts);
// fprintf(stderr, "try_raw_render: %s\n", prompt.c_str());
return prompt;
} catch (const std::exception & e) {
// fprintf(stderr, "try_raw_render error: %s\n", e.what());
return "";
}
} | O3 | cpp | minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
xorl %r13d, %r13d
leaq 0x48(%rsp), %r14
movb %r13b, (%r14)
movq %r13, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x8400e
movq %r14, %rdi
movl $0x1, %esi
callq 0x8400e
leaq 0x58(%rsp), %r14
movb %r13b, (%r14)
movq %r13, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x8400e
movq %r14, %rdi
movl $0x1, %esi
callq 0x8400e
movb $0x1, 0x10(%r14)
leaq 0x70(%rsp), %r12
movb %r13b, (%r12)
movq %r13, 0x8(%r12)
movq %r12, %rdi
movl $0x1, %esi
callq 0x8400e
movq %r12, %rdi
movl $0x1, %esi
callq 0x8400e
callq 0x20c60
movq %rax, 0x10(%r12)
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
callq 0x8825c
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %r15
movq %r15, %rsi
callq 0x8617a
movq %r15, %rdi
xorl %esi, %esi
callq 0x8400e
movq %r15, %rdi
callq 0x88728
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x8825c
leaq 0x28(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8617a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8400e
movq %rbx, %rdi
callq 0x88728
movb %bpl, 0x68(%rsp)
leaq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8825c
leaq 0x18(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8617a
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8400e
movq %rbx, %rdi
callq 0x88728
leaq 0x48(%rsp), %rdx
movq $0x0, 0x38(%rdx)
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
leaq 0x8d(%rsp), %rcx
movq %rax, 0x1(%rcx)
movw $0x101, 0x9(%rcx) # imm = 0x101
movb $0x0, (%rcx)
movq (%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0xb15aa
movq %r12, %rdi
xorl %esi, %esi
callq 0x8400e
movq %r12, %rdi
callq 0x88728
movq %r14, %rdi
xorl %esi, %esi
callq 0x8400e
movq %r14, %rdi
callq 0x88728
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8400e
movq %rbx, %rdi
callq 0x88728
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd92b1
movq %rdx, %r14
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xb40fa
cmpl $0x1, %r14d
jne 0xd92fc
movq %rbx, %rdi
callq 0x200c0
movq (%rsp), %rdi
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0x452f0(%rip), %rdx # 0x11e5d1
movq %rdx, %rsi
callq 0x27960
callq 0x20d60
movq (%rsp), %r15
jmp 0xd929a
movq %rax, %rbx
callq 0x20d60
movq %rbx, %rdi
callq 0x20b00
movq %rax, %rdi
callq 0x2777d
| _ZNK5minja13chat_template14try_raw_renderERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_B8], r9
mov ebp, r8d
mov rbx, rcx
mov r15, rdx
mov [rsp+0C8h+var_C0], rsi
mov [rsp+0C8h+var_C8], rdi
xor r13d, r13d
lea r14, [rsp+0C8h+var_80]
mov [r14], r13b
mov [r14+8], r13
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
lea r14, [rsp+0C8h+var_70]
mov [r14], r13b
mov [r14+8], r13
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14+10h], 1
lea r12, [rsp+0C8h+var_58]
mov [r12], r13b
mov [r12+8], r13
mov rdi, r12
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, r12; this
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)
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov [r12+10h], rax
lea rdi, [rsp+0C8h+var_90]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
lea rdi, [rsp+0C8h+var_80]
lea r15, [rsp+0C8h+var_90]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0C8h+var_A0]
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
lea rbx, [rsp+0C8h+var_A0]
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov [rsp+0C8h+var_60], bpl
lea rdi, [rsp+0C8h+var_B0]
mov rsi, [rsp+0C8h+var_B8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
lea rbx, [rsp+0C8h+var_B0]
mov rdi, r12
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdx, [rsp+0C8h+var_80]
mov qword ptr [rdx+38h], 0
mov rax, 101010101010101h
lea rcx, [rsp+0C8h+var_3B]
mov [rcx+1], rax
mov word ptr [rcx+9], 101h
mov byte ptr [rcx], 0
mov r15, [rsp+0C8h+var_C8]
mov rdi, r15
mov rsi, [rsp+0C8h+var_C0]
call _ZNK5minja13chat_template5applyB5cxx11ERKNS_20chat_template_inputsERKNS_21chat_template_optionsE; minja::chat_template::apply(minja::chat_template_inputs const&,minja::chat_template_options const&)
mov rdi, r12
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, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r14
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()
lea rbx, [rsp+0C8h+var_80]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_D929A:
mov rax, r15
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_D92B1:
mov r14, rdx
mov rbx, rax
lea rdi, [rsp+0C8h+var_80]; this
call _ZN5minja20chat_template_inputsD2Ev; minja::chat_template_inputs::~chat_template_inputs()
cmp r14d, 1
jnz short loc_D92FC
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rdi, [rsp+0C8h+var_C8]
lea rax, [rdi+10h]
mov [rdi], rax
lea rdx, aExampleToolCal+1Dh; ""
mov rsi, rdx
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)
call ___cxa_end_catch
mov r15, [rsp+0C8h+var_C8]
jmp short loc_D929A
mov rbx, rax
call ___cxa_end_catch
loc_D92FC:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long minja::chat_template::try_raw_render(
long long a1,
long long a2,
unsigned __int8 *a3,
unsigned __int8 *a4,
char a5,
unsigned __int8 *a6)
{
unsigned __int8 v11[16]; // [rsp+18h] [rbp-B0h] BYREF
unsigned __int8 v12[16]; // [rsp+28h] [rbp-A0h] BYREF
unsigned __int8 v13[16]; // [rsp+38h] [rbp-90h] BYREF
char v14[8]; // [rsp+48h] [rbp-80h] BYREF
long long v15; // [rsp+50h] [rbp-78h]
char v16[8]; // [rsp+58h] [rbp-70h] BYREF
long long v17; // [rsp+60h] [rbp-68h]
char v18; // [rsp+68h] [rbp-60h]
char v19[8]; // [rsp+70h] [rbp-58h] BYREF
long long v20; // [rsp+78h] [rbp-50h]
long long v21; // [rsp+80h] [rbp-48h]
char v22; // [rsp+8Dh] [rbp-3Bh] BYREF
long long v23; // [rsp+8Eh] [rbp-3Ah]
__int16 v24; // [rsp+96h] [rbp-32h]
v14[0] = 0;
v15 = 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(v14);
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(v14);
v16[0] = 0;
v17 = 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(v16);
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(v16);
v18 = 1;
v19[0] = 0;
v20 = 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(v19);
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(v19);
v21 = std::chrono::_V2::system_clock::now((std::chrono::_V2::system_clock *)v19);
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(
v13,
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>::operator=(
(long long)v14,
(long long)v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v13);
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(
v12,
a4);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
(long long)v16,
(long long)v12);
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 *)v12);
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(v12);
v18 = a5;
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(
v11,
a6);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
(long long)v19,
(long long)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((char *)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>::data::~data(v11);
v21 = 0LL;
v23 = 0x101010101010101LL;
v24 = 257;
v22 = 0;
minja::chat_template::apply[abi:cxx11](a1, a2, (long long)v14, (long long)&v22);
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(v19);
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(v19);
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(v16);
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(v16);
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(v14);
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(v14);
return a1;
}
| try_raw_render:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x10],R9
MOV EBP,R8D
MOV RBX,RCX
MOV R15,RDX
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDI
XOR R13D,R13D
LEA R14,[RSP + 0x48]
MOV byte ptr [R14],R13B
MOV qword ptr [R14 + 0x8],R13
MOV RDI,R14
MOV ESI,0x1
CALL 0x0018400e
MOV RDI,R14
MOV ESI,0x1
CALL 0x0018400e
LEA R14,[RSP + 0x58]
MOV byte ptr [R14],R13B
MOV qword ptr [R14 + 0x8],R13
MOV RDI,R14
MOV ESI,0x1
CALL 0x0018400e
MOV RDI,R14
MOV ESI,0x1
CALL 0x0018400e
MOV byte ptr [R14 + 0x10],0x1
LEA R12,[RSP + 0x70]
MOV byte ptr [R12],R13B
MOV qword ptr [R12 + 0x8],R13
MOV RDI,R12
MOV ESI,0x1
CALL 0x0018400e
MOV RDI,R12
MOV ESI,0x1
CALL 0x0018400e
CALL 0x00120c60
MOV qword ptr [R12 + 0x10],RAX
LAB_001d918c:
LEA RDI,[RSP + 0x38]
MOV RSI,R15
CALL 0x0018825c
LEA RDI,[RSP + 0x48]
LEA R15,[RSP + 0x38]
MOV RSI,R15
CALL 0x0018617a
MOV RDI,R15
XOR ESI,ESI
CALL 0x0018400e
MOV RDI,R15
CALL 0x00188728
LEA RDI,[RSP + 0x28]
MOV RSI,RBX
CALL 0x0018825c
LEA RBX,[RSP + 0x28]
MOV RDI,R14
MOV RSI,RBX
CALL 0x0018617a
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0018400e
MOV RDI,RBX
CALL 0x00188728
MOV byte ptr [RSP + 0x68],BPL
LEA RDI,[RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0018825c
LEA RBX,[RSP + 0x18]
MOV RDI,R12
MOV RSI,RBX
CALL 0x0018617a
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0018400e
MOV RDI,RBX
CALL 0x00188728
LEA RDX,[RSP + 0x48]
MOV qword ptr [RDX + 0x38],0x0
MOV RAX,0x101010101010101
LEA RCX,[RSP + 0x8d]
MOV qword ptr [RCX + 0x1],RAX
MOV word ptr [RCX + 0x9],0x101
MOV byte ptr [RCX],0x0
LAB_001d924e:
MOV R15,qword ptr [RSP]
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001b15aa
LAB_001d925f:
MOV RDI,R12
XOR ESI,ESI
CALL 0x0018400e
MOV RDI,R12
CALL 0x00188728
MOV RDI,R14
XOR ESI,ESI
CALL 0x0018400e
MOV RDI,R14
CALL 0x00188728
LEA RBX,[RSP + 0x48]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0018400e
MOV RDI,RBX
CALL 0x00188728
LAB_001d929a:
MOV RAX,R15
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, bool,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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&) const */
basic_json *
minja::chat_template::try_raw_render
(basic_json *param_1,basic_json *param_2,bool param_3,basic_json *param_4)
{
int7 in_register_00000011;
bool bVar1;
bool bVar2;
basic_json *in_R9;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_b0 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_a0 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_90 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_80 [8];
int8 local_78;
data local_70 [8];
int8 local_68;
int1 local_60;
data local_58 [8];
int8 local_50;
int8 local_48;
int1 local_3b;
int8 local_3a;
int2 local_32;
local_80[0] = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
local_78 = 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(SUB81(local_80,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(SUB81(local_80,0));
local_70[0] = (data)0x0;
local_68 = 0;
bVar1 = SUB81(local_70,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(bVar1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar1);
local_60 = 1;
local_58[0] = (data)0x0;
local_50 = 0;
bVar2 = SUB81(local_58,0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar2);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar2);
local_48 = std::chrono::_V2::system_clock::now();
/* try { // try from 001d918c to 001d91ff has its CatchHandler @ 001d92b1 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_90,(basic_json *)CONCAT71(in_register_00000011,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>
::operator=(local_80,(data *)local_90);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_90);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_a0,param_4);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)local_70,(data *)local_a0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_a0,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_a0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_b0,in_R9);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)local_58,(data *)local_b0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_b0,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_b0);
local_48 = 0;
local_3a = 0x101010101010101;
local_32 = 0x101;
local_3b = 0;
/* try { // try from 001d924e to 001d925e has its CatchHandler @ 001d92af */
apply_abi_cxx11_((chat_template_inputs *)param_1,(chat_template_options *)param_2);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar2);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_58);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_70);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_80,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_80);
return param_1;
}
| |
22,460 | my_sync_dir_by_file | eloqsql/mysys/my_sync.c | int my_sync_dir_by_file(const char *file_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
char dir_name[FN_REFLEN];
size_t dir_name_length;
dirname_part(dir_name, file_name, &dir_name_length);
return my_sync_dir(dir_name, my_flags & ~MY_NOSYMLINKS);
#else
return 0;
#endif
} | O0 | c | my_sync_dir_by_file:
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 -0x218(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movq %rdi, -0x238(%rbp)
leaq -0x228(%rbp), %rdx
callq 0xdf3e0
movq -0x238(%rbp), %rdi
movq -0x220(%rbp), %rax
andl $0xfffffdff, %eax # imm = 0xFFFFFDFF
movl %eax, %esi
callq 0xf5c70
movl %eax, -0x22c(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xf5da8
movl -0x22c(%rbp), %eax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x2a250
nopl (%rax)
| my_sync_dir_by_file:
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 rsi, [rbp+var_218]
lea rdi, [rbp+var_210]
mov [rbp+var_238], rdi
lea rdx, [rbp+var_228]
call dirname_part
mov rdi, [rbp+var_238]
mov rax, [rbp+var_220]
and eax, 0FFFFFDFFh
mov esi, eax
call my_sync_dir
mov [rbp+var_22C], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_F5DA8
mov eax, [rbp+var_22C]
add rsp, 240h
pop rbp
retn
loc_F5DA8:
call ___stack_chk_fail
| long long my_sync_dir_by_file(_BYTE *a1, long long a2)
{
long long v3; // [rsp+18h] [rbp-228h] BYREF
long long v4; // [rsp+20h] [rbp-220h]
_BYTE *v5; // [rsp+28h] [rbp-218h]
_BYTE v6[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v7; // [rsp+238h] [rbp-8h]
v7 = __readfsqword(0x28u);
v5 = a1;
v4 = a2;
dirname_part((long long)v6, a1, &v3);
return (unsigned int)my_sync_dir(v6, (unsigned int)v4 & 0xFFFFFDFF);
}
| my_sync_dir_by_file:
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 RSI,qword ptr [RBP + -0x218]
LEA RDI,[RBP + -0x210]
MOV qword ptr [RBP + -0x238],RDI
LEA RDX,[RBP + -0x228]
CALL 0x001df3e0
MOV RDI,qword ptr [RBP + -0x238]
MOV RAX,qword ptr [RBP + -0x220]
AND EAX,0xfffffdff
MOV ESI,EAX
CALL 0x001f5c70
MOV dword ptr [RBP + -0x22c],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001f5da8
MOV EAX,dword ptr [RBP + -0x22c]
ADD RSP,0x240
POP RBP
RET
LAB_001f5da8:
CALL 0x0012a250
|
int4 my_sync_dir_by_file(int8 param_1,int8 param_2)
{
int4 uVar1;
long in_FS_OFFSET;
int1 local_230 [8];
int8 local_228;
int8 local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_228 = param_2;
local_220 = param_1;
dirname_part(local_218,param_1,local_230);
uVar1 = my_sync_dir(local_218,(uint)local_228 & 0xfffffdff);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return uVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,461 | my_sync_dir_by_file | eloqsql/mysys/my_sync.c | int my_sync_dir_by_file(const char *file_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
char dir_name[FN_REFLEN];
size_t dir_name_length;
dirname_part(dir_name, file_name, &dir_name_length);
return my_sync_dir(dir_name, my_flags & ~MY_NOSYMLINKS);
#else
return 0;
#endif
} | O3 | c | my_sync_dir_by_file:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rsi, %rbx
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq -0x220(%rbp), %r14
leaq -0x228(%rbp), %rdx
movq %r14, %rdi
callq 0x94789
andl $0xfffffdff, %ebx # imm = 0xFFFFFDFF
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa15d9
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0xa16aa
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
callq 0x29250
nop
| my_sync_dir_by_file:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 220h
mov rbx, rsi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea r14, [rbp+var_220]
lea rdx, [rbp+var_228]
mov rdi, r14
call dirname_part
and ebx, 0FFFFFDFFh
mov rdi, r14
mov rsi, rbx
call my_sync_dir
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_A16AA
add rsp, 220h
pop rbx
pop r14
pop rbp
retn
loc_A16AA:
call ___stack_chk_fail
| long long my_sync_dir_by_file(_BYTE *a1, int a2)
{
long long v3; // [rsp+8h] [rbp-228h] BYREF
_BYTE v4[520]; // [rsp+10h] [rbp-220h] BYREF
unsigned long long v5; // [rsp+218h] [rbp-18h]
v5 = __readfsqword(0x28u);
dirname_part((long long)v4, a1, &v3);
return my_sync_dir(v4, a2 & 0xFFFFFDFF);
}
| my_sync_dir_by_file:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x220
MOV RBX,RSI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA R14,[RBP + -0x220]
LEA RDX,[RBP + -0x228]
MOV RDI,R14
CALL 0x00194789
AND EBX,0xfffffdff
MOV RDI,R14
MOV RSI,RBX
CALL 0x001a15d9
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x001a16aa
ADD RSP,0x220
POP RBX
POP R14
POP RBP
RET
LAB_001a16aa:
CALL 0x00129250
|
void my_sync_dir_by_file(int8 param_1,uint param_2)
{
long in_FS_OFFSET;
int1 local_230 [8];
int1 local_228 [520];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
dirname_part(local_228,param_1,local_230);
my_sync_dir(local_228,param_2 & 0xfffffdff);
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,462 | LefDefParser::lefwLayerAntennaAreaRatio(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerAntennaAreaRatio(double value)
{
lefw54Num = LEFW_ANTENNAAREARATIO;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START && lefwState != LEFW_LAYERROUTING
&& lefwState != LEFW_LAYER_START && lefwState != LEFW_LAYER)
return LEFW_BAD_ORDER;
// only routing or cut calls this func
if (!lefwIsRouting && !lefwIsCut)
return LEFW_BAD_DATA;
if (versionNum < 5.4)
return LEFW_WRONG_VERSION;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " ANTENNAAREARATIO %.11g ;\n", value);
else
fprintf(lefwFile, " ANTENNAAREARATIO %.11g ;\n", value);
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwLayerAntennaAreaRatio(double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movl $0x65, 0x1e388(%rip) # 0x32d4c
leaq 0x1e435(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x149de
movl $0x1, 0x14(%rsp)
jmp 0x14ac0
leaq 0x1e66b(%rip), %rax # 0x33050
cmpl $0x7, (%rax)
je 0x14a1b
leaq 0x1e65f(%rip), %rax # 0x33050
cmpl $0x1f, (%rax)
je 0x14a1b
leaq 0x1e653(%rip), %rax # 0x33050
cmpl $0x6, (%rax)
je 0x14a1b
leaq 0x1e647(%rip), %rax # 0x33050
cmpl $0x1c, (%rax)
je 0x14a1b
movl $0x2, 0x14(%rsp)
jmp 0x14ac0
leaq 0x1e6a2(%rip), %rax # 0x330c4
cmpl $0x0, (%rax)
jne 0x14a40
leaq 0x1e656(%rip), %rax # 0x33084
cmpl $0x0, (%rax)
jne 0x14a40
movl $0x3, 0x14(%rsp)
jmp 0x14ac0
movsd 0x147b8(%rip), %xmm0 # 0x29200
ucomisd 0x1e2f0(%rip), %xmm0 # 0x32d40
jbe 0x14a5c
movl $0x5, 0x14(%rsp)
jmp 0x14ac0
cmpl $0x0, 0x1e689(%rip) # 0x330ec
je 0x14a85
leaq 0x1e394(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x15fff(%rip), %rsi # 0x2aa7b
movb $0x1, %al
callq 0x289b0
jmp 0x14aa3
leaq 0x1e374(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x15fdf(%rip), %rsi # 0x2aa7b
movb $0x1, %al
callq 0x1100
leaq 0x1e5a2(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x1e596(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser25lefwLayerAntennaAreaRatioEd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
mov cs:_ZN12LefDefParserL9lefw54NumE, 65h ; 'e'; LefDefParser::lefw54Num
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_149DE
mov [rsp+18h+var_4], 1
jmp loc_14AC0
loc_149DE:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 7
jz short loc_14A1B
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Fh
jz short loc_14A1B
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 6
jz short loc_14A1B
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Ch
jz short loc_14A1B
mov [rsp+18h+var_4], 2
jmp loc_14AC0
loc_14A1B:
lea rax, _ZN12LefDefParser13lefwIsRoutingE; LefDefParser::lefwIsRouting
cmp dword ptr [rax], 0
jnz short loc_14A40
lea rax, _ZN12LefDefParser9lefwIsCutE; LefDefParser::lefwIsCut
cmp dword ptr [rax], 0
jnz short loc_14A40
mov [rsp+18h+var_4], 3
jmp loc_14AC0
loc_14A40:
movsd xmm0, cs:dbl_29200
ucomisd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
jbe short loc_14A5C
mov [rsp+18h+var_4], 5
jmp short loc_14AC0
loc_14A5C:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_14A85
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aAntennaarearat; " ANTENNAAREARATIO %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_14AA3
loc_14A85:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aAntennaarearat; " ANTENNAAREARATIO %.11g ;\n"
mov al, 1
call _fprintf
loc_14AA3:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_14AC0:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwLayerAntennaAreaRatio(
LefDefParser *this,
double a2,
long long a3,
int a4,
int a5,
int a6,
int a7)
{
LefDefParser::lefw54Num = 101;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 7
|| LefDefParser::lefwState == 31
|| LefDefParser::lefwState == 6
|| LefDefParser::lefwState == 28 )
{
if ( LefDefParser::lefwIsRouting || LefDefParser::lefwIsCut )
{
if ( *(double *)&LefDefParser::versionNum >= 5.4 )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" ANTENNAAREARATIO %.11g ;\n",
a4,
a5,
a6,
a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " ANTENNAAREARATIO %.11g ;\n", a2);
++LefDefParser::lefwLines;
return 0;
}
else
{
return 5;
}
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwLayerAntennaAreaRatio:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOV dword ptr [0x00132d4c],0x65
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x001149de
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00114ac0
LAB_001149de:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x7
JZ 0x00114a1b
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1f
JZ 0x00114a1b
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x6
JZ 0x00114a1b
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1c
JZ 0x00114a1b
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00114ac0
LAB_00114a1b:
LEA RAX,[0x1330c4]
CMP dword ptr [RAX],0x0
JNZ 0x00114a40
LEA RAX,[0x133084]
CMP dword ptr [RAX],0x0
JNZ 0x00114a40
MOV dword ptr [RSP + 0x14],0x3
JMP 0x00114ac0
LAB_00114a40:
MOVSD XMM0,qword ptr [0x00129200]
UCOMISD XMM0,qword ptr [0x00132d40]
JBE 0x00114a5c
MOV dword ptr [RSP + 0x14],0x5
JMP 0x00114ac0
LAB_00114a5c:
CMP dword ptr [0x001330ec],0x0
JZ 0x00114a85
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12aa7b]
MOV AL,0x1
CALL 0x001289b0
JMP 0x00114aa3
LAB_00114a85:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12aa7b]
MOV AL,0x1
CALL 0x00101100
LAB_00114aa3:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_00114ac0:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwLayerAntennaAreaRatio(double) */
int4 LefDefParser::lefwLayerAntennaAreaRatio(double param_1)
{
int4 local_4;
lefw54Num = 0x65;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((((lefwState == 7) || (lefwState == 0x1f)) || (lefwState == 6)) || (lefwState == 0x1c)) {
if ((lefwIsRouting == 0) && (lefwIsCut == 0)) {
local_4 = 3;
}
else if (DAT_00129200 <= versionNum) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," ANTENNAAREARATIO %.11g ;\n",param_1);
}
else {
encPrint(lefwFile," ANTENNAAREARATIO %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
local_4 = 0;
}
else {
local_4 = 5;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
22,463 | define_var | bluesky950520[P]quickjs/quickjs.c | static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
JSVarDefEnum var_def_type)
{
JSContext *ctx = s->ctx;
JSVarDef *vd;
int idx;
switch (var_def_type) {
case JS_VAR_DEF_WITH:
idx = add_scope_var(ctx, fd, name, JS_VAR_NORMAL);
break;
case JS_VAR_DEF_LET:
case JS_VAR_DEF_CONST:
case JS_VAR_DEF_FUNCTION_DECL:
case JS_VAR_DEF_NEW_FUNCTION_DECL:
idx = find_lexical_decl(ctx, fd, name, fd->scope_first, TRUE);
if (idx >= 0) {
if (idx < GLOBAL_VAR_OFFSET) {
if (fd->vars[idx].scope_level == fd->scope_level) {
/* same scope: in non strict mode, functions
can be redefined (annex B.3.3.4). */
if (!(!fd->is_strict_mode &&
var_def_type == JS_VAR_DEF_FUNCTION_DECL &&
fd->vars[idx].var_kind == JS_VAR_FUNCTION_DECL)) {
goto redef_lex_error;
}
} else if (fd->vars[idx].var_kind == JS_VAR_CATCH && (fd->vars[idx].scope_level + 2) == fd->scope_level) {
goto redef_lex_error;
}
} else {
if (fd->scope_level == fd->body_scope) {
redef_lex_error:
/* redefining a scoped var in the same scope: error */
return js_parse_error(s, "invalid redefinition of lexical identifier");
}
}
}
if (var_def_type != JS_VAR_DEF_FUNCTION_DECL &&
var_def_type != JS_VAR_DEF_NEW_FUNCTION_DECL &&
fd->scope_level == fd->body_scope &&
find_arg(ctx, fd, name) >= 0) {
/* lexical variable redefines a parameter name */
return js_parse_error(s, "invalid redefinition of parameter name");
}
if (find_var_in_child_scope(ctx, fd, name, fd->scope_level) >= 0) {
return js_parse_error(s, "invalid redefinition of a variable");
}
if (fd->is_global_var) {
JSGlobalVar *hf;
hf = find_global_var(fd, name);
if (hf && is_child_scope(ctx, fd, hf->scope_level,
fd->scope_level)) {
return js_parse_error(s, "invalid redefinition of global identifier");
}
}
if (fd->is_eval &&
(fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
fd->eval_type == JS_EVAL_TYPE_MODULE) &&
fd->scope_level == fd->body_scope) {
JSGlobalVar *hf;
hf = add_global_var(s->ctx, fd, name);
if (!hf)
return -1;
hf->is_lexical = TRUE;
hf->is_const = (var_def_type == JS_VAR_DEF_CONST);
idx = GLOBAL_VAR_OFFSET;
} else {
JSVarKindEnum var_kind;
if (var_def_type == JS_VAR_DEF_FUNCTION_DECL)
var_kind = JS_VAR_FUNCTION_DECL;
else if (var_def_type == JS_VAR_DEF_NEW_FUNCTION_DECL)
var_kind = JS_VAR_NEW_FUNCTION_DECL;
else
var_kind = JS_VAR_NORMAL;
idx = add_scope_var(ctx, fd, name, var_kind);
if (idx >= 0) {
vd = &fd->vars[idx];
vd->is_lexical = 1;
vd->is_const = (var_def_type == JS_VAR_DEF_CONST);
}
}
break;
case JS_VAR_DEF_CATCH:
idx = add_scope_var(ctx, fd, name, JS_VAR_CATCH);
break;
case JS_VAR_DEF_VAR:
if (find_lexical_decl(ctx, fd, name, fd->scope_first,
FALSE) >= 0) {
invalid_lexical_redefinition:
/* error to redefine a var that inside a lexical scope */
return js_parse_error(s, "invalid redefinition of lexical identifier");
}
if (fd->is_global_var) {
JSGlobalVar *hf;
hf = find_global_var(fd, name);
if (hf && hf->is_lexical && hf->scope_level == fd->scope_level &&
fd->eval_type == JS_EVAL_TYPE_MODULE) {
goto invalid_lexical_redefinition;
}
hf = add_global_var(s->ctx, fd, name);
if (!hf)
return -1;
idx = GLOBAL_VAR_OFFSET;
} else {
/* if the variable already exists, don't add it again */
idx = find_var(ctx, fd, name);
if (idx >= 0)
break;
idx = add_var(ctx, fd, name);
if (idx >= 0) {
if (name == JS_ATOM_arguments && fd->has_arguments_binding)
fd->arguments_var_idx = idx;
fd->vars[idx].scope_next = fd->scope_level;
}
}
break;
default:
abort();
}
return idx;
} | O1 | c | define_var:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movl %ecx, %eax
leaq 0x3a528(%rip), %rcx # 0x9d3b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0xec(%rbx), %edx
movq %rbx, %rdi
movl %ebp, %esi
movl $0x1, %ecx
callq 0x62c91
movl %eax, %r12d
testl %eax, %eax
js 0x63005
cmpl $0x3fffffff, %r12d # imm = 0x3FFFFFFF
jg 0x62f0c
movq 0x90(%rbx), %rcx
movl %r12d, %edx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movl 0x4(%rcx,%rdx), %ecx
movl 0xe8(%rbx), %edx
cmpl %edx, %ecx
jne 0x62fe5
cmpl $0x3, %r13d
jne 0x62ff9
cmpw $0x0, 0x84(%rbx)
js 0x62ff9
movl $0xf0, %ecx
andl 0xc(%rax), %ecx
cmpl $0x10, %ecx
jne 0x62ff9
jmp 0x63005
movl 0xe8(%rbx), %eax
cmpl 0x120(%rbx), %eax
je 0x62ff9
jmp 0x63005
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl $0x3, %ecx
jmp 0x62fd8
movl 0xec(%rbx), %edx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
callq 0x62c91
testl %eax, %eax
jns 0x62ff9
cmpl $0x0, 0x40(%rbx)
je 0x63206
movslq 0x124(%rbx), %rcx
testq %rcx, %rcx
jle 0x62f7e
movq 0x130(%rbx), %rdx
cmpl %ebp, 0xc(%rdx)
cmoveq %rdx, %rax
je 0x62f80
addq $0x10, %rdx
decq %rcx
jne 0x62f6c
xorl %eax, %eax
testq %rax, %rax
je 0x62fa1
testb $0x2, 0x4(%rax)
je 0x62fa1
movl 0x8(%rax), %eax
cmpl 0xe8(%rbx), %eax
jne 0x62fa1
movl $0x4, %ecx
cmpl $0x1, 0x3c(%rbx)
je 0x62fb6
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x651bc
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
testl %ecx, %ecx
je 0x63262
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpl $0x4, %ecx
je 0x62ff9
jmp 0x630eb
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x65257
movl %eax, %r12d
jmp 0x630eb
movl $0xf0, %esi
andl 0xc(%rax), %esi
xorl $0x30, %esi
addl $0x2, %ecx
xorl %edx, %ecx
orl %esi, %ecx
jne 0x63005
leaq 0x3da02(%rip), %rsi # 0xa0a02
jmp 0x630db
leal -0x5(%r13), %eax
cmpl $-0x3, %eax
ja 0x6305a
movl 0xe8(%rbx), %eax
cmpl 0x120(%rbx), %eax
jne 0x6305a
movslq 0xb4(%rbx), %rax
movq %rax, %rcx
shlq $0x4, %rcx
addq $-0x10, %rcx
incq %rax
decq %rax
jle 0x6305a
leaq -0x10(%rcx), %rdx
movq 0xa8(%rbx), %rsi
cmpl %ebp, (%rsi,%rcx)
movq %rdx, %rcx
jne 0x63031
testq %rax, %rax
jle 0x6305a
leaq 0x3d9d8(%rip), %rsi # 0xa0a2d
jmp 0x630db
movl 0xe8(%rbx), %eax
movslq 0xa4(%rbx), %rcx
testq %rcx, %rcx
jle 0x630fd
movq 0x90(%rbx), %rsi
xorl %edi, %edi
movq %rdi, %r9
shlq $0x4, %r9
movb $0x1, %r8b
cmpl %ebp, (%rsi,%r9)
jne 0x63093
addq %rsi, %r9
cmpl $0x0, 0x4(%r9)
je 0x630a2
testb %r8b, %r8b
je 0x630d0
incq %rdi
cmpq %rcx, %rdi
jne 0x63079
jmp 0x630cb
movl 0x8(%r9), %r9d
testl %r9d, %r9d
js 0x63093
cmpl %eax, %r9d
setne %r10b
je 0x630c4
movq 0xf8(%rbx), %r10
movl %r9d, %r9d
movl (%r10,%r9,8), %r9d
jmp 0x630a6
movl %edi, %edx
movl %r10d, %r8d
jmp 0x63093
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
testl %edx, %edx
js 0x630fd
leaq 0x3d979(%rip), %rsi # 0xa0a54
movq %r14, %rdi
xorl %eax, %eax
callq 0x2fce9
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x40(%rbx)
je 0x6314c
movslq 0x124(%rbx), %rdx
testq %rdx, %rdx
jle 0x63128
movq 0x130(%rbx), %rsi
cmpl %ebp, 0xc(%rsi)
cmoveq %rsi, %rcx
je 0x6312a
addq $0x10, %rsi
decq %rdx
jne 0x63116
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x6314c
movl 0x8(%rcx), %ecx
testl %ecx, %ecx
js 0x6314c
cmpl %eax, %ecx
je 0x631fa
movq 0xf8(%rbx), %rdx
movl %ecx, %ecx
movl (%rdx,%rcx,8), %ecx
jmp 0x63132
cmpl $0x0, 0x38(%rbx)
je 0x6319e
cmpl $0x1, 0x3c(%rbx)
ja 0x6319e
cmpl 0x120(%rbx), %eax
jne 0x6319e
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x651bc
testq %rax, %rax
je 0x63190
movb 0x4(%rax), %cl
cmpl $0x2, %r13d
sete %dl
andb $-0x7, %cl
shlb $0x2, %dl
orb %cl, %dl
orb $0x2, %dl
movb %dl, 0x4(%rax)
movl $0x40000000, %r12d # imm = 0x40000000
testq %rax, %rax
jne 0x630eb
jmp 0x630e5
xorl %eax, %eax
cmpl $0x4, %r13d
sete %al
addl %eax, %eax
cmpl $0x3, %r13d
movl $0x1, %ecx
cmovnel %eax, %ecx
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x65257
movl %eax, %r12d
testl %eax, %eax
js 0x630eb
movq 0x90(%rbx), %rax
movl %r12d, %ecx
shlq $0x4, %rcx
movl 0xc(%rax,%rcx), %edx
xorl %esi, %esi
cmpl $0x2, %r13d
sete %sil
andl $-0x4, %edx
addl %esi, %edx
addl $0x2, %edx
movl %edx, 0xc(%rax,%rcx)
jmp 0x630eb
leaq 0x3d76f(%rip), %rsi # 0xa0970
jmp 0x630db
movq %rbx, %rdi
movl %ebp, %esi
callq 0x62d2a
movl %eax, %r12d
testl %eax, %eax
jns 0x630eb
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x5de5e
movl %eax, %r12d
testl %eax, %eax
js 0x630eb
cmpl $0x4e, %ebp
jne 0x63245
cmpl $0x0, 0x60(%rbx)
je 0x63245
movl %r12d, 0xc4(%rbx)
movl 0xe8(%rbx), %eax
movq 0x90(%rbx), %rcx
movl %r12d, %edx
shlq $0x4, %rdx
movl %eax, 0x8(%rcx,%rdx)
jmp 0x630eb
movl $0x40000000, %r12d # imm = 0x40000000
jmp 0x630eb
| define_var:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13d, ecx
mov ebp, edx
mov rbx, rsi
mov r14, rdi
mov r15, [rdi]
mov eax, ecx
lea rcx, jpt_62E8F
movsxd rax, ds:(jpt_62E8F - 9D3B0h)[rcx+rax*4]; switch 7 cases
add rax, rcx
jmp rax; switch jump
loc_62E91:
mov edx, [rbx+0ECh]; jumptable 0000000000062E8F cases 1-4
mov rdi, rbx
mov esi, ebp
mov ecx, 1
call find_lexical_decl
mov r12d, eax
test eax, eax
js loc_63005
cmp r12d, 3FFFFFFFh
jg short loc_62F0C
mov rcx, [rbx+90h]
mov edx, r12d
shl rdx, 4
lea rax, [rcx+rdx]
mov ecx, [rcx+rdx+4]
mov edx, [rbx+0E8h]
cmp ecx, edx
jnz loc_62FE5
cmp r13d, 3
jnz loc_62FF9
cmp word ptr [rbx+84h], 0
js loc_62FF9
mov ecx, 0F0h
and ecx, [rax+0Ch]
cmp ecx, 10h
jnz loc_62FF9
jmp loc_63005
loc_62F0C:
mov eax, [rbx+0E8h]
cmp eax, [rbx+120h]
jz loc_62FF9
jmp loc_63005
loc_62F23:
mov rdi, r15; jumptable 0000000000062E8F case 5
mov rsi, rbx
mov edx, ebp
mov ecx, 3
jmp loc_62FD8
loc_62F35:
mov edx, [rbx+0ECh]; jumptable 0000000000062E8F case 6
mov rdi, rbx
mov esi, ebp
xor ecx, ecx
call find_lexical_decl
test eax, eax
jns loc_62FF9
cmp dword ptr [rbx+40h], 0
jz loc_63206
movsxd rcx, dword ptr [rbx+124h]
test rcx, rcx
jle short loc_62F7E
mov rdx, [rbx+130h]
loc_62F6C:
cmp [rdx+0Ch], ebp
cmovz rax, rdx
jz short loc_62F80
add rdx, 10h
dec rcx
jnz short loc_62F6C
loc_62F7E:
xor eax, eax
loc_62F80:
test rax, rax
jz short loc_62FA1
test byte ptr [rax+4], 2
jz short loc_62FA1
mov eax, [rax+8]
cmp eax, [rbx+0E8h]
jnz short loc_62FA1
mov ecx, 4
cmp dword ptr [rbx+3Ch], 1
jz short loc_62FB6
loc_62FA1:
mov rdi, r15
mov rsi, rbx
mov edx, ebp
call add_global_var
xor ecx, ecx
test rax, rax
setz cl
loc_62FB6:
test ecx, ecx
jz loc_63262
mov r12d, 0FFFFFFFFh
cmp ecx, 4
jz short loc_62FF9
jmp loc_630EB
loc_62FCE:
mov rdi, r15; jumptable 0000000000062E8F case 0
mov rsi, rbx
mov edx, ebp
xor ecx, ecx
loc_62FD8:
call add_scope_var
mov r12d, eax
jmp loc_630EB
loc_62FE5:
mov esi, 0F0h
and esi, [rax+0Ch]
xor esi, 30h
add ecx, 2
xor ecx, edx
or ecx, esi
jnz short loc_63005
loc_62FF9:
lea rsi, aInvalidRedefin_1; "invalid redefinition of lexical identif"...
jmp loc_630DB
loc_63005:
lea eax, [r13-5]
cmp eax, 0FFFFFFFDh
ja short loc_6305A
mov eax, [rbx+0E8h]
cmp eax, [rbx+120h]
jnz short loc_6305A
movsxd rax, dword ptr [rbx+0B4h]
mov rcx, rax
shl rcx, 4
add rcx, 0FFFFFFFFFFFFFFF0h
inc rax
loc_63031:
dec rax
jle short loc_6305A
lea rdx, [rcx-10h]
mov rsi, [rbx+0A8h]
cmp [rsi+rcx], ebp
mov rcx, rdx
jnz short loc_63031
test rax, rax
jle short loc_6305A
lea rsi, aInvalidRedefin_2; "invalid redefinition of parameter name"
jmp loc_630DB
loc_6305A:
mov eax, [rbx+0E8h]
movsxd rcx, dword ptr [rbx+0A4h]
test rcx, rcx
jle loc_630FD
mov rsi, [rbx+90h]
xor edi, edi
loc_63079:
mov r9, rdi
shl r9, 4
mov r8b, 1
cmp [rsi+r9], ebp
jnz short loc_63093
add r9, rsi
cmp dword ptr [r9+4], 0
jz short loc_630A2
loc_63093:
test r8b, r8b
jz short loc_630D0
inc rdi
cmp rdi, rcx
jnz short loc_63079
jmp short loc_630CB
loc_630A2:
mov r9d, [r9+8]
loc_630A6:
test r9d, r9d
js short loc_63093
cmp r9d, eax
setnz r10b
jz short loc_630C4
mov r10, [rbx+0F8h]
mov r9d, r9d
mov r9d, [r10+r9*8]
jmp short loc_630A6
loc_630C4:
mov edx, edi
mov r8d, r10d
jmp short loc_63093
loc_630CB:
mov edx, 0FFFFFFFFh
loc_630D0:
test edx, edx
js short loc_630FD
lea rsi, aInvalidRedefin_3; "invalid redefinition of a variable"
loc_630DB:
mov rdi, r14
xor eax, eax
call js_parse_error
loc_630E5:
mov r12d, 0FFFFFFFFh
loc_630EB:
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_630FD:
cmp dword ptr [rbx+40h], 0
jz short loc_6314C
movsxd rdx, dword ptr [rbx+124h]
test rdx, rdx
jle short loc_63128
mov rsi, [rbx+130h]
loc_63116:
cmp [rsi+0Ch], ebp
cmovz rcx, rsi
jz short loc_6312A
add rsi, 10h
dec rdx
jnz short loc_63116
loc_63128:
xor ecx, ecx
loc_6312A:
test rcx, rcx
jz short loc_6314C
mov ecx, [rcx+8]
loc_63132:
test ecx, ecx
js short loc_6314C
cmp ecx, eax
jz loc_631FA
mov rdx, [rbx+0F8h]
mov ecx, ecx
mov ecx, [rdx+rcx*8]
jmp short loc_63132
loc_6314C:
cmp dword ptr [rbx+38h], 0
jz short loc_6319E
cmp dword ptr [rbx+3Ch], 1
ja short loc_6319E
cmp eax, [rbx+120h]
jnz short loc_6319E
mov rdi, r15
mov rsi, rbx
mov edx, ebp
call add_global_var
test rax, rax
jz short loc_63190
mov cl, [rax+4]
cmp r13d, 2
setz dl
and cl, 0F9h
shl dl, 2
or dl, cl
or dl, 2
mov [rax+4], dl
mov r12d, 40000000h
loc_63190:
test rax, rax
jnz loc_630EB
jmp loc_630E5
loc_6319E:
xor eax, eax
cmp r13d, 4
setz al
add eax, eax
cmp r13d, 3
mov ecx, 1
cmovnz ecx, eax
mov rdi, r15
mov rsi, rbx
mov edx, ebp
call add_scope_var
mov r12d, eax
test eax, eax
js loc_630EB
mov rax, [rbx+90h]
mov ecx, r12d
shl rcx, 4
mov edx, [rax+rcx+0Ch]
xor esi, esi
cmp r13d, 2
setz sil
and edx, 0FFFFFFFCh
add edx, esi
add edx, 2
mov [rax+rcx+0Ch], edx
jmp loc_630EB
loc_631FA:
lea rsi, aInvalidRedefin_0; "invalid redefinition of global identifi"...
jmp loc_630DB
loc_63206:
mov rdi, rbx
mov esi, ebp
call find_var
mov r12d, eax
test eax, eax
jns loc_630EB
mov rdi, r15
mov rsi, rbx
mov edx, ebp
call add_var
mov r12d, eax
test eax, eax
js loc_630EB
cmp ebp, 4Eh ; 'N'
jnz short loc_63245
cmp dword ptr [rbx+60h], 0
jz short loc_63245
mov [rbx+0C4h], r12d
loc_63245:
mov eax, [rbx+0E8h]
mov rcx, [rbx+90h]
mov edx, r12d
shl rdx, 4
mov [rcx+rdx+8], eax
jmp loc_630EB
loc_63262:
mov r12d, 40000000h
jmp loc_630EB
| long long define_var(
long long *a1,
long long a2,
long long a3,
int a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
char v12; // al
unsigned int v14; // ebp
long long v17; // r15
int v18; // eax
long long v19; // rdx
long long j; // rcx
long long v21; // r8
long long i; // r9
long long v23; // r10
__m128 v24; // xmm4
__m128 v25; // xmm5
long long v26; // rax
long long v27; // rdi
long long v28; // rcx
int v29; // eax
long long v30; // rcx
long long v31; // rax
int var; // r12d
const char *v33; // rsi
long long v34; // rax
bool v36; // zf
int v37; // eax
long long v38; // rsi
long long v39; // rdi
long long v41; // rsi
long long v42; // rcx
long long v43; // rax
long long v44; // rcx
long long v45; // rcx
long long v46; // r8
long long v47; // r9
__m128 v48; // xmm4
__m128 v49; // xmm5
char v50; // [rsp-8h] [rbp-38h]
v50 = v12;
v14 = a3;
v17 = *a1;
switch ( a4 )
{
case 0:
v27 = *a1;
a3 = (unsigned int)a3;
v28 = 0LL;
return (unsigned int)add_scope_var(v27, a2, a3, v28);
case 1:
case 2:
case 3:
case 4:
find_lexical_decl(a2, a3, *(_DWORD *)(a2 + 236), 1);
if ( v18 < 0 )
goto LABEL_32;
if ( v18 > 0x3FFFFFFF )
{
if ( *(_DWORD *)(a2 + 232) == *(_DWORD *)(a2 + 288) )
goto LABEL_31;
}
else
{
v26 = *(_QWORD *)(a2 + 144) + 16LL * (unsigned int)v18;
j = *(unsigned int *)(v26 + 4);
v19 = *(unsigned int *)(a2 + 232);
if ( (_DWORD)j == (_DWORD)v19 )
{
if ( a4 != 3 )
goto LABEL_31;
if ( *(__int16 *)(a2 + 132) < 0 )
goto LABEL_31;
j = *(_DWORD *)(v26 + 12) & 0xF0;
if ( (_DWORD)j != 16 )
goto LABEL_31;
}
else
{
j = *(_DWORD *)(v26 + 12) & 0xF0 ^ 0x30 | (unsigned int)v19 ^ ((_DWORD)j + 2);
if ( !(_DWORD)j )
goto LABEL_31;
}
}
LABEL_32:
if ( (unsigned int)(a4 - 5) > 0xFFFFFFFD || *(_DWORD *)(a2 + 232) != *(_DWORD *)(a2 + 288) )
goto LABEL_39;
j = 16LL * *(int *)(a2 + 180) - 16;
v34 = *(int *)(a2 + 180) + 1LL;
while ( v34-- > 1 )
{
v19 = j - 16;
v36 = *(_DWORD *)(*(_QWORD *)(a2 + 168) + j) == v14;
j -= 16LL;
if ( v36 )
{
if ( v34 > 0 )
{
v33 = "invalid redefinition of parameter name";
goto LABEL_53;
}
break;
}
}
LABEL_39:
v37 = *(_DWORD *)(a2 + 232);
j = *(int *)(a2 + 164);
if ( j > 0 )
{
v38 = *(_QWORD *)(a2 + 144);
v39 = 0LL;
while ( 1 )
{
i = 16 * v39;
LOBYTE(v21) = 1;
if ( *(_DWORD *)(v38 + 16 * v39) == v14 )
{
i += v38;
if ( !*(_DWORD *)(i + 4) )
{
for ( i = *(unsigned int *)(i + 8); (int)i >= 0; i = *(unsigned int *)(v23 + 8LL * (unsigned int)i) )
{
if ( (_DWORD)i == v37 )
{
v19 = (unsigned int)v39;
LOBYTE(v23) = (_DWORD)i != v37;
v21 = (unsigned int)v23;
break;
}
v23 = *(_QWORD *)(a2 + 248);
}
}
}
if ( !(_BYTE)v21 )
break;
if ( ++v39 == j )
{
v19 = 0xFFFFFFFFLL;
break;
}
}
if ( (int)v19 >= 0 )
{
v33 = "invalid redefinition of a variable";
goto LABEL_53;
}
}
if ( *(_DWORD *)(a2 + 64) )
{
v19 = *(int *)(a2 + 292);
if ( v19 <= 0 )
{
LABEL_62:
v42 = 0LL;
}
else
{
v41 = *(_QWORD *)(a2 + 304);
while ( *(_DWORD *)(v41 + 12) != v14 )
{
v41 += 16LL;
if ( !--v19 )
goto LABEL_62;
}
v42 = v41;
}
if ( v42 )
{
for ( j = *(unsigned int *)(v42 + 8); (int)j >= 0; j = *(unsigned int *)(v19 + 8LL * (unsigned int)j) )
{
if ( (_DWORD)j == v37 )
{
v33 = "invalid redefinition of global identifier";
goto LABEL_53;
}
v19 = *(_QWORD *)(a2 + 248);
}
}
}
if ( *(_DWORD *)(a2 + 56) && *(_DWORD *)(a2 + 60) <= 1u && v37 == *(_DWORD *)(a2 + 288) )
{
v43 = add_global_var(v17, a2, v14);
if ( !v43 )
return (unsigned int)-1;
*(_BYTE *)(v43 + 4) = *(_BYTE *)(v43 + 4) & 0xF9 | (4 * (a4 == 2)) | 2;
return 0x40000000;
}
else
{
v44 = 1LL;
if ( a4 != 3 )
v44 = 2 * (unsigned int)(a4 == 4);
var = add_scope_var(v17, a2, v14, v44);
if ( var >= 0 )
*(_DWORD *)(*(_QWORD *)(a2 + 144) + 16LL * (unsigned int)var + 12) = (a4 == 2)
+ (*(_DWORD *)(*(_QWORD *)(a2 + 144)
+ 16LL * (unsigned int)var
+ 12) & 0xFFFFFFFC)
+ 2;
}
return (unsigned int)var;
case 5:
v27 = *a1;
a3 = (unsigned int)a3;
v28 = 3LL;
return (unsigned int)add_scope_var(v27, a2, a3, v28);
case 6:
find_lexical_decl(a2, a3, *(_DWORD *)(a2 + 236), 0);
if ( v29 >= 0 )
goto LABEL_31;
if ( !*(_DWORD *)(a2 + 64) )
{
var = find_var(a2, v14);
if ( var < 0 )
{
var = add_var(v17, a2, v14, v45, a5, a6, a7, a8, v48, v49, a11, a12, v46, v47);
if ( var >= 0 )
{
if ( v14 == 78 && *(_DWORD *)(a2 + 96) )
*(_DWORD *)(a2 + 196) = var;
*(_DWORD *)(*(_QWORD *)(a2 + 144) + 16LL * (unsigned int)var + 8) = *(_DWORD *)(a2 + 232);
}
}
return (unsigned int)var;
}
v30 = *(int *)(a2 + 292);
if ( v30 <= 0 )
goto LABEL_19;
v19 = *(_QWORD *)(a2 + 304);
break;
}
do
{
if ( *(_DWORD *)(v19 + 12) == v14 )
{
v31 = v19;
goto LABEL_20;
}
v19 += 16LL;
--v30;
}
while ( v30 );
LABEL_19:
v31 = 0LL;
LABEL_20:
if ( !v31
|| (*(_BYTE *)(v31 + 4) & 2) == 0
|| *(_DWORD *)(v31 + 8) != *(_DWORD *)(a2 + 232)
|| (j = 4LL, *(_DWORD *)(a2 + 60) != 1) )
{
j = add_global_var(v17, a2, v14) == 0;
}
if ( (_DWORD)j )
{
var = -1;
if ( (_DWORD)j == 4 )
{
LABEL_31:
v33 = "invalid redefinition of lexical identifier";
LABEL_53:
js_parse_error(a1, (long long)v33, v19, j, v21, i, a5, a6, a7, a8, v24, v25, a11, a12, v50);
return (unsigned int)-1;
}
}
else
{
return 0x40000000;
}
return (unsigned int)var;
}
| define_var:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13D,ECX
MOV EBP,EDX
MOV RBX,RSI
MOV R14,RDI
MOV R15,qword ptr [RDI]
MOV EAX,ECX
LEA RCX,[0x19d3b0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
JMP RAX
|
void define_var(void)
{
ulong in_RCX;
/* WARNING: Could not recover jumptable at 0x00162e8f. Too many branches */
/* WARNING: Treating indirect jump as call */
(*(code *)(&DAT_0019d3b0 + *(int *)(&DAT_0019d3b0 + (in_RCX & 0xffffffff) * 4)))();
return;
}
| |
22,464 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/json.hpp | iterator insert_iterator(const_iterator pos, Args&& ... args)
{
iterator result(this);
JSON_ASSERT(m_data.m_value.array != nullptr);
auto insert_pos = std::distance(m_data.m_value.array->begin(), pos.m_it.array_iterator);
m_data.m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
result.m_it.array_iterator = m_data.m_value.array->begin() + insert_pos;
// This could have been written as:
// result.m_it.array_iterator = m_data.m_value.array->insert(pos.m_it.array_iterator, cnt, val);
// but the return value of insert is missing in GCC 4.8, so it is written this way instead.
set_parents();
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq $0x0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0xaf9ef
movq %rsi, %r14
movq 0x10(%rdx), %rsi
movq %rsi, %r15
subq (%rdi), %r15
movq %rcx, %rdx
callq 0xafa98
movq 0x8(%r14), %rax
addq (%rax), %r15
movq %r15, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x411a3(%rip), %rdi # 0xf0b99
leaq 0x3abf8(%rip), %rdx # 0xea5f5
leaq 0x41258(%rip), %rcx # 0xf0c5c
movl $0x582c, %esi # imm = 0x582C
xorl %eax, %eax
callq 0x1bfb0
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_:
push r15
push r14
push rbx
mov rbx, rdi
mov [rdi], rsi
mov qword ptr [rdi+8], 0
mov rax, 8000000000000000h
mov [rdi+18h], rax
mov rdi, [rsi+8]
test rdi, rdi
jz short loc_AF9EF
mov r14, rsi
mov rsi, [rdx+10h]
mov r15, rsi
sub r15, [rdi]
mov rdx, rcx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE6insertEN9__gnu_cxx17__normal_iteratorIPKSD_SF_EERSI_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::insert(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [r14+8]
add r15, [rax]
mov [rbx+10h], r15
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_AF9EF:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMDataMTypeValu_0+23h; "m_data.m_value.array != nullptr"
mov esi, 582Ch
xor eax, eax
call _ggml_abort
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&>(
_QWORD *a1,
long long a2,
long long a3,
long long a4)
{
_QWORD *v5; // rdi
long long v6; // r15
*a1 = a2;
a1[1] = 0LL;
a1[3] = 0x8000000000000000LL;
v5 = *(_QWORD **)(a2 + 8);
if ( v5 )
{
v6 = *(_QWORD *)(a3 + 16) - *v5;
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::insert(
v5,
*(_QWORD *)(a3 + 16),
a4);
a1[2] = **(_QWORD **)(a2 + 8) + v6;
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
22572LL,
"GGML_ASSERT(%s) failed",
"m_data.m_value.array != nullptr");
return nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
22572LL);
}
}
| insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],0x0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x18],RAX
MOV RDI,qword ptr [RSI + 0x8]
TEST RDI,RDI
JZ 0x001af9ef
MOV R14,RSI
MOV RSI,qword ptr [RDX + 0x10]
MOV R15,RSI
SUB R15,qword ptr [RDI]
MOV RDX,RCX
CALL 0x001afa98
MOV RAX,qword ptr [R14 + 0x8]
ADD R15,qword ptr [RAX]
MOV qword ptr [RBX + 0x10],R15
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_001af9ef:
LEA RDI,[0x1f0b99]
LEA RDX,[0x1ea5f5]
LEA RCX,[0x1f0c5c]
MOV ESI,0x582c
XOR EAX,EAX
CALL 0x0011bfb0
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>
const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&) */
long * nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&>
(long *param_1,long param_2,long param_3,int8 param_4)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*pvVar1;
long lVar2;
long lVar3;
*param_1 = param_2;
param_1[1] = 0;
param_1[3] = -0x8000000000000000;
pvVar1 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(param_2 + 8);
if (pvVar1 != (vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)0x0) {
lVar2 = *(long *)(param_3 + 0x10);
lVar3 = *(long *)pvVar1;
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::insert(pvVar1,lVar2,param_4);
param_1[2] = (lVar2 - lVar3) + **(long **)(param_2 + 8);
return param_1;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x582c,
"GGML_ASSERT(%s) failed","m_data.m_value.array != nullptr");
}
| |
22,465 | LEX::sp_for_loop_increment(THD*, Lex_for_loop_st const&) | eloqsql/sql/sql_lex.cc | bool LEX::sp_for_loop_increment(THD *thd, const Lex_for_loop_st &loop)
{
Item_splocal *splocal= new (thd->mem_root)
Item_splocal(thd, &sp_rcontext_handler_local,
&loop.m_index->name, loop.m_index->offset,
loop.m_index->type_handler());
if (unlikely(splocal == NULL))
return true;
#ifdef DBUG_ASSERT_EXISTS
splocal->m_sp= sphead;
#endif
Item_int *inc= new (thd->mem_root) Item_int(thd, loop.m_direction);
if (unlikely(!inc))
return true;
Item *expr= new (thd->mem_root) Item_func_plus(thd, splocal, inc);
if (unlikely(!expr) ||
unlikely(sphead->set_local_variable(thd, spcont,
&sp_rcontext_handler_local,
loop.m_index, expr, this, true)))
return true;
return false;
} | O0 | cpp | LEX::sp_for_loop_increment(THD*, Lex_for_loop_st const&):
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0x98(%rbp)
movl $0xb8, %edi
callq 0x7ee3b0
movq %rax, %rcx
movq %rcx, -0x90(%rbp)
movb $0x0, -0x29(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x88(%rbp)
je 0x8ce8d1
movb $0x1, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq %rdi, -0xb8(%rbp)
movl 0x14(%rdi), %eax
movl %eax, -0xac(%rbp)
callq 0x8debc0
movq %rax, -0xa8(%rbp)
jmp 0x8ce880
movq -0xa8(%rbp), %r9
movl -0xac(%rbp), %r8d
movq -0xb8(%rbp), %rcx
movq -0xc0(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq %rsp, %rax
movl $0x0, 0x8(%rax)
movl $0x0, (%rax)
leaq 0x11fe5e6(%rip), %rdx # 0x1accea0
callq 0xc346b0
jmp 0x8ce8c1
movq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x8ce8d1
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8ce923
movb $0x1, -0x1(%rbp)
jmp 0x8ceaee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x8ce90b
jmp 0x8ce91e
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdi
callq 0x7ee470
jmp 0x8ceafc
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0xd8(%rbp)
movl $0x78, %edi
callq 0x7ee3b0
movq %rax, %rcx
movq %rcx, -0xd0(%rbp)
movb $0x0, -0x59(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0xc8(%rbp)
je 0x8ce99b
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rax
movq %rdi, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movb $0x1, -0x59(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movsbl 0x14(%rax), %edx
movl $0xb, %ecx
callq 0x8e1470
jmp 0x8ce98b
movq -0xd0(%rbp), %rax
movq %rax, -0xc8(%rbp)
jmp 0x8ce99b
movq -0xc8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8ce9e9
movb $0x1, -0x1(%rbp)
jmp 0x8ceaee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x59(%rbp)
jne 0x8ce9d7
jmp 0x8ce9e4
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x7ee470
jmp 0x8ceafc
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0xf0(%rbp)
movl $0xb0, %edi
callq 0x7ee3b0
movq %rax, %rcx
movq %rcx, -0xe8(%rbp)
movb $0x0, -0x79(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0xe0(%rbp)
je 0x8cea5c
movq -0xe8(%rbp), %rdi
movq -0xf0(%rbp), %rax
movq %rdi, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movb $0x1, -0x79(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x8e14e0
jmp 0x8cea4c
movq -0xe8(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x8cea5c
movq -0xe0(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8ceac1
movq -0xa0(%rbp), %rax
movq 0x1960(%rax), %rdi
movq -0x18(%rbp), %rsi
movq 0x1970(%rax), %rdx
movq -0x20(%rbp), %rcx
movq (%rcx), %r8
movq -0x68(%rbp), %r9
leaq 0x11fe3fa(%rip), %rcx # 0x1accea0
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x820610
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x8ceaea
movb $0x1, -0x1(%rbp)
jmp 0x8ceaee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
testb $0x1, -0x79(%rbp)
jne 0x8ceadb
jmp 0x8ceae8
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x7ee470
jmp 0x8ceafc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x7589b0
nopw %cs:(%rax,%rax)
| _ZN3LEX21sp_for_loop_incrementEP3THDRK15Lex_for_loop_st:
push rbp
mov rbp, rsp
sub rsp, 100h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
mov [rbp+var_A0], rax
mov rax, [rbp+var_18]
mov rsi, [rax+28h]
mov [rbp+var_98], rsi
mov edi, 0B8h
call _ZN4ItemnwEmP11st_mem_root; Item::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_90], rcx
mov [rbp+var_29], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_88], rax
jz loc_8CE8D1
mov [rbp+var_29], 1
mov rax, [rbp+var_18]
mov [rbp+var_C0], rax
mov rax, [rbp+var_20]
mov rdi, [rax]; this
mov [rbp+var_B8], rdi
mov eax, [rdi+14h]
mov [rbp+var_AC], eax
call _ZNK11sp_variable12type_handlerEv; sp_variable::type_handler(void)
mov [rbp+var_A8], rax
jmp short $+2
loc_8CE880:
mov r9, [rbp+var_A8]
mov r8d, [rbp+var_AC]
mov rcx, [rbp+var_B8]
mov rsi, [rbp+var_C0]
mov rdi, [rbp+var_90]
mov rax, rsp
mov dword ptr [rax+8], 0
mov dword ptr [rax], 0
lea rdx, sp_rcontext_handler_local
call _ZN12Item_splocalC2EP3THDPK19Sp_rcontext_handlerPK25st_mysql_const_lex_stringjPK12Type_handlerjj; Item_splocal::Item_splocal(THD *,Sp_rcontext_handler const*,st_mysql_const_lex_string const*,uint,Type_handler const*,uint,uint)
jmp short $+2
loc_8CE8C1:
mov rax, [rbp+var_90]
mov [rbp+var_88], rax
jmp short $+2
loc_8CE8D1:
mov rax, [rbp+var_88]
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_8CE923
mov [rbp+var_1], 1
jmp loc_8CEAEE
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
test [rbp+var_29], 1
jnz short loc_8CE90B
jmp short loc_8CE91E
loc_8CE90B:
mov rsi, [rbp+var_98]
mov rdi, [rbp+var_90]
call _ZN4ItemdlEPvP11st_mem_root; Item::operator delete(void *,st_mem_root *)
loc_8CE91E:
jmp loc_8CEAFC
loc_8CE923:
mov rax, [rbp+var_18]
mov rsi, [rax+28h]
mov [rbp+var_D8], rsi
mov edi, 78h ; 'x'
call _ZN4ItemnwEmP11st_mem_root; Item::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_D0], rcx
mov [rbp+var_59], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_C8], rax
jz short loc_8CE99B
mov rdi, [rbp+var_D0]; this
mov rax, [rbp+var_D8]
mov [rbp+var_50], rdi
mov [rbp+var_58], rax
mov [rbp+var_59], 1
mov rsi, [rbp+var_18]; THD *
mov rax, [rbp+var_20]
movsx edx, byte ptr [rax+14h]; int
mov ecx, 0Bh; unsigned __int64
call _ZN8Item_intC2EP3THDim; Item_int::Item_int(THD *,int,ulong)
jmp short $+2
loc_8CE98B:
mov rax, [rbp+var_D0]
mov [rbp+var_C8], rax
jmp short $+2
loc_8CE99B:
mov rax, [rbp+var_C8]
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_8CE9E9
mov [rbp+var_1], 1
jmp loc_8CEAEE
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
test [rbp+var_59], 1
jnz short loc_8CE9D7
jmp short loc_8CE9E4
loc_8CE9D7:
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_58]
call _ZN4ItemdlEPvP11st_mem_root; Item::operator delete(void *,st_mem_root *)
loc_8CE9E4:
jmp loc_8CEAFC
loc_8CE9E9:
mov rax, [rbp+var_18]
mov rsi, [rax+28h]
mov [rbp+var_F0], rsi
mov edi, 0B0h
call _ZN4ItemnwEmP11st_mem_root; Item::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_E8], rcx
mov [rbp+var_79], 0
xor eax, eax
cmp rcx, 0
mov [rbp+var_E0], rax
jz short loc_8CEA5C
mov rdi, [rbp+var_E8]; this
mov rax, [rbp+var_F0]
mov [rbp+var_70], rdi
mov [rbp+var_78], rax
mov [rbp+var_79], 1
mov rsi, [rbp+var_18]; THD *
mov rdx, [rbp+var_28]; Item *
mov rcx, [rbp+var_48]; Item *
call _ZN14Item_func_plusC2EP3THDP4ItemS3_; Item_func_plus::Item_func_plus(THD *,Item *,Item *)
jmp short $+2
loc_8CEA4C:
mov rax, [rbp+var_E8]
mov [rbp+var_E0], rax
jmp short $+2
loc_8CEA5C:
mov rax, [rbp+var_E0]
mov [rbp+var_68], rax
cmp [rbp+var_68], 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
cmp eax, 0
jnz short loc_8CEAC1
mov rax, [rbp+var_A0]
mov rdi, [rax+1960h]; this
mov rsi, [rbp+var_18]; THD *
mov rdx, [rax+1970h]; sp_pcontext *
mov rcx, [rbp+var_20]
mov r8, [rcx]; sp_variable *
mov r9, [rbp+var_68]; Item *
lea rcx, sp_rcontext_handler_local; Sp_rcontext_handler *
mov [rsp+100h+var_100], rax; LEX *
mov dword ptr [rsp+100h+var_F8], 1; bool
call _ZN7sp_head18set_local_variableEP3THDP11sp_pcontextPK19Sp_rcontext_handlerP11sp_variableP4ItemP3LEXb; sp_head::set_local_variable(THD *,sp_pcontext *,Sp_rcontext_handler const*,sp_variable *,Item *,LEX *,bool)
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_8CEAEA
loc_8CEAC1:
mov [rbp+var_1], 1
jmp short loc_8CEAEE
mov rcx, rax
mov eax, edx
mov [rbp+var_38], rcx
mov [rbp+var_3C], eax
test [rbp+var_79], 1
jnz short loc_8CEADB
jmp short loc_8CEAE8
loc_8CEADB:
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_78]
call _ZN4ItemdlEPvP11st_mem_root; Item::operator delete(void *,st_mem_root *)
loc_8CEAE8:
jmp short loc_8CEAFC
loc_8CEAEA:
mov [rbp+var_1], 0
loc_8CEAEE:
mov al, [rbp+var_1]
and al, 1
add rsp, 100h
pop rbp
retn
loc_8CEAFC:
mov rdi, [rbp+var_38]
call __Unwind_Resume
| bool LEX::sp_for_loop_increment(sp_head **this, THD *a2, sp_variable **a3)
{
Item_func_plus *v4; // [rsp+18h] [rbp-E8h]
Item *v5; // [rsp+20h] [rbp-E0h]
Item_int *v6; // [rsp+30h] [rbp-D0h]
Item *v7; // [rsp+38h] [rbp-C8h]
sp_variable *v8; // [rsp+48h] [rbp-B8h]
int v9; // [rsp+54h] [rbp-ACh]
int v10; // [rsp+58h] [rbp-A8h]
long long v11; // [rsp+70h] [rbp-90h]
Item *v12; // [rsp+78h] [rbp-88h]
v11 = Item::operator new(184LL, *((_QWORD *)a2 + 5));
v12 = 0LL;
if ( v11 )
{
v8 = *a3;
v9 = *((_DWORD *)*a3 + 5);
v10 = sp_variable::type_handler(*a3);
Item_splocal::Item_splocal(v11, (_DWORD)a2, (unsigned int)sp_rcontext_handler_local, (_DWORD)v8, v9, v10, 0, 0);
v12 = (Item *)v11;
}
if ( !v12 )
return 1;
v6 = (Item_int *)Item::operator new(120LL, *((_QWORD *)a2 + 5));
v7 = 0LL;
if ( v6 )
{
Item_int::Item_int(v6, a2, *((char *)a3 + 20), 0xBuLL);
v7 = v6;
}
if ( !v7 )
return 1;
v4 = (Item_func_plus *)Item::operator new(176LL, *((_QWORD *)a2 + 5));
v5 = 0LL;
if ( v4 )
{
Item_func_plus::Item_func_plus(v4, a2, v12, v7);
v5 = v4;
}
return !v5
|| (sp_head::set_local_variable(
this[812],
a2,
this[814],
(const Sp_rcontext_handler *)sp_rcontext_handler_local,
*a3,
v5,
(LEX *)this,
1) & 1) != 0;
}
| inline_mysql_rwlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x90],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x008ce831
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x013ca960
MOV dword ptr [RBP + -0x4],EAX
JMP 0x008ce83d
LAB_008ce831:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x013d02c0
MOV dword ptr [RBP + -0x4],EAX
LAB_008ce83d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
/* inline_mysql_rwlock_wrlock(st_mysql_rwlock*, char const*, unsigned int) */
int4 inline_mysql_rwlock_wrlock(st_mysql_rwlock *param_1,char *param_2,uint param_3)
{
int4 local_c;
if (*(long *)(param_1 + 0x90) == 0) {
local_c = my_rw_wrlock(param_1);
}
else {
local_c = psi_rwlock_wrlock(param_1,param_2,param_3);
}
return local_c;
}
| |
22,466 | get_stack_info_from_data | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_io.c | static inline mjStackInfo get_stack_info_from_data(mjData* d) {
mjStackInfo stack_info;
stack_info.bottom = (uintptr_t)d->arena + (uintptr_t)d->narena;
stack_info.top = stack_info.bottom - d->pstack;
stack_info.limit = (uintptr_t)d->arena + (uintptr_t)d->parena;
stack_info.stack_base = d->pbase;
return stack_info;
} | O0 | c | get_stack_info_from_data:
movq %rdi, %rax
movq %rsi, -0x8(%rsp)
movq -0x8(%rsp), %rcx
movq 0x27770(%rcx), %rcx
movq -0x8(%rsp), %rdx
addq (%rdx), %rcx
movq %rcx, (%rdi)
movq (%rdi), %rcx
movq -0x8(%rsp), %rdx
subq 0x18(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movq -0x8(%rsp), %rcx
movq 0x27770(%rcx), %rcx
movq -0x8(%rsp), %rdx
addq 0x28(%rdx), %rcx
movq %rcx, 0x10(%rdi)
movq -0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, 0x18(%rdi)
retq
nopw %cs:(%rax,%rax)
| get_stack_info_from_data:
mov rax, rdi
mov [rsp+var_8], rsi
mov rcx, [rsp+var_8]
mov rcx, [rcx+27770h]
mov rdx, [rsp+var_8]
add rcx, [rdx]
mov [rdi], rcx
mov rcx, [rdi]
mov rdx, [rsp+var_8]
sub rcx, [rdx+18h]
mov [rdi+8], rcx
mov rcx, [rsp+var_8]
mov rcx, [rcx+27770h]
mov rdx, [rsp+var_8]
add rcx, [rdx+28h]
mov [rdi+10h], rcx
mov rcx, [rsp+var_8]
mov rcx, [rcx+20h]
mov [rdi+18h], rcx
retn
| _QWORD * get_stack_info_from_data(_QWORD *a1, _QWORD *a2)
{
_QWORD *result; // rax
result = a1;
*a1 = *a2 + a2[20206];
a1[1] = *a1 - a2[3];
a1[2] = a2[5] + a2[20206];
a1[3] = a2[4];
return result;
}
| get_stack_info_from_data:
MOV RAX,RDI
MOV qword ptr [RSP + -0x8],RSI
MOV RCX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RCX + 0x27770]
MOV RDX,qword ptr [RSP + -0x8]
ADD RCX,qword ptr [RDX]
MOV qword ptr [RDI],RCX
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RSP + -0x8]
SUB RCX,qword ptr [RDX + 0x18]
MOV qword ptr [RDI + 0x8],RCX
MOV RCX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RCX + 0x27770]
MOV RDX,qword ptr [RSP + -0x8]
ADD RCX,qword ptr [RDX + 0x28]
MOV qword ptr [RDI + 0x10],RCX
MOV RCX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RCX + 0x20]
MOV qword ptr [RDI + 0x18],RCX
RET
|
long * get_stack_info_from_data(long *param_1,long *param_2)
{
*param_1 = param_2[0x4eee] + *param_2;
param_1[1] = *param_1 - param_2[3];
param_1[2] = param_2[0x4eee] + param_2[5];
param_1[3] = param_2[4];
return param_1;
}
| |
22,467 | my_strxfrm_desc_and_reverse | eloqsql/strings/ctype-simple.c | void
my_strxfrm_desc_and_reverse(uchar *str, uchar *strend,
uint flags, uint level)
{
if (flags & (MY_STRXFRM_DESC_LEVEL1 << level))
{
if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str <= strend;)
{
uchar tmp= *str;
*str++= ~*strend;
*strend--= ~tmp;
}
}
else
{
for (; str < strend; str++)
*str= ~*str;
}
}
else if (flags & (MY_STRXFRM_REVERSE_LEVEL1 << level))
{
for (strend--; str < strend;)
{
uchar tmp= *str;
*str++= *strend;
*strend--= tmp;
}
}
} | O3 | c | my_strxfrm_desc_and_reverse:
pushq %rbp
movq %rsp, %rbp
movl %edx, %r8d
shrl %cl, %r8d
movl $0x10000, %eax # imm = 0x10000
shll %cl, %eax
btl $0x8, %r8d
jae 0x71dc4
testl %edx, %eax
je 0x71df7
decq %rsi
cmpq %rdi, %rsi
jb 0x71e06
incq %rdi
movb -0x1(%rdi), %al
movb (%rsi), %cl
notb %cl
movb %cl, -0x1(%rdi)
notb %al
movb %al, (%rsi)
decq %rsi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rdi
movq %rax, %rdi
jbe 0x71da5
jmp 0x71e06
testl %edx, %eax
setne %al
decq %rsi
cmpq %rdi, %rsi
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x71e06
incq %rdi
movb -0x1(%rdi), %al
movb (%rsi), %cl
movb %cl, -0x1(%rdi)
movb %al, (%rsi)
decq %rsi
leaq 0x1(%rdi), %rax
cmpq %rsi, %rdi
movq %rax, %rdi
jb 0x71ddc
jmp 0x71e06
cmpq %rsi, %rdi
jae 0x71e06
notb (%rdi)
incq %rdi
cmpq %rsi, %rdi
jne 0x71dfc
popq %rbp
retq
| my_strxfrm_desc_and_reverse:
push rbp
mov rbp, rsp
mov r8d, edx
shr r8d, cl
mov eax, 10000h
shl eax, cl
bt r8d, 8
jnb short loc_71DC4
test eax, edx
jz short loc_71DF7
dec rsi
cmp rsi, rdi
jb short loc_71E06
inc rdi
loc_71DA5:
mov al, [rdi-1]
mov cl, [rsi]
not cl
mov [rdi-1], cl
not al
mov [rsi], al
dec rsi
lea rax, [rdi+1]
cmp rdi, rsi
mov rdi, rax
jbe short loc_71DA5
jmp short loc_71E06
loc_71DC4:
test eax, edx
setnz al
dec rsi
cmp rsi, rdi
setnbe cl
and cl, al
cmp cl, 1
jnz short loc_71E06
inc rdi
loc_71DDC:
mov al, [rdi-1]
mov cl, [rsi]
mov [rdi-1], cl
mov [rsi], al
dec rsi
lea rax, [rdi+1]
cmp rdi, rsi
mov rdi, rax
jb short loc_71DDC
jmp short loc_71E06
loc_71DF7:
cmp rdi, rsi
jnb short loc_71E06
loc_71DFC:
not byte ptr [rdi]
inc rdi
cmp rdi, rsi
jnz short loc_71DFC
loc_71E06:
pop rbp
retn
| char my_strxfrm_desc_and_reverse(_BYTE *a1, _BYTE *a2, unsigned int a3, char a4)
{
int v4; // eax
_BYTE *v5; // rsi
_BYTE *v6; // rdi
char v7; // al
_BYTE *v9; // rsi
_BYTE *v10; // rdi
char v11; // al
v4 = 0x10000 << a4;
if ( ((a3 >> a4) & 0x100) != 0 )
{
if ( (a3 & v4) != 0 )
{
v5 = a2 - 1;
if ( v5 >= a1 )
{
v6 = a1 + 1;
do
{
v7 = *(v6 - 1);
*(v6 - 1) = ~*v5;
*v5-- = ~v7;
LOBYTE(v4) = (_BYTE)v6 + 1;
}
while ( v6++ <= v5 );
}
}
else if ( a1 < a2 )
{
do
{
*a1 = ~*a1;
++a1;
}
while ( a1 != a2 );
}
}
else
{
LOBYTE(v4) = (a3 & v4) != 0;
v9 = a2 - 1;
if ( ((unsigned __int8)v4 & (v9 > a1)) == 1 )
{
v10 = a1 + 1;
do
{
v11 = *(v10 - 1);
*(v10 - 1) = *v9;
*v9-- = v11;
LOBYTE(v4) = (_BYTE)v10 + 1;
}
while ( v10++ < v9 );
}
}
return v4;
}
| my_strxfrm_desc_and_reverse:
PUSH RBP
MOV RBP,RSP
MOV R8D,EDX
SHR R8D,CL
MOV EAX,0x10000
SHL EAX,CL
BT R8D,0x8
JNC 0x00171dc4
TEST EAX,EDX
JZ 0x00171df7
DEC RSI
CMP RSI,RDI
JC 0x00171e06
INC RDI
LAB_00171da5:
MOV AL,byte ptr [RDI + -0x1]
MOV CL,byte ptr [RSI]
NOT CL
MOV byte ptr [RDI + -0x1],CL
NOT AL
MOV byte ptr [RSI],AL
DEC RSI
LEA RAX,[RDI + 0x1]
CMP RDI,RSI
MOV RDI,RAX
JBE 0x00171da5
JMP 0x00171e06
LAB_00171dc4:
TEST EAX,EDX
SETNZ AL
DEC RSI
CMP RSI,RDI
SETA CL
AND CL,AL
CMP CL,0x1
JNZ 0x00171e06
INC RDI
LAB_00171ddc:
MOV AL,byte ptr [RDI + -0x1]
MOV CL,byte ptr [RSI]
MOV byte ptr [RDI + -0x1],CL
MOV byte ptr [RSI],AL
DEC RSI
LEA RAX,[RDI + 0x1]
CMP RDI,RSI
MOV RDI,RAX
JC 0x00171ddc
JMP 0x00171e06
LAB_00171df7:
CMP RDI,RSI
JNC 0x00171e06
LAB_00171dfc:
NOT byte ptr [RDI]
INC RDI
CMP RDI,RSI
JNZ 0x00171dfc
LAB_00171e06:
POP RBP
RET
|
void my_strxfrm_desc_and_reverse(byte *param_1,byte *param_2,uint param_3,byte param_4)
{
byte bVar1;
uint uVar2;
byte *pbVar3;
bool bVar4;
uVar2 = 0x10000 << (param_4 & 0x1f);
if (((param_3 >> (param_4 & 0x1f)) >> 8 & 1) == 0) {
param_2 = param_2 + -1;
if (param_1 < param_2 && (uVar2 & param_3) != 0) {
pbVar3 = param_1 + 1;
do {
bVar1 = pbVar3[-1];
pbVar3[-1] = *param_2;
*param_2 = bVar1;
param_2 = param_2 + -1;
bVar4 = pbVar3 < param_2;
pbVar3 = pbVar3 + 1;
} while (bVar4);
}
}
else if ((uVar2 & param_3) == 0) {
if (param_1 < param_2) {
do {
*param_1 = ~*param_1;
param_1 = param_1 + 1;
} while (param_1 != param_2);
}
}
else {
param_2 = param_2 + -1;
if (param_1 <= param_2) {
pbVar3 = param_1 + 1;
do {
bVar1 = pbVar3[-1];
pbVar3[-1] = ~*param_2;
*param_2 = ~bVar1;
param_2 = param_2 + -1;
bVar4 = pbVar3 <= param_2;
pbVar3 = pbVar3 + 1;
} while (bVar4);
}
}
return;
}
| |
22,468 | google::protobuf::RepeatedField<long>::Reserve(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | void RepeatedField<Element>::Reserve(int new_size) {
if (total_size_ >= new_size) return;
Rep* old_rep = total_size_ > 0 ? rep() : nullptr;
Rep* new_rep;
Arena* arena = GetOwningArena();
new_size = internal::CalculateReserveSize<Element, kRepHeaderSize>(
total_size_, new_size);
GOOGLE_DCHECK_LE(
static_cast<size_t>(new_size),
(std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
<< "Requested size is too large to fit into size_t.";
size_t bytes =
kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
if (arena == nullptr) {
new_rep = static_cast<Rep*>(::operator new(bytes));
} else {
new_rep = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
}
new_rep->arena = arena;
int old_total_size = total_size_;
// Already known: new_size >= internal::kMinRepeatedFieldAllocationSize
// Maintain invariant:
// total_size_ == 0 ||
// total_size_ >= internal::kMinRepeatedFieldAllocationSize
total_size_ = new_size;
arena_or_elements_ = new_rep->elements();
// Invoke placement-new on newly allocated elements. We shouldn't have to do
// this, since Element is supposed to be POD, but a previous version of this
// code allocated storage with "new Element[size]" and some code uses
// RepeatedField with non-POD types, relying on constructor invocation. If
// Element has a trivial constructor (e.g., int32_t), gcc (tested with -O2)
// completely removes this loop because the loop body is empty, so this has no
// effect unless its side-effects are required for correctness.
// Note that we do this before MoveArray() below because Element's copy
// assignment implementation will want an initialized instance first.
Element* e = &elements()[0];
Element* limit = e + total_size_;
for (; e < limit; e++) {
new (e) Element;
}
if (current_size_ > 0) {
MoveArray(&elements()[0], old_rep->elements(), current_size_);
}
// Likewise, we need to invoke destructors on the old array.
InternalDeallocate(old_rep, old_total_size, false);
} | O0 | c | google::protobuf::RepeatedField<long>::Reserve(int):
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x120(%rsp)
movl %esi, 0x11c(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x88(%rsp)
movl 0x4(%rax), %eax
cmpl 0x11c(%rsp), %eax
jl 0x20ec47
jmp 0x20f197
movq 0x88(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jle 0x20ec6c
movq 0x88(%rsp), %rdi
callq 0x20f7e0
movq %rax, 0x80(%rsp)
jmp 0x20ec78
xorl %eax, %eax
movq %rax, 0x80(%rsp)
jmp 0x20ec78
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x110(%rsp)
callq 0x20f8f0
movq %rax, %rcx
movq 0x88(%rsp), %rax
movq %rcx, 0x100(%rsp)
movl 0x4(%rax), %edi
movl 0x11c(%rsp), %esi
callq 0x210900
movl %eax, 0x11c(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x20ecc9
jmp 0x20edbb
movslq 0x11c(%rsp), %rax
movq %rax, 0x78(%rsp)
callq 0x1e6a50
movq %rax, %rcx
movq 0x78(%rsp), %rax
subq $0x8, %rcx
shrq $0x3, %rcx
movb $0x0, 0xc7(%rsp)
cmpq %rcx, %rax
ja 0x20ecfa
jmp 0x20ed6b
leaq 0x1edd7f(%rip), %rdx # 0x3fca80
leaq 0xc8(%rsp), %rdi
movq %rdi, 0x68(%rsp)
movl $0x3, %esi
movl $0x3ab, %ecx # imm = 0x3AB
callq 0x219560
movq 0x68(%rsp), %rdi
movb $0x1, 0xc7(%rsp)
leaq 0x1ede52(%rip), %rsi # 0x3fcb83
callq 0x218e20
movq %rax, 0x70(%rsp)
jmp 0x20ed3d
movq 0x70(%rsp), %rdi
leaq 0x1edeb7(%rip), %rsi # 0x3fcc00
callq 0x218e20
movq %rax, 0x60(%rsp)
jmp 0x20ed55
movq 0x60(%rsp), %rsi
leaq 0xb3(%rsp), %rdi
callq 0x218fd0
jmp 0x20ed69
jmp 0x20ed6b
testb $0x1, 0xc7(%rsp)
jne 0x20ed77
jmp 0x20ed84
leaq 0xc8(%rsp), %rdi
callq 0x2195a0
jmp 0x20ecbe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
testb $0x1, 0xc7(%rsp)
jne 0x20eda9
jmp 0x20edb6
leaq 0xc8(%rsp), %rdi
callq 0x2195a0
jmp 0x20f19f
movslq 0x11c(%rsp), %rax
shlq $0x3, %rax
addq $0x8, %rax
movq %rax, 0xa8(%rsp)
cmpq $0x0, 0x100(%rsp)
jne 0x20edf8
movq 0xa8(%rsp), %rdi
callq 0x211c0
movq %rax, 0x108(%rsp)
jmp 0x20f096
movq 0x100(%rsp), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x180(%rsp)
movq %rax, 0x178(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x58(%rsp)
callq 0x1e6a50
movq %rax, %rcx
movq 0x58(%rsp), %rax
movb $0x0, 0x13f(%rsp)
cmpq %rcx, %rax
ja 0x20ee41
jmp 0x20eeb2
leaq 0x1ee154(%rip), %rdx # 0x3fcf9c
leaq 0x140(%rsp), %rdi
movq %rdi, 0x48(%rsp)
movl $0x3, %esi
movl $0x159, %ecx # imm = 0x159
callq 0x219560
movq 0x48(%rsp), %rdi
movb $0x1, 0x13f(%rsp)
leaq 0x1ee185(%rip), %rsi # 0x3fcffd
callq 0x218e20
movq %rax, 0x50(%rsp)
jmp 0x20ee84
movq 0x50(%rsp), %rdi
leaq 0x1edd70(%rip), %rsi # 0x3fcc00
callq 0x218e20
movq %rax, 0x40(%rsp)
jmp 0x20ee9c
movq 0x40(%rsp), %rsi
leaq 0x12b(%rsp), %rdi
callq 0x218fd0
jmp 0x20eeb0
jmp 0x20eeb2
testb $0x1, 0x13f(%rsp)
jne 0x20eebe
jmp 0x20eecb
leaq 0x140(%rsp), %rdi
callq 0x2195a0
cmpq $0x0, 0x180(%rsp)
jne 0x20ef2f
movq 0x178(%rsp), %rdi
callq 0x214f0
movq %rax, 0x188(%rsp)
jmp 0x20f086
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x130(%rsp)
movl %eax, 0x12c(%rsp)
testb $0x1, 0x13f(%rsp)
jne 0x20ef10
jmp 0x20ef1d
leaq 0x140(%rsp), %rdi
callq 0x2195a0
movq 0x130(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x20f1ac
movq 0x180(%rsp), %rcx
movq 0x178(%rsp), %rax
movq %rcx, 0x1f0(%rsp)
movq %rax, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x1e8(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x1e6a50
movq %rax, %rcx
movq 0x30(%rsp), %rax
movb $0x0, 0x1af(%rsp)
cmpq %rcx, %rax
ja 0x20ef85
jmp 0x20eff6
leaq 0x1ee010(%rip), %rdx # 0x3fcf9c
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x284, %ecx # imm = 0x284
callq 0x219560
movq 0x18(%rsp), %rdi
movb $0x1, 0x1af(%rsp)
leaq 0x1ee041(%rip), %rsi # 0x3fcffd
callq 0x218e20
movq %rax, 0x20(%rsp)
jmp 0x20efc8
movq 0x20(%rsp), %rdi
leaq 0x1edc2c(%rip), %rsi # 0x3fcc00
callq 0x218e20
movq %rax, 0x10(%rsp)
jmp 0x20efe0
movq 0x10(%rsp), %rsi
leaq 0x19b(%rsp), %rdi
callq 0x218fd0
jmp 0x20eff4
jmp 0x20eff6
testb $0x1, 0x1af(%rsp)
jne 0x20f002
jmp 0x20f050
leaq 0x1b0(%rsp), %rdi
callq 0x2195a0
jmp 0x20f050
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a0(%rsp)
movl %eax, 0x19c(%rsp)
testb $0x1, 0x1af(%rsp)
jne 0x20f031
jmp 0x20f03e
leaq 0x1b0(%rsp), %rdi
callq 0x2195a0
movq 0x1a0(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x20f1ac
movq 0x28(%rsp), %rdi
movq 0x1e8(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x190(%rsp), %rsi
movl $0x1, %edx
movq 0x2e2eff(%rip), %rcx # 0x4f1f78
callq 0x215b80
movq %rax, 0x188(%rsp)
movq 0x188(%rsp), %rax
movq %rax, 0x108(%rsp)
movq 0x88(%rsp), %rax
movq 0x100(%rsp), %rdx
movq 0x108(%rsp), %rcx
movq %rdx, (%rcx)
movl 0x4(%rax), %ecx
movl %ecx, 0xa4(%rsp)
movl 0x11c(%rsp), %ecx
movl %ecx, 0x4(%rax)
movq 0x108(%rsp), %rdi
callq 0x210970
movq 0x88(%rsp), %rdi
movq %rax, 0x8(%rdi)
callq 0x20fad0
movq 0x88(%rsp), %rcx
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movslq 0x4(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rax
cmpq 0x90(%rsp), %rax
jae 0x20f136
movq 0x98(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x98(%rsp)
jmp 0x20f10e
movq 0x88(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x20f179
movq 0x88(%rsp), %rdi
callq 0x20fad0
movq %rax, 0x8(%rsp)
movq 0x110(%rsp), %rdi
callq 0x210970
movq 0x88(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movl (%rdi), %ecx
callq 0x210980
movq 0x88(%rsp), %rdi
movq 0x110(%rsp), %rsi
movl 0xa4(%rsp), %edx
xorl %ecx, %ecx
callq 0x20f750
addq $0x1f8, %rsp # imm = 0x1F8
retq
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x21700
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf13RepeatedFieldIdE7ReserveEi:
sub rsp, 1F8h
mov [rsp+1F8h+var_D8], rdi
mov [rsp+1F8h+var_DC], esi
mov rax, [rsp+1F8h+var_D8]
mov [rsp+1F8h+var_170], rax
mov eax, [rax+4]
cmp eax, [rsp+1F8h+var_DC]
jl short loc_20EC47
jmp loc_20F197
loc_20EC47:
mov rax, [rsp+1F8h+var_170]
cmp dword ptr [rax+4], 0
jle short loc_20EC6C
mov rdi, [rsp+1F8h+var_170]
call _ZNK6google8protobuf13RepeatedFieldIdE3repEv; google::protobuf::RepeatedField<double>::rep(void)
mov [rsp+1F8h+var_178], rax
jmp short loc_20EC78
loc_20EC6C:
xor eax, eax
mov [rsp+1F8h+var_178], rax
jmp short $+2
loc_20EC78:
mov rdi, [rsp+1F8h+var_170]
mov rax, [rsp+1F8h+var_178]
mov [rsp+1F8h+var_E8], rax
call _ZNK6google8protobuf13RepeatedFieldIdE14GetOwningArenaEv; google::protobuf::RepeatedField<double>::GetOwningArena(void)
mov rcx, rax
mov rax, [rsp+1F8h+var_170]
mov [rsp+1F8h+var_F8], rcx
mov edi, [rax+4]
mov esi, [rsp+1F8h+var_DC]
call _ZN6google8protobuf8internal20CalculateReserveSizeIdLi8EEEiii; google::protobuf::internal::CalculateReserveSize<double,8>(int,int)
mov [rsp+1F8h+var_DC], eax
loc_20ECBE:
xor eax, eax
test al, 1
jnz short loc_20ECC9
jmp loc_20EDBB
loc_20ECC9:
movsxd rax, [rsp+1F8h+var_DC]
mov [rsp+1F8h+var_180], rax
call _ZNSt14numeric_limitsImE3maxEv; std::numeric_limits<ulong>::max(void)
mov rcx, rax
mov rax, [rsp+1F8h+var_180]
sub rcx, 8
shr rcx, 3
mov [rsp+1F8h+var_131], 0
cmp rax, rcx
ja short loc_20ECFA
jmp short loc_20ED6B
loc_20ECFA:
lea rdx, aWorkspaceLlm4b_69; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+1F8h+var_130]
mov [rsp+1F8h+var_190], rdi
mov esi, 3
mov ecx, 3ABh
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+1F8h+var_190]
mov [rsp+1F8h+var_131], 1
lea rsi, aCheckFailedSta_0; "CHECK failed: (static_cast<size_t>(new_"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1F8h+var_188], rax
jmp short $+2
loc_20ED3D:
mov rdi, [rsp+1F8h+var_188]
lea rsi, aRequestedSizeI; "Requested size is too large to fit into"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1F8h+var_198], rax
jmp short $+2
loc_20ED55:
mov rsi, [rsp+1F8h+var_198]
lea rdi, [rsp+1F8h+var_145]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_20ED69:
jmp short $+2
loc_20ED6B:
test [rsp+1F8h+var_131], 1
jnz short loc_20ED77
jmp short loc_20ED84
loc_20ED77:
lea rdi, [rsp+1F8h+var_130]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_20ED84:
jmp loc_20ECBE
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
test [rsp+arg_BF], 1
jnz short loc_20EDA9
jmp short loc_20EDB6
loc_20EDA9:
lea rdi, [rsp+arg_C0]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_20EDB6:
jmp loc_20F19F
loc_20EDBB:
movsxd rax, [rsp+1F8h+var_DC]
shl rax, 3
add rax, 8
mov [rsp+1F8h+var_150], rax
cmp [rsp+1F8h+var_F8], 0
jnz short loc_20EDF8
mov rdi, [rsp+1F8h+var_150]; unsigned __int64
call __Znwm; operator new(ulong)
mov [rsp+1F8h+var_F0], rax
jmp loc_20F096
loc_20EDF8:
mov rcx, [rsp+1F8h+var_F8]
mov rax, [rsp+1F8h+var_150]
mov [rsp+1F8h+var_78], rcx
mov [rsp+1F8h+var_80], rax
mov rax, [rsp+1F8h+var_80]
mov [rsp+1F8h+var_1A0], rax
call _ZNSt14numeric_limitsImE3maxEv; std::numeric_limits<ulong>::max(void)
mov rcx, rax
mov rax, [rsp+1F8h+var_1A0]
mov [rsp+1F8h+var_B9], 0
cmp rax, rcx
ja short loc_20EE41
jmp short loc_20EEB2
loc_20EE41:
lea rdx, aWorkspaceLlm4b_70; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+1F8h+var_B8]
mov [rsp+1F8h+var_1B0], rdi
mov esi, 3
mov ecx, 159h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+1F8h+var_1B0]
mov [rsp+1F8h+var_B9], 1
lea rsi, aCheckFailedNum_1; "CHECK failed: (num_elements) <= (std::n"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1F8h+var_1A8], rax
jmp short $+2
loc_20EE84:
mov rdi, [rsp+1F8h+var_1A8]
lea rsi, aRequestedSizeI; "Requested size is too large to fit into"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1F8h+var_1B8], rax
jmp short $+2
loc_20EE9C:
mov rsi, [rsp+1F8h+var_1B8]
lea rdi, [rsp+1F8h+var_CD]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_20EEB0:
jmp short $+2
loc_20EEB2:
test [rsp+1F8h+var_B9], 1
jnz short loc_20EEBE
jmp short loc_20EECB
loc_20EEBE:
lea rdi, [rsp+1F8h+var_B8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_20EECB:
cmp [rsp+1F8h+var_78], 0
jnz short loc_20EF2F
mov rdi, [rsp+1F8h+var_80]; unsigned __int64
call __Znam; operator new[](ulong)
mov [rsp+1F8h+var_70], rax
jmp loc_20F086
mov rcx, rax
mov eax, edx
mov [rsp+arg_128], rcx
mov [rsp+arg_124], eax
test [rsp+arg_137], 1
jnz short loc_20EF10
jmp short loc_20EF1D
loc_20EF10:
lea rdi, [rsp+arg_138]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_20EF1D:
mov rax, [rsp+arg_128]
mov [rsp+arg_30], rax
jmp loc_20F1AC
loc_20EF2F:
mov rcx, [rsp+1F8h+var_78]
mov rax, [rsp+1F8h+var_80]
mov [rsp+1F8h+var_8], rcx
mov [rsp+1F8h+var_10], rax
mov rax, [rsp+1F8h+var_8]
mov [rsp+1F8h+var_1D0], rax
mov rax, [rsp+1F8h+var_10]
mov [rsp+1F8h+var_1C8], rax
call _ZNSt14numeric_limitsImE3maxEv; std::numeric_limits<ulong>::max(void)
mov rcx, rax
mov rax, [rsp+1F8h+var_1C8]
mov [rsp+1F8h+var_49], 0
cmp rax, rcx
ja short loc_20EF85
jmp short loc_20EFF6
loc_20EF85:
lea rdx, aWorkspaceLlm4b_70; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+1F8h+var_48]
mov [rsp+1F8h+var_1E0], rdi
mov esi, 3
mov ecx, 284h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+1F8h+var_1E0]
mov [rsp+1F8h+var_49], 1
lea rsi, aCheckFailedNum_1; "CHECK failed: (num_elements) <= (std::n"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1F8h+var_1D8], rax
jmp short $+2
loc_20EFC8:
mov rdi, [rsp+1F8h+var_1D8]
lea rsi, aRequestedSizeI; "Requested size is too large to fit into"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+1F8h+var_1E8], rax
jmp short $+2
loc_20EFE0:
mov rsi, [rsp+1F8h+var_1E8]
lea rdi, [rsp+1F8h+var_5D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_20EFF4:
jmp short $+2
loc_20EFF6:
test [rsp+1F8h+var_49], 1
jnz short loc_20F002
jmp short loc_20F050
loc_20F002:
lea rdi, [rsp+1F8h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
jmp short loc_20F050
mov rcx, rax
mov eax, edx
mov [rsp+arg_198], rcx
mov [rsp+arg_194], eax
test [rsp+arg_1A7], 1
jnz short loc_20F031
jmp short loc_20F03E
loc_20F031:
lea rdi, [rsp+arg_1A8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_20F03E:
mov rax, [rsp+arg_198]
mov [rsp+arg_30], rax
jmp loc_20F1AC
loc_20F050:
mov rdi, [rsp+1F8h+var_1D0]; this
mov rax, [rsp+1F8h+var_10]
mov [rsp+1F8h+var_68], rax
mov rsi, [rsp+1F8h+var_68]; unsigned __int64
mov edx, 1; unsigned __int64
mov rcx, cs:_ZTIc_ptr; type_info *
call _ZN6google8protobuf5Arena31AllocateAlignedWithHookForArrayEmmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithHookForArray(ulong,ulong,std::type_info const*)
mov [rsp+1F8h+var_70], rax
loc_20F086:
mov rax, [rsp+1F8h+var_70]
mov [rsp+1F8h+var_F0], rax
loc_20F096:
mov rax, [rsp+1F8h+var_170]
mov rdx, [rsp+1F8h+var_F8]
mov rcx, [rsp+1F8h+var_F0]
mov [rcx], rdx
mov ecx, [rax+4]
mov [rsp+1F8h+var_154], ecx
mov ecx, [rsp+1F8h+var_DC]
mov [rax+4], ecx
mov rdi, [rsp+1F8h+var_F0]
call _ZN6google8protobuf13RepeatedFieldIdE3Rep8elementsEv; google::protobuf::RepeatedField<double>::Rep::elements(void)
mov rdi, [rsp+1F8h+var_170]
mov [rdi+8], rax
call _ZNK6google8protobuf13RepeatedFieldIdE8elementsEv; google::protobuf::RepeatedField<double>::elements(void)
mov rcx, [rsp+1F8h+var_170]
mov [rsp+1F8h+var_160], rax
mov rax, [rsp+1F8h+var_160]
movsxd rcx, dword ptr [rcx+4]
shl rcx, 3
add rax, rcx
mov [rsp+1F8h+var_168], rax
loc_20F10E:
mov rax, [rsp+1F8h+var_160]
cmp rax, [rsp+1F8h+var_168]
jnb short loc_20F136
mov rax, [rsp+1F8h+var_160]
add rax, 8
mov [rsp+1F8h+var_160], rax
jmp short loc_20F10E
loc_20F136:
mov rax, [rsp+1F8h+var_170]
cmp dword ptr [rax], 0
jle short loc_20F179
mov rdi, [rsp+1F8h+var_170]
call _ZNK6google8protobuf13RepeatedFieldIdE8elementsEv; google::protobuf::RepeatedField<double>::elements(void)
mov [rsp+1F8h+var_1F0], rax
mov rdi, [rsp+1F8h+var_E8]
call _ZN6google8protobuf13RepeatedFieldIdE3Rep8elementsEv; google::protobuf::RepeatedField<double>::Rep::elements(void)
mov rdi, [rsp+1F8h+var_170]
mov rsi, [rsp+1F8h+var_1F0]
mov rdx, rax
mov ecx, [rdi]
call _ZN6google8protobuf13RepeatedFieldIdE9MoveArrayEPdS3_i; google::protobuf::RepeatedField<double>::MoveArray(double *,double *,int)
loc_20F179:
mov rdi, [rsp+1F8h+var_170]
mov rsi, [rsp+1F8h+var_E8]
mov edx, [rsp+1F8h+var_154]
xor ecx, ecx
call _ZN6google8protobuf13RepeatedFieldIdE18InternalDeallocateEPNS2_3RepEib; google::protobuf::RepeatedField<double>::InternalDeallocate(google::protobuf::RepeatedField<double>::Rep *,int,bool)
loc_20F197:
add rsp, 1F8h
retn
loc_20F19F:
mov rax, [rsp+arg_B0]
mov [rsp+arg_30], rax
loc_20F1AC:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
| long long google::protobuf::RepeatedField<double>::Reserve(unsigned int *a1, long long a2)
{
long long result; // rax
unsigned long long v3; // rcx
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // edx
int v9; // r8d
int v10; // r9d
long long v11; // rcx
long long v12; // rax
long long v13; // [rsp+8h] [rbp-1F0h]
long long v14; // [rsp+10h] [rbp-1E8h]
long long v15; // [rsp+20h] [rbp-1D8h]
google::protobuf::Arena *v16; // [rsp+28h] [rbp-1D0h]
unsigned long long v17; // [rsp+30h] [rbp-1C8h]
long long v18; // [rsp+50h] [rbp-1A8h]
long long v19; // [rsp+80h] [rbp-178h]
unsigned long long v20; // [rsp+90h] [rbp-168h]
unsigned long long v21; // [rsp+98h] [rbp-160h]
unsigned int v22; // [rsp+A4h] [rbp-154h]
unsigned long long v23; // [rsp+A8h] [rbp-150h]
long long OwningArena; // [rsp+100h] [rbp-F8h]
_QWORD *v25; // [rsp+108h] [rbp-F0h]
signed int v26; // [rsp+11Ch] [rbp-DCh]
char v27[20]; // [rsp+12Bh] [rbp-CDh] BYREF
char v28; // [rsp+13Fh] [rbp-B9h]
_BYTE v29[56]; // [rsp+140h] [rbp-B8h] BYREF
unsigned long long v30; // [rsp+178h] [rbp-80h]
google::protobuf::Arena *v31; // [rsp+180h] [rbp-78h]
long long AlignedWithHookForArray; // [rsp+188h] [rbp-70h]
unsigned long long v33; // [rsp+190h] [rbp-68h]
char v34[20]; // [rsp+19Bh] [rbp-5Dh] BYREF
char v35; // [rsp+1AFh] [rbp-49h]
_BYTE v36[56]; // [rsp+1B0h] [rbp-48h] BYREF
unsigned long long v37; // [rsp+1E8h] [rbp-10h]
google::protobuf::Arena *v38; // [rsp+1F0h] [rbp-8h]
result = a1[1];
if ( (int)result < (int)a2 )
{
if ( (int)a1[1] <= 0 )
v19 = 0LL;
else
v19 = google::protobuf::RepeatedField<double>::rep(a1);
OwningArena = google::protobuf::RepeatedField<double>::GetOwningArena(a1);
v26 = google::protobuf::internal::CalculateReserveSize<double,8>(a1[1], (unsigned int)a2);
v23 = 8LL * v26 + 8;
if ( OwningArena )
{
v31 = (google::protobuf::Arena *)OwningArena;
v30 = 8LL * v26 + 8;
v28 = 0;
if ( v23 > std::numeric_limits<unsigned long>::max() )
{
google::protobuf::internal::LogMessage::LogMessage(
v29,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/arena.h",
345LL);
v28 = 1;
v18 = google::protobuf::internal::LogMessage::operator<<(
v29,
"CHECK failed: (num_elements) <= (std::numeric_limits<size_t>::max() / sizeof(T)): ");
a2 = google::protobuf::internal::LogMessage::operator<<(v18, "Requested size is too large to fit into size_t.");
google::protobuf::internal::LogFinisher::operator=(v27, a2);
}
if ( (v28 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v29);
if ( v31 )
{
v38 = v31;
v37 = v30;
v16 = v31;
v17 = v30;
v3 = std::numeric_limits<unsigned long>::max();
v35 = 0;
if ( v17 > v3 )
{
google::protobuf::internal::LogMessage::LogMessage(
v36,
3LL,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/arena.h",
644LL);
v35 = 1;
v15 = google::protobuf::internal::LogMessage::operator<<(
v36,
"CHECK failed: (num_elements) <= (std::numeric_limits<size_t>::max() / sizeof(T)): ");
v14 = google::protobuf::internal::LogMessage::operator<<(
v15,
"Requested size is too large to fit into size_t.");
google::protobuf::internal::LogFinisher::operator=(v34, v14);
}
if ( (v35 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v36);
v33 = v37;
LODWORD(a2) = v37;
AlignedWithHookForArray = google::protobuf::Arena::AllocateAlignedWithHookForArray(
v16,
v37,
1uLL,
(const type_info *)&`typeinfo for'char);
}
else
{
AlignedWithHookForArray = operator new[](v30);
}
v25 = (_QWORD *)AlignedWithHookForArray;
}
else
{
v25 = (_QWORD *)operator new(v23);
}
*v25 = OwningArena;
v22 = a1[1];
a1[1] = v26;
*((_QWORD *)a1 + 1) = google::protobuf::RepeatedField<double>::Rep::elements(v25);
v21 = google::protobuf::RepeatedField<double>::elements((_DWORD)a1, a2, v4, v5, v6, v7);
v11 = 8LL * (int)a1[1];
v20 = v11 + v21;
while ( v21 < v20 )
v21 += 8LL;
if ( (int)*a1 > 0 )
{
v13 = google::protobuf::RepeatedField<double>::elements((_DWORD)a1, a2, v8, v11, v9, v10);
v12 = google::protobuf::RepeatedField<double>::Rep::elements(v19);
google::protobuf::RepeatedField<double>::MoveArray(a1, v13, v12, *a1);
}
return google::protobuf::RepeatedField<double>::InternalDeallocate(a1, v19, v22, 0LL);
}
return result;
}
| FieldRange<google::protobuf::OneofDescriptor>:
MOV qword ptr [RSP + -0x10],RDI
MOV RAX,qword ptr [RSP + -0x10]
MOV qword ptr [RSP + -0x8],RAX
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* google::protobuf::compiler::cpp::FieldRangeImpl<google::protobuf::OneofDescriptor>
google::protobuf::compiler::cpp::FieldRange<google::protobuf::OneofDescriptor>(google::protobuf::OneofDescriptor
const*) */
OneofDescriptor *
google::protobuf::compiler::cpp::FieldRange<google::protobuf::OneofDescriptor>
(OneofDescriptor *param_1)
{
return param_1;
}
| |
22,469 | google::protobuf::RepeatedField<long>::Reserve(int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | void RepeatedField<Element>::Reserve(int new_size) {
if (total_size_ >= new_size) return;
Rep* old_rep = total_size_ > 0 ? rep() : nullptr;
Rep* new_rep;
Arena* arena = GetOwningArena();
new_size = internal::CalculateReserveSize<Element, kRepHeaderSize>(
total_size_, new_size);
GOOGLE_DCHECK_LE(
static_cast<size_t>(new_size),
(std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
<< "Requested size is too large to fit into size_t.";
size_t bytes =
kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
if (arena == nullptr) {
new_rep = static_cast<Rep*>(::operator new(bytes));
} else {
new_rep = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
}
new_rep->arena = arena;
int old_total_size = total_size_;
// Already known: new_size >= internal::kMinRepeatedFieldAllocationSize
// Maintain invariant:
// total_size_ == 0 ||
// total_size_ >= internal::kMinRepeatedFieldAllocationSize
total_size_ = new_size;
arena_or_elements_ = new_rep->elements();
// Invoke placement-new on newly allocated elements. We shouldn't have to do
// this, since Element is supposed to be POD, but a previous version of this
// code allocated storage with "new Element[size]" and some code uses
// RepeatedField with non-POD types, relying on constructor invocation. If
// Element has a trivial constructor (e.g., int32_t), gcc (tested with -O2)
// completely removes this loop because the loop body is empty, so this has no
// effect unless its side-effects are required for correctness.
// Note that we do this before MoveArray() below because Element's copy
// assignment implementation will want an initialized instance first.
Element* e = &elements()[0];
Element* limit = e + total_size_;
for (; e < limit; e++) {
new (e) Element;
}
if (current_size_ > 0) {
MoveArray(&elements()[0], old_rep->elements(), current_size_);
}
// Likewise, we need to invoke destructors on the old array.
InternalDeallocate(old_rep, old_total_size, false);
} | O3 | c | google::protobuf::RepeatedField<long>::Reserve(int):
movl %esi, %edx
movq %rdi, %rsi
movl 0x4(%rdi), %edi
cmpl %edx, %edi
jl 0x103cf5
retq
pushq %rax
leaq 0x4(%rsi), %rcx
callq 0x213cf
addq $0x8, %rsp
retq
| _ZN6google8protobuf13RepeatedFieldIfE7ReserveEi:
mov edx, esi
mov rsi, rdi
mov edi, [rdi+4]
cmp edi, edx
jl short loc_103CF5
retn
loc_103CF5:
push rax
lea rcx, [rsi+4]
call _ZN6google8protobuf13RepeatedFieldIfE7ReserveEi_cold_1; google::protobuf::RepeatedField<float>::Reserve(int) [clone]
add rsp, 8
retn
| long long google::protobuf::RepeatedField<float>::Reserve(int *a1, int a2)
{
int v4; // edi
long long result; // rax
v4 = a1[1];
if ( v4 < a2 )
return google::protobuf::RepeatedField<float>::Reserve(v4, a1, a2, (unsigned int *)a1 + 1);
return result;
}
| |||
22,470 | ma_bitmap_find_new_place | eloqsql/storage/maria/ma_bitmap.c | my_bool _ma_bitmap_find_new_place(MARIA_HA *info, MARIA_ROW *row,
pgcache_page_no_t page, uint free_size,
MARIA_BITMAP_BLOCKS *blocks)
{
MARIA_SHARE *share= info->s;
my_bool res= 1;
uint position;
uint head_length, row_length, rest_length, extents_length;
ulonglong bitmap_page;
DBUG_ENTER("_ma_bitmap_find_new_place");
blocks->count= 0;
blocks->tail_page_skipped= blocks->page_skipped= 0;
row->extents_count= 0;
info->bitmap_blocks.elements= ELEMENTS_RESERVED_FOR_MAIN_PART;
mysql_mutex_lock(&share->bitmap.bitmap_lock);
/*
First allocate all blobs (so that we can find out the needed size for
the main block.
*/
if (row->blob_length && allocate_blobs(info, row))
goto abort;
/* Switch bitmap to current head page */
bitmap_page= page - page % share->bitmap.pages_covered;
if (share->bitmap.page != bitmap_page &&
_ma_change_bitmap_page(info, &share->bitmap, bitmap_page))
goto abort;
extents_length= row->extents_count * ROW_EXTENT_SIZE;
if ((head_length= (row->head_length + extents_length + 3)) <= free_size)
{
/* Main row part fits into one page */
position= ELEMENTS_RESERVED_FOR_MAIN_PART - 1;
use_head(info, page, head_length, position);
row->space_on_head_page= head_length;
goto end;
}
/* Allocate enough space */
head_length+= ELEMENTS_RESERVED_FOR_MAIN_PART * ROW_EXTENT_SIZE;
/*
The first segment size is stored in 'row_length'
We have to add ELEMENTS_RESERVED_FOR_MAIN_PART here as the extent
information may be up to this size when the header splits.
*/
row_length= find_where_to_split_row(share, row, row->extents_count +
ELEMENTS_RESERVED_FOR_MAIN_PART-1,
free_size);
position= 0;
rest_length= head_length - row_length;
if (rest_length <= MAX_TAIL_SIZE(share->block_size))
position= ELEMENTS_RESERVED_FOR_MAIN_PART -2; /* Only head and tail */
use_head(info, page, row_length, position);
row->space_on_head_page= row_length;
if (write_rest_of_head(info, position, rest_length))
goto abort;
end:
blocks->block= dynamic_element(&info->bitmap_blocks, position,
MARIA_BITMAP_BLOCK*);
blocks->block->sub_blocks= ELEMENTS_RESERVED_FOR_MAIN_PART - position;
/* First block's page_count is for all blocks */
blocks->count= info->bitmap_blocks.elements - position;
res= 0;
abort:
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
DBUG_RETURN(res);
} | O0 | c | ma_bitmap_find_new_place:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0xd(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xac(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x2c8(%rax)
movq -0x30(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0xd6ab4(%rip), %rsi # 0x11ebee
movl $0x8b1, %edx # imm = 0x8B1
callq 0x46de0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x4816c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47dd0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x4816c
jmp 0x482ef
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
xorl %edx, %edx
divq 0xb48(%rcx)
movq -0x58(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq 0xa20(%rax), %rax
cmpq -0x50(%rbp), %rax
je 0x481c6
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
movq -0x50(%rbp), %rdx
callq 0x48320
movsbl %al, %eax
cmpl $0x0, %eax
je 0x481c6
jmp 0x482ef
movq -0x10(%rbp), %rax
imull $0x7, 0xac(%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0xa0(%rax), %eax
addl -0x48(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x3c(%rbp)
cmpl -0x1c(%rbp), %eax
ja 0x48218
movl $0x3, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x3c(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x483a0
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb8(%rax)
jmp 0x482a9
movl -0x3c(%rbp), %eax
addl $0x1c, %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0xac(%rax), %edx
addl $0x4, %edx
subl $0x1, %edx
movl -0x1c(%rbp), %ecx
callq 0x47e80
movl %eax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
subl -0x40(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x30(%rbp), %rcx
imull $0x3, 0x7bc(%rcx), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
ja 0x48270
movl $0x2, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x40(%rbp), %edx
movl -0x38(%rbp), %ecx
callq 0x483a0
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb8(%rax)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x44(%rbp), %eax
movl %eax, %edx
callq 0x47f80
cmpb $0x0, %al
je 0x482a7
jmp 0x482ef
jmp 0x482a9
movq -0x8(%rbp), %rax
movq 0x2c0(%rax), %rcx
movl -0x38(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x4, %ecx
subl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x2c8(%rax), %ecx
subl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x0, -0x31(%rbp)
movq -0x30(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x47090
movb -0x31(%rbp), %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_bitmap_find_new_place:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_30], rax
mov [rbp+var_31], 1
mov rax, [rbp+var_28]
mov dword ptr [rax+8], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+0Dh], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+0Ch], 0
mov rax, [rbp+var_10]
mov dword ptr [rax+0ACh], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+2C8h], 4
mov rdi, [rbp+var_30]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_9; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 8B1h
call inline_mysql_mutex_lock_3
mov rax, [rbp+var_10]
cmp qword ptr [rax+88h], 0
jz short loc_4816C
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
call allocate_blobs
movsx eax, al
cmp eax, 0
jz short loc_4816C
jmp loc_482EF
loc_4816C:
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
xor edx, edx
div qword ptr [rcx+0B48h]
mov rax, [rbp+var_58]
sub rax, rdx
mov [rbp+var_50], rax
mov rax, [rbp+var_30]
mov rax, [rax+0A20h]
cmp rax, [rbp+var_50]
jz short loc_481C6
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
add rsi, 0A10h
mov rdx, [rbp+var_50]
call _ma_change_bitmap_page
movsx eax, al
cmp eax, 0
jz short loc_481C6
jmp loc_482EF
loc_481C6:
mov rax, [rbp+var_10]
imul eax, [rax+0ACh], 7
mov [rbp+var_48], eax
mov rax, [rbp+var_10]
mov eax, [rax+0A0h]
add eax, [rbp+var_48]
add eax, 3
mov [rbp+var_3C], eax
cmp eax, [rbp+var_1C]
ja short loc_48218
mov [rbp+var_38], 3
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_3C]
mov ecx, [rbp+var_38]
call use_head
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_10]
mov [rax+0B8h], ecx
jmp loc_482A9
loc_48218:
mov eax, [rbp+var_3C]
add eax, 1Ch
mov [rbp+var_3C], eax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_10]
mov edx, [rax+0ACh]
add edx, 4
sub edx, 1
mov ecx, [rbp+var_1C]
call find_where_to_split_row
mov [rbp+var_40], eax
mov [rbp+var_38], 0
mov eax, [rbp+var_3C]
sub eax, [rbp+var_40]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
mov rcx, [rbp+var_30]
imul ecx, [rcx+7BCh], 3
shr ecx, 2
cmp eax, ecx
ja short loc_48270
mov [rbp+var_38], 2
loc_48270:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_40]
mov ecx, [rbp+var_38]
call use_head
mov ecx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+0B8h], ecx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_38]
mov eax, [rbp+var_44]
mov edx, eax
call write_rest_of_head
cmp al, 0
jz short loc_482A7
jmp short loc_482EF
loc_482A7:
jmp short $+2
loc_482A9:
mov rax, [rbp+var_8]
mov rcx, [rax+2C0h]
mov eax, [rbp+var_38]
imul rax, 18h
add rcx, rax
mov rax, [rbp+var_28]
mov [rax], rcx
mov ecx, 4
sub ecx, [rbp+var_38]
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rax+10h], ecx
mov rax, [rbp+var_8]
mov ecx, [rax+2C8h]
sub ecx, [rbp+var_38]
mov rax, [rbp+var_28]
mov [rax+8], ecx
mov [rbp+var_31], 0
loc_482EF:
mov rdi, [rbp+var_30]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_3
mov al, [rbp+var_31]
mov [rbp+var_59], al
mov al, [rbp+var_59]
add rsp, 60h
pop rbp
retn
| char ma_bitmap_find_new_place(long long *a1, long long a2, unsigned long long a3, unsigned int a4, long long a5)
{
unsigned long long v6; // [rsp+10h] [rbp-50h]
unsigned int v7; // [rsp+1Ch] [rbp-44h]
unsigned int where_to_split_row; // [rsp+20h] [rbp-40h]
unsigned int v9; // [rsp+24h] [rbp-3Ch]
unsigned int v10; // [rsp+28h] [rbp-38h]
char v11; // [rsp+2Fh] [rbp-31h]
long long v12; // [rsp+30h] [rbp-30h]
v12 = *a1;
v11 = 1;
*(_DWORD *)(a5 + 8) = 0;
*(_BYTE *)(a5 + 13) = 0;
*(_BYTE *)(a5 + 12) = 0;
*(_DWORD *)(a2 + 172) = 0;
*((_DWORD *)a1 + 178) = 4;
inline_mysql_mutex_lock_3(
v12 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x8B1u);
if ( !*(_QWORD *)(a2 + 136) || !allocate_blobs(a1, a2) )
{
v6 = a3 - a3 % *(_QWORD *)(v12 + 2888);
if ( *(_QWORD *)(v12 + 2592) == v6 || !(unsigned __int8)ma_change_bitmap_page(a1, v12 + 2576, v6) )
{
v9 = 7 * *(_DWORD *)(a2 + 172) + *(_DWORD *)(a2 + 160) + 3;
if ( v9 <= a4 )
{
v10 = 3;
use_head(a1, a3, v9, 3LL);
*(_DWORD *)(a2 + 184) = v9;
LABEL_10:
*(_QWORD *)a5 = 24LL * v10 + a1[88];
*(_DWORD *)(*(_QWORD *)a5 + 16LL) = 4 - v10;
*(_DWORD *)(a5 + 8) = *((_DWORD *)a1 + 178) - v10;
v11 = 0;
goto LABEL_11;
}
where_to_split_row = find_where_to_split_row((unsigned int *)v12, a2, *(_DWORD *)(a2 + 172) + 3, a4);
v10 = 0;
v7 = v9 + 28 - where_to_split_row;
if ( v7 <= (unsigned int)(3 * *(_DWORD *)(v12 + 1980)) >> 2 )
v10 = 2;
use_head(a1, a3, where_to_split_row, v10);
*(_DWORD *)(a2 + 184) = where_to_split_row;
if ( !write_rest_of_head(a1, v10, v7) )
goto LABEL_10;
}
}
LABEL_11:
inline_mysql_mutex_unlock_3(v12 + 2712);
return v11;
}
| _ma_bitmap_find_new_place:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV byte ptr [RBP + -0x31],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xd],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0xc],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xac],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c8],0x4
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x21ebee]
MOV EDX,0x8b1
CALL 0x00146de0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x88],0x0
JZ 0x0014816c
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x00147dd0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0014816c
JMP 0x001482ef
LAB_0014816c:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
XOR EDX,EDX
DIV qword ptr [RCX + 0xb48]
MOV RAX,qword ptr [RBP + -0x58]
SUB RAX,RDX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0xa20]
CMP RAX,qword ptr [RBP + -0x50]
JZ 0x001481c6
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
ADD RSI,0xa10
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x00148320
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x001481c6
JMP 0x001482ef
LAB_001481c6:
MOV RAX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RAX + 0xac],0x7
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xa0]
ADD EAX,dword ptr [RBP + -0x48]
ADD EAX,0x3
MOV dword ptr [RBP + -0x3c],EAX
CMP EAX,dword ptr [RBP + -0x1c]
JA 0x00148218
MOV dword ptr [RBP + -0x38],0x3
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x3c]
MOV ECX,dword ptr [RBP + -0x38]
CALL 0x001483a0
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xb8],ECX
JMP 0x001482a9
LAB_00148218:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1c
MOV dword ptr [RBP + -0x3c],EAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xac]
ADD EDX,0x4
SUB EDX,0x1
MOV ECX,dword ptr [RBP + -0x1c]
CALL 0x00147e80
MOV dword ptr [RBP + -0x40],EAX
MOV dword ptr [RBP + -0x38],0x0
MOV EAX,dword ptr [RBP + -0x3c]
SUB EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV RCX,qword ptr [RBP + -0x30]
IMUL ECX,dword ptr [RCX + 0x7bc],0x3
SHR ECX,0x2
CMP EAX,ECX
JA 0x00148270
MOV dword ptr [RBP + -0x38],0x2
LAB_00148270:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x38]
CALL 0x001483a0
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xb8],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x44]
MOV EDX,EAX
CALL 0x00147f80
CMP AL,0x0
JZ 0x001482a7
JMP 0x001482ef
LAB_001482a7:
JMP 0x001482a9
LAB_001482a9:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x2c0]
MOV EAX,dword ptr [RBP + -0x38]
IMUL RAX,RAX,0x18
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV ECX,0x4
SUB ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x2c8]
SUB ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x8],ECX
MOV byte ptr [RBP + -0x31],0x0
LAB_001482ef:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x00147090
MOV AL,byte ptr [RBP + -0x31]
MOV byte ptr [RBP + -0x59],AL
MOV AL,byte ptr [RBP + -0x59]
ADD RSP,0x60
POP RBP
RET
|
int1
_ma_bitmap_find_new_place(long *param_1,long param_2,ulong param_3,uint param_4,long *param_5)
{
long lVar1;
char cVar2;
int iVar3;
uint uVar4;
int iVar5;
long lVar6;
uint local_40;
int1 local_39;
lVar1 = *param_1;
local_39 = 1;
*(int4 *)(param_5 + 1) = 0;
*(int1 *)((long)param_5 + 0xd) = 0;
*(int1 *)((long)param_5 + 0xc) = 0;
*(int4 *)(param_2 + 0xac) = 0;
*(int4 *)(param_1 + 0x59) = 4;
inline_mysql_mutex_lock
(lVar1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0x8b1);
if (((*(long *)(param_2 + 0x88) == 0) || (cVar2 = allocate_blobs(param_1,param_2), cVar2 == '\0'))
&& ((lVar6 = param_3 - param_3 % *(ulong *)(lVar1 + 0xb48), *(long *)(lVar1 + 0xa20) == lVar6
|| (cVar2 = _ma_change_bitmap_page(param_1,lVar1 + 0xa10,lVar6), cVar2 == '\0')))) {
iVar3 = *(int *)(param_2 + 0xa0) + *(int *)(param_2 + 0xac) * 7;
uVar4 = iVar3 + 3;
if (param_4 < uVar4) {
iVar5 = find_where_to_split_row(lVar1,param_2,*(int *)(param_2 + 0xac) + 3,param_4);
local_40 = 0;
uVar4 = (iVar3 + 0x1f) - iVar5;
if (uVar4 <= (uint)(*(int *)(lVar1 + 0x7bc) * 3) >> 2) {
local_40 = 2;
}
use_head(param_1,param_3,iVar5,local_40);
*(int *)(param_2 + 0xb8) = iVar5;
cVar2 = write_rest_of_head(param_1,local_40,uVar4);
if (cVar2 != '\0') goto LAB_001482ef;
}
else {
local_40 = 3;
use_head(param_1,param_3,uVar4,3);
*(uint *)(param_2 + 0xb8) = uVar4;
}
*param_5 = param_1[0x58] + (ulong)local_40 * 0x18;
*(uint *)(*param_5 + 0x10) = 4 - local_40;
*(uint *)(param_5 + 1) = (int)param_1[0x59] - local_40;
local_39 = 0;
}
LAB_001482ef:
inline_mysql_mutex_unlock(lVar1 + 0xa98);
return local_39;
}
| |
22,471 | mp_div_dec | bluesky950520[P]quickjs/libbf.c | static int mp_div_dec(bf_context_t *s, limb_t *tabq,
limb_t *taba, mp_size_t na,
const limb_t *tabb1, mp_size_t nb)
{
limb_t base = BF_DEC_BASE;
limb_t r, mult, t0, t1, a, c, q, v, *tabb;
mp_size_t i, j;
limb_t static_tabb[DIV_STATIC_ALLOC_LEN];
#ifdef DEBUG_DIV_SLOW
mp_print_str_dec("a", taba, na);
mp_print_str_dec("b", tabb1, nb);
#endif
/* normalize tabb */
r = tabb1[nb - 1];
assert(r != 0);
i = na - nb;
if (r >= BF_DEC_BASE / 2) {
mult = 1;
tabb = (limb_t *)tabb1;
q = 1;
for(j = nb - 1; j >= 0; j--) {
if (taba[i + j] != tabb[j]) {
if (taba[i + j] < tabb[j])
q = 0;
break;
}
}
tabq[i] = q;
if (q) {
mp_sub_dec(taba + i, taba + i, tabb, nb, 0);
}
i--;
} else {
mult = base / (r + 1);
if (likely(nb <= DIV_STATIC_ALLOC_LEN)) {
tabb = static_tabb;
} else {
tabb = bf_malloc(s, sizeof(limb_t) * nb);
if (!tabb)
return -1;
}
mp_mul1_dec(tabb, tabb1, nb, mult, 0);
taba[na] = mp_mul1_dec(taba, taba, na, mult, 0);
}
#ifdef DEBUG_DIV_SLOW
printf("mult=" FMT_LIMB "\n", mult);
mp_print_str_dec("a_norm", taba, na + 1);
mp_print_str_dec("b_norm", tabb, nb);
#endif
for(; i >= 0; i--) {
if (unlikely(taba[i + nb] >= tabb[nb - 1])) {
/* XXX: check if it is really possible */
q = base - 1;
} else {
muldq(t1, t0, taba[i + nb], base);
adddq(t1, t0, 0, taba[i + nb - 1]);
divdq(q, r, t1, t0, tabb[nb - 1]);
}
// printf("i=%d q1=%ld\n", i, q);
r = mp_sub_mul1_dec(taba + i, tabb, nb, q);
// mp_dump("r1", taba + i, nb, bd);
// printf("r2=%ld\n", r);
v = taba[i + nb];
a = v - r;
c = a > v;
if (c)
a += base;
taba[i + nb] = a;
if (c != 0) {
/* negative result */
for(;;) {
q--;
c = mp_add_dec(taba + i, taba + i, tabb, nb, 0);
/* propagate carry and test if positive result */
if (c != 0) {
if (++taba[i + nb] == base) {
break;
}
}
}
}
tabq[i] = q;
}
#ifdef DEBUG_DIV_SLOW
mp_print_str_dec("q", tabq, na - nb + 1);
mp_print_str_dec("r", taba, nb);
#endif
/* remove the normalization */
if (mult != 1) {
mp_div1_dec(taba, taba, nb, mult, 0);
if (unlikely(tabb != static_tabb))
bf_free(s, tabb);
}
return 0;
} | O1 | c | mp_div_dec:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, 0x18(%rsp)
movq -0x8(%r8,%r9,8), %rcx
movq %rbx, %r8
subq %r9, %r8
movabsq $0x4563918244f40000, %rax # imm = 0x4563918244F40000
movabsq $-0x7538dcfb76180000, %rbp # imm = 0x8AC7230489E80000
cmpq %rax, %rcx
movq %rdi, 0x20(%rsp)
jb 0x96ba5
testq %r15, %r15
jle 0x96b59
movq (%rsp), %rax
leaq (%rax,%rbx,8), %rax
addq $-0x8, %rax
movq %r15, %rcx
movq -0x8(%r14,%rcx,8), %rdx
cmpq %rdx, (%rax)
jne 0x96c0d
addq $-0x8, %rax
decq %rcx
jg 0x96b42
movq 0x18(%rsp), %rax
movq $0x1, (%rax,%r8,8)
testq %r15, %r15
jle 0x96c22
movq (%rsp), %rax
leaq (%rax,%r8,8), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rax,%rcx,8), %rsi
addq (%r14,%rcx,8), %rdx
xorl %edi, %edi
subq %rdx, %rsi
setb %dil
leaq (%rsi,%rbp), %rdx
cmovaeq %rsi, %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
movq %rdi, %rdx
cmpq %rcx, %r15
jne 0x96b7b
jmp 0x96c22
movq %r8, 0x8(%rsp)
incq %rcx
movabsq $-0x7538dcfb76180000, %rax # imm = 0x8AC7230489E80000
xorl %edx, %edx
divq %rcx
cmpq $0x11, %r15
movq %rax, 0x10(%rsp)
jge 0x96d84
movq %rax, %rcx
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rcx, %r12
xorl %r8d, %r8d
callq 0x919d1
movq (%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x919d1
movq %rax, (%r14,%rbx,8)
movq %r13, %r14
movq 0x8(%rsp), %r8
jmp 0x96c2f
setae %al
movzbl %al, %eax
movq 0x18(%rsp), %rcx
movq %rax, (%rcx,%r8,8)
jae 0x96b66
decq %r8
movl $0x1, %eax
movq %rax, 0x10(%rsp)
testq %r8, %r8
js 0x96d45
movq (%rsp), %rax
leaq (%rax,%r15,8), %r12
leaq (%rax,%r8,8), %r13
leaq -0x1(%rbp), %rax
movq %rax, 0x28(%rsp)
movabsq $0x7538dcfb76180000, %rbp # imm = 0x7538DCFB76180000
movq (%r12,%r8,8), %rax
movq -0x8(%r14,%r15,8), %rcx
movq 0x28(%rsp), %rbx
cmpq %rcx, %rax
movq %r8, 0x8(%rsp)
jae 0x96c9d
movabsq $-0x7538dcfb76180000, %rdx # imm = 0x8AC7230489E80000
mulq %rdx
addq -0x8(%r12,%r8,8), %rax
adcq $0x0, %rdx
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x9e970
movq 0x8(%rsp), %r8
movq %rax, %rbx
movq (%rsp), %rax
leaq (%rax,%r8,8), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x91b30
movq 0x8(%rsp), %r8
movq (%r12,%r8,8), %rcx
subq %rax, %rcx
movabsq $-0x7538dcfb76180000, %rdx # imm = 0x8AC7230489E80000
leaq (%rcx,%rdx), %rax
cmovaeq %rcx, %rax
movq %rax, (%r12,%r8,8)
jae 0x96d28
movq %rdx, %r9
decq %rbx
testq %r15, %r15
jle 0x96cda
xorl %eax, %eax
xorl %edx, %edx
movq (%r13,%rax,8), %rcx
addq %rcx, %rdx
addq (%r14,%rax,8), %rdx
leaq (%rdx,%rbp), %rsi
xorl %edi, %edi
cmpq %rcx, %rsi
setbe %dil
cmovbeq %rsi, %rdx
movq %rdx, (%r13,%rax,8)
incq %rax
movq %rdi, %rdx
cmpq %rax, %r15
jne 0x96ce6
cmpq %rcx, %rsi
ja 0x96cda
movq (%r12,%r8,8), %rax
incq %rax
movq %rax, (%r12,%r8,8)
cmpq %r9, %rax
jne 0x96cda
movq 0x18(%rsp), %rax
movq %rbx, (%rax,%r8,8)
leaq -0x1(%r8), %rax
addq $-0x8, %r13
testq %r8, %r8
movq %rax, %r8
jg 0x96c57
xorl %ebx, %ebx
movq 0x10(%rsp), %rcx
cmpq $0x1, %rcx
je 0x96d70
xorl %ebx, %ebx
movq (%rsp), %rdi
movq %rdi, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x91c8a
leaq 0x30(%rsp), %rax
cmpq %rax, %r14
jne 0x96db1
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r12
leaq (,%r15,8), %rdx
movq (%rdi), %rdi
xorl %esi, %esi
callq *0x8(%r12)
movq 0x10(%rsp), %rcx
movq %rax, %r13
testq %rax, %rax
jne 0x96bd3
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
jmp 0x96d70
testq %r14, %r14
je 0x96d70
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %ebx, %ebx
movq %r14, %rsi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x96d70
| mp_div_dec:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov r15, r9
mov r14, r8
mov rbx, rcx
mov [rsp+0E8h+var_E8], rdx
mov [rsp+0E8h+var_D0], rsi
mov rcx, [r8+r9*8-8]
mov r8, rbx
sub r8, r9
mov rax, 4563918244F40000h
mov rbp, 8AC7230489E80000h
cmp rcx, rax
mov [rsp+0E8h+var_C8], rdi
jb short loc_96BA5
test r15, r15
jle short loc_96B59
mov rax, [rsp+0E8h+var_E8]
lea rax, [rax+rbx*8]
add rax, 0FFFFFFFFFFFFFFF8h
mov rcx, r15
loc_96B42:
mov rdx, [r14+rcx*8-8]
cmp [rax], rdx
jnz loc_96C0D
add rax, 0FFFFFFFFFFFFFFF8h
dec rcx
jg short loc_96B42
loc_96B59:
mov rax, [rsp+0E8h+var_D0]
mov qword ptr [rax+r8*8], 1
loc_96B66:
test r15, r15
jle loc_96C22
mov rax, [rsp+0E8h+var_E8]
lea rax, [rax+r8*8]
xor ecx, ecx
xor edx, edx
loc_96B7B:
mov rsi, [rax+rcx*8]
add rdx, [r14+rcx*8]
xor edi, edi
sub rsi, rdx
setb dil
lea rdx, [rsi+rbp]
cmovnb rdx, rsi
mov [rax+rcx*8], rdx
inc rcx
mov rdx, rdi
cmp r15, rcx
jnz short loc_96B7B
jmp short loc_96C22
loc_96BA5:
mov [rsp+0E8h+var_E0], r8
inc rcx
mov rax, 8AC7230489E80000h
xor edx, edx
div rcx
cmp r15, 11h
mov [rsp+0E8h+var_D8], rax
jge loc_96D84
mov rcx, rax
lea r13, [rsp+0E8h+var_B8]
loc_96BD3:
mov rdi, r13
mov rsi, r14
mov rdx, r15
mov r12, rcx
xor r8d, r8d
call mp_mul1_dec
mov r14, [rsp+0E8h+var_E8]
mov rdi, r14
mov rsi, r14
mov rdx, rbx
mov rcx, r12
xor r8d, r8d
call mp_mul1_dec
mov [r14+rbx*8], rax
mov r14, r13
mov r8, [rsp+0E8h+var_E0]
jmp short loc_96C2F
loc_96C0D:
setnb al
movzx eax, al
mov rcx, [rsp+0E8h+var_D0]
mov [rcx+r8*8], rax
jnb loc_96B66
loc_96C22:
dec r8
mov eax, 1
mov [rsp+0E8h+var_D8], rax
loc_96C2F:
test r8, r8
js loc_96D45
mov rax, [rsp+0E8h+var_E8]
lea r12, [rax+r15*8]
lea r13, [rax+r8*8]
lea rax, [rbp-1]
mov [rsp+0E8h+var_C0], rax
mov rbp, 7538DCFB76180000h
loc_96C57:
mov rax, [r12+r8*8]
mov rcx, [r14+r15*8-8]
mov rbx, [rsp+0E8h+var_C0]
cmp rax, rcx
mov [rsp+0E8h+var_E0], r8
jnb short loc_96C9D
mov rdx, 8AC7230489E80000h
mul rdx
add rax, [r12+r8*8-8]
adc rdx, 0
mov rdi, rax
mov rsi, rdx
mov rdx, rcx
xor ecx, ecx
call __udivti3
mov r8, [rsp+0E8h+var_E0]
mov rbx, rax
loc_96C9D:
mov rax, [rsp+0E8h+var_E8]
lea rdi, [rax+r8*8]
mov rsi, r14
mov rdx, r15
mov rcx, rbx
call mp_sub_mul1_dec
mov r8, [rsp+0E8h+var_E0]
mov rcx, [r12+r8*8]
sub rcx, rax
mov rdx, 8AC7230489E80000h
lea rax, [rcx+rdx]
cmovnb rax, rcx
mov [r12+r8*8], rax
jnb short loc_96D28
mov r9, rdx
loc_96CDA:
dec rbx
test r15, r15
jle short loc_96CDA
xor eax, eax
xor edx, edx
loc_96CE6:
mov rcx, [r13+rax*8+0]
add rdx, rcx
add rdx, [r14+rax*8]
lea rsi, [rdx+rbp]
xor edi, edi
cmp rsi, rcx
setbe dil
cmovbe rdx, rsi
mov [r13+rax*8+0], rdx
inc rax
mov rdx, rdi
cmp r15, rax
jnz short loc_96CE6
cmp rsi, rcx
ja short loc_96CDA
mov rax, [r12+r8*8]
inc rax
mov [r12+r8*8], rax
cmp rax, r9
jnz short loc_96CDA
loc_96D28:
mov rax, [rsp+0E8h+var_D0]
mov [rax+r8*8], rbx
lea rax, [r8-1]
add r13, 0FFFFFFFFFFFFFFF8h
test r8, r8
mov r8, rax
jg loc_96C57
loc_96D45:
xor ebx, ebx
mov rcx, [rsp+0E8h+var_D8]
cmp rcx, 1
jz short loc_96D70
xor ebx, ebx
mov rdi, [rsp+0E8h+var_E8]
mov rsi, rdi
mov rdx, r15
xor r8d, r8d
call mp_div1_dec
lea rax, [rsp+0E8h+var_B8]
cmp r14, rax
jnz short loc_96DB1
loc_96D70:
mov eax, ebx
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_96D84:
mov r12, rdi
lea rdx, ds:0[r15*8]
mov rdi, [rdi]
xor esi, esi
call qword ptr [r12+8]
mov rcx, [rsp+0E8h+var_D8]
mov r13, rax
test rax, rax
jnz loc_96BD3
mov ebx, 0FFFFFFFFh
jmp short loc_96D70
loc_96DB1:
test r14, r14
jz short loc_96D70
mov rax, [rsp+0E8h+var_C8]
mov rdi, [rax]
xor ebx, ebx
mov rsi, r14
xor edx, edx
call qword ptr [rax+8]
jmp short loc_96D70
| long long mp_div_dec(_QWORD *a1, long long a2, long long a3, long long a4, _BYTE *a5, long long a6)
{
_BYTE *v7; // r14
unsigned long long v9; // rcx
long long v10; // r8
unsigned long long *v11; // rax
long long v12; // rcx
unsigned long long v13; // rdx
bool v14; // cf
long long v16; // rax
long long v17; // rcx
_BOOL8 v18; // rdx
unsigned long long v19; // rsi
unsigned long long v20; // rdx
bool v21; // cf
unsigned long long v22; // rsi
unsigned long long v23; // rdx
unsigned long long v24; // rcx
unsigned long long v25; // rcx
_BYTE *v26; // r13
unsigned long long v27; // r12
long long v28; // r8
long long v29; // r12
long long v30; // r13
unsigned long long v31; // rax
unsigned long long v32; // rcx
unsigned long long v33; // rbx
unsigned __int128 v34; // rdi
long long v35; // rax
unsigned long long v36; // rax
unsigned long long v37; // rcx
bool v38; // cf
unsigned long long v39; // rcx
unsigned long long v40; // rax
long long v41; // rax
_BOOL8 v42; // rdx
unsigned long long v43; // rcx
unsigned long long v44; // rdx
unsigned long long v45; // rsi
_BOOL8 v46; // rdi
long long v47; // rax
unsigned int v48; // ebx
long long v50; // rax
long long v52; // [rsp+8h] [rbp-E0h]
long long v53; // [rsp+8h] [rbp-E0h]
long long v54; // [rsp+10h] [rbp-D8h]
unsigned long long v57; // [rsp+28h] [rbp-C0h]
_BYTE v58[184]; // [rsp+30h] [rbp-B8h] BYREF
v7 = a5;
v9 = *(_QWORD *)&a5[8 * a6 - 8];
v10 = a4 - a6;
if ( v9 >= 0x4563918244F40000LL )
{
if ( a6 <= 0 )
{
LABEL_6:
*(_QWORD *)(a2 + 8 * v10) = 1LL;
}
else
{
v11 = (unsigned long long *)(a3 + 8 * a4 - 8);
v12 = a6;
while ( 1 )
{
v13 = *(_QWORD *)&v7[8 * v12 - 8];
v14 = *v11 < v13;
if ( *v11 != v13 )
break;
--v11;
if ( v12-- <= 1 )
goto LABEL_6;
}
*(_QWORD *)(a2 + 8 * v10) = *v11 >= v13;
if ( v14 )
goto LABEL_17;
}
if ( a6 > 0 )
{
v16 = a3 + 8 * v10;
v17 = 0LL;
v18 = 0LL;
do
{
v19 = *(_QWORD *)(v16 + 8 * v17);
v20 = *(_QWORD *)&v7[8 * v17] + v18;
v21 = v19 < v20;
v22 = v19 - v20;
v23 = v22 - 0x7538DCFB76180000LL;
if ( !v21 )
v23 = v22;
*(_QWORD *)(v16 + 8 * v17++) = v23;
v18 = v21;
}
while ( a6 != v17 );
}
LABEL_17:
v28 = v10 - 1;
v54 = 1LL;
goto LABEL_18;
}
v52 = a4 - a6;
v24 = v9 + 1;
v54 = 0x8AC7230489E80000LL / v24;
if ( a6 >= 17 )
{
v50 = ((long long ( *)(_QWORD, _QWORD, long long, unsigned long long, long long))a1[1])(
*a1,
0LL,
8 * a6,
v24,
v10);
v25 = v54;
v26 = (_BYTE *)v50;
if ( !v50 )
return (unsigned int)-1;
}
else
{
v25 = 0x8AC7230489E80000LL / v24;
v26 = v58;
}
v27 = v25;
mp_mul1_dec((long long)v26, (long long)v7, a6, v25, 0LL);
*(_QWORD *)(a3 + 8 * a4) = mp_mul1_dec(a3, a3, a4, v27, 0LL);
v7 = v26;
v28 = v52;
LABEL_18:
if ( v28 >= 0 )
{
v29 = a3 + 8 * a6;
v30 = a3 + 8 * v28;
v57 = 0x8AC7230489E7FFFFLL;
do
{
v31 = *(_QWORD *)(v29 + 8 * v28);
v32 = *(_QWORD *)&v7[8 * a6 - 8];
v33 = v57;
v53 = v28;
if ( v31 < v32 )
{
v34 = *(unsigned long long *)(v29 + 8 * v28 - 8) + 0x8AC7230489E80000LL * (unsigned __int128)v31;
v35 = _udivti3(v34, *((_QWORD *)&v34 + 1), v32, 0LL);
v28 = v53;
v33 = v35;
}
v36 = mp_sub_mul1_dec(a3 + 8 * v28, (long long)v7, a6, v33);
v37 = *(_QWORD *)(v29 + 8 * v53);
v38 = v37 < v36;
v39 = v37 - v36;
v40 = v39 - 0x7538DCFB76180000LL;
if ( !v38 )
v40 = v39;
*(_QWORD *)(v29 + 8 * v53) = v40;
if ( v38 )
{
while ( 1 )
{
do
--v33;
while ( a6 <= 0 );
v41 = 0LL;
v42 = 0LL;
do
{
v43 = *(_QWORD *)(v30 + 8 * v41);
v44 = *(_QWORD *)&v7[8 * v41] + v43 + v42;
v45 = v44 + 0x7538DCFB76180000LL;
v46 = v44 + 0x7538DCFB76180000LL <= v43;
if ( v44 + 0x7538DCFB76180000LL <= v43 )
v44 += 0x7538DCFB76180000LL;
*(_QWORD *)(v30 + 8 * v41++) = v44;
v42 = v46;
}
while ( a6 != v41 );
if ( v45 <= v43 )
{
v47 = *(_QWORD *)(v29 + 8 * v53) + 1LL;
*(_QWORD *)(v29 + 8 * v53) = v47;
if ( v47 == 0x8AC7230489E80000LL )
break;
}
}
}
*(_QWORD *)(a2 + 8 * v53) = v33;
v30 -= 8LL;
v28 = v53 - 1;
}
while ( v53 > 0 );
}
v48 = 0;
if ( v54 != 1 )
{
v48 = 0;
mp_div1_dec(a3, a3, a6, v54, 0LL);
if ( v7 != v58 )
{
if ( v7 )
{
v48 = 0;
((void ( *)(_QWORD, _BYTE *, _QWORD))a1[1])(*a1, v7, 0LL);
}
}
}
return v48;
}
| mp_div_dec:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R15,R9
MOV R14,R8
MOV RBX,RCX
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x18],RSI
MOV RCX,qword ptr [R8 + R9*0x8 + -0x8]
MOV R8,RBX
SUB R8,R9
MOV RAX,0x4563918244f40000
MOV RBP,-0x7538dcfb76180000
CMP RCX,RAX
MOV qword ptr [RSP + 0x20],RDI
JC 0x00196ba5
TEST R15,R15
JLE 0x00196b59
MOV RAX,qword ptr [RSP]
LEA RAX,[RAX + RBX*0x8]
ADD RAX,-0x8
MOV RCX,R15
LAB_00196b42:
MOV RDX,qword ptr [R14 + RCX*0x8 + -0x8]
CMP qword ptr [RAX],RDX
JNZ 0x00196c0d
ADD RAX,-0x8
DEC RCX
JG 0x00196b42
LAB_00196b59:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + R8*0x8],0x1
LAB_00196b66:
TEST R15,R15
JLE 0x00196c22
MOV RAX,qword ptr [RSP]
LEA RAX,[RAX + R8*0x8]
XOR ECX,ECX
XOR EDX,EDX
LAB_00196b7b:
MOV RSI,qword ptr [RAX + RCX*0x8]
ADD RDX,qword ptr [R14 + RCX*0x8]
XOR EDI,EDI
SUB RSI,RDX
SETC DIL
LEA RDX,[RSI + RBP*0x1]
CMOVNC RDX,RSI
MOV qword ptr [RAX + RCX*0x8],RDX
INC RCX
MOV RDX,RDI
CMP R15,RCX
JNZ 0x00196b7b
JMP 0x00196c22
LAB_00196ba5:
MOV qword ptr [RSP + 0x8],R8
INC RCX
MOV RAX,-0x7538dcfb76180000
XOR EDX,EDX
DIV RCX
CMP R15,0x11
MOV qword ptr [RSP + 0x10],RAX
JGE 0x00196d84
MOV RCX,RAX
LEA R13,[RSP + 0x30]
LAB_00196bd3:
MOV RDI,R13
MOV RSI,R14
MOV RDX,R15
MOV R12,RCX
XOR R8D,R8D
CALL 0x001919d1
MOV R14,qword ptr [RSP]
MOV RDI,R14
MOV RSI,R14
MOV RDX,RBX
MOV RCX,R12
XOR R8D,R8D
CALL 0x001919d1
MOV qword ptr [R14 + RBX*0x8],RAX
MOV R14,R13
MOV R8,qword ptr [RSP + 0x8]
JMP 0x00196c2f
LAB_00196c0d:
SETNC AL
MOVZX EAX,AL
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RCX + R8*0x8],RAX
JNC 0x00196b66
LAB_00196c22:
DEC R8
MOV EAX,0x1
MOV qword ptr [RSP + 0x10],RAX
LAB_00196c2f:
TEST R8,R8
JS 0x00196d45
MOV RAX,qword ptr [RSP]
LEA R12,[RAX + R15*0x8]
LEA R13,[RAX + R8*0x8]
LEA RAX,[RBP + -0x1]
MOV qword ptr [RSP + 0x28],RAX
MOV RBP,0x7538dcfb76180000
LAB_00196c57:
MOV RAX,qword ptr [R12 + R8*0x8]
MOV RCX,qword ptr [R14 + R15*0x8 + -0x8]
MOV RBX,qword ptr [RSP + 0x28]
CMP RAX,RCX
MOV qword ptr [RSP + 0x8],R8
JNC 0x00196c9d
MOV RDX,-0x7538dcfb76180000
MUL RDX
ADD RAX,qword ptr [R12 + R8*0x8 + -0x8]
ADC RDX,0x0
MOV RDI,RAX
MOV RSI,RDX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x0019e970
MOV R8,qword ptr [RSP + 0x8]
MOV RBX,RAX
LAB_00196c9d:
MOV RAX,qword ptr [RSP]
LEA RDI,[RAX + R8*0x8]
MOV RSI,R14
MOV RDX,R15
MOV RCX,RBX
CALL 0x00191b30
MOV R8,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [R12 + R8*0x8]
SUB RCX,RAX
MOV RDX,-0x7538dcfb76180000
LEA RAX,[RCX + RDX*0x1]
CMOVNC RAX,RCX
MOV qword ptr [R12 + R8*0x8],RAX
JNC 0x00196d28
MOV R9,RDX
LAB_00196cda:
DEC RBX
TEST R15,R15
JLE 0x00196cda
XOR EAX,EAX
XOR EDX,EDX
LAB_00196ce6:
MOV RCX,qword ptr [R13 + RAX*0x8]
ADD RDX,RCX
ADD RDX,qword ptr [R14 + RAX*0x8]
LEA RSI,[RDX + RBP*0x1]
XOR EDI,EDI
CMP RSI,RCX
SETBE DIL
CMOVBE RDX,RSI
MOV qword ptr [R13 + RAX*0x8],RDX
INC RAX
MOV RDX,RDI
CMP R15,RAX
JNZ 0x00196ce6
CMP RSI,RCX
JA 0x00196cda
MOV RAX,qword ptr [R12 + R8*0x8]
INC RAX
MOV qword ptr [R12 + R8*0x8],RAX
CMP RAX,R9
JNZ 0x00196cda
LAB_00196d28:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + R8*0x8],RBX
LEA RAX,[R8 + -0x1]
ADD R13,-0x8
TEST R8,R8
MOV R8,RAX
JG 0x00196c57
LAB_00196d45:
XOR EBX,EBX
MOV RCX,qword ptr [RSP + 0x10]
CMP RCX,0x1
JZ 0x00196d70
XOR EBX,EBX
MOV RDI,qword ptr [RSP]
MOV RSI,RDI
MOV RDX,R15
XOR R8D,R8D
CALL 0x00191c8a
LEA RAX,[RSP + 0x30]
CMP R14,RAX
JNZ 0x00196db1
LAB_00196d70:
MOV EAX,EBX
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00196d84:
MOV R12,RDI
LEA RDX,[R15*0x8]
MOV RDI,qword ptr [RDI]
XOR ESI,ESI
CALL qword ptr [R12 + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
MOV R13,RAX
TEST RAX,RAX
JNZ 0x00196bd3
MOV EBX,0xffffffff
JMP 0x00196d70
LAB_00196db1:
TEST R14,R14
JZ 0x00196d70
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX]
XOR EBX,EBX
MOV RSI,R14
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
JMP 0x00196d70
|
int8
mp_div_dec(int8 *param_1,long param_2,long param_3,long param_4,int1 *param_5,
long param_6)
{
bool bVar1;
int1 auVar2 [16];
int1 auVar3 [16];
ulong *puVar4;
int8 uVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
long lVar9;
int1 *puVar10;
long lVar11;
long lVar12;
ulong uVar13;
ulong uVar14;
long lVar15;
long local_d8;
long local_c0;
int1 local_b8 [136];
lVar15 = param_4 - param_6;
if (*(ulong *)(param_5 + param_6 * 8 + -8) < 5000000000000000000) {
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_5 + param_6 * 8 + -8) + 1;
local_d8 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(10000000000000000000)) / auVar2,0);
if (param_6 < 0x11) {
puVar10 = local_b8;
}
else {
puVar10 = (int1 *)(*(code *)param_1[1])(*param_1,0,param_6 * 8);
if (puVar10 == (int1 *)0x0) {
return 0xffffffff;
}
}
mp_mul1_dec(puVar10,param_5,param_6,local_d8,0);
uVar5 = mp_mul1_dec(param_3,param_3,param_4,local_d8,0);
*(int8 *)(param_3 + param_4 * 8) = uVar5;
}
else {
if (0 < param_6) {
puVar4 = (ulong *)(param_3 + param_4 * 8);
lVar11 = param_6;
do {
puVar4 = puVar4 + -1;
uVar6 = *(ulong *)(param_5 + lVar11 * 8 + -8);
uVar8 = *puVar4;
if (uVar8 != uVar6) {
*(ulong *)(param_2 + lVar15 * 8) = (ulong)(uVar6 <= uVar8);
if (uVar6 > uVar8) goto LAB_00196c22;
goto LAB_00196b66;
}
lVar12 = lVar11 + -1;
bVar1 = 0 < lVar11;
lVar11 = lVar12;
} while (lVar12 != 0 && bVar1);
}
*(int8 *)(param_2 + lVar15 * 8) = 1;
LAB_00196b66:
if (0 < param_6) {
lVar11 = param_3 + lVar15 * 8;
lVar12 = 0;
uVar6 = 0;
do {
uVar8 = *(ulong *)(lVar11 + lVar12 * 8);
uVar13 = uVar6 + *(long *)(param_5 + lVar12 * 8);
uVar6 = (ulong)(uVar8 < uVar13);
lVar7 = (uVar8 - uVar13) + -0x7538dcfb76180000;
if (uVar8 >= uVar13) {
lVar7 = uVar8 - uVar13;
}
*(long *)(lVar11 + lVar12 * 8) = lVar7;
lVar12 = lVar12 + 1;
} while (param_6 != lVar12);
}
LAB_00196c22:
lVar15 = lVar15 + -1;
local_d8 = 1;
puVar10 = param_5;
}
if (-1 < lVar15) {
lVar11 = param_3 + param_6 * 8;
lVar12 = param_3 + lVar15 * 8;
local_c0 = -0x7538dcfb76180001;
do {
uVar6 = *(ulong *)(lVar11 + lVar15 * 8);
lVar7 = local_c0;
if (uVar6 < *(ulong *)(puVar10 + param_6 * 8 + -8)) {
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar6;
uVar6 = SUB168(auVar3 * ZEXT816(10000000000000000000),0);
puVar4 = (ulong *)(lVar11 + -8 + lVar15 * 8);
lVar7 = __udivti3(uVar6 + *puVar4,
SUB168(auVar3 * ZEXT816(10000000000000000000),8) +
(ulong)CARRY8(uVar6,*puVar4),*(ulong *)(puVar10 + param_6 * 8 + -8),0);
}
uVar8 = mp_sub_mul1_dec(param_3 + lVar15 * 8,puVar10,param_6,lVar7);
uVar6 = *(ulong *)(lVar11 + lVar15 * 8);
lVar9 = (uVar6 - uVar8) + -0x7538dcfb76180000;
if (uVar8 <= uVar6) {
lVar9 = uVar6 - uVar8;
}
*(long *)(lVar11 + lVar15 * 8) = lVar9;
if (uVar8 > uVar6) {
do {
do {
lVar7 = lVar7 + -1;
} while (param_6 < 1);
lVar9 = 0;
uVar6 = 0;
do {
uVar13 = *(ulong *)(lVar12 + lVar9 * 8);
uVar14 = uVar6 + uVar13 + *(long *)(puVar10 + lVar9 * 8);
uVar8 = uVar14 + 0x7538dcfb76180000;
uVar6 = (ulong)(uVar8 <= uVar13);
if (uVar8 <= uVar13) {
uVar14 = uVar8;
}
*(ulong *)(lVar12 + lVar9 * 8) = uVar14;
lVar9 = lVar9 + 1;
} while (param_6 != lVar9);
} while ((uVar13 < uVar8) ||
(lVar9 = *(long *)(lVar11 + lVar15 * 8) + 1, *(long *)(lVar11 + lVar15 * 8) = lVar9,
lVar9 != -0x7538dcfb76180000));
}
*(long *)(param_2 + lVar15 * 8) = lVar7;
lVar12 = lVar12 + -8;
bVar1 = 0 < lVar15;
lVar15 = lVar15 + -1;
} while (bVar1);
}
if (((local_d8 != 1) && (mp_div1_dec(param_3,param_3,param_6,local_d8,0), puVar10 != local_b8)) &&
(puVar10 != (int1 *)0x0)) {
(*(code *)param_1[1])(*param_1,puVar10,0);
}
return 0;
}
| |
22,472 | mp_div_dec | bluesky950520[P]quickjs/libbf.c | static int mp_div_dec(bf_context_t *s, limb_t *tabq,
limb_t *taba, mp_size_t na,
const limb_t *tabb1, mp_size_t nb)
{
limb_t base = BF_DEC_BASE;
limb_t r, mult, t0, t1, a, c, q, v, *tabb;
mp_size_t i, j;
limb_t static_tabb[DIV_STATIC_ALLOC_LEN];
#ifdef DEBUG_DIV_SLOW
mp_print_str_dec("a", taba, na);
mp_print_str_dec("b", tabb1, nb);
#endif
/* normalize tabb */
r = tabb1[nb - 1];
assert(r != 0);
i = na - nb;
if (r >= BF_DEC_BASE / 2) {
mult = 1;
tabb = (limb_t *)tabb1;
q = 1;
for(j = nb - 1; j >= 0; j--) {
if (taba[i + j] != tabb[j]) {
if (taba[i + j] < tabb[j])
q = 0;
break;
}
}
tabq[i] = q;
if (q) {
mp_sub_dec(taba + i, taba + i, tabb, nb, 0);
}
i--;
} else {
mult = base / (r + 1);
if (likely(nb <= DIV_STATIC_ALLOC_LEN)) {
tabb = static_tabb;
} else {
tabb = bf_malloc(s, sizeof(limb_t) * nb);
if (!tabb)
return -1;
}
mp_mul1_dec(tabb, tabb1, nb, mult, 0);
taba[na] = mp_mul1_dec(taba, taba, na, mult, 0);
}
#ifdef DEBUG_DIV_SLOW
printf("mult=" FMT_LIMB "\n", mult);
mp_print_str_dec("a_norm", taba, na + 1);
mp_print_str_dec("b_norm", tabb, nb);
#endif
for(; i >= 0; i--) {
if (unlikely(taba[i + nb] >= tabb[nb - 1])) {
/* XXX: check if it is really possible */
q = base - 1;
} else {
muldq(t1, t0, taba[i + nb], base);
adddq(t1, t0, 0, taba[i + nb - 1]);
divdq(q, r, t1, t0, tabb[nb - 1]);
}
// printf("i=%d q1=%ld\n", i, q);
r = mp_sub_mul1_dec(taba + i, tabb, nb, q);
// mp_dump("r1", taba + i, nb, bd);
// printf("r2=%ld\n", r);
v = taba[i + nb];
a = v - r;
c = a > v;
if (c)
a += base;
taba[i + nb] = a;
if (c != 0) {
/* negative result */
for(;;) {
q--;
c = mp_add_dec(taba + i, taba + i, tabb, nb, 0);
/* propagate carry and test if positive result */
if (c != 0) {
if (++taba[i + nb] == base) {
break;
}
}
}
}
tabq[i] = q;
}
#ifdef DEBUG_DIV_SLOW
mp_print_str_dec("q", tabq, na - nb + 1);
mp_print_str_dec("r", taba, nb);
#endif
/* remove the normalization */
if (mult != 1) {
mp_div1_dec(taba, taba, nb, mult, 0);
if (unlikely(tabb != static_tabb))
bf_free(s, tabb);
}
return 0;
} | O2 | c | mp_div_dec:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rsi, 0x10(%rsp)
movq -0x8(%r8,%r9,8), %rcx
movq %rbx, %r13
subq %r9, %r13
movabsq $0x4563918244f40000, %rax # imm = 0x4563918244F40000
cmpq %rax, %rcx
movq %r9, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
jb 0x7df19
movq %rdx, %rbp
leaq -0x1(%r9), %rax
leaq (%rdx,%r13,8), %rdi
leaq (%rdx,%rbx,8), %rcx
addq $-0x8, %rcx
testq %rax, %rax
js 0x7df81
movq (%r15,%rax,8), %rdx
decq %rax
leaq -0x8(%rcx), %rsi
cmpq %rdx, (%rcx)
movq %rsi, %rcx
je 0x7dee7
setae %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r13,8)
jae 0x7df8e
jmp 0x7dfa3
incq %rcx
movabsq $-0x7538dcfb76180000, %rax # imm = 0x8AC7230489E80000
xorl %edx, %edx
divq %rcx
movq %rax, 0x8(%rsp)
cmpq $0x11, %r9
jge 0x7e0d4
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movq %r9, %rdx
movq 0x8(%rsp), %r14
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x79fa6
movq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x79fa6
movq (%rsp), %r9
movq %rax, (%r12,%rbx,8)
movq %rbp, %r15
movq %r12, %rbp
jmp 0x7dfae
movq 0x10(%rsp), %rax
movq $0x1, (%rax,%r13,8)
movq %rdi, %rsi
movq %r15, %rdx
movq %r9, %rcx
xorl %r8d, %r8d
callq 0x79f25
movq (%rsp), %r9
decq %r13
pushq $0x1
popq %rax
movq %rax, 0x8(%rsp)
movabsq $-0x7538dcfb76180000, %rax # imm = 0x8AC7230489E80000
leaq (,%r9,8), %r12
addq %rbp, %r12
decq %rax
movq %rax, 0x28(%rsp)
testq %r13, %r13
js 0x7e096
movq (%r12,%r13,8), %rax
movq %r15, %r14
movq -0x8(%r15,%r9,8), %rcx
movq 0x28(%rsp), %rbx
cmpq %rcx, %rax
jae 0x7e017
movabsq $-0x7538dcfb76180000, %rdx # imm = 0x8AC7230489E80000
mulq %rdx
addq -0x8(%r12,%r13,8), %rax
adcq $0x0, %rdx
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x84d00
movq (%rsp), %r9
movq %rax, %rbx
leaq (%rbp,%r13,8), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r9, %rdx
movq %rbx, %rcx
callq 0x7a10d
movq (%r12,%r13,8), %rcx
subq %rax, %rcx
movabsq $-0x7538dcfb76180000, %rax # imm = 0x8AC7230489E80000
movq %rax, %r14
leaq (%rcx,%rax), %rax
cmovaeq %rcx, %rax
movq %rax, (%r12,%r13,8)
jae 0x7e07c
decq %rbx
movq %rbp, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq (%rsp), %rcx
xorl %r8d, %r8d
callq 0x79e9e
testq %rax, %rax
je 0x7e04f
movq (%r12,%r13,8), %rax
incq %rax
movq %rax, (%r12,%r13,8)
cmpq %r14, %rax
jne 0x7e04f
movq 0x10(%rsp), %rax
movq %rbx, (%rax,%r13,8)
decq %r13
movq 0x18(%rsp), %rbp
movq (%rsp), %r9
jmp 0x7dfcb
xorl %ebx, %ebx
movq 0x8(%rsp), %rcx
cmpq $0x1, %rcx
je 0x7e0c0
xorl %ebx, %ebx
movq %rbp, %rdi
movq %rbp, %rsi
movq %r9, %rdx
xorl %r8d, %r8d
callq 0x7a238
leaq 0x30(%rsp), %rax
cmpq %rax, %r15
jne 0x7e0fe
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r12
leaq (,%r9,8), %rdx
movq (%rdi), %rdi
xorl %esi, %esi
callq *0x8(%r12)
movq (%rsp), %r9
movq %rax, %rbp
testq %rax, %rax
jne 0x7df3f
pushq $-0x1
popq %rbx
jmp 0x7e0c0
testq %r15, %r15
je 0x7e0c0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %ebx, %ebx
movq %r15, %rsi
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x7e0c0
| mp_div_dec:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0B8h
mov r15, r8
mov rbx, rcx
mov [rsp+0E8h+var_D8], rsi
mov rcx, [r8+r9*8-8]
mov r13, rbx
sub r13, r9
mov rax, 4563918244F40000h
cmp rcx, rax
mov [rsp+0E8h+var_E8], r9
mov [rsp+0E8h+var_C8], rdi
mov [rsp+0E8h+var_D0], rdx
jb short loc_7DF19
mov rbp, rdx
lea rax, [r9-1]
lea rdi, [rdx+r13*8]
lea rcx, [rdx+rbx*8]
add rcx, 0FFFFFFFFFFFFFFF8h
loc_7DEE7:
test rax, rax
js loc_7DF81
mov rdx, [r15+rax*8]
dec rax
lea rsi, [rcx-8]
cmp [rcx], rdx
mov rcx, rsi
jz short loc_7DEE7
setnb al
movzx eax, al
mov rcx, [rsp+0E8h+var_D8]
mov [rcx+r13*8], rax
jnb short loc_7DF8E
jmp loc_7DFA3
loc_7DF19:
inc rcx
mov rax, 8AC7230489E80000h
xor edx, edx
div rcx
mov [rsp+0E8h+var_E0], rax
cmp r9, 11h
jge loc_7E0D4
lea rbp, [rsp+0E8h+var_B8]
loc_7DF3F:
mov rdi, rbp
mov rsi, r15
mov rdx, r9
mov r14, [rsp+0E8h+var_E0]
mov rcx, r14
xor r8d, r8d
call mp_mul1_dec
mov r12, [rsp+0E8h+var_D0]
mov rdi, r12
mov rsi, r12
mov rdx, rbx
mov rcx, r14
xor r8d, r8d
call mp_mul1_dec
mov r9, [rsp+0E8h+var_E8]
mov [r12+rbx*8], rax
mov r15, rbp
mov rbp, r12
jmp short loc_7DFAE
loc_7DF81:
mov rax, [rsp+0E8h+var_D8]
mov qword ptr [rax+r13*8], 1
loc_7DF8E:
mov rsi, rdi
mov rdx, r15
mov rcx, r9
xor r8d, r8d
call mp_sub_dec
mov r9, [rsp+0E8h+var_E8]
loc_7DFA3:
dec r13
push 1
pop rax
mov [rsp+0E8h+var_E0], rax
loc_7DFAE:
mov rax, 8AC7230489E80000h
lea r12, ds:0[r9*8]
add r12, rbp
dec rax
mov [rsp+0E8h+var_C0], rax
loc_7DFCB:
test r13, r13
js loc_7E096
mov rax, [r12+r13*8]
mov r14, r15
mov rcx, [r15+r9*8-8]
mov rbx, [rsp+0E8h+var_C0]
cmp rax, rcx
jnb short loc_7E017
mov rdx, 8AC7230489E80000h
mul rdx
add rax, [r12+r13*8-8]
adc rdx, 0
mov rdi, rax
mov rsi, rdx
mov rdx, rcx
xor ecx, ecx
call __udivti3
mov r9, [rsp+0E8h+var_E8]
mov rbx, rax
loc_7E017:
lea rbp, [rbp+r13*8+0]
mov rdi, rbp
mov rsi, r14
mov rdx, r9
mov rcx, rbx
call mp_sub_mul1_dec
mov rcx, [r12+r13*8]
sub rcx, rax
mov rax, 8AC7230489E80000h
mov r14, rax
lea rax, [rcx+rax]
cmovnb rax, rcx
mov [r12+r13*8], rax
jnb short loc_7E07C
loc_7E04F:
dec rbx
mov rdi, rbp
mov rsi, rbp
mov rdx, r15
mov rcx, [rsp+0E8h+var_E8]
xor r8d, r8d
call mp_add_dec
test rax, rax
jz short loc_7E04F
mov rax, [r12+r13*8]
inc rax
mov [r12+r13*8], rax
cmp rax, r14
jnz short loc_7E04F
loc_7E07C:
mov rax, [rsp+0E8h+var_D8]
mov [rax+r13*8], rbx
dec r13
mov rbp, [rsp+0E8h+var_D0]
mov r9, [rsp+0E8h+var_E8]
jmp loc_7DFCB
loc_7E096:
xor ebx, ebx
mov rcx, [rsp+0E8h+var_E0]
cmp rcx, 1
jz short loc_7E0C0
xor ebx, ebx
mov rdi, rbp
mov rsi, rbp
mov rdx, r9
xor r8d, r8d
call mp_div1_dec
lea rax, [rsp+0E8h+var_B8]
cmp r15, rax
jnz short loc_7E0FE
loc_7E0C0:
mov eax, ebx
add rsp, 0B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7E0D4:
mov r12, rdi
lea rdx, ds:0[r9*8]
mov rdi, [rdi]
xor esi, esi
call qword ptr [r12+8]
mov r9, [rsp+0E8h+var_E8]
mov rbp, rax
test rax, rax
jnz loc_7DF3F
push 0FFFFFFFFFFFFFFFFh
pop rbx
jmp short loc_7E0C0
loc_7E0FE:
test r15, r15
jz short loc_7E0C0
mov rax, [rsp+0E8h+var_C8]
mov rdi, [rax]
xor ebx, ebx
mov rsi, r15
xor edx, edx
call qword ptr [rax+8]
jmp short loc_7E0C0
| long long mp_div_dec(_QWORD *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
_BYTE *v6; // r15
unsigned long long v8; // rcx
long long v9; // r13
long long v10; // rbp
long long v11; // rax
long long v12; // rdi
unsigned long long *v13; // rcx
unsigned long long v14; // rdx
bool v15; // cf
_BYTE *v17; // rbp
long long v18; // rax
long long v19; // r12
unsigned long long v20; // rax
unsigned long long v21; // rcx
unsigned long long v22; // rbx
unsigned __int128 v23; // rdi
long long v24; // rax
long long v25; // rbp
unsigned long long v26; // rax
unsigned long long v27; // rcx
bool v28; // cf
unsigned long long v29; // rcx
unsigned long long v30; // rax
long long v31; // rax
unsigned int v32; // ebx
long long v34; // rax
long long v35; // [rsp+0h] [rbp-E8h]
long long v36; // [rsp+8h] [rbp-E0h]
unsigned long long v40; // [rsp+28h] [rbp-C0h]
_BYTE v41[184]; // [rsp+30h] [rbp-B8h] BYREF
v6 = (_BYTE *)a5;
v8 = *(_QWORD *)(a5 + 8 * a6 - 8);
v9 = a4 - a6;
v35 = a6;
if ( v8 < 0x4563918244F40000LL )
{
v36 = 0x8AC7230489E80000LL / (v8 + 1);
if ( a6 >= 17 )
{
v34 = ((long long ( *)(_QWORD, _QWORD, long long))a1[1])(*a1, 0LL, 8 * a6);
a6 = v35;
v17 = (_BYTE *)v34;
if ( !v34 )
return (unsigned int)-1;
}
else
{
v17 = v41;
}
mp_mul1_dec((long long)v17, (long long)v6, a6, v36, 0LL);
v18 = mp_mul1_dec(a3, a3, a4, v36, 0LL);
a6 = v35;
*(_QWORD *)(a3 + 8 * a4) = v18;
v6 = v17;
v10 = a3;
}
else
{
v10 = a3;
v11 = a6 - 1;
v12 = a3 + 8 * v9;
v13 = (unsigned long long *)(a3 + 8 * a4 - 8);
do
{
if ( v11 < 0 )
{
*(_QWORD *)(a2 + 8 * v9) = 1LL;
goto LABEL_11;
}
v14 = *(_QWORD *)(a5 + 8 * v11--);
v15 = *v13 < v14;
}
while ( *v13-- == v14 );
*(_QWORD *)(a2 + 8 * v9) = !v15;
if ( v15 )
goto LABEL_12;
LABEL_11:
mp_sub_dec(v12, v12, a5, a6, 0LL);
a6 = v35;
LABEL_12:
--v9;
v36 = 1LL;
}
v19 = v10 + 8 * a6;
v40 = 0x8AC7230489E7FFFFLL;
while ( v9 >= 0 )
{
v20 = *(_QWORD *)(v19 + 8 * v9);
v21 = *(_QWORD *)&v6[8 * a6 - 8];
v22 = v40;
if ( v20 < v21 )
{
v23 = *(unsigned long long *)(v19 + 8 * v9 - 8) + 0x8AC7230489E80000LL * (unsigned __int128)v20;
v24 = _udivti3(v23, *((_QWORD *)&v23 + 1), v21, 0LL);
a6 = v35;
v22 = v24;
}
v25 = v10 + 8 * v9;
v26 = mp_sub_mul1_dec(v25, (long long)v6, a6, v22);
v27 = *(_QWORD *)(v19 + 8 * v9);
v28 = v27 < v26;
v29 = v27 - v26;
v30 = v29 - 0x7538DCFB76180000LL;
if ( !v28 )
v30 = v29;
*(_QWORD *)(v19 + 8 * v9) = v30;
if ( v28 )
{
do
{
do
--v22;
while ( !mp_add_dec(v25, v25, (long long)v6, v35, 0LL) );
v31 = *(_QWORD *)(v19 + 8 * v9) + 1LL;
*(_QWORD *)(v19 + 8 * v9) = v31;
}
while ( v31 != 0x8AC7230489E80000LL );
}
*(_QWORD *)(a2 + 8 * v9--) = v22;
v10 = a3;
a6 = v35;
}
v32 = 0;
if ( v36 != 1 )
{
v32 = 0;
mp_div1_dec(v10, v10, a6, v36, 0LL);
if ( v6 != v41 )
{
if ( v6 )
{
v32 = 0;
((void ( *)(_QWORD, _BYTE *, _QWORD))a1[1])(*a1, v6, 0LL);
}
}
}
return v32;
}
| mp_div_dec:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xb8
MOV R15,R8
MOV RBX,RCX
MOV qword ptr [RSP + 0x10],RSI
MOV RCX,qword ptr [R8 + R9*0x8 + -0x8]
MOV R13,RBX
SUB R13,R9
MOV RAX,0x4563918244f40000
CMP RCX,RAX
MOV qword ptr [RSP],R9
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RDX
JC 0x0017df19
MOV RBP,RDX
LEA RAX,[R9 + -0x1]
LEA RDI,[RDX + R13*0x8]
LEA RCX,[RDX + RBX*0x8]
ADD RCX,-0x8
LAB_0017dee7:
TEST RAX,RAX
JS 0x0017df81
MOV RDX,qword ptr [R15 + RAX*0x8]
DEC RAX
LEA RSI,[RCX + -0x8]
CMP qword ptr [RCX],RDX
MOV RCX,RSI
JZ 0x0017dee7
SETNC AL
MOVZX EAX,AL
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RCX + R13*0x8],RAX
JNC 0x0017df8e
JMP 0x0017dfa3
LAB_0017df19:
INC RCX
MOV RAX,-0x7538dcfb76180000
XOR EDX,EDX
DIV RCX
MOV qword ptr [RSP + 0x8],RAX
CMP R9,0x11
JGE 0x0017e0d4
LEA RBP,[RSP + 0x30]
LAB_0017df3f:
MOV RDI,RBP
MOV RSI,R15
MOV RDX,R9
MOV R14,qword ptr [RSP + 0x8]
MOV RCX,R14
XOR R8D,R8D
CALL 0x00179fa6
MOV R12,qword ptr [RSP + 0x18]
MOV RDI,R12
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R14
XOR R8D,R8D
CALL 0x00179fa6
MOV R9,qword ptr [RSP]
MOV qword ptr [R12 + RBX*0x8],RAX
MOV R15,RBP
MOV RBP,R12
JMP 0x0017dfae
LAB_0017df81:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + R13*0x8],0x1
LAB_0017df8e:
MOV RSI,RDI
MOV RDX,R15
MOV RCX,R9
XOR R8D,R8D
CALL 0x00179f25
MOV R9,qword ptr [RSP]
LAB_0017dfa3:
DEC R13
PUSH 0x1
POP RAX
MOV qword ptr [RSP + 0x8],RAX
LAB_0017dfae:
MOV RAX,-0x7538dcfb76180000
LEA R12,[R9*0x8]
ADD R12,RBP
DEC RAX
MOV qword ptr [RSP + 0x28],RAX
LAB_0017dfcb:
TEST R13,R13
JS 0x0017e096
MOV RAX,qword ptr [R12 + R13*0x8]
MOV R14,R15
MOV RCX,qword ptr [R15 + R9*0x8 + -0x8]
MOV RBX,qword ptr [RSP + 0x28]
CMP RAX,RCX
JNC 0x0017e017
MOV RDX,-0x7538dcfb76180000
MUL RDX
ADD RAX,qword ptr [R12 + R13*0x8 + -0x8]
ADC RDX,0x0
MOV RDI,RAX
MOV RSI,RDX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x00184d00
MOV R9,qword ptr [RSP]
MOV RBX,RAX
LAB_0017e017:
LEA RBP,[RBP + R13*0x8]
MOV RDI,RBP
MOV RSI,R14
MOV RDX,R9
MOV RCX,RBX
CALL 0x0017a10d
MOV RCX,qword ptr [R12 + R13*0x8]
SUB RCX,RAX
MOV RAX,-0x7538dcfb76180000
MOV R14,RAX
LEA RAX,[RCX + RAX*0x1]
CMOVNC RAX,RCX
MOV qword ptr [R12 + R13*0x8],RAX
JNC 0x0017e07c
LAB_0017e04f:
DEC RBX
MOV RDI,RBP
MOV RSI,RBP
MOV RDX,R15
MOV RCX,qword ptr [RSP]
XOR R8D,R8D
CALL 0x00179e9e
TEST RAX,RAX
JZ 0x0017e04f
MOV RAX,qword ptr [R12 + R13*0x8]
INC RAX
MOV qword ptr [R12 + R13*0x8],RAX
CMP RAX,R14
JNZ 0x0017e04f
LAB_0017e07c:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + R13*0x8],RBX
DEC R13
MOV RBP,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP]
JMP 0x0017dfcb
LAB_0017e096:
XOR EBX,EBX
MOV RCX,qword ptr [RSP + 0x8]
CMP RCX,0x1
JZ 0x0017e0c0
XOR EBX,EBX
MOV RDI,RBP
MOV RSI,RBP
MOV RDX,R9
XOR R8D,R8D
CALL 0x0017a238
LEA RAX,[RSP + 0x30]
CMP R15,RAX
JNZ 0x0017e0fe
LAB_0017e0c0:
MOV EAX,EBX
ADD RSP,0xb8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017e0d4:
MOV R12,RDI
LEA RDX,[R9*0x8]
MOV RDI,qword ptr [RDI]
XOR ESI,ESI
CALL qword ptr [R12 + 0x8]
MOV R9,qword ptr [RSP]
MOV RBP,RAX
TEST RAX,RAX
JNZ 0x0017df3f
PUSH -0x1
POP RBX
JMP 0x0017e0c0
LAB_0017e0fe:
TEST R15,R15
JZ 0x0017e0c0
MOV RAX,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RAX]
XOR EBX,EBX
MOV RSI,R15
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
JMP 0x0017e0c0
|
int4
mp_div_dec(int8 *param_1,long param_2,long param_3,long param_4,int1 *param_5,
long param_6)
{
long lVar1;
int1 auVar2 [16];
int1 auVar3 [16];
long lVar4;
int8 uVar5;
ulong uVar6;
long lVar7;
ulong uVar8;
long lVar9;
int1 *puVar10;
ulong *puVar11;
long lVar12;
long local_e0;
long local_c0;
int1 local_b8 [136];
lVar12 = param_4 - param_6;
if (*(ulong *)(param_5 + param_6 * 8 + -8) < 5000000000000000000) {
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_5 + param_6 * 8 + -8) + 1;
local_e0 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(10000000000000000000)) / auVar2,0);
if (param_6 < 0x11) {
puVar10 = local_b8;
}
else {
puVar10 = (int1 *)(*(code *)param_1[1])(*param_1,0,param_6 * 8);
if (puVar10 == (int1 *)0x0) {
return 0xffffffff;
}
}
mp_mul1_dec(puVar10,param_5,param_6,local_e0,0);
uVar5 = mp_mul1_dec(param_3,param_3,param_4,local_e0,0);
*(int8 *)(param_3 + param_4 * 8) = uVar5;
}
else {
lVar4 = param_6 + -1;
lVar7 = param_3 + lVar12 * 8;
puVar11 = (ulong *)(param_3 + param_4 * 8);
do {
puVar11 = puVar11 + -1;
if (lVar4 < 0) {
*(int8 *)(param_2 + lVar12 * 8) = 1;
goto LAB_0017df8e;
}
uVar6 = *(ulong *)(param_5 + lVar4 * 8);
lVar4 = lVar4 + -1;
uVar8 = *puVar11;
} while (uVar8 == uVar6);
*(ulong *)(param_2 + lVar12 * 8) = (ulong)(uVar6 <= uVar8);
if (uVar6 <= uVar8) {
LAB_0017df8e:
mp_sub_dec(lVar7,lVar7,param_5,param_6,0);
}
lVar12 = lVar12 + -1;
local_e0 = 1;
puVar10 = param_5;
}
lVar4 = param_6 * 8 + param_3;
local_c0 = -0x7538dcfb76180001;
for (; -1 < lVar12; lVar12 = lVar12 + -1) {
uVar6 = *(ulong *)(lVar4 + lVar12 * 8);
lVar7 = local_c0;
if (uVar6 < *(ulong *)(puVar10 + param_6 * 8 + -8)) {
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar6;
uVar6 = SUB168(auVar3 * ZEXT816(10000000000000000000),0);
puVar11 = (ulong *)(lVar4 + -8 + lVar12 * 8);
lVar7 = __udivti3(uVar6 + *puVar11,
SUB168(auVar3 * ZEXT816(10000000000000000000),8) +
(ulong)CARRY8(uVar6,*puVar11),*(ulong *)(puVar10 + param_6 * 8 + -8),0);
}
lVar1 = param_3 + lVar12 * 8;
uVar8 = mp_sub_mul1_dec(lVar1,puVar10,param_6,lVar7);
uVar6 = *(ulong *)(lVar4 + lVar12 * 8);
lVar9 = (uVar6 - uVar8) + -0x7538dcfb76180000;
if (uVar8 <= uVar6) {
lVar9 = uVar6 - uVar8;
}
*(long *)(lVar4 + lVar12 * 8) = lVar9;
if (uVar8 > uVar6) {
do {
do {
lVar7 = lVar7 + -1;
lVar9 = mp_add_dec(lVar1,lVar1,puVar10,param_6);
} while (lVar9 == 0);
lVar9 = *(long *)(lVar4 + lVar12 * 8) + 1;
*(long *)(lVar4 + lVar12 * 8) = lVar9;
} while (lVar9 != -0x7538dcfb76180000);
}
*(long *)(param_2 + lVar12 * 8) = lVar7;
}
if (((local_e0 != 1) && (mp_div1_dec(param_3,param_3,param_6,local_e0,0), puVar10 != local_b8)) &&
(puVar10 != (int1 *)0x0)) {
(*(code *)param_1[1])(*param_1,puVar10,0);
}
return 0;
}
| |
22,473 | js_setlike_get_has | bluesky950520[P]quickjs/quickjs.c | static int js_setlike_get_has(JSContext *ctx, JSValue setlike, JSValue *pout)
{
JSValue v;
v = JS_GetProperty(ctx, setlike, JS_ATOM_has);
if (JS_IsException(v))
return -1;
if (JS_IsUndefined(v)) {
JS_ThrowTypeError(ctx, ".has is undefined");
return -1;
}
if (!JS_IsFunction(ctx, v)) {
JS_ThrowTypeError(ctx, ".has is not a function");
JS_FreeValue(ctx, v);
return -1;
}
*pout = v;
return 0;
} | O1 | c | js_setlike_get_has:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdi, %r14
movl $0x64, %ecx
movq %rsi, %r8
movq %rdx, %r9
pushq $0x0
pushq $0x0
callq 0x22fa3
addq $0x10, %rsp
movq %rdx, %r12
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpl $0x6, %r12d
je 0x51f4b
cmpl $0x3, %r12d
jne 0x51f0b
leaq 0x4e358(%rip), %rsi # 0xa0257
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
jmp 0x51f4b
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x22dbe
testl %eax, %eax
je 0x51f2b
movq %r13, (%r15)
movq %r12, 0x8(%r15)
xorl %ebx, %ebx
jmp 0x51f4b
leaq 0x4e337(%rip), %rsi # 0xa0269
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d8c6
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_setlike_get_has:
push r15
push r14
push r13
push r12
push rbx
mov r15, rcx
mov r14, rdi
mov ecx, 64h ; 'd'
mov r8, rsi
mov r9, rdx
push 0
push 0
call JS_GetPropertyInternal2
add rsp, 10h
mov r12, rdx
mov ebx, 0FFFFFFFFh
cmp r12d, 6
jz short loc_51F4B
cmp r12d, 3
jnz short loc_51F0B
lea rsi, aHasIsUndefined; ".has is undefined"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp short loc_51F4B
loc_51F0B:
mov r13, rax
mov rdi, r14
mov rsi, rax
mov rdx, r12
call JS_IsFunction
test eax, eax
jz short loc_51F2B
mov [r15], r13
mov [r15+8], r12
xor ebx, ebx
jmp short loc_51F4B
loc_51F2B:
lea rsi, aHasIsNotAFunct; ".has is not a function"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
loc_51F4B:
mov eax, ebx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long js_setlike_get_has(
long long a1,
long long a2,
long long a3,
_QWORD *a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
unsigned long long PropertyInternal2; // rax
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
long long v20; // r12
unsigned int v21; // ebx
_DWORD *v22; // r13
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
char v30; // [rsp+0h] [rbp-28h]
PropertyInternal2 = JS_GetPropertyInternal2(a1, a2, a3, 0x64u, a2, a3, 0LL, 0);
v20 = v14;
v21 = -1;
if ( (_DWORD)v14 != 6 )
{
if ( (_DWORD)v14 == 3 )
{
JS_ThrowTypeError(a1, (long long)".has is undefined", v14, v15, v16, v17, a5, a6, a7, a8, v18, v19, a11, a12, v30);
}
else
{
v22 = (_DWORD *)PropertyInternal2;
if ( (unsigned int)JS_IsFunction(a1, PropertyInternal2, v14) )
{
*a4 = v22;
a4[1] = v20;
return 0;
}
else
{
JS_ThrowTypeError(
a1,
(long long)".has is not a function",
v23,
v24,
v25,
v26,
a5,
a6,
a7,
a8,
v27,
v28,
a11,
a12,
v30);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v22, v20);
}
}
}
return v21;
}
| js_setlike_get_has:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RCX
MOV R14,RDI
MOV ECX,0x64
MOV R8,RSI
MOV R9,RDX
PUSH 0x0
PUSH 0x0
CALL 0x00122fa3
ADD RSP,0x10
MOV R12,RDX
MOV EBX,0xffffffff
CMP R12D,0x6
JZ 0x00151f4b
CMP R12D,0x3
JNZ 0x00151f0b
LEA RSI,[0x1a0257]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
JMP 0x00151f4b
LAB_00151f0b:
MOV R13,RAX
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R12
CALL 0x00122dbe
TEST EAX,EAX
JZ 0x00151f2b
MOV qword ptr [R15],R13
MOV qword ptr [R15 + 0x8],R12
XOR EBX,EBX
JMP 0x00151f4b
LAB_00151f2b:
LEA RSI,[0x1a0269]
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R13
MOV RDX,R12
CALL 0x0011d8c6
LAB_00151f4b:
MOV EAX,EBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8
js_setlike_get_has(long param_1,int8 param_2,int8 param_3,int1 (*param_4) [16])
{
int iVar1;
int8 uVar2;
int1 auVar3 [16];
auVar3 = JS_GetPropertyInternal2();
uVar2 = 0xffffffff;
if (auVar3._8_4_ != 6) {
if (auVar3._8_4_ == 3) {
JS_ThrowTypeError(param_1,".has is int");
}
else {
iVar1 = JS_IsFunction(param_1,auVar3._0_8_,auVar3._8_8_);
if (iVar1 == 0) {
JS_ThrowTypeError(param_1,".has is not a function");
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar3._0_8_,auVar3._8_8_);
}
else {
*param_4 = auVar3;
uVar2 = 0;
}
}
}
return uVar2;
}
| |
22,474 | js_setlike_get_has | bluesky950520[P]quickjs/quickjs.c | static int js_setlike_get_has(JSContext *ctx, JSValue setlike, JSValue *pout)
{
JSValue v;
v = JS_GetProperty(ctx, setlike, JS_ATOM_has);
if (JS_IsException(v))
return -1;
if (JS_IsUndefined(v)) {
JS_ThrowTypeError(ctx, ".has is undefined");
return -1;
}
if (!JS_IsFunction(ctx, v)) {
JS_ThrowTypeError(ctx, ".has is not a function");
JS_FreeValue(ctx, v);
return -1;
}
*pout = v;
return 0;
} | O2 | c | js_setlike_get_has:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdi, %r14
pushq $0x64
popq %rcx
callq 0x1b043
movq %rdx, %r15
pushq $-0x1
popq %rbx
cmpl $0x6, %r15d
je 0x4654c
cmpl $0x3, %r15d
jne 0x4650b
leaq 0x40c92(%rip), %rsi # 0x87191
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c64d
jmp 0x4654c
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1ce7d
testl %eax, %eax
je 0x4652d
movq %r13, (%r12)
movq %r15, 0x8(%r12)
xorl %ebx, %ebx
jmp 0x4654c
leaq 0x40c6f(%rip), %rsi # 0x871a3
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c64d
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1801e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_setlike_get_has:
push r15
push r14
push r13
push r12
push rbx
mov r12, rcx
mov r14, rdi
push 64h ; 'd'
pop rcx
call JS_GetProperty
mov r15, rdx
push 0FFFFFFFFFFFFFFFFh
pop rbx
cmp r15d, 6
jz short loc_4654C
cmp r15d, 3
jnz short loc_4650B
lea rsi, aHasIsUndefined; ".has is undefined"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp short loc_4654C
loc_4650B:
mov r13, rax
mov rdi, r14
mov rsi, rax
mov rdx, r15
call JS_IsFunction
test eax, eax
jz short loc_4652D
mov [r12], r13
mov [r12+8], r15
xor ebx, ebx
jmp short loc_4654C
loc_4652D:
lea rsi, aHasIsNotAFunct; ".has is not a function"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov rdi, r14
mov rsi, r13
mov rdx, r15
call JS_FreeValue
loc_4654C:
mov eax, ebx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long js_setlike_get_has(
long long a1,
int a2,
int a3,
long long *a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
long long Property; // rax
long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
__m128 v18; // xmm4
__m128 v19; // xmm5
long long v20; // r15
unsigned int v21; // ebx
long long v22; // r13
long long v23; // rdx
long long v24; // rcx
long long v25; // r8
long long v26; // r9
__m128 v27; // xmm4
__m128 v28; // xmm5
char v30; // [rsp+0h] [rbp-28h]
Property = JS_GetProperty(a1, a2, a3, 100);
v20 = v14;
v21 = -1;
if ( (_DWORD)v14 != 6 )
{
if ( (_DWORD)v14 == 3 )
{
JS_ThrowTypeError(a1, (long long)".has is undefined", v14, v15, v16, v17, a5, a6, a7, a8, v18, v19, a11, a12, v30);
}
else
{
v22 = Property;
if ( (unsigned int)JS_IsFunction(a1, Property, v14) )
{
*a4 = v22;
a4[1] = v20;
return 0;
}
else
{
JS_ThrowTypeError(
a1,
(long long)".has is not a function",
v23,
v24,
v25,
v26,
a5,
a6,
a7,
a8,
v27,
v28,
a11,
a12,
v30);
JS_FreeValue(a1, v22, v20);
}
}
}
return v21;
}
| js_setlike_get_has:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R12,RCX
MOV R14,RDI
PUSH 0x64
POP RCX
CALL 0x0011b043
MOV R15,RDX
PUSH -0x1
POP RBX
CMP R15D,0x6
JZ 0x0014654c
CMP R15D,0x3
JNZ 0x0014650b
LEA RSI,[0x187191]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011c64d
JMP 0x0014654c
LAB_0014650b:
MOV R13,RAX
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R15
CALL 0x0011ce7d
TEST EAX,EAX
JZ 0x0014652d
MOV qword ptr [R12],R13
MOV qword ptr [R12 + 0x8],R15
XOR EBX,EBX
JMP 0x0014654c
LAB_0014652d:
LEA RSI,[0x1871a3]
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011c64d
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
CALL 0x0011801e
LAB_0014654c:
MOV EAX,EBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int4
js_setlike_get_has(int8 param_1,int8 param_2,int8 param_3,
int1 (*param_4) [16])
{
int iVar1;
int4 uVar2;
int1 auVar3 [16];
auVar3 = JS_GetProperty();
uVar2 = 0xffffffff;
if (auVar3._8_4_ != 6) {
if (auVar3._8_4_ == 3) {
JS_ThrowTypeError(param_1,".has is int");
}
else {
iVar1 = JS_IsFunction(param_1,auVar3._0_8_,auVar3._8_8_);
if (iVar1 == 0) {
JS_ThrowTypeError(param_1,".has is not a function");
JS_FreeValue(param_1,auVar3._0_8_,auVar3._8_8_);
}
else {
*param_4 = auVar3;
uVar2 = 0;
}
}
}
return uVar2;
}
| |
22,475 | fail(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | msxemulator/build_O3/_deps/picotool-src/errors/errors.cpp | void fail(int code, std::string msg) {
throw command_failure(code, std::move(msg));
} | O3 | cpp | fail(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movl %edi, %ebx
movl $0x30, %edi
callq 0xf260
movq %rax, %rdi
leaq 0x10(%rsp), %r15
movq (%r14), %rcx
leaq 0x10(%r14), %rsi
cmpq %rsi, %rcx
jne 0x7b3f8
movups (%rsi), %xmm0
movups %xmm0, (%r15)
movq %r15, %rcx
jmp 0x7b404
movq %rcx, (%rsp)
movq (%rsi), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%r14), %rdx
movq %rsi, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x66a31(%rip), %rsi # 0xe1e50
movq %rsi, (%rdi)
movl %ebx, 0x8(%rdi)
addq $0x20, %rax
movq %rax, 0x10(%rdi)
cmpq %r15, %rcx
jne 0x7b43b
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x7b448
movq %rcx, 0x10(%rdi)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rdi)
movq %rdx, 0x18(%rdi)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x64543(%rip), %rsi # 0xdf9a8
leaq 0x118(%rip), %rdx # 0x7b584
callq 0xf790
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7b48a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf7d0
| _Z4failiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
sub rsp, 20h
mov r14, rsi
mov ebx, edi
mov edi, 30h ; '0'; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; void *
lea r15, [rsp+38h+var_28]
mov rcx, [r14]
lea rsi, [r14+10h]
cmp rcx, rsi
jnz short loc_7B3F8
movups xmm0, xmmword ptr [rsi]
movups xmmword ptr [r15], xmm0
mov rcx, r15
jmp short loc_7B404
loc_7B3F8:
mov [rsp+38h+var_38], rcx
mov rdx, [rsi]
mov [rsp+38h+var_28], rdx
loc_7B404:
mov rdx, [r14+8]
mov [r14], rsi
mov qword ptr [r14+8], 0
mov byte ptr [r14+10h], 0
lea rsi, off_E1E50
mov [rdi], rsi
mov [rdi+8], ebx
add rax, 20h ; ' '
mov [rdi+10h], rax
cmp rcx, r15
jnz short loc_7B43B
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
jmp short loc_7B448
loc_7B43B:
mov [rdi+10h], rcx
mov rax, [rsp+38h+var_28]
mov [rdi+20h], rax
loc_7B448:
mov [rdi+18h], rdx
mov [rsp+38h+var_38], r15
mov [rsp+38h+var_30], 0
mov byte ptr [rsp+38h+var_28], 0
lea rsi, _ZTI15command_failure; lptinfo
lea rdx, _ZN15command_failureD2Ev; void (*)(void *)
call ___cxa_throw
mov rbx, rax
mov rdi, [rsp+38h+var_38]; void *
cmp rdi, r15
jz short loc_7B48A
mov rsi, [rsp+38h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B48A:
mov rdi, rbx
call __Unwind_Resume
| void __noreturn fail(int a1, long long a2)
{
char *exception; // rax
_QWORD *v5; // rdi
_OWORD *v6; // rcx
_OWORD *v7; // rsi
long long v8; // rdx
_OWORD *v9; // rax
_OWORD v10[2]; // [rsp+10h] [rbp-28h] BYREF
exception = (char *)__cxa_allocate_exception(0x30uLL);
v5 = exception;
v6 = *(_OWORD **)a2;
v7 = (_OWORD *)(a2 + 16);
if ( *(_QWORD *)a2 == a2 + 16 )
{
v10[0] = *v7;
v6 = v10;
}
else
{
*(_QWORD *)&v10[0] = *(_QWORD *)v7;
}
v8 = *(_QWORD *)(a2 + 8);
*(_QWORD *)a2 = v7;
*(_QWORD *)(a2 + 8) = 0LL;
*(_BYTE *)(a2 + 16) = 0;
*(_QWORD *)exception = off_E1E50;
*((_DWORD *)exception + 2) = a1;
v9 = exception + 32;
v5[2] = v9;
if ( v6 == v10 )
{
*v9 = v10[0];
}
else
{
v5[2] = v6;
v5[4] = *(_QWORD *)&v10[0];
}
v5[3] = v8;
LOBYTE(v10[0]) = 0;
__cxa_throw(v5, (struct type_info *)&`typeinfo for'command_failure, command_failure::~command_failure);
}
| fail:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x20
MOV R14,RSI
MOV EBX,EDI
MOV EDI,0x30
CALL 0x0010f260
MOV RDI,RAX
LEA R15,[RSP + 0x10]
MOV RCX,qword ptr [R14]
LEA RSI,[R14 + 0x10]
CMP RCX,RSI
JNZ 0x0017b3f8
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS xmmword ptr [R15],XMM0
MOV RCX,R15
JMP 0x0017b404
LAB_0017b3f8:
MOV qword ptr [RSP],RCX
MOV RDX,qword ptr [RSI]
MOV qword ptr [RSP + 0x10],RDX
LAB_0017b404:
MOV RDX,qword ptr [R14 + 0x8]
MOV qword ptr [R14],RSI
MOV qword ptr [R14 + 0x8],0x0
MOV byte ptr [R14 + 0x10],0x0
LEA RSI,[0x1e1e50]
MOV qword ptr [RDI],RSI
MOV dword ptr [RDI + 0x8],EBX
ADD RAX,0x20
MOV qword ptr [RDI + 0x10],RAX
CMP RCX,R15
JNZ 0x0017b43b
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
JMP 0x0017b448
LAB_0017b43b:
MOV qword ptr [RDI + 0x10],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RDI + 0x20],RAX
LAB_0017b448:
MOV qword ptr [RDI + 0x18],RDX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LAB_0017b45e:
LEA RSI,[0x1df9a8]
LEA RDX,[0x17b584]
CALL 0x0010f790
|
/* fail(int, std::__cxx11::string) */
void fail(int4 param_1,long *param_2)
{
ulong *puVar1;
long lVar2;
int8 *puVar3;
ulong *puVar4;
int8 local_28;
int4 uStack_20;
int4 uStack_1c;
puVar3 = (int8 *)__cxa_allocate_exception(0x30);
puVar4 = (ulong *)*param_2;
puVar1 = (ulong *)(param_2 + 2);
if (puVar4 == puVar1) {
local_28 = *puVar1;
uStack_20 = (int4)param_2[3];
uStack_1c = *(int4 *)((long)param_2 + 0x1c);
puVar4 = &local_28;
}
else {
local_28 = *puVar1;
}
lVar2 = param_2[1];
*param_2 = (long)puVar1;
param_2[1] = 0;
*(int1 *)(param_2 + 2) = 0;
*puVar3 = &PTR__command_failure_001e1e50;
*(int4 *)(puVar3 + 1) = param_1;
puVar3[2] = puVar3 + 4;
if (puVar4 == &local_28) {
*(int4 *)(puVar3 + 4) = (int4)local_28;
*(int4 *)((long)puVar3 + 0x24) = local_28._4_4_;
*(int4 *)(puVar3 + 5) = uStack_20;
*(int4 *)((long)puVar3 + 0x2c) = uStack_1c;
}
else {
puVar3[2] = puVar4;
puVar3[4] = local_28;
}
puVar3[3] = lVar2;
local_28 = local_28 & 0xffffffffffffff00;
/* try { // try from 0017b45e to 0017b470 has its CatchHandler @ 0017b471 */
/* WARNING: Subroutine does not return */
__cxa_throw(puVar3,&command_failure::typeinfo,command_failure::~command_failure);
}
| |
22,476 | JS_IsCFunction | bluesky950520[P]quickjs/quickjs.c | BOOL JS_IsCFunction(JSContext *ctx, JSValue val, JSCFunction *func, int magic)
{
JSObject *p;
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT)
return FALSE;
p = JS_VALUE_GET_OBJ(val);
if (p->class_id == JS_CLASS_C_FUNCTION)
return (p->u.cfunc.c_function.generic == func && p->u.cfunc.magic == magic);
else
return FALSE;
} | O3 | c | JS_IsCFunction:
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x26fc3
cmpw $0xc, 0x6(%rsi)
jne 0x26fc3
cmpq %rcx, 0x38(%rsi)
je 0x26fc4
retq
movswl 0x42(%rsi), %ecx
xorl %eax, %eax
cmpl %r8d, %ecx
sete %al
retq
| JS_IsCFunction:
xor eax, eax
cmp edx, 0FFFFFFFFh
jnz short locret_26FC3
cmp word ptr [rsi+6], 0Ch
jnz short locret_26FC3
cmp [rsi+38h], rcx
jz short loc_26FC4
locret_26FC3:
retn
loc_26FC4:
movsx ecx, word ptr [rsi+42h]
xor eax, eax
cmp ecx, r8d
setz al
retn
| _BOOL8 JS_IsCFunction(long long a1, long long a2, int a3, long long a4, int a5)
{
_BOOL8 result; // rax
result = 0LL;
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 12 && *(_QWORD *)(a2 + 56) == a4 )
return *(__int16 *)(a2 + 66) == a5;
return result;
}
| JS_IsCFunction:
XOR EAX,EAX
CMP EDX,-0x1
JNZ 0x00126fc3
CMP word ptr [RSI + 0x6],0xc
JNZ 0x00126fc3
CMP qword ptr [RSI + 0x38],RCX
JZ 0x00126fc4
LAB_00126fc3:
RET
LAB_00126fc4:
MOVSX ECX,word ptr [RSI + 0x42]
XOR EAX,EAX
CMP ECX,R8D
SETZ AL
RET
|
bool JS_IsCFunction(int8 param_1,long param_2,int param_3,long param_4,int param_5)
{
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0xc)) &&
(*(long *)(param_2 + 0x38) == param_4)) {
return *(short *)(param_2 + 0x42) == param_5;
}
return false;
}
| |
22,477 | nglog::tools::ReadFromOffset(int, void*, unsigned long, unsigned long) | ng-log[P]ng-log/src/symbolize.cc | static ssize_t ReadFromOffset(const int fd, void* buf, const size_t count,
const size_t offset) {
NGLOG_SAFE_ASSERT(fd >= 0);
NGLOG_SAFE_ASSERT(count <=
static_cast<size_t>(std::numeric_limits<ssize_t>::max()));
char* buf0 = reinterpret_cast<char*>(buf);
size_t num_bytes = 0;
while (num_bytes < count) {
ssize_t len = FailureRetry([fd, p = buf0 + num_bytes, n = count - num_bytes,
m = static_cast<off_t>(offset + num_bytes)] {
return pread(fd, p, n, m);
});
if (len < 0) { // There was an error other than EINTR.
return -1;
}
if (len == 0) { // Reached EOF.
break;
}
num_bytes += static_cast<size_t>(len);
}
NGLOG_SAFE_ASSERT(num_bytes <= count);
return static_cast<ssize_t>(num_bytes);
} | O1 | cpp | nglog::tools::ReadFromOffset(int, void*, unsigned long, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testl %edi, %edi
js 0x2152c
testq %rdx, %rdx
js 0x2152c
movl %edi, %ebp
xorl %r14d, %r14d
movq %rdx, (%rsp)
movq %rdx, %rbx
subq %r14, %rbx
jbe 0x21527
movq 0x8(%rsp), %rax
leaq (%rax,%r14), %r12
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %r15
movl %ebp, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x7690
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x214fb
callq 0x7050
cmpl $0x4, (%rax)
je 0x214d8
xorl %eax, %eax
testq %r13, %r13
sete %al
leal (%rax,%rax,2), %eax
movl $0x0, %ecx
cmovleq %rcx, %r13
movl $0x1, %ecx
cmovsl %ecx, %eax
addq %r13, %r14
testl %eax, %eax
movq (%rsp), %rdx
je 0x214be
cmpl $0x3, %eax
jne 0x21531
cmpq %rdx, %r14
jbe 0x21538
callq 0x72c0
movq $-0x1, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN5nglog5toolsL14ReadFromOffsetEiPvmm:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rsp+48h+var_38], rcx
mov [rsp+48h+var_40], rsi
test edi, edi
js short loc_2152C
test rdx, rdx
js short loc_2152C
mov ebp, edi
xor r14d, r14d
mov [rsp+48h+var_48], rdx
loc_214BE:
mov rbx, rdx
sub rbx, r14
jbe short loc_21527
mov rax, [rsp+48h+var_40]
lea r12, [rax+r14]
mov rax, [rsp+48h+var_38]
lea r15, [r14+rax]
loc_214D8:
mov edi, ebp
mov rsi, r12
mov rdx, rbx
mov rcx, r15
call _pread
mov r13, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_214FB
call ___errno_location
cmp dword ptr [rax], 4
jz short loc_214D8
loc_214FB:
xor eax, eax
test r13, r13
setz al
lea eax, [rax+rax*2]
mov ecx, 0
cmovle r13, rcx
mov ecx, 1
cmovs eax, ecx
add r14, r13
test eax, eax
mov rdx, [rsp+48h+var_48]
jz short loc_214BE
cmp eax, 3
jnz short loc_21531
loc_21527:
cmp r14, rdx
jbe short loc_21538
loc_2152C:
call _abort
loc_21531:
mov r14, 0FFFFFFFFFFFFFFFFh
loc_21538:
mov rax, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| unsigned long long nglog::tools::ReadFromOffset(unsigned long long this, long long a2, char *a3, long long a4)
{
unsigned int v4; // ebp
unsigned long long v5; // r14
char *v6; // rbx
long long v7; // r13
bool v8; // sf
int v9; // eax
char *v11; // [rsp+0h] [rbp-48h]
if ( (this & 0x80000000) != 0LL || (long long)a3 < 0 )
LABEL_14:
abort(this);
v4 = this;
v5 = 0LL;
v11 = a3;
do
{
v6 = &a3[-v5];
if ( (unsigned long long)a3 <= v5 )
goto LABEL_13;
do
{
this = v4;
v7 = pread(v4, a2 + v5, v6, v5 + a4);
}
while ( v7 == -1 && *(_DWORD *)__errno_location(v4) == 4 );
v8 = v7 < 0;
v9 = 3 * (v7 == 0);
if ( v7 <= 0 )
v7 = 0LL;
if ( v8 )
v9 = 1;
v5 += v7;
a3 = v11;
}
while ( !v9 );
if ( v9 != 3 )
return -1LL;
LABEL_13:
if ( v5 > (unsigned long long)a3 )
goto LABEL_14;
return v5;
}
| ReadFromOffset:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RSI
TEST EDI,EDI
JS 0x0012152c
TEST RDX,RDX
JS 0x0012152c
MOV EBP,EDI
XOR R14D,R14D
MOV qword ptr [RSP],RDX
LAB_001214be:
MOV RBX,RDX
SUB RBX,R14
JBE 0x00121527
MOV RAX,qword ptr [RSP + 0x8]
LEA R12,[RAX + R14*0x1]
MOV RAX,qword ptr [RSP + 0x10]
LEA R15,[R14 + RAX*0x1]
LAB_001214d8:
MOV EDI,EBP
MOV RSI,R12
MOV RDX,RBX
MOV RCX,R15
CALL 0x00107690
MOV R13,RAX
CMP RAX,-0x1
JNZ 0x001214fb
CALL 0x00107050
CMP dword ptr [RAX],0x4
JZ 0x001214d8
LAB_001214fb:
XOR EAX,EAX
TEST R13,R13
SETZ AL
LEA EAX,[RAX + RAX*0x2]
MOV ECX,0x0
CMOVLE R13,RCX
MOV ECX,0x1
CMOVS EAX,ECX
ADD R14,R13
TEST EAX,EAX
MOV RDX,qword ptr [RSP]
JZ 0x001214be
CMP EAX,0x3
JNZ 0x00121531
LAB_00121527:
CMP R14,RDX
JBE 0x00121538
LAB_0012152c:
CALL 0x001072c0
LAB_00121531:
MOV R14,-0x1
LAB_00121538:
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::tools::ReadFromOffset(int, void*, unsigned long, unsigned long) */
ulong nglog::tools::ReadFromOffset(int param_1,void *param_2,ulong param_3,ulong param_4)
{
char cVar1;
ssize_t sVar2;
int *piVar3;
ulong uVar4;
bool bVar5;
if ((-1 < param_1) && (-1 < (long)param_3)) {
uVar4 = 0;
do {
if (param_3 < uVar4 || param_3 - uVar4 == 0) goto LAB_00121527;
do {
sVar2 = pread(param_1,(void *)((long)param_2 + uVar4),param_3 - uVar4,uVar4 + param_4);
if (sVar2 != -1) break;
piVar3 = __errno_location();
} while (*piVar3 == 4);
bVar5 = sVar2 < 0;
cVar1 = (sVar2 == 0) * '\x03';
if (sVar2 < 1) {
sVar2 = 0;
}
if (bVar5) {
cVar1 = '\x01';
}
uVar4 = uVar4 + sVar2;
} while (cVar1 == '\0');
if (cVar1 == '\x03') {
LAB_00121527:
if (param_3 < uVar4) goto LAB_0012152c;
}
else {
uVar4 = 0xffffffffffffffff;
}
return uVar4;
}
LAB_0012152c:
/* WARNING: Subroutine does not return */
abort();
}
| |
22,478 | bchange | eloqsql/strings/bchange.c | void bchange(register uchar *dst, size_t old_length, register const uchar *src,
size_t new_length, size_t tot_length)
{
size_t rest=tot_length-old_length;
if (old_length < new_length)
bmove_upp(dst+rest+new_length,dst+tot_length,rest);
else
bmove(dst+new_length,dst+old_length,rest);
memcpy(dst,src,new_length);
} | O3 | c | bchange:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq %r8, %rdx
subq %rsi, %rdx
cmpq %rcx, %rsi
jae 0x36c92
leaq (%r15,%rdx), %rdi
addq %rbx, %rdi
addq %r15, %r8
movq %r8, %rsi
callq 0x36cb8
jmp 0x36c9e
leaq (%r15,%rbx), %rdi
addq %r15, %rsi
callq 0x24610
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24290
nop
| bchange:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rcx
mov r14, rdx
mov r15, rdi
mov rdx, r8
sub rdx, rsi
cmp rsi, rcx
jnb short loc_36C92
lea rdi, [r15+rdx]
add rdi, rbx
add r8, r15
mov rsi, r8
call bmove_upp
jmp short loc_36C9E
loc_36C92:
lea rdi, [r15+rbx]
add rsi, r15
call _memmove
loc_36C9E:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _memcpy
| long long bchange(long long a1, unsigned long long a2, long long a3, unsigned long long a4, long long a5)
{
long long v6; // rdx
v6 = a5 - a2;
if ( a2 >= a4 )
memmove(a1 + a4, a1 + a2, v6);
else
bmove_upp(a4 + a1 + v6, a1 + a5, v6);
return memcpy(a1, a3);
}
| bchange:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
MOV RDX,R8
SUB RDX,RSI
CMP RSI,RCX
JNC 0x00136c92
LEA RDI,[R15 + RDX*0x1]
ADD RDI,RBX
ADD R8,R15
MOV RSI,R8
CALL 0x00136cb8
JMP 0x00136c9e
LAB_00136c92:
LEA RDI,[R15 + RBX*0x1]
ADD RSI,R15
CALL 0x00124610
LAB_00136c9e:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00124290
|
void bchange(void *param_1,ulong param_2,void *param_3,ulong param_4,long param_5)
{
if (param_2 < param_4) {
bmove_upp((long)param_1 + param_4 + (param_5 - param_2),param_5 + (long)param_1);
}
else {
memmove((void *)((long)param_1 + param_4),(void *)(param_2 + (long)param_1),param_5 - param_2);
}
memcpy(param_1,param_3,param_4);
return;
}
| |
22,479 | google::protobuf::OneofDescriptorProto* google::protobuf::Arena::CreateMaybeMessage<google::protobuf::OneofDescriptorProto>(google::protobuf::Arena*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.pb.cc | PROTOBUF_NOINLINE ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto*
Arena::CreateMaybeMessage< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >(Arena* arena) {
return Arena::CreateMessageInternal< ::PROTOBUF_NAMESPACE_ID::OneofDescriptorProto >(arena);
} | O0 | cpp | google::protobuf::OneofDescriptorProto* google::protobuf::Arena::CreateMaybeMessage<google::protobuf::OneofDescriptorProto>(google::protobuf::Arena*):
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x52ea3f
movl $0x28, %edi
callq 0x18da00
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x511eb0
jmp 0x52ea30
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x1961a0
movq 0x38(%rsp), %rdi
callq 0x198ce0
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x52ebf3
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x98(%rsp)
movq $0x28, 0x90(%rsp)
movq $0x8, 0x88(%rsp)
movq $0x0, 0x80(%rsp)
leaq 0x21c46b(%rip), %rax # 0x74aef0
movq %rax, 0x78(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x80(%rsp)
jne 0x52eace
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0x3b8b30
movq %rax, 0xa0(%rsp)
jmp 0x52ebd3
cmpq $0x8, 0x88(%rsp)
ja 0x52eb32
movq 0x90(%rsp), %rdi
callq 0x3b8be0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x78(%rsp), %rdx
callq 0x3bae60
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0x52ebd3
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rsi
addq 0x88(%rsp), %rsi
subq $0x8, %rsi
movq 0x78(%rsp), %rdx
callq 0x3bae60
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x88(%rsp), %rax
movq %rcx, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
addq 0xa8(%rsp), %rax
subq $0x1, %rax
movq 0xa8(%rsp), %rcx
xorq $-0x1, %rcx
addq $0x1, %rcx
andq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq (%rsp), %rax
movq 0xa0(%rsp), %rdi
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x53e9d0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
| _ZN6google8protobuf5Arena18CreateMaybeMessageINS0_20OneofDescriptorProtoEJEEEPT_PS1_DpOT0_:
sub rsp, 0B8h
mov [rsp+0B8h+var_A0], rdi
mov rax, [rsp+0B8h+var_A0]
mov [rsp+0B8h+var_98], rax
cmp [rsp+0B8h+var_98], 0
jnz short loc_52EA3F
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
xor edx, edx; bool
mov esi, edx; google::protobuf::Arena *
call _ZN6google8protobuf20OneofDescriptorProtoC2EPNS0_5ArenaEb; google::protobuf::OneofDescriptorProto::OneofDescriptorProto(google::protobuf::Arena *,bool)
jmp short loc_52EA30
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
call __ZdlPv; operator delete(void *)
mov rdi, [rsp+arg_30]
call __Unwind_Resume
loc_52EA30:
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_90], rax
jmp loc_52EBF3
loc_52EA3F:
mov rax, [rsp+0B8h+var_98]
mov [rsp+0B8h+var_70], rax
mov rax, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_B8], rax
mov [rsp+0B8h+var_20], rax
mov [rsp+0B8h+var_28], 28h ; '('
mov [rsp+0B8h+var_30], 8
mov [rsp+0B8h+var_38], 0
lea rax, _ZTIN6google8protobuf20OneofDescriptorProtoE; `typeinfo for'google::protobuf::OneofDescriptorProto
mov [rsp+0B8h+var_40], rax
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_B0], rax
cmp [rsp+0B8h+var_38], 0
jnz short loc_52EACE
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, [rsp+0B8h+var_28]; unsigned __int64
mov rdx, [rsp+0B8h+var_30]; unsigned __int64
mov rcx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena23AllocateAlignedWithHookEmmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithHook(ulong,ulong,std::type_info const*)
mov [rsp+0B8h+var_18], rax
jmp loc_52EBD3
loc_52EACE:
cmp [rsp+0B8h+var_30], 8
ja short loc_52EB32
mov rdi, [rsp+0B8h+var_28]; this
call _ZN6google8protobuf8internal10AlignUpTo8Em; google::protobuf::internal::AlignUpTo8(ulong)
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, rax; unsigned __int64
mov rdx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+0B8h+var_50], rax
mov [rsp+0B8h+var_48], rdx
mov rcx, [rsp+0B8h+var_50]
mov rax, [rsp+0B8h+var_48]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_38]
mov rax, [rsp+0B8h+var_48]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_50]
mov [rsp+0B8h+var_18], rax
jmp loc_52EBD3
loc_52EB32:
mov rdi, [rsp+0B8h+var_B0]; this
mov rsi, [rsp+0B8h+var_28]
add rsi, [rsp+0B8h+var_30]
sub rsi, 8; unsigned __int64
mov rdx, [rsp+0B8h+var_40]; type_info *
call _ZN6google8protobuf5Arena26AllocateAlignedWithCleanupEmPKSt9type_info; google::protobuf::Arena::AllocateAlignedWithCleanup(ulong,std::type_info const*)
mov [rsp+0B8h+var_60], rax
mov [rsp+0B8h+var_58], rdx
mov rcx, [rsp+0B8h+var_60]
mov rax, [rsp+0B8h+var_30]
mov [rsp+0B8h+var_8], rcx
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_8]
add rax, [rsp+0B8h+var_10]
sub rax, 1
mov rcx, [rsp+0B8h+var_10]
xor rcx, 0FFFFFFFFFFFFFFFFh
add rcx, 1
and rax, rcx
mov [rsp+0B8h+var_68], rax
mov rcx, [rsp+0B8h+var_68]
mov rax, [rsp+0B8h+var_58]
mov [rax], rcx
mov rcx, [rsp+0B8h+var_38]
mov rax, [rsp+0B8h+var_58]
mov [rax+8], rcx
mov rax, [rsp+0B8h+var_68]
mov [rsp+0B8h+var_18], rax
loc_52EBD3:
mov rax, [rsp+0B8h+var_B8]
mov rdi, [rsp+0B8h+var_18]
mov [rsp+0B8h+var_78], rax
lea rsi, [rsp+0B8h+var_78]
call _ZN6google8protobuf5Arena14InternalHelperINS0_20OneofDescriptorProtoEE9ConstructIJPS1_EEEPS3_PvDpOT_; google::protobuf::Arena::InternalHelper<google::protobuf::OneofDescriptorProto>::Construct<google::protobuf::Arena*>(void *,google::protobuf::Arena* &&)
mov [rsp+0B8h+var_90], rax
loc_52EBF3:
mov rax, [rsp+0B8h+var_90]
add rsp, 0B8h
retn
| google::protobuf::OneofDescriptorProto * google::protobuf::Arena::CreateMaybeMessage<google::protobuf::OneofDescriptorProto>(
google::protobuf::Arena *a1)
{
google::protobuf::OneofDescriptorProto *v2; // [rsp+10h] [rbp-A8h]
_QWORD v4[12]; // [rsp+40h] [rbp-78h] BYREF
unsigned long long AlignedWithHook; // [rsp+A0h] [rbp-18h]
if ( a1 )
{
v4[1] = a1;
v4[11] = a1;
v4[10] = 40LL;
v4[9] = 8LL;
v4[8] = 0LL;
v4[7] = &`typeinfo for'google::protobuf::OneofDescriptorProto;
AlignedWithHook = google::protobuf::Arena::AllocateAlignedWithHook(
a1,
(google::protobuf::internal *)&qword_28,
8uLL,
(const type_info *)&`typeinfo for'google::protobuf::OneofDescriptorProto);
v4[0] = a1;
return (google::protobuf::OneofDescriptorProto *)google::protobuf::Arena::InternalHelper<google::protobuf::OneofDescriptorProto>::Construct<google::protobuf::Arena*>(
AlignedWithHook,
v4);
}
else
{
v2 = (google::protobuf::OneofDescriptorProto *)operator new(0x28uLL);
google::protobuf::OneofDescriptorProto::OneofDescriptorProto(v2, 0LL, 0);
return v2;
}
}
| EraseFromLinkedList:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP + 0x10]
JNZ 0x0052ea08
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0052ea35
LAB_0052ea08:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x0052e9d0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
LAB_0052ea35:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
/* google::protobuf::Map<google::protobuf::MapKey,
google::protobuf::MapValueRef>::InnerMap::EraseFromLinkedList(google::protobuf::Map<google::protobuf::MapKey,
google::protobuf::MapValueRef>::InnerMap::Node*, google::protobuf::Map<google::protobuf::MapKey,
google::protobuf::MapValueRef>::InnerMap::Node*) */
Node * __thiscall
google::protobuf::Map<google::protobuf::MapKey,google::protobuf::MapValueRef>::InnerMap::
EraseFromLinkedList(InnerMap *this,Node *param_1,Node *param_2)
{
int8 uVar1;
Node *local_8;
if (param_2 == param_1) {
local_8 = *(Node **)(param_2 + 0x38);
}
else {
uVar1 = EraseFromLinkedList(this,param_1,*(Node **)(param_2 + 0x38));
*(int8 *)(param_2 + 0x38) = uVar1;
local_8 = param_2;
}
return local_8;
}
| |
22,480 | google::protobuf::internal::WireFormatLite::UInt32Size(google::protobuf::RepeatedField<unsigned int> const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline int RepeatedField<Element>::size() const {
return current_size_;
} | O3 | c | google::protobuf::internal::WireFormatLite::UInt32Size(google::protobuf::RepeatedField<unsigned int> const&):
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0xaaeb3
movq 0x8(%rdi), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq (%rdx,%rsi,8), %rdi
orq $0x1, %rdi
bsrq %rdi, %rdi
leal (%rdi,%rdi,8), %edi
addl $0x49, %edi
shrl $0x6, %edi
addq %rdi, %rax
incq %rsi
cmpq %rsi, %rcx
jne 0xaae92
retq
xorl %eax, %eax
retq
| _ZN6google8protobuf8internal14WireFormatLite10UInt64SizeERKNS0_13RepeatedFieldImEE:
movsxd rcx, dword ptr [rdi]
test rcx, rcx
jle short loc_AAEB3
mov rdx, [rdi+8]
xor esi, esi
xor eax, eax
loc_AAE92:
mov rdi, [rdx+rsi*8]
or rdi, 1
bsr rdi, rdi
lea edi, [rdi+rdi*8]
add edi, 49h ; 'I'
shr edi, 6
add rax, rdi
inc rsi
cmp rcx, rsi
jnz short loc_AAE92
retn
loc_AAEB3:
xor eax, eax
retn
| long long google::protobuf::internal::WireFormatLite::UInt64Size(int *a1)
{
long long v1; // rcx
long long v2; // rdx
long long v3; // rsi
long long result; // rax
unsigned long long v5; // rdi
v1 = *a1;
if ( v1 <= 0 )
return 0LL;
v2 = *((_QWORD *)a1 + 1);
v3 = 0LL;
result = 0LL;
do
{
_BitScanReverse64(&v5, *(_QWORD *)(v2 + 8 * v3) | 1LL);
result += (unsigned int)(9 * v5 + 73) >> 6;
++v3;
}
while ( v1 != v3 );
return result;
}
| UInt64Size:
MOVSXD RCX,dword ptr [RDI]
TEST RCX,RCX
JLE 0x001aaeb3
MOV RDX,qword ptr [RDI + 0x8]
XOR ESI,ESI
XOR EAX,EAX
LAB_001aae92:
MOV RDI,qword ptr [RDX + RSI*0x8]
OR RDI,0x1
BSR RDI,RDI
LEA EDI,[RDI + RDI*0x8]
ADD EDI,0x49
SHR EDI,0x6
ADD RAX,RDI
INC RSI
CMP RCX,RSI
JNZ 0x001aae92
RET
LAB_001aaeb3:
XOR EAX,EAX
RET
|
/* google::protobuf::internal::WireFormatLite::UInt64Size(google::protobuf::RepeatedField<unsigned
long> const&) */
long google::protobuf::internal::WireFormatLite::UInt64Size(RepeatedField *param_1)
{
long lVar1;
long lVar2;
long lVar3;
ulong uVar4;
if (0 < (long)*(int *)param_1) {
lVar3 = 0;
lVar2 = 0;
do {
uVar4 = *(ulong *)(*(long *)(param_1 + 8) + lVar3 * 8) | 1;
lVar1 = 0x3f;
if (uVar4 != 0) {
for (; uVar4 >> lVar1 == 0; lVar1 = lVar1 + -1) {
}
}
lVar2 = lVar2 + (ulong)((int)lVar1 * 9 + 0x49U >> 6);
lVar3 = lVar3 + 1;
} while (*(int *)param_1 != lVar3);
return lVar2;
}
return 0;
}
| |
22,481 | my_hash_sort_utf16_nopad_bin | eloqsql/strings/ctype-ucs2.c | static void
my_hash_sort_utf16_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *pos, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= pos + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; pos < end ; pos++)
{
MY_HASH_ADD(m1, m2, (uint)*pos);
}
*nr1= m1;
*nr2= m2;
} | O0 | c | my_hash_sort_utf16_nopad_bin:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x637de
jmp 0x63796
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x637d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6378a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_utf16_nopad_bin:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_40], rax
loc_6378A:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jnb short loc_637DE
jmp short $+2
loc_63796:
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
jmp short $+2
loc_637D0:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_6378A
loc_637DE:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
| _QWORD * my_hash_sort_utf16_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-40h]
long long v7; // [rsp+8h] [rbp-38h]
unsigned __int8 *v8; // [rsp+30h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *v8 * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
| my_hash_sort_utf16_nopad_bin:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_0016378a:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001637de
JMP 0x00163796
LAB_00163796:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001637d0
LAB_001637d0:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0016378a
LAB_001637de:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_utf16_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_48;
ulong local_40;
byte *local_18;
local_40 = *param_4;
local_48 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_40 = ((local_40 & 0x3f) + local_48) * (ulong)*local_18 + local_40 * 0x100 ^ local_40;
local_48 = local_48 + 3;
}
*param_4 = local_40;
*param_5 = local_48;
return;
}
| |
22,482 | DepthAnything::preprocessBatch(std::vector<cv::Mat, std::allocator<cv::Mat>> const&, std::vector<float, std::allocator<float>>&, std::vector<long, std::allocator<long>>&) | Depths-CPP/include/depth_anything.hpp | std::vector<cv::Mat> DepthAnything::preprocessBatch(const std::vector<cv::Mat> &images, std::vector<float> &blob, std::vector<int64_t> &inputTensorShape)
{
if (images.empty())
{
throw std::runtime_error("Input images vector is empty.");
}
// Determine common dimensions for all images in the batch
cv::Size batchSize = determineBatchDimensions(images);
// Setup input tensor shape for the batch
int batchCount = static_cast<int>(images.size());
inputTensorShape = {batchCount, 3, batchSize.height, batchSize.width};
// Pre-allocate memory for the blob
blob.reserve(batchCount * 3 * batchSize.height * batchSize.width);
std::vector<cv::Mat> preprocessedImages;
preprocessedImages.reserve(images.size());
// Process each image
for (const cv::Mat &img : images)
{
if (img.empty())
{
throw std::runtime_error("One of the input images is empty.");
}
// Resize image to match batch dimensions
cv::Mat resizedImage = DepthUtils::resize_no_padding(img, batchSize.width, batchSize.height);
preprocessedImages.push_back(resizedImage);
// Convert to float and normalize
cv::Mat floatImage;
resizedImage.convertTo(floatImage, CV_32FC3, 1.0f / 255.0f);
// Apply mean/std normalization
for (int c = 0; c < 3; ++c)
{
floatImage.forEach<cv::Vec3f>([c, this](cv::Vec3f &pixel, const int *) -> void
{ pixel[c] = (pixel[c] - mean[c]) / std[c]; });
}
// Convert from HWC to CHW and add to blob
std::vector<cv::Mat> chw;
cv::split(floatImage, chw);
for (auto &channel : chw)
{
blob.insert(blob.end(), (float *)channel.datastart, (float *)channel.dataend);
}
}
return preprocessedImages;
} | O0 | cpp | DepthAnything::preprocessBatch(std::vector<cv::Mat, std::allocator<cv::Mat>> const&, std::vector<float, std::allocator<float>>&, std::vector<long, std::allocator<long>>&):
subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x248(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x240(%rsp), %rdi
callq 0x1ff60
testb $0x1, %al
jne 0x1a87c
jmp 0x1a8da
movl $0x10, %edi
callq 0x191c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x30(%rsp)
leaq 0x12863(%rip), %rsi # 0x2d0fb
callq 0x19040
jmp 0x1a89f
movq 0x30(%rsp), %rdi
movq 0x1c70d(%rip), %rsi # 0x36fb8
movq 0x1c746(%rip), %rdx # 0x36ff8
callq 0x19350
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
callq 0x19240
jmp 0x1ae47
movq 0x48(%rsp), %rsi
movq 0x240(%rsp), %rdx
leaq 0x21c(%rsp), %rdi
callq 0x1ae60
movq 0x240(%rsp), %rdi
callq 0x1ffb0
movl %eax, 0x218(%rsp)
movslq 0x218(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq $0x3, 0x1f0(%rsp)
movslq 0x220(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movslq 0x21c(%rsp), %rax
movq %rax, 0x200(%rsp)
leaq 0x1e8(%rsp), %rax
movq %rax, 0x208(%rsp)
movq $0x4, 0x210(%rsp)
movq 0x230(%rsp), %rdi
movq 0x208(%rsp), %rsi
movq 0x210(%rsp), %rdx
callq 0x1fa90
movq 0x238(%rsp), %rdi
movl 0x218(%rsp), %ecx
movl 0x21c(%rsp), %eax
movl 0x220(%rsp), %edx
imull %edx, %ecx
imull %eax, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movslq %eax, %rsi
callq 0x1ffd0
movq 0x38(%rsp), %rdi
movb $0x0, 0x1e7(%rsp)
callq 0x1fc70
movq 0x240(%rsp), %rdi
callq 0x1ffb0
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x200e0
jmp 0x1a9db
movq 0x240(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x20220
movq %rax, 0x1d0(%rsp)
movq 0x1d8(%rsp), %rdi
callq 0x20250
movq %rax, 0x1c8(%rsp)
leaq 0x1d0(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x20280
testb $0x1, %al
jne 0x1aa33
jmp 0x1ae14
leaq 0x1d0(%rsp), %rdi
callq 0x202c0
movq %rax, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rdi
callq 0x191e0
movb %al, 0x2f(%rsp)
jmp 0x1aa5b
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x1aa65
jmp 0x1aae1
movl $0x10, %edi
callq 0x191c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x12698(%rip), %rsi # 0x2d119
callq 0x19040
jmp 0x1aa88
movq 0x20(%rsp), %rdi
movq 0x1c524(%rip), %rsi # 0x36fb8
movq 0x1c55d(%rip), %rdx # 0x36ff8
callq 0x19350
jmp 0x1ae54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x1ae3d
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
callq 0x19240
jmp 0x1ae3d
movq 0x1c0(%rsp), %rsi
movl 0x21c(%rsp), %edx
movl 0x220(%rsp), %ecx
leaq 0x160(%rsp), %rdi
callq 0x1faf0
jmp 0x1ab06
movq 0x38(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x202d0
jmp 0x1ab1a
leaq 0x100(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x19050
movq 0x18(%rsp), %rsi
leaq 0xe8(%rsp), %rdi
callq 0x1fc00
jmp 0x1ab40
leaq 0x160(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
movl $0x15, %edx
vmovsd 0x124ab(%rip), %xmm0 # 0x2d008
vpxor %xmm1, %xmm1, %xmm1
callq 0x19540
jmp 0x1ab68
leaq 0xe8(%rsp), %rdi
callq 0x1fc60
movl $0x0, 0xe4(%rsp)
cmpl $0x3, 0xe4(%rsp)
jge 0x1ac2d
movq 0x48(%rsp), %rax
movl 0xe4(%rsp), %ecx
movl %ecx, 0xd0(%rsp)
movq %rax, 0xd8(%rsp)
leaq 0x100(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1afb0
jmp 0x1abc0
jmp 0x1abc2
movl 0xe4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
jmp 0x1ab80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x1ae05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x1adf8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x1fc60
jmp 0x1adf8
leaq 0xb8(%rsp), %rdi
callq 0x1fc70
leaq 0xa0(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x1fc80
jmp 0x1ac51
leaq 0x88(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1fcc0
jmp 0x1ac68
leaq 0xa0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x19460
jmp 0x1ac7f
leaq 0x88(%rsp), %rdi
callq 0x1fc60
leaq 0xa0(%rsp), %rdi
callq 0x1fd00
leaq 0xb8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1fd10
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x1fd40
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1fd70
testb $0x1, %al
jne 0x1ace5
jmp 0x1adb2
leaq 0x78(%rsp), %rdi
callq 0x1fdb0
movq %rax, 0x68(%rsp)
movq 0x238(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1fe70
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1fea0
movq 0x8(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rcx
movq 0x60(%rsp), %rsi
callq 0x1fdc0
movq %rax, 0x10(%rsp)
jmp 0x1ad3d
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x1fee0
jmp 0x1accd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x1adeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
jmp 0x1ada3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x228(%rsp)
movl %eax, 0x224(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x1fc60
leaq 0xa0(%rsp), %rdi
callq 0x1fd00
jmp 0x1adeb
leaq 0xb8(%rsp), %rdi
callq 0x1ff00
leaq 0x100(%rsp), %rdi
callq 0x19080
leaq 0x160(%rsp), %rdi
callq 0x19080
leaq 0x1d0(%rsp), %rdi
callq 0x20340
jmp 0x1aa15
leaq 0xb8(%rsp), %rdi
callq 0x1ff00
leaq 0x100(%rsp), %rdi
callq 0x19080
leaq 0x160(%rsp), %rdi
callq 0x19080
jmp 0x1ae3d
movb $0x1, 0x1e7(%rsp)
testb $0x1, 0x1e7(%rsp)
jne 0x1ae30
movq 0x38(%rsp), %rdi
callq 0x1ff00
movq 0x40(%rsp), %rax
addq $0x258, %rsp # imm = 0x258
retq
movq 0x38(%rsp), %rdi
callq 0x1ff00
movq 0x228(%rsp), %rdi
callq 0x19360
nopw %cs:(%rax,%rax)
| _ZN13DepthAnything15preprocessBatchERKSt6vectorIN2cv3MatESaIS2_EERS0_IfSaIfEERS0_IlSaIlEE:
sub rsp, 258h
mov [rsp+258h+var_220], rdi
mov rax, rdi
mov [rsp+258h+var_218], rax
mov [rsp+258h+var_8], rdi
mov [rsp+258h+var_10], rsi
mov [rsp+258h+var_18], rdx
mov [rsp+258h+var_20], rcx
mov [rsp+258h+var_28], r8
mov rax, [rsp+258h+var_10]
mov [rsp+258h+var_210], rax
mov rdi, [rsp+258h+var_18]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE5emptyEv; std::vector<cv::Mat>::empty(void)
test al, 1
jnz short loc_1A87C
jmp short loc_1A8DA
loc_1A87C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+258h+var_228], rax
lea rsi, aInputImagesVec; "Input images vector is empty."
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_1A89F:
mov rdi, [rsp+258h+var_228]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+258h+var_228]; void *
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
call ___cxa_free_exception
jmp loc_1AE47
loc_1A8DA:
mov rsi, [rsp+258h+var_210]
mov rdx, [rsp+258h+var_18]
lea rdi, [rsp+258h+var_3C]
call _ZN13DepthAnything24determineBatchDimensionsERKSt6vectorIN2cv3MatESaIS2_EE; DepthAnything::determineBatchDimensions(std::vector<cv::Mat> const&)
mov rdi, [rsp+258h+var_18]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE4sizeEv; std::vector<cv::Mat>::size(void)
mov [rsp+258h+var_40], eax
movsxd rax, [rsp+258h+var_40]
mov [rsp+258h+var_70], rax
mov [rsp+258h+var_68], 3
movsxd rax, [rsp+258h+var_38]
mov [rsp+258h+var_60], rax
movsxd rax, [rsp+258h+var_3C]
mov [rsp+258h+var_58], rax
lea rax, [rsp+258h+var_70]
mov [rsp+258h+var_50], rax
mov [rsp+258h+var_48], 4
mov rdi, [rsp+258h+var_28]
mov rsi, [rsp+258h+var_50]
mov rdx, [rsp+258h+var_48]
call _ZNSt6vectorIlSaIlEEaSESt16initializer_listIlE; std::vector<long>::operator=(std::initializer_list<long>)
mov rdi, [rsp+258h+var_20]
mov ecx, [rsp+258h+var_40]
mov eax, [rsp+258h+var_3C]
mov edx, [rsp+258h+var_38]
imul ecx, edx
imul ecx, eax
mov eax, ecx
lea eax, [rax+rax*2]
movsxd rsi, eax
call _ZNSt6vectorIfSaIfEE7reserveEm; std::vector<float>::reserve(ulong)
mov rdi, [rsp+258h+var_220]
mov [rsp+258h+var_71], 0
call _ZNSt6vectorIN2cv3MatESaIS1_EEC2Ev; std::vector<cv::Mat>::vector(void)
mov rdi, [rsp+258h+var_18]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE4sizeEv; std::vector<cv::Mat>::size(void)
mov rdi, [rsp+258h+var_220]
mov rsi, rax
call _ZNSt6vectorIN2cv3MatESaIS1_EE7reserveEm; std::vector<cv::Mat>::reserve(ulong)
jmp short $+2
loc_1A9DB:
mov rax, [rsp+258h+var_18]
mov [rsp+258h+var_80], rax
mov rdi, [rsp+258h+var_80]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE5beginEv; std::vector<cv::Mat>::begin(void)
mov [rsp+258h+var_88], rax
mov rdi, [rsp+258h+var_80]
call _ZNKSt6vectorIN2cv3MatESaIS1_EE3endEv; std::vector<cv::Mat>::end(void)
mov [rsp+258h+var_90], rax
loc_1AA15:
lea rdi, [rsp+258h+var_88]
lea rsi, [rsp+258h+var_90]
call _ZN9__gnu_cxxneIPKN2cv3MatESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<cv::Mat const*,std::vector<cv::Mat>>(__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>> const&,__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>> const&)
test al, 1
jnz short loc_1AA33
jmp loc_1AE14
loc_1AA33:
lea rdi, [rsp+258h+var_88]
call _ZNK9__gnu_cxx17__normal_iteratorIPKN2cv3MatESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator*(void)
mov [rsp+258h+var_98], rax
mov rdi, [rsp+258h+var_98]; this
call __ZNK2cv3Mat5emptyEv; cv::Mat::empty(void)
mov [rsp+258h+var_229], al
jmp short $+2
loc_1AA5B:
mov al, [rsp+258h+var_229]
test al, 1
jnz short loc_1AA65
jmp short loc_1AAE1
loc_1AA65:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+258h+var_238], rax
lea rsi, aOneOfTheInputI; "One of the input images is empty."
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_1AA88:
mov rdi, [rsp+258h+var_238]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_1AE54
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp loc_1AE3D
mov rdi, [rsp+258h+var_238]; void *
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
call ___cxa_free_exception
jmp loc_1AE3D
loc_1AAE1:
mov rsi, [rsp+258h+var_98]; cv::Mat *
mov edx, [rsp+258h+var_3C]; int
mov ecx, [rsp+258h+var_38]; int
lea rdi, [rsp+258h+var_F8]; this
call _ZN10DepthUtils17resize_no_paddingERKN2cv3MatEii; DepthUtils::resize_no_padding(cv::Mat const&,int,int)
jmp short $+2
loc_1AB06:
mov rdi, [rsp+258h+var_220]
lea rsi, [rsp+258h+var_F8]
call _ZNSt6vectorIN2cv3MatESaIS1_EE9push_backERKS1_; std::vector<cv::Mat>::push_back(cv::Mat const&)
jmp short $+2
loc_1AB1A:
lea rdi, [rsp+258h+var_158]; this
mov [rsp+258h+var_240], rdi
call __ZN2cv3MatC1Ev; cv::Mat::Mat(void)
mov rsi, [rsp+258h+var_240]; cv::Mat *
lea rdi, [rsp+258h+var_170]; this
call _ZN2cv12_OutputArrayC2ERNS_3MatE; cv::_OutputArray::_OutputArray(cv::Mat &)
jmp short $+2
loc_1AB40:
lea rdi, [rsp+258h+var_F8]
lea rsi, [rsp+258h+var_170]
mov edx, 15h
vmovsd xmm0, cs:qword_2D008
vpxor xmm1, xmm1, xmm1
call __ZNK2cv3Mat9convertToERKNS_12_OutputArrayEidd; cv::Mat::convertTo(cv::_OutputArray const&,int,double,double)
jmp short $+2
loc_1AB68:
lea rdi, [rsp+258h+var_170]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
mov [rsp+258h+var_174], 0
loc_1AB80:
cmp [rsp+258h+var_174], 3
jge loc_1AC2D
mov rax, [rsp+258h+var_210]
mov ecx, [rsp+258h+var_174]
mov [rsp+258h+var_188], ecx
mov [rsp+258h+var_180], rax
lea rdi, [rsp+258h+var_158]
lea rsi, [rsp+258h+var_188]
call _ZN2cv3Mat7forEachINS_3VecIfLi3EEEZN13DepthAnything15preprocessBatchERKSt6vectorIS0_SaIS0_EERS5_IfSaIfEERS5_IlSaIlEEE3$_0EEvRKT0_; cv::Mat::forEach<cv::Vec<float,3>,DepthAnything::preprocessBatch(std::vector<cv::Mat> const&,std::vector&<float,std::allocator<float>>,std::vector&<long,std::allocator<long>>)::$_0>(DepthAnything::preprocessBatch(std::vector<cv::Mat> const&,std::vector&<float,std::allocator<float>>,std::vector&<long,std::allocator<long>>)::$_0 const&)
jmp short $+2
loc_1ABC0:
jmp short $+2
loc_1ABC2:
mov eax, [rsp+258h+var_174]
add eax, 1
mov [rsp+258h+var_174], eax
jmp short loc_1AB80
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp loc_1AE05
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp loc_1ADF8
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
lea rdi, [rsp+258h+var_170]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
jmp loc_1ADF8
loc_1AC2D:
lea rdi, [rsp+258h+var_1A0]
call _ZNSt6vectorIN2cv3MatESaIS1_EEC2Ev; std::vector<cv::Mat>::vector(void)
lea rdi, [rsp+258h+var_1B8]; this
lea rsi, [rsp+258h+var_158]; cv::Mat *
call _ZN2cv11_InputArrayC2ERKNS_3MatE; cv::_InputArray::_InputArray(cv::Mat const&)
jmp short $+2
loc_1AC51:
lea rdi, [rsp+258h+var_1D0]
lea rsi, [rsp+258h+var_1A0]
call _ZN2cv12_OutputArrayC2ERSt6vectorINS_3MatESaIS2_EE; cv::_OutputArray::_OutputArray(std::vector<cv::Mat> &)
jmp short $+2
loc_1AC68:
lea rdi, [rsp+258h+var_1B8]
lea rsi, [rsp+258h+var_1D0]
call __ZN2cv5splitERKNS_11_InputArrayERKNS_12_OutputArrayE; cv::split(cv::_InputArray const&,cv::_OutputArray const&)
jmp short $+2
loc_1AC7F:
lea rdi, [rsp+258h+var_1D0]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
lea rdi, [rsp+258h+var_1B8]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
lea rax, [rsp+258h+var_1A0]
mov [rsp+258h+var_1D8], rax
mov rdi, [rsp+258h+var_1D8]
call _ZNSt6vectorIN2cv3MatESaIS1_EE5beginEv; std::vector<cv::Mat>::begin(void)
mov [rsp+258h+var_1E0], rax
mov rdi, [rsp+258h+var_1D8]
call _ZNSt6vectorIN2cv3MatESaIS1_EE3endEv; std::vector<cv::Mat>::end(void)
mov [rsp+258h+var_1E8], rax
loc_1ACCD:
lea rdi, [rsp+258h+var_1E0]
lea rsi, [rsp+258h+var_1E8]
call _ZN9__gnu_cxxneIPN2cv3MatESt6vectorIS2_SaIS2_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<cv::Mat *,std::vector<cv::Mat>>(__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>> const&,__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>> const&)
test al, 1
jnz short loc_1ACE5
jmp loc_1ADB2
loc_1ACE5:
lea rdi, [rsp+258h+var_1E0]
call _ZNK9__gnu_cxx17__normal_iteratorIPN2cv3MatESt6vectorIS2_SaIS2_EEEdeEv; __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator*(void)
mov [rsp+258h+var_1F0], rax
mov rdi, [rsp+258h+var_20]
mov [rsp+258h+var_250], rdi
call _ZNSt6vectorIfSaIfEE3endEv; std::vector<float>::end(void)
mov [rsp+258h+var_200], rax
lea rdi, [rsp+258h+var_1F8]
lea rsi, [rsp+258h+var_200]
call _ZN9__gnu_cxx17__normal_iteratorIPKfSt6vectorIfSaIfEEEC2IPfEERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameIS9_S8_EE7__valueES5_E6__typeEEE
mov rdi, [rsp+258h+var_250]
mov rax, [rsp+258h+var_1F0]
mov rdx, [rax+18h]
mov rcx, [rax+20h]
mov rsi, [rsp+258h+var_1F8]
call _ZNSt6vectorIfSaIfEE6insertIPfvEEN9__gnu_cxx17__normal_iteratorIS3_S1_EENS5_IPKfS1_EET_SA_; std::vector<float>::insert<float *,void>(__gnu_cxx::__normal_iterator<float const*,std::vector<float>>,float *,float *)
mov [rsp+258h+var_248], rax
jmp short $+2
loc_1AD3D:
mov rax, [rsp+258h+var_248]
mov [rsp+258h+var_208], rax
lea rdi, [rsp+258h+var_1E0]
call _ZN9__gnu_cxx17__normal_iteratorIPN2cv3MatESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator++(void)
jmp loc_1ACCD
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp short loc_1ADEB
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
jmp short loc_1ADA3
mov rcx, rax
mov eax, edx
mov [rsp+258h+var_30], rcx
mov [rsp+258h+var_34], eax
lea rdi, [rsp+258h+var_1D0]; this
call _ZN2cv12_OutputArrayD2Ev; cv::_OutputArray::~_OutputArray()
loc_1ADA3:
lea rdi, [rsp+258h+var_1B8]; this
call _ZN2cv11_InputArrayD2Ev; cv::_InputArray::~_InputArray()
jmp short loc_1ADEB
loc_1ADB2:
lea rdi, [rsp+258h+var_1A0]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
lea rdi, [rsp+258h+var_158]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+258h+var_F8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
lea rdi, [rsp+258h+var_88]
call _ZN9__gnu_cxx17__normal_iteratorIPKN2cv3MatESt6vectorIS2_SaIS2_EEEppEv; __gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator++(void)
jmp loc_1AA15
loc_1ADEB:
lea rdi, [rsp+258h+var_1A0]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_1ADF8:
lea rdi, [rsp+258h+var_158]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
loc_1AE05:
lea rdi, [rsp+258h+var_F8]; this
call __ZN2cv3MatD1Ev; cv::Mat::~Mat()
jmp short loc_1AE3D
loc_1AE14:
mov [rsp+258h+var_71], 1
test [rsp+258h+var_71], 1
jnz short loc_1AE30
mov rdi, [rsp+258h+var_220]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_1AE30:
mov rax, [rsp+258h+var_218]
add rsp, 258h
retn
loc_1AE3D:
mov rdi, [rsp+258h+var_220]
call _ZNSt6vectorIN2cv3MatESaIS1_EED2Ev; std::vector<cv::Mat>::~vector()
loc_1AE47:
mov rdi, [rsp+258h+var_30]
call __Unwind_Resume
loc_1AE54:
nop word ptr [rax+rax+00000000h]
| long long DepthAnything::preprocessBatch(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
double a6,
__m128 _XMM1)
{
long long v7; // rax
const cv::_OutputArray *v9; // rdx
long long v11; // [rsp+8h] [rbp-250h]
std::runtime_error *v12; // [rsp+20h] [rbp-238h]
std::runtime_error *exception; // [rsp+30h] [rbp-228h]
long long v14; // [rsp+58h] [rbp-200h] BYREF
long long v15; // [rsp+60h] [rbp-1F8h] BYREF
long long v16; // [rsp+68h] [rbp-1F0h]
long long v17; // [rsp+70h] [rbp-1E8h] BYREF
long long v18; // [rsp+78h] [rbp-1E0h] BYREF
_BYTE *v19; // [rsp+80h] [rbp-1D8h]
_BYTE v20[24]; // [rsp+88h] [rbp-1D0h] BYREF
_BYTE v21[24]; // [rsp+A0h] [rbp-1B8h] BYREF
_BYTE v22[24]; // [rsp+B8h] [rbp-1A0h] BYREF
int v23; // [rsp+D0h] [rbp-188h] BYREF
long long v24; // [rsp+D8h] [rbp-180h]
int i; // [rsp+E4h] [rbp-174h]
_BYTE v26[24]; // [rsp+E8h] [rbp-170h] BYREF
_BYTE v27[96]; // [rsp+100h] [rbp-158h] BYREF
_BYTE v28[96]; // [rsp+160h] [rbp-F8h] BYREF
cv::Mat *v29; // [rsp+1C0h] [rbp-98h]
long long v30; // [rsp+1C8h] [rbp-90h] BYREF
long long v31; // [rsp+1D0h] [rbp-88h] BYREF
long long v32; // [rsp+1D8h] [rbp-80h]
char v33; // [rsp+1E7h] [rbp-71h]
_QWORD v34[6]; // [rsp+1E8h] [rbp-70h] BYREF
int v35; // [rsp+218h] [rbp-40h]
int v36; // [rsp+21Ch] [rbp-3Ch] BYREF
int v37; // [rsp+220h] [rbp-38h]
long long v38; // [rsp+230h] [rbp-28h]
long long v39; // [rsp+238h] [rbp-20h]
long long v40; // [rsp+240h] [rbp-18h]
long long v41; // [rsp+248h] [rbp-10h]
long long v42; // [rsp+250h] [rbp-8h]
v42 = a1;
v41 = a2;
v40 = a3;
v39 = a4;
v38 = a5;
if ( (std::vector<cv::Mat>::empty(a3) & 1) != 0 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Input images vector is empty.");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
DepthAnything::determineBatchDimensions(&v36, a2, v40);
v35 = std::vector<cv::Mat>::size(v40);
v34[0] = v35;
v34[1] = 3LL;
v34[2] = v37;
v34[3] = v36;
v34[4] = v34;
v34[5] = 4LL;
std::vector<long>::operator=(v38, v34, 4LL);
std::vector<float>::reserve(v39, 3 * v36 * v37 * v35);
v33 = 0;
std::vector<cv::Mat>::vector(a1);
v7 = std::vector<cv::Mat>::size(v40);
std::vector<cv::Mat>::reserve(a1, v7);
v32 = v40;
v31 = std::vector<cv::Mat>::begin(v40);
v30 = std::vector<cv::Mat>::end(v32);
while ( (__gnu_cxx::operator!=<cv::Mat const*,std::vector<cv::Mat>>(&v31, &v30) & 1) != 0 )
{
v29 = (cv::Mat *)__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator*(&v31);
if ( (cv::Mat::empty(v29) & 1) != 0 )
{
v12 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v12, "One of the input images is empty.");
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
DepthUtils::resize_no_padding((DepthUtils *)v28, v29, v36, v37);
std::vector<cv::Mat>::push_back(a1, v28);
cv::Mat::Mat((cv::Mat *)v27);
cv::_OutputArray::_OutputArray((cv::_OutputArray *)v26, (cv::Mat *)v27);
__asm
{
vmovsd xmm0, cs:qword_2D008
vpxor xmm1, xmm1, xmm1
}
cv::Mat::convertTo((cv::Mat *)v28, (const cv::_OutputArray *)v26, 21, *(double *)&_XMM0, *(double *)_XMM1.m128_u64);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v26);
for ( i = 0; i < 3; ++i )
{
v23 = i;
v24 = a2;
cv::Mat::forEach<cv::Vec<float,3>,DepthAnything::preprocessBatch(std::vector<cv::Mat> const&,std::vector&<float,std::allocator<float>>,std::vector&<long,std::allocator<long>>)::$_0>(
v27,
&v23);
}
std::vector<cv::Mat>::vector(v22);
cv::_InputArray::_InputArray((cv::_InputArray *)v21, (const cv::Mat *)v27);
cv::_OutputArray::_OutputArray(v20, v22);
cv::split((cv *)v21, (const cv::_InputArray *)v20, v9);
cv::_OutputArray::~_OutputArray((cv::_OutputArray *)v20);
cv::_InputArray::~_InputArray((cv::_InputArray *)v21);
v19 = v22;
v18 = std::vector<cv::Mat>::begin(v22);
v17 = std::vector<cv::Mat>::end(v19);
while ( (__gnu_cxx::operator!=<cv::Mat *,std::vector<cv::Mat>>(&v18, &v17) & 1) != 0 )
{
v16 = __gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator*(&v18);
v11 = v39;
v14 = std::vector<float>::end();
__gnu_cxx::__normal_iterator<float const*,std::vector<float>>::__normal_iterator<float *>(&v15, &v14);
std::vector<float>::insert<float *,void>(v11, v15, *(_QWORD *)(v16 + 24), *(_QWORD *)(v16 + 32));
__gnu_cxx::__normal_iterator<cv::Mat *,std::vector<cv::Mat>>::operator++(&v18);
}
std::vector<cv::Mat>::~vector(v22);
cv::Mat::~Mat((cv::Mat *)v27);
cv::Mat::~Mat((cv::Mat *)v28);
__gnu_cxx::__normal_iterator<cv::Mat const*,std::vector<cv::Mat>>::operator++(&v31);
}
return a1;
}
| preprocessBatch:
SUB RSP,0x258
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x250],RDI
MOV qword ptr [RSP + 0x248],RSI
MOV qword ptr [RSP + 0x240],RDX
MOV qword ptr [RSP + 0x238],RCX
MOV qword ptr [RSP + 0x230],R8
MOV RAX,qword ptr [RSP + 0x248]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x240]
CALL 0x0011ff60
TEST AL,0x1
JNZ 0x0011a87c
JMP 0x0011a8da
LAB_0011a87c:
MOV EDI,0x10
CALL 0x001191c0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x30],RAX
LAB_0011a891:
LEA RSI,[0x12d0fb]
CALL 0x00119040
LAB_0011a89d:
JMP 0x0011a89f
LAB_0011a89f:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [0x00136fb8]
MOV RDX,qword ptr [0x00136ff8]
CALL 0x00119350
LAB_0011a8da:
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x240]
LEA RDI,[RSP + 0x21c]
CALL 0x0011ae60
MOV RDI,qword ptr [RSP + 0x240]
CALL 0x0011ffb0
MOV dword ptr [RSP + 0x218],EAX
MOVSXD RAX,dword ptr [RSP + 0x218]
MOV qword ptr [RSP + 0x1e8],RAX
MOV qword ptr [RSP + 0x1f0],0x3
MOVSXD RAX,dword ptr [RSP + 0x220]
MOV qword ptr [RSP + 0x1f8],RAX
MOVSXD RAX,dword ptr [RSP + 0x21c]
MOV qword ptr [RSP + 0x200],RAX
LEA RAX,[RSP + 0x1e8]
MOV qword ptr [RSP + 0x208],RAX
MOV qword ptr [RSP + 0x210],0x4
MOV RDI,qword ptr [RSP + 0x230]
MOV RSI,qword ptr [RSP + 0x208]
MOV RDX,qword ptr [RSP + 0x210]
CALL 0x0011fa90
MOV RDI,qword ptr [RSP + 0x238]
MOV ECX,dword ptr [RSP + 0x218]
MOV EAX,dword ptr [RSP + 0x21c]
MOV EDX,dword ptr [RSP + 0x220]
IMUL ECX,EDX
IMUL ECX,EAX
MOV EAX,ECX
LEA EAX,[RAX + RAX*0x2]
MOVSXD RSI,EAX
CALL 0x0011ffd0
MOV RDI,qword ptr [RSP + 0x38]
MOV byte ptr [RSP + 0x1e7],0x0
CALL 0x0011fc70
MOV RDI,qword ptr [RSP + 0x240]
CALL 0x0011ffb0
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,RAX
LAB_0011a9d4:
CALL 0x001200e0
JMP 0x0011a9db
LAB_0011a9db:
MOV RAX,qword ptr [RSP + 0x240]
MOV qword ptr [RSP + 0x1d8],RAX
MOV RDI,qword ptr [RSP + 0x1d8]
CALL 0x00120220
MOV qword ptr [RSP + 0x1d0],RAX
MOV RDI,qword ptr [RSP + 0x1d8]
CALL 0x00120250
MOV qword ptr [RSP + 0x1c8],RAX
LAB_0011aa15:
LEA RDI,[RSP + 0x1d0]
LEA RSI,[RSP + 0x1c8]
CALL 0x00120280
TEST AL,0x1
JNZ 0x0011aa33
JMP 0x0011ae14
LAB_0011aa33:
LEA RDI,[RSP + 0x1d0]
CALL 0x001202c0
MOV qword ptr [RSP + 0x1c0],RAX
MOV RDI,qword ptr [RSP + 0x1c0]
CALL 0x001191e0
LAB_0011aa55:
MOV byte ptr [RSP + 0x2f],AL
JMP 0x0011aa5b
LAB_0011aa5b:
MOV AL,byte ptr [RSP + 0x2f]
TEST AL,0x1
JNZ 0x0011aa65
JMP 0x0011aae1
LAB_0011aa65:
MOV EDI,0x10
CALL 0x001191c0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x20],RAX
LAB_0011aa7a:
LEA RSI,[0x12d119]
CALL 0x00119040
JMP 0x0011aa88
LAB_0011aa88:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [0x00136fb8]
MOV RDX,qword ptr [0x00136ff8]
CALL 0x00119350
LAB_0011aae1:
MOV RSI,qword ptr [RSP + 0x1c0]
MOV EDX,dword ptr [RSP + 0x21c]
MOV ECX,dword ptr [RSP + 0x220]
LAB_0011aaf7:
LEA RDI,[RSP + 0x160]
CALL 0x0011faf0
JMP 0x0011ab06
LAB_0011ab06:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x160]
CALL 0x001202d0
JMP 0x0011ab1a
LAB_0011ab1a:
LEA RDI,[RSP + 0x100]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00119050
MOV RSI,qword ptr [RSP + 0x18]
LAB_0011ab31:
LEA RDI,[RSP + 0xe8]
CALL 0x0011fc00
JMP 0x0011ab40
LAB_0011ab40:
LEA RDI,[RSP + 0x160]
LEA RSI,[RSP + 0xe8]
MOV EDX,0x15
VMOVSD XMM0,qword ptr [0x0012d008]
VPXOR XMM1,XMM1,XMM1
CALL 0x00119540
JMP 0x0011ab68
LAB_0011ab68:
LEA RDI,[RSP + 0xe8]
CALL 0x0011fc60
MOV dword ptr [RSP + 0xe4],0x0
LAB_0011ab80:
CMP dword ptr [RSP + 0xe4],0x3
JGE 0x0011ac2d
MOV RAX,qword ptr [RSP + 0x48]
MOV ECX,dword ptr [RSP + 0xe4]
MOV dword ptr [RSP + 0xd0],ECX
MOV qword ptr [RSP + 0xd8],RAX
LAB_0011aba9:
LEA RDI,[RSP + 0x100]
LEA RSI,[RSP + 0xd0]
CALL 0x0011afb0
JMP 0x0011abc0
LAB_0011abc0:
JMP 0x0011abc2
LAB_0011abc2:
MOV EAX,dword ptr [RSP + 0xe4]
ADD EAX,0x1
MOV dword ptr [RSP + 0xe4],EAX
JMP 0x0011ab80
LAB_0011ac2d:
LEA RDI,[RSP + 0xb8]
CALL 0x0011fc70
LAB_0011ac3a:
LEA RDI,[RSP + 0xa0]
LEA RSI,[RSP + 0x100]
CALL 0x0011fc80
JMP 0x0011ac51
LAB_0011ac51:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0xb8]
CALL 0x0011fcc0
JMP 0x0011ac68
LAB_0011ac68:
LEA RDI,[RSP + 0xa0]
LEA RSI,[RSP + 0x88]
CALL 0x00119460
JMP 0x0011ac7f
LAB_0011ac7f:
LEA RDI,[RSP + 0x88]
CALL 0x0011fc60
LEA RDI,[RSP + 0xa0]
CALL 0x0011fd00
LEA RAX,[RSP + 0xb8]
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x0011fd10
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x80]
CALL 0x0011fd40
MOV qword ptr [RSP + 0x70],RAX
LAB_0011accd:
LEA RDI,[RSP + 0x78]
LEA RSI,[RSP + 0x70]
CALL 0x0011fd70
TEST AL,0x1
JNZ 0x0011ace5
JMP 0x0011adb2
LAB_0011ace5:
LEA RDI,[RSP + 0x78]
CALL 0x0011fdb0
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x238]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0011fe70
MOV qword ptr [RSP + 0x58],RAX
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0x58]
CALL 0x0011fea0
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RAX + 0x20]
MOV RSI,qword ptr [RSP + 0x60]
LAB_0011ad31:
CALL 0x0011fdc0
LAB_0011ad36:
MOV qword ptr [RSP + 0x10],RAX
JMP 0x0011ad3d
LAB_0011ad3d:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x50],RAX
LEA RDI,[RSP + 0x78]
CALL 0x0011fee0
JMP 0x0011accd
LAB_0011adb2:
LEA RDI,[RSP + 0xb8]
CALL 0x0011ff00
LEA RDI,[RSP + 0x100]
CALL 0x00119080
LEA RDI,[RSP + 0x160]
CALL 0x00119080
LEA RDI,[RSP + 0x1d0]
CALL 0x00120340
JMP 0x0011aa15
LAB_0011ae14:
MOV byte ptr [RSP + 0x1e7],0x1
TEST byte ptr [RSP + 0x1e7],0x1
JNZ 0x0011ae30
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x0011ff00
LAB_0011ae30:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x258
RET
|
/* WARNING: Removing unreachable block (ram,0x0011ae26) */
/* DepthAnything::preprocessBatch(std::vector<cv::Mat, std::allocator<cv::Mat> > const&,
std::vector<float, std::allocator<float> >&, std::vector<long, std::allocator<long> >&) */
vector * DepthAnything::preprocessBatch(vector *param_1,vector *param_2,vector *param_3)
{
vector<float,std::allocator<float>> *pvVar1;
bool bVar2;
byte bVar3;
ulong uVar4;
runtime_error *prVar5;
vector<float,std::allocator<float>> *in_RCX;
vector<long,std::allocator<long>> *in_R8;
int8 local_200;
int8 local_1f8;
long local_1f0;
int8 local_1e8;
int8 local_1e0;
vector<cv::Mat,std::allocator<cv::Mat>> *local_1d8;
_OutputArray local_1d0 [24];
_InputArray local_1b8 [24];
vector<cv::Mat,std::allocator<cv::Mat>> local_1a0 [24];
int local_188 [2];
vector *local_180;
int local_174;
_OutputArray local_170 [24];
Mat local_158 [96];
DepthUtils local_f8 [96];
Mat *local_98;
int8 local_90;
int8 local_88;
vector<cv::Mat,std::allocator<cv::Mat>> *local_80;
int1 local_71;
long local_70 [3];
long local_58;
long *local_50;
int8 local_48;
int local_40;
int local_3c;
int local_38;
vector<long,std::allocator<long>> *local_28;
vector<float,std::allocator<float>> *local_20;
vector *local_18;
vector *local_10;
vector *local_8;
local_28 = in_R8;
local_20 = in_RCX;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar4 = std::vector<cv::Mat,std::allocator<cv::Mat>>::empty
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_3);
if ((uVar4 & 1) != 0) {
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0011a891 to 0011a89c has its CatchHandler @ 0011a8b7 */
std::runtime_error::runtime_error(prVar5,"Input images vector is empty.");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00136fb8,PTR__runtime_error_00136ff8);
}
determineBatchDimensions((vector *)&local_3c);
local_40 = std::vector<cv::Mat,std::allocator<cv::Mat>>::size
((vector<cv::Mat,std::allocator<cv::Mat>> *)local_18);
local_70[0] = (long)local_40;
local_70[1] = 3;
local_70[2] = (long)local_38;
local_58 = (long)local_3c;
local_50 = local_70;
local_48 = 4;
std::vector<long,std::allocator<long>>::operator=(local_28,local_50,4);
std::vector<float,std::allocator<float>>::reserve
(local_20,(long)(local_40 * local_38 * local_3c * 3));
local_71 = 0;
std::vector<cv::Mat,std::allocator<cv::Mat>>::vector
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1);
uVar4 = std::vector<cv::Mat,std::allocator<cv::Mat>>::size
((vector<cv::Mat,std::allocator<cv::Mat>> *)local_18);
/* try { // try from 0011a9d4 to 0011aa54 has its CatchHandler @ 0011aaa5 */
std::vector<cv::Mat,std::allocator<cv::Mat>>::reserve
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1,uVar4);
local_80 = (vector<cv::Mat,std::allocator<cv::Mat>> *)local_18;
local_88 = std::vector<cv::Mat,std::allocator<cv::Mat>>::begin
((vector<cv::Mat,std::allocator<cv::Mat>> *)local_18);
local_90 = std::vector<cv::Mat,std::allocator<cv::Mat>>::end(local_80);
while( true ) {
bVar2 = __gnu_cxx::operator!=((__normal_iterator *)&local_88,(__normal_iterator *)&local_90);
if (!bVar2) {
return param_1;
}
local_98 = (Mat *)__gnu_cxx::
__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
::operator*((__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
*)&local_88);
bVar3 = cv::Mat::empty();
if ((bVar3 & 1) != 0) break;
/* try { // try from 0011aaf7 to 0011ab03 has its CatchHandler @ 0011aaa5 */
DepthUtils::resize_no_padding(local_f8,local_98,local_3c,local_38);
/* try { // try from 0011ab06 to 0011ab17 has its CatchHandler @ 0011abd5 */
std::vector<cv::Mat,std::allocator<cv::Mat>>::push_back
((vector<cv::Mat,std::allocator<cv::Mat>> *)param_1,(Mat *)local_f8);
cv::Mat::Mat(local_158);
/* try { // try from 0011ab31 to 0011ab3d has its CatchHandler @ 0011abee */
cv::_OutputArray::_OutputArray(local_170,local_158);
/* try { // try from 0011ab40 to 0011ab65 has its CatchHandler @ 0011ac07 */
cv::Mat::convertTo((_OutputArray *)local_f8,(int)local_170,DAT_0012d008,0.0);
cv::_OutputArray::~_OutputArray(local_170);
for (local_174 = 0; local_174 < 3; local_174 = local_174 + 1) {
local_188[0] = local_174;
/* try { // try from 0011aba9 to 0011abbd has its CatchHandler @ 0011abee */
local_180 = param_2;
cv::Mat::
forEach<cv::Vec<float,3>,DepthAnything::preprocessBatch(std::vector<cv::Mat,std::allocator<cv::Mat>>const&,std::vector<float,std::allocator<float>>&,std::vector<long,std::allocator<long>>&)::__0>
(local_158,(__0 *)local_188);
}
std::vector<cv::Mat,std::allocator<cv::Mat>>::vector(local_1a0);
/* try { // try from 0011ac3a to 0011ac4e has its CatchHandler @ 0011ad56 */
cv::_InputArray::_InputArray(local_1b8,local_158);
/* try { // try from 0011ac51 to 0011ac65 has its CatchHandler @ 0011ad6c */
cv::_OutputArray::_OutputArray(local_1d0,(vector *)local_1a0);
/* try { // try from 0011ac68 to 0011ac7c has its CatchHandler @ 0011ad82 */
cv::split(local_1b8,local_1d0);
cv::_OutputArray::~_OutputArray(local_1d0);
cv::_InputArray::~_InputArray(local_1b8);
local_1d8 = local_1a0;
local_1e0 = std::vector<cv::Mat,std::allocator<cv::Mat>>::begin(local_1d8);
local_1e8 = std::vector<cv::Mat,std::allocator<cv::Mat>>::end(local_1d8);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_1e0,(__normal_iterator *)&local_1e8),
bVar2) {
local_1f0 = __gnu_cxx::
__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator*((__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>
*)&local_1e0);
pvVar1 = local_20;
local_200 = std::vector<float,std::allocator<float>>::end(local_20);
__gnu_cxx::__normal_iterator<float_const*,std::vector<float,std::allocator<float>>>::
__normal_iterator<float*>
((__normal_iterator<float_const*,std::vector<float,std::allocator<float>>> *)
&local_1f8,(__normal_iterator *)&local_200);
/* try { // try from 0011ad31 to 0011ad35 has its CatchHandler @ 0011ad56 */
std::vector<float,std::allocator<float>>::insert<float*,void>
(pvVar1,local_1f8,*(int8 *)(local_1f0 + 0x18),
*(int8 *)(local_1f0 + 0x20));
__gnu_cxx::__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator++((__normal_iterator<cv::Mat*,std::vector<cv::Mat,std::allocator<cv::Mat>>> *)
&local_1e0);
}
std::vector<cv::Mat,std::allocator<cv::Mat>>::~vector(local_1a0);
cv::Mat::~Mat(local_158);
cv::Mat::~Mat((Mat *)local_f8);
__gnu_cxx::__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>>::
operator++((__normal_iterator<cv::Mat_const*,std::vector<cv::Mat,std::allocator<cv::Mat>>> *)
&local_88);
}
prVar5 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0011aa7a to 0011aa85 has its CatchHandler @ 0011aabe */
std::runtime_error::runtime_error(prVar5,"One of the input images is empty.");
/* try { // try from 0011aa88 to 0011aa9f has its CatchHandler @ 0011aaa5 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar5,PTR_typeinfo_00136fb8,PTR__runtime_error_00136ff8);
}
| |
22,483 | get_store_length | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static size_t get_store_length(size_t length)
{
#define MAX_STORE_SIZE 9
unsigned char buffer[MAX_STORE_SIZE], *p;
/* We just store the length and subtract offset of our buffer
to determine the length */
p= mysql_net_store_length(buffer, length);
return p - buffer;
} | O0 | c | get_store_length:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x28aa0
movq -0x38(%rbp), %rcx
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x22d99
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
callq 0x134b0
nop
| get_store_length:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_20], rdi
mov rsi, [rbp+var_20]
lea rdi, [rbp+var_11]
mov [rbp+var_38], rdi
call mysql_net_store_length
mov rcx, [rbp+var_38]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_22D99
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
loc_22D99:
call ___stack_chk_fail
| long long get_store_length(long long a1)
{
_BYTE v2[9]; // [rsp+2Fh] [rbp-11h] BYREF
unsigned long long v3; // [rsp+38h] [rbp-8h]
v3 = __readfsqword(0x28u);
return mysql_net_store_length(v2, a1) - (_QWORD)v2;
}
| get_store_length:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x20],RDI
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x11]
MOV qword ptr [RBP + -0x38],RDI
CALL 0x00128aa0
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00122d99
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
LAB_00122d99:
CALL 0x001134b0
|
long get_store_length(int8 param_1)
{
long lVar1;
long in_FS_OFFSET;
int1 local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = mysql_net_store_length(local_19,param_1);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return lVar1 - (long)local_19;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,484 | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/minja.hpp | static std::string strip(const std::string & s) {
auto start = s.find_first_not_of(" \t\n\r");
if (start == std::string::npos) return "";
auto end = s.find_last_not_of(" \t\n\r");
return s.substr(start, end - start + 1);
} | O1 | cpp | minja::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7c95d(%rip), %rsi # 0x118de4
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x1e560
cmpq $-0x1, %rax
je 0x9c4d1
movq %rax, %r15
leaq 0x7c93e(%rip), %rsi # 0x118de4
movl $0x4, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x1e430
subq %r15, %rax
leaq 0x1(%rax), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1dcb0
jmp 0x9c4ea
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6fc5b(%rip), %rdx # 0x10c13a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2698a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
| _ZN5minjaL5stripERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
lea rsi, asc_118DE4; " \t\n\r"
mov ecx, 4
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17find_first_not_ofEPKcmm; std::string::find_first_not_of(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_9C4D1
mov r15, rax
lea rsi, asc_118DE4; " \t\n\r"
mov ecx, 4
mov rdi, r14
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16find_last_not_ofEPKcmm; std::string::find_last_not_of(char const*,ulong,ulong)
sub rax, r15
lea rcx, [rax+1]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short loc_9C4EA
loc_9C4D1:
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aSFailedToLoadI+2Ah; ""
mov rdi, rbx
mov rsi, rdx
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)
loc_9C4EA:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
| _QWORD * minja::strip(_QWORD *a1, long long a2)
{
long long first_not_of; // rax
long long v3; // r15
long long last_not_of; // rax
first_not_of = std::string::find_first_not_of(a2, " \t\n\r", 0LL, 4LL);
if ( first_not_of == -1 )
{
*a1 = a1 + 2;
std::string::_M_construct<char const*>(a1, "", (long long)"");
}
else
{
v3 = first_not_of;
last_not_of = std::string::find_last_not_of(a2, " \t\n\r", -1LL, 4LL);
std::string::substr(a1, a2, v3, last_not_of - v3 + 1);
}
return a1;
}
| strip:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[0x218de4]
MOV ECX,0x4
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011e560
CMP RAX,-0x1
JZ 0x0019c4d1
MOV R15,RAX
LEA RSI,[0x218de4]
MOV ECX,0x4
MOV RDI,R14
MOV RDX,-0x1
CALL 0x0011e430
SUB RAX,R15
LEA RCX,[RAX + 0x1]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011dcb0
JMP 0x0019c4ea
LAB_0019c4d1:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x20c13a]
MOV RDI,RBX
MOV RSI,RDX
CALL 0x0012698a
LAB_0019c4ea:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* minja::strip(std::__cxx11::string const&) */
minja * __thiscall minja::strip(minja *this,string *param_1)
{
long lVar1;
lVar1 = std::__cxx11::string::find_first_not_of((char *)param_1,0x218de4,0);
if (lVar1 == -1) {
*(minja **)this = this + 0x10;
std::__cxx11::string::_M_construct<char_const*>(this,"");
}
else {
std::__cxx11::string::find_last_not_of((char *)param_1,0x218de4,0xffffffffffffffff);
std::__cxx11::string::substr((ulong)this,(ulong)param_1);
}
return this;
}
| |
22,485 | js_resolve_export | bluesky950520[P]quickjs/quickjs.c | static JSResolveResultEnum js_resolve_export(JSContext *ctx,
JSModuleDef **pmodule,
JSExportEntry **pme,
JSModuleDef *m,
JSAtom export_name)
{
JSResolveState ss, *s = &ss;
int i;
JSResolveResultEnum ret;
s->array = NULL;
s->size = 0;
s->count = 0;
ret = js_resolve_export1(ctx, pmodule, pme, m, export_name, s);
for(i = 0; i < s->count; i++)
JS_FreeAtom(ctx, s->array[i].name);
js_free(ctx, s->array);
return ret;
} | O0 | c | js_resolve_export:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movl 0x24(%rsp), %r8d
movq 0x8(%rsp), %r9
callq 0x72780
movl %eax, (%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x72405
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x27d80
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x723c9
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x20af0
movl (%rsp), %eax
addq $0x48, %rsp
retq
nop
| js_resolve_export:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_20], rcx
mov [rsp+48h+var_24], r8d
lea rax, [rsp+48h+var_38]
mov [rsp+48h+var_40], rax
mov rax, [rsp+48h+var_40]
mov qword ptr [rax], 0
mov rax, [rsp+48h+var_40]
mov dword ptr [rax+8], 0
mov rax, [rsp+48h+var_40]
mov dword ptr [rax+0Ch], 0
mov rdi, [rsp+48h+var_8]
mov rsi, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_18]
mov rcx, [rsp+48h+var_20]
mov r8d, [rsp+48h+var_24]
mov r9, [rsp+48h+var_40]
call js_resolve_export1
mov [rsp+48h+var_48], eax
mov [rsp+48h+var_44], 0
loc_723C9:
mov eax, [rsp+48h+var_44]
mov rcx, [rsp+48h+var_40]
cmp eax, [rcx+0Ch]
jge short loc_72405
mov rdi, [rsp+48h+var_8]
mov rax, [rsp+48h+var_40]
mov rax, [rax]
movsxd rcx, [rsp+48h+var_44]
shl rcx, 4
add rax, rcx
mov esi, [rax+8]
call JS_FreeAtom
mov eax, [rsp+48h+var_44]
add eax, 1
mov [rsp+48h+var_44], eax
jmp short loc_723C9
loc_72405:
mov rdi, [rsp+48h+var_8]
mov rax, [rsp+48h+var_40]
mov rsi, [rax]
call js_free
mov eax, [rsp+48h+var_48]
add rsp, 48h
retn
| long long js_resolve_export(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
unsigned int v6; // [rsp+0h] [rbp-48h]
int i; // [rsp+4h] [rbp-44h]
long long v8; // [rsp+10h] [rbp-38h] BYREF
int v9; // [rsp+18h] [rbp-30h]
int v10; // [rsp+1Ch] [rbp-2Ch]
unsigned int v11; // [rsp+24h] [rbp-24h]
long long v12; // [rsp+28h] [rbp-20h]
long long v13; // [rsp+30h] [rbp-18h]
long long v14; // [rsp+38h] [rbp-10h]
long long v15; // [rsp+40h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v12 = a4;
v11 = a5;
v8 = 0LL;
v9 = 0;
v10 = 0;
v6 = js_resolve_export1(a1, a2, a3, a4, a5, &v8);
for ( i = 0; i < v10; ++i )
JS_FreeAtom(v15, *(_DWORD *)(16LL * i + v8 + 8));
js_free(v15, v8);
return v6;
}
| js_resolve_export:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x28],RCX
MOV dword ptr [RSP + 0x24],R8D
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RSP + 0x8]
MOV dword ptr [RAX + 0xc],0x0
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x28]
MOV R8D,dword ptr [RSP + 0x24]
MOV R9,qword ptr [RSP + 0x8]
CALL 0x00172780
MOV dword ptr [RSP],EAX
MOV dword ptr [RSP + 0x4],0x0
LAB_001723c9:
MOV EAX,dword ptr [RSP + 0x4]
MOV RCX,qword ptr [RSP + 0x8]
CMP EAX,dword ptr [RCX + 0xc]
JGE 0x00172405
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOVSXD RCX,dword ptr [RSP + 0x4]
SHL RCX,0x4
ADD RAX,RCX
MOV ESI,dword ptr [RAX + 0x8]
CALL 0x00127d80
MOV EAX,dword ptr [RSP + 0x4]
ADD EAX,0x1
MOV dword ptr [RSP + 0x4],EAX
JMP 0x001723c9
LAB_00172405:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
CALL 0x00120af0
MOV EAX,dword ptr [RSP]
ADD RSP,0x48
RET
|
int4
js_resolve_export(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5)
{
int4 uVar1;
int local_44;
long local_38;
int4 local_30;
int local_2c;
int4 local_24;
int8 local_20;
int8 local_18;
int8 local_10;
int8 local_8;
local_38 = 0;
local_30 = 0;
local_2c = 0;
local_24 = param_5;
local_20 = param_4;
local_18 = param_3;
local_10 = param_2;
local_8 = param_1;
uVar1 = js_resolve_export1(param_1,param_2,param_3,param_4,param_5,&local_38);
for (local_44 = 0; local_44 < local_2c; local_44 = local_44 + 1) {
JS_FreeAtom(local_8,*(int4 *)(local_38 + (long)local_44 * 0x10 + 8));
}
js_free(local_8,local_38);
return uVar1;
}
| |
22,486 | js_resolve_export | bluesky950520[P]quickjs/quickjs.c | static JSResolveResultEnum js_resolve_export(JSContext *ctx,
JSModuleDef **pmodule,
JSExportEntry **pme,
JSModuleDef *m,
JSAtom export_name)
{
JSResolveState ss, *s = &ss;
int i;
JSResolveResultEnum ret;
s->array = NULL;
s->size = 0;
s->count = 0;
ret = js_resolve_export1(ctx, pmodule, pme, m, export_name, s);
for(i = 0; i < s->count; i++)
JS_FreeAtom(ctx, s->array[i].name);
js_free(ctx, s->array);
return ret;
} | O1 | c | js_resolve_export:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq %r14, %r9
callq 0x42cf4
movl %eax, %ebp
cmpl $0x0, 0xc(%r14)
jle 0x42bbc
movl $0x8, %r14d
xorl %r15d, %r15d
movq (%rsp), %rax
movl (%rax,%r14), %esi
movq %rbx, %rdi
callq 0x1fbc4
incq %r15
movslq 0xc(%rsp), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x42b9b
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1bf85
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| js_resolve_export:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
xorps xmm0, xmm0
mov r14, rsp
movaps xmmword ptr [r14], xmm0
mov r9, r14
call js_resolve_export1
mov ebp, eax
cmp dword ptr [r14+0Ch], 0
jle short loc_42BBC
mov r14d, 8
xor r15d, r15d
loc_42B9B:
mov rax, [rsp+38h+var_38]
mov esi, [rax+r14]
mov rdi, rbx
call JS_FreeAtom
inc r15
movsxd rax, [rsp+38h+var_2C]
add r14, 10h
cmp r15, rax
jl short loc_42B9B
loc_42BBC:
mov rsi, [rsp+38h+var_38]
mov rdi, rbx
call js_free
mov eax, ebp
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long js_resolve_export(long long a1, long long a2, long long a3, long long a4, long long a5)
{
unsigned int v5; // ebp
long long v6; // r14
long long v7; // r15
__int128 v9; // [rsp+0h] [rbp-38h] BYREF
v9 = 0LL;
v5 = js_resolve_export1(a1, a2, a3, a4, a5, &v9);
if ( SHIDWORD(v9) > 0 )
{
v6 = 8LL;
v7 = 0LL;
do
{
JS_FreeAtom(a1, *(_DWORD *)(v9 + v6));
++v7;
v6 += 16LL;
}
while ( v7 < SHIDWORD(v9) );
}
js_free(a1, v9);
return v5;
}
| js_resolve_export:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
XORPS XMM0,XMM0
MOV R14,RSP
MOVAPS xmmword ptr [R14],XMM0
MOV R9,R14
CALL 0x00142cf4
MOV EBP,EAX
CMP dword ptr [R14 + 0xc],0x0
JLE 0x00142bbc
MOV R14D,0x8
XOR R15D,R15D
LAB_00142b9b:
MOV RAX,qword ptr [RSP]
MOV ESI,dword ptr [RAX + R14*0x1]
MOV RDI,RBX
CALL 0x0011fbc4
INC R15
MOVSXD RAX,dword ptr [RSP + 0xc]
ADD R14,0x10
CMP R15,RAX
JL 0x00142b9b
LAB_00142bbc:
MOV RSI,qword ptr [RSP]
MOV RDI,RBX
CALL 0x0011bf85
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00142b92) */
/* WARNING: Removing unreachable block (ram,0x00142b9b) */
int4 js_resolve_export(int8 param_1)
{
int4 uVar1;
uVar1 = js_resolve_export1();
js_free(param_1,0);
return uVar1;
}
| |
22,487 | minja::Value::empty() const | monkey531[P]llama/common/minja.hpp | bool empty() const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_string()) return primitive_.empty();
if (is_array()) return array_->empty();
if (is_object()) return object_->empty();
return false;
} | O2 | cpp | minja::Value::empty() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x64022
testb %al, %al
jne 0x64581
cmpb $0x3, 0x40(%rbx)
jne 0x64559
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x647ec
movq 0x10(%rbx), %rax
testq %rax, %rax
jne 0x6456b
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x6457d
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0x64575
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x4f5c7(%rip), %rsi # 0xb3b5a
movq %rax, %rdi
callq 0x23310
movq 0x99a4e(%rip), %rsi # 0xfdff0
movq 0x999af(%rip), %rdx # 0xfdf58
movq %rbx, %rdi
callq 0x23f20
movq %rax, %r14
movq %rbx, %rdi
callq 0x23690
movq %r14, %rdi
callq 0x23fb0
| _ZNK5minja5Value5emptyEv:
push r14
push rbx
push rax
mov rbx, rdi
call _ZNK5minja5Value7is_nullEv; minja::Value::is_null(void)
test al, al
jnz short loc_64581
cmp byte ptr [rbx+40h], 3
jnz short loc_64559
add rbx, 40h ; '@'
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::empty(void)
loc_64559:
mov rax, [rbx+10h]
test rax, rax
jnz short loc_6456B
mov rax, [rbx+20h]
test rax, rax
jz short loc_6457D
loc_6456B:
mov rcx, [rax]
cmp rcx, [rax+8]
setz al
loc_64575:
add rsp, 8
pop rbx
pop r14
retn
loc_6457D:
xor eax, eax
jmp short loc_64575
loc_64581:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| char minja::Value::empty(minja::Value *this)
{
_QWORD *v2; // rax
std::runtime_error *exception; // rbx
if ( minja::Value::is_null(this) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( *((_BYTE *)this + 64) == 3 )
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>::empty((char *)this + 64);
v2 = (_QWORD *)*((_QWORD *)this + 2);
return (v2 || (v2 = (_QWORD *)*((_QWORD *)this + 4)) != 0LL) && *v2 == v2[1];
}
| empty:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x00164022
TEST AL,AL
JNZ 0x00164581
CMP byte ptr [RBX + 0x40],0x3
JNZ 0x00164559
ADD RBX,0x40
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001647ec
LAB_00164559:
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JNZ 0x0016456b
MOV RAX,qword ptr [RBX + 0x20]
TEST RAX,RAX
JZ 0x0016457d
LAB_0016456b:
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
SETZ AL
LAB_00164575:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_0016457d:
XOR EAX,EAX
JMP 0x00164575
LAB_00164581:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_0016458c:
LEA RSI,[0x1b3b5a]
MOV RDI,RAX
CALL 0x00123310
LAB_0016459b:
MOV RSI,qword ptr [0x001fdff0]
MOV RDX,qword ptr [0x001fdf58]
MOV RDI,RBX
CALL 0x00123f20
|
/* minja::Value::empty() const */
int8 __thiscall minja::Value::empty(Value *this)
{
char cVar1;
int8 uVar2;
long *plVar3;
runtime_error *this_00;
cVar1 = is_null(this);
if (cVar1 != '\0') {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0016458c to 0016459a has its CatchHandler @ 001645b1 */
std::runtime_error::runtime_error(this_00,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001fdff0,PTR__runtime_error_001fdf58);
}
if (this[0x40] == (Value)0x3) {
uVar2 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::empty((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 + 0x40));
return uVar2;
}
plVar3 = *(long **)(this + 0x10);
if ((plVar3 == (long *)0x0) && (plVar3 = *(long **)(this + 0x20), plVar3 == (long *)0x0)) {
uVar2 = 0;
}
else {
uVar2 = CONCAT71((int7)((ulong)plVar3 >> 8),*plVar3 == plVar3[1]);
}
return uVar2;
}
| |
22,488 | minja::Value::empty() const | monkey531[P]llama/common/minja.hpp | bool empty() const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_string()) return primitive_.empty();
if (is_array()) return array_->empty();
if (is_object()) return object_->empty();
return false;
} | O3 | cpp | minja::Value::empty() const:
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
movb 0x40(%rdi), %sil
testq %rcx, %rcx
jne 0x87ca0
testq %rdx, %rdx
jne 0x87ca0
testb %sil, %sil
jne 0x87ca0
cmpq $0x0, 0x30(%rdi)
je 0x87cd0
movq %rdx, %rax
orq %rcx, %rax
sete %dil
xorl %eax, %eax
cmpb $0x3, %sil
je 0x87cc8
testb %dil, %dil
jne 0x87cc8
testq %rdx, %rdx
cmovneq %rdx, %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1a430
movq %rax, %rbx
leaq 0x67ed6(%rip), %rsi # 0xefbba
movq %rax, %rdi
callq 0x1a310
movq 0xa42fd(%rip), %rsi # 0x12bff0
movq 0xa4266(%rip), %rdx # 0x12bf60
movq %rbx, %rdi
callq 0x1af20
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a670
movq %r14, %rdi
callq 0x1afb0
| _ZNK5minja5Value5emptyEv:
push r14
push rbx
push rax
mov rdx, [rdi+10h]
mov rcx, [rdi+20h]
mov sil, [rdi+40h]
test rcx, rcx
jnz short loc_87CA0
test rdx, rdx
jnz short loc_87CA0
test sil, sil
jnz short loc_87CA0
cmp qword ptr [rdi+30h], 0
jz short loc_87CD0
loc_87CA0:
mov rax, rdx
or rax, rcx
setz dil
xor eax, eax
cmp sil, 3
jz short loc_87CC8
test dil, dil
jnz short loc_87CC8
test rdx, rdx
cmovnz rcx, rdx
mov rax, [rcx]
cmp rax, [rcx+8]
setz al
loc_87CC8:
add rsp, 8
pop rbx
pop r14
retn
loc_87CD0:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| bool minja::Value::empty(minja::Value *this)
{
unsigned long long v1; // rdx
_QWORD *v2; // rcx
char v3; // si
bool result; // al
std::runtime_error *exception; // rbx
v1 = *((_QWORD *)this + 2);
v2 = (_QWORD *)*((_QWORD *)this + 4);
v3 = *((_BYTE *)this + 64);
if ( __PAIR128__((unsigned long long)v2, v1) == 0 && !v3 && !*((_QWORD *)this + 6) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
result = 0;
if ( v3 != 3 && __PAIR128__((unsigned long long)v2, v1) != 0 )
{
if ( v1 )
v2 = (_QWORD *)*((_QWORD *)this + 2);
return *v2 == v2[1];
}
return result;
}
| empty:
PUSH R14
PUSH RBX
PUSH RAX
MOV RDX,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RDI + 0x20]
MOV SIL,byte ptr [RDI + 0x40]
TEST RCX,RCX
JNZ 0x00187ca0
TEST RDX,RDX
JNZ 0x00187ca0
TEST SIL,SIL
JNZ 0x00187ca0
CMP qword ptr [RDI + 0x30],0x0
JZ 0x00187cd0
LAB_00187ca0:
MOV RAX,RDX
OR RAX,RCX
SETZ DIL
XOR EAX,EAX
CMP SIL,0x3
JZ 0x00187cc8
TEST DIL,DIL
JNZ 0x00187cc8
TEST RDX,RDX
CMOVNZ RCX,RDX
MOV RAX,qword ptr [RCX]
CMP RAX,qword ptr [RCX + 0x8]
SETZ AL
LAB_00187cc8:
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_00187cd0:
MOV EDI,0x10
CALL 0x0011a430
MOV RBX,RAX
LAB_00187cdd:
LEA RSI,[0x1efbba]
MOV RDI,RAX
CALL 0x0011a310
LAB_00187cec:
MOV RSI,qword ptr [0x0022bff0]
MOV RDX,qword ptr [0x0022bf60]
MOV RDI,RBX
CALL 0x0011af20
|
/* minja::Value::empty() const */
int8 __thiscall minja::Value::empty(Value *this)
{
long *plVar1;
int8 uVar2;
runtime_error *this_00;
long *plVar3;
plVar1 = *(long **)(this + 0x10);
plVar3 = *(long **)(this + 0x20);
if ((((plVar3 == (long *)0x0) && (plVar1 == (long *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00187cdd to 00187ceb has its CatchHandler @ 00187d02 */
std::runtime_error::runtime_error(this_00,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022bff0,PTR__runtime_error_0022bf60);
}
uVar2 = 0;
if ((this[0x40] != (Value)0x3) && (plVar1 != (long *)0x0 || plVar3 != (long *)0x0)) {
if (plVar1 != (long *)0x0) {
plVar3 = plVar1;
}
uVar2 = CONCAT71((int7)((ulong)*plVar3 >> 8),*plVar3 == plVar3[1]);
}
return uVar2;
}
| |
22,489 | common_log::resume() | monkey531[P]llama/common/log.cpp | void resume() {
std::lock_guard<std::mutex> lock(mtx);
if (running) {
return;
}
running = true;
thrd = std::thread([this]() {
while (true) {
{
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]() { return head != tail; });
cur = entries[head];
head = (head + 1) % entries.size();
}
if (cur.is_end) {
break;
}
cur.print(); // stdout and stderr
if (file) {
cur.print(file);
}
}
});
} | O3 | cpp | common_log::resume():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x1ad00
testl %eax, %eax
jne 0xcbe45
cmpb $0x0, 0x6a(%rbx)
jne 0xcbe35
movb $0x1, 0x6a(%rbx)
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0xcc678
cmpq $0x0, 0x28(%rbx)
jne 0xcbe4c
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rdi
callq 0x1a6c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl %eax, %edi
callq 0x1a600
callq 0x1a220
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a6c0
movq %r14, %rdi
callq 0x1afc0
| _ZN10common_log6resumeEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
call _pthread_mutex_lock
test eax, eax
jnz short loc_CBE45
cmp byte ptr [rbx+6Ah], 0
jnz short loc_CBE35
mov byte ptr [rbx+6Ah], 1
lea rsi, [rsp+28h+var_18]
mov [rsi], rbx
lea rdi, [rsp+28h+var_20]
call _ZNSt6threadC2IZN10common_log6resumeEvEUlvE_JEvEEOT_DpOT0_
cmp qword ptr [rbx+28h], 0
jnz short loc_CBE4C
mov rax, [rsp+28h+var_20]
mov [rbx+28h], rax
loc_CBE35:
mov rdi, rbx
call _pthread_mutex_unlock
add rsp, 18h
pop rbx
pop r14
retn
loc_CBE45:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
loc_CBE4C:
call __ZSt9terminatev; std::terminate(void)
mov r14, rax
mov rdi, rbx
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long common_log::resume(common_log *this)
{
int v1; // eax
_QWORD v3[4]; // [rsp+8h] [rbp-20h] BYREF
v1 = pthread_mutex_lock();
if ( v1 )
std::__throw_system_error(v1);
if ( !*((_BYTE *)this + 106) )
{
*((_BYTE *)this + 106) = 1;
v3[1] = this;
ZNSt6threadC2IZN10common_log6resumeEvEUlvE_JEvEEOT_DpOT0_(v3);
if ( *((_QWORD *)this + 5) )
std::terminate();
*((_QWORD *)this + 5) = v3[0];
}
return pthread_mutex_unlock(this);
}
| resume:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
CALL 0x0011ad00
TEST EAX,EAX
JNZ 0x001cbe45
CMP byte ptr [RBX + 0x6a],0x0
JNZ 0x001cbe35
MOV byte ptr [RBX + 0x6a],0x1
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RBX
LAB_001cbe1b:
LEA RDI,[RSP + 0x8]
CALL 0x001cc678
LAB_001cbe25:
CMP qword ptr [RBX + 0x28],0x0
JNZ 0x001cbe4c
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x28],RAX
LAB_001cbe35:
MOV RDI,RBX
CALL 0x0011a6c0
ADD RSP,0x18
POP RBX
POP R14
RET
LAB_001cbe45:
MOV EDI,EAX
CALL 0x0011a600
LAB_001cbe4c:
CALL 0x0011a220
|
/* common_log::resume() */
void __thiscall common_log::resume(common_log *this)
{
int iVar1;
int8 local_20;
common_log *local_18;
iVar1 = pthread_mutex_lock((pthread_mutex_t *)this);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar1);
}
if (this[0x6a] == (common_log)0x0) {
this[0x6a] = (common_log)0x1;
/* try { // try from 001cbe1b to 001cbe24 has its CatchHandler @ 001cbe51 */
local_18 = this;
std::thread::thread<common_log::resume()::_lambda()_1_,,void>
((thread *)&local_20,(_lambda___1_ *)&local_18);
if (*(long *)(this + 0x28) != 0) {
/* WARNING: Subroutine does not return */
std::terminate();
}
*(int8 *)(this + 0x28) = local_20;
}
pthread_mutex_unlock((pthread_mutex_t *)this);
return;
}
| |
22,490 | mul_fp6x2 | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/fp12_tower.c | static void mul_fp6x2(vec768fp6 ret, const vec384fp6 a, const vec384fp6 b)
{
vec768x t0, t1, t2;
vec384x aa, bb;
mul_fp2x2(t0, a[0], b[0]);
mul_fp2x2(t1, a[1], b[1]);
mul_fp2x2(t2, a[2], b[2]);
/* ret[0] = ((a1 + a2)*(b1 + b2) - a1*b1 - a2*b2)*(u+1) + a0*b0
= (a1*b2 + a2*b1)*(u+1) + a0*b0 */
add_fp2(aa, a[1], a[2]);
add_fp2(bb, b[1], b[2]);
mul_fp2x2(ret[0], aa, bb);
sub_fp2x2(ret[0], ret[0], t1);
sub_fp2x2(ret[0], ret[0], t2);
mul_by_u_plus_1_fp2x2(ret[1], ret[0]); /* borrow ret[1] for a moment */
add_fp2x2(ret[0], ret[1], t0);
/* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1 + a2*b2*(u+1)
= a0*b1 + a1*b0 + a2*b2*(u+1) */
add_fp2(aa, a[0], a[1]);
add_fp2(bb, b[0], b[1]);
mul_fp2x2(ret[1], aa, bb);
sub_fp2x2(ret[1], ret[1], t0);
sub_fp2x2(ret[1], ret[1], t1);
mul_by_u_plus_1_fp2x2(ret[2], t2); /* borrow ret[2] for a moment */
add_fp2x2(ret[1], ret[1], ret[2]);
/* ret[2] = (a0 + a2)*(b0 + b2) - a0*b0 - a2*b2 + a1*b1
= a0*b2 + a2*b0 + a1*b1 */
add_fp2(aa, a[0], a[2]);
add_fp2(bb, b[0], b[2]);
mul_fp2x2(ret[2], aa, bb);
sub_fp2x2(ret[2], ret[2], t0);
sub_fp2x2(ret[2], ret[2], t2);
add_fp2x2(ret[2], ret[2], t1);
} | O2 | c | mul_fp6x2:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x290(%rbp), %rdi
callq 0x5cec8
leaq 0x60(%r14), %r12
movq %r14, -0x40(%rbp)
leaq 0x60(%r13), %rdx
movq %rdx, -0x30(%rbp)
movq %r13, -0x38(%rbp)
leaq -0x1d0(%rbp), %rdi
movq %r12, %rsi
callq 0x5cec8
movl $0xc0, %r15d
addq %r15, %r14
addq %r15, %r13
leaq -0x350(%rbp), %rdi
movq %r14, %rsi
movq %r14, -0x50(%rbp)
movq %r13, %rdx
movq %r13, -0x48(%rbp)
callq 0x5cec8
leaq -0x110(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5acb9
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
callq 0x5acb9
movq %rbx, %rdi
leaq -0x110(%rbp), %r13
movq %r13, %rsi
movq %r14, %rdx
callq 0x5cec8
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x1d0(%rbp), %rdx
callq 0x5ced9
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x350(%rbp), %rdx
callq 0x5ced9
addq %rbx, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5cf21
movq %rbx, %rdi
movq %r15, %rsi
leaq -0x290(%rbp), %rdx
callq 0x5cf65
movq %r13, %rdi
movq -0x40(%rbp), %r14
movq %r14, %rsi
movq %r12, %rdx
callq 0x5acb9
leaq -0xb0(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5acb9
movq %r15, %rdi
movq %r13, %rsi
leaq -0xb0(%rbp), %rdx
callq 0x5cec8
movq %r15, %rdi
movq %r15, %rsi
leaq -0x290(%rbp), %rdx
callq 0x5ced9
movq %r15, %rdi
movq %r15, %rsi
leaq -0x1d0(%rbp), %rdx
callq 0x5ced9
addq $0x180, %rbx # imm = 0x180
movq %rbx, %rdi
leaq -0x350(%rbp), %r12
movq %r12, %rsi
callq 0x5cf21
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5cf65
movq %r13, %rdi
movq %r14, %rsi
movq -0x50(%rbp), %rdx
callq 0x5acb9
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x5acb9
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x5cec8
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x290(%rbp), %rdx
callq 0x5ced9
movq %rbx, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x5ced9
movq %rbx, %rdi
movq %rbx, %rsi
leaq -0x1d0(%rbp), %rdx
callq 0x5cf65
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mul_fp6x2:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 328h
mov r13, rdx
mov r14, rsi
mov rbx, rdi
lea rdi, [rbp+var_290]
call mul_fp2x2
lea r12, [r14+60h]
mov [rbp+var_40], r14
lea rdx, [r13+60h]
mov [rbp+var_30], rdx
mov [rbp+var_38], r13
lea rdi, [rbp+var_1D0]
mov rsi, r12
call mul_fp2x2
mov r15d, 0C0h
add r14, r15
add r13, r15
lea rdi, [rbp+var_350]
mov rsi, r14
mov [rbp+var_50], r14
mov rdx, r13
mov [rbp+var_48], r13
call mul_fp2x2
lea rdi, [rbp+var_110]
mov rsi, r12
mov rdx, r14
call add_fp2
lea r14, [rbp+var_B0]
mov rdi, r14
mov rsi, [rbp+var_30]
mov rdx, r13
call add_fp2
mov rdi, rbx
lea r13, [rbp+var_110]
mov rsi, r13
mov rdx, r14
call mul_fp2x2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_1D0]
call _sub_fp2x2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_350]
call _sub_fp2x2
add r15, rbx
mov rdi, r15
mov rsi, rbx
call mul_by_u_plus_1_fp2x2
mov rdi, rbx
mov rsi, r15
lea rdx, [rbp+var_290]
call add_fp2x2
mov rdi, r13
mov r14, [rbp+var_40]
mov rsi, r14
mov rdx, r12
call add_fp2
lea rdi, [rbp+var_B0]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_30]
call add_fp2
mov rdi, r15
mov rsi, r13
lea rdx, [rbp+var_B0]
call mul_fp2x2
mov rdi, r15
mov rsi, r15
lea rdx, [rbp+var_290]
call _sub_fp2x2
mov rdi, r15
mov rsi, r15
lea rdx, [rbp+var_1D0]
call _sub_fp2x2
add rbx, 180h
mov rdi, rbx
lea r12, [rbp+var_350]
mov rsi, r12
call mul_by_u_plus_1_fp2x2
mov rdi, r15
mov rsi, r15
mov rdx, rbx
call add_fp2x2
mov rdi, r13
mov rsi, r14
mov rdx, [rbp+var_50]
call add_fp2
lea r14, [rbp+var_B0]
mov rdi, r14
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_48]
call add_fp2
mov rdi, rbx
mov rsi, r13
mov rdx, r14
call mul_fp2x2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_290]
call _sub_fp2x2
mov rdi, rbx
mov rsi, rbx
mov rdx, r12
call _sub_fp2x2
mov rdi, rbx
mov rsi, rbx
lea rdx, [rbp+var_1D0]
call add_fp2x2
add rsp, 328h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mul_fp6x2(long long a1, long long a2, long long a3)
{
long long v3; // r13
long long v5; // r15
long long v6; // r14
long long v7; // rbx
_BYTE v9[192]; // [rsp+0h] [rbp-350h] BYREF
_BYTE v10[192]; // [rsp+C0h] [rbp-290h] BYREF
_BYTE v11[192]; // [rsp+180h] [rbp-1D0h] BYREF
_BYTE v12[96]; // [rsp+240h] [rbp-110h] BYREF
_BYTE v13[96]; // [rsp+2A0h] [rbp-B0h] BYREF
long long v14; // [rsp+300h] [rbp-50h]
long long v15; // [rsp+308h] [rbp-48h]
long long v16; // [rsp+310h] [rbp-40h]
long long v17; // [rsp+318h] [rbp-38h]
long long v18; // [rsp+320h] [rbp-30h]
v3 = a3;
mul_fp2x2(v10, a2, a3);
v16 = a2;
v18 = v3 + 96;
v17 = v3;
mul_fp2x2(v11, a2 + 96, v3 + 96);
v3 += 192LL;
v14 = a2 + 192;
v15 = v3;
mul_fp2x2(v9, a2 + 192, v3);
add_fp2((long long)v12, a2 + 96, a2 + 192);
add_fp2((long long)v13, v18, v3);
mul_fp2x2(a1, v12, v13);
sub_fp2x2(a1, a1, v11);
sub_fp2x2(a1, a1, v9);
v5 = a1 + 192;
mul_by_u_plus_1_fp2x2(a1 + 192, a1);
add_fp2x2(a1, a1 + 192, v10);
v6 = v16;
add_fp2((long long)v12, v16, a2 + 96);
add_fp2((long long)v13, v17, v18);
mul_fp2x2(a1 + 192, v12, v13);
sub_fp2x2(v5, v5, v10);
sub_fp2x2(v5, v5, v11);
v7 = a1 + 384;
mul_by_u_plus_1_fp2x2(a1 + 384, v9);
add_fp2x2(v5, v5, a1 + 384);
add_fp2((long long)v12, v6, v14);
add_fp2((long long)v13, v17, v15);
mul_fp2x2(a1 + 384, v12, v13);
sub_fp2x2(v7, v7, v10);
sub_fp2x2(v7, v7, v9);
return add_fp2x2(v7, v7, v11);
}
| mul_fp6x2:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x328
MOV R13,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RBP + -0x290]
CALL 0x0015cec8
LEA R12,[R14 + 0x60]
MOV qword ptr [RBP + -0x40],R14
LEA RDX,[R13 + 0x60]
MOV qword ptr [RBP + -0x30],RDX
MOV qword ptr [RBP + -0x38],R13
LEA RDI,[RBP + -0x1d0]
MOV RSI,R12
CALL 0x0015cec8
MOV R15D,0xc0
ADD R14,R15
ADD R13,R15
LEA RDI,[RBP + -0x350]
MOV RSI,R14
MOV qword ptr [RBP + -0x50],R14
MOV RDX,R13
MOV qword ptr [RBP + -0x48],R13
CALL 0x0015cec8
LEA RDI,[RBP + -0x110]
MOV RSI,R12
MOV RDX,R14
CALL 0x0015acb9
LEA R14,[RBP + -0xb0]
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R13
CALL 0x0015acb9
MOV RDI,RBX
LEA R13,[RBP + -0x110]
MOV RSI,R13
MOV RDX,R14
CALL 0x0015cec8
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x1d0]
CALL 0x0015ced9
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x350]
CALL 0x0015ced9
ADD R15,RBX
MOV RDI,R15
MOV RSI,RBX
CALL 0x0015cf21
MOV RDI,RBX
MOV RSI,R15
LEA RDX,[RBP + -0x290]
CALL 0x0015cf65
MOV RDI,R13
MOV R14,qword ptr [RBP + -0x40]
MOV RSI,R14
MOV RDX,R12
CALL 0x0015acb9
LEA RDI,[RBP + -0xb0]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x0015acb9
MOV RDI,R15
MOV RSI,R13
LEA RDX,[RBP + -0xb0]
CALL 0x0015cec8
MOV RDI,R15
MOV RSI,R15
LEA RDX,[RBP + -0x290]
CALL 0x0015ced9
MOV RDI,R15
MOV RSI,R15
LEA RDX,[RBP + -0x1d0]
CALL 0x0015ced9
ADD RBX,0x180
MOV RDI,RBX
LEA R12,[RBP + -0x350]
MOV RSI,R12
CALL 0x0015cf21
MOV RDI,R15
MOV RSI,R15
MOV RDX,RBX
CALL 0x0015cf65
MOV RDI,R13
MOV RSI,R14
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x0015acb9
LEA R14,[RBP + -0xb0]
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x0015acb9
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R14
CALL 0x0015cec8
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x290]
CALL 0x0015ced9
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R12
CALL 0x0015ced9
MOV RDI,RBX
MOV RSI,RBX
LEA RDX,[RBP + -0x1d0]
CALL 0x0015cf65
ADD RSP,0x328
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void mul_fp6x2(long param_1,long param_2,long param_3)
{
long lVar1;
long lVar2;
long lVar3;
int1 local_358 [192];
int1 local_298 [192];
int1 local_1d8 [192];
int1 local_118 [96];
int1 local_b8 [96];
long local_58;
long local_50;
long local_48;
long local_40;
long local_38;
mul_fp2x2(local_298);
lVar1 = param_2 + 0x60;
local_38 = param_3 + 0x60;
local_48 = param_2;
local_40 = param_3;
mul_fp2x2(local_1d8,lVar1);
param_2 = param_2 + 0xc0;
param_3 = param_3 + 0xc0;
local_58 = param_2;
local_50 = param_3;
mul_fp2x2(local_358,param_2,param_3);
add_fp2(local_118,lVar1,param_2);
add_fp2(local_b8,local_38,param_3);
mul_fp2x2(param_1,local_118,local_b8);
sub_fp2x2(param_1,param_1,local_1d8);
sub_fp2x2(param_1,param_1,local_358);
lVar3 = param_1 + 0xc0;
mul_by_u_plus_1_fp2x2(lVar3,param_1);
add_fp2x2(param_1,lVar3,local_298);
lVar2 = local_48;
add_fp2(local_118,local_48,lVar1);
add_fp2(local_b8,local_40,local_38);
mul_fp2x2(lVar3,local_118,local_b8);
sub_fp2x2(lVar3,lVar3,local_298);
sub_fp2x2(lVar3,lVar3,local_1d8);
param_1 = param_1 + 0x180;
mul_by_u_plus_1_fp2x2(param_1,local_358);
add_fp2x2(lVar3,lVar3,param_1);
add_fp2(local_118,lVar2,local_58);
add_fp2(local_b8,local_40,local_50);
mul_fp2x2(param_1,local_118,local_b8);
sub_fp2x2(param_1,param_1,local_298);
sub_fp2x2(param_1,param_1,local_358);
add_fp2x2(param_1,param_1,local_1d8);
return;
}
| |
22,491 | glfwCreateCursorX11 | untodesu[P]riteg/build_O3/_deps/glfw-src/src/x11_init.c | Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle)
return None;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native->yhot = yhot;
unsigned char* source = (unsigned char*) image->pixels;
XcursorPixel* target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4)
{
unsigned int alpha = source[3];
*target = (alpha << 24) |
((unsigned char) ((source[0] * alpha) / 255) << 16) |
((unsigned char) ((source[1] * alpha) / 255) << 8) |
((unsigned char) ((source[2] * alpha) / 255) << 0);
}
cursor = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
return cursor;
} | O3 | c | glfwCreateCursorX11:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x8a0b4(%rip), %r12 # 0xa8638
cmpq $0x0, 0x20668(%r12)
je 0x1e657
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %esi
callq *0x20670(%r12)
testq %rax, %rax
je 0x1e657
movq %rax, %r14
movl %r15d, 0x10(%rax)
movl %ebp, 0x14(%rax)
movl 0x4(%rbx), %eax
imull (%rbx), %eax
testl %eax, %eax
jle 0x1e631
movq 0x20(%r14), %rax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movzbl 0x3(%rcx,%rdx,4), %esi
movzbl (%rcx,%rdx,4), %edi
imull %esi, %edi
movzbl 0x1(%rcx,%rdx,4), %r8d
imull %esi, %r8d
movzbl 0x2(%rcx,%rdx,4), %r9d
imull %esi, %r9d
shll $0x18, %esi
imull $0x8081, %edi, %edi # imm = 0x8081
shrl $0x7, %edi
andl $0xff0000, %edi # imm = 0xFF0000
orl %esi, %edi
imull $0x8081, %r8d, %esi # imm = 0x8081
shrl $0xf, %esi
andl $0xff00, %esi # imm = 0xFF00
orl %edi, %esi
imull $0x8081, %r9d, %edi # imm = 0x8081
shrl $0x17, %edi
addl %esi, %edi
movl %edi, (%rax,%rdx,4)
movl 0x4(%rbx), %esi
imull (%rbx), %esi
incq %rdx
cmpl %esi, %edx
jl 0x1e5cf
movq 0x1fec0(%r12), %rdi
movq %r14, %rsi
callq *0x20680(%r12)
movq %rax, %rbx
movq %r14, %rdi
callq *0x20678(%r12)
movq %rbx, %rax
jmp 0x1e659
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _glfwCreateCursorX11:
push rbp
push r15
push r14
push r12
push rbx
lea r12, _glfw
cmp qword ptr [r12+20668h], 0
jz loc_1E657
mov ebp, edx
mov r15d, esi
mov rbx, rdi
mov edi, [rdi]
mov esi, [rbx+4]
call qword ptr [r12+20670h]
test rax, rax
jz loc_1E657
mov r14, rax
mov [rax+10h], r15d
mov [rax+14h], ebp
mov eax, [rbx+4]
imul eax, [rbx]
test eax, eax
jle short loc_1E631
mov rax, [r14+20h]
mov rcx, [rbx+8]
xor edx, edx
loc_1E5CF:
movzx esi, byte ptr [rcx+rdx*4+3]
movzx edi, byte ptr [rcx+rdx*4]
imul edi, esi
movzx r8d, byte ptr [rcx+rdx*4+1]
imul r8d, esi
movzx r9d, byte ptr [rcx+rdx*4+2]
imul r9d, esi
shl esi, 18h
imul edi, 8081h
shr edi, 7
and edi, 0FF0000h
or edi, esi
imul esi, r8d, 8081h
shr esi, 0Fh
and esi, 0FF00h
or esi, edi
imul edi, r9d, 8081h
shr edi, 17h
add edi, esi
mov [rax+rdx*4], edi
mov esi, [rbx+4]
imul esi, [rbx]
inc rdx
cmp edx, esi
jl short loc_1E5CF
loc_1E631:
mov rdi, [r12+1FEC0h]
mov rsi, r14
call qword ptr [r12+20680h]
mov rbx, rax
mov rdi, r14
call qword ptr [r12+20678h]
mov rax, rbx
jmp short loc_1E659
loc_1E657:
xor eax, eax
loc_1E659:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long glfwCreateCursorX11(unsigned int *a1, int a2, int a3)
{
long long v4; // rax
long long v5; // r14
long long v6; // rax
long long v7; // rcx
long long v8; // rdx
int v9; // esi
long long v10; // rbx
if ( !*(_QWORD *)&glfw[33178] )
return 0LL;
v4 = (*(long long ( **)(_QWORD, _QWORD))&glfw[33180])(*a1, a1[1]);
if ( !v4 )
return 0LL;
v5 = v4;
*(_DWORD *)(v4 + 16) = a2;
*(_DWORD *)(v4 + 20) = a3;
if ( (int)(*a1 * a1[1]) > 0 )
{
v6 = *(_QWORD *)(v4 + 32);
v7 = *((_QWORD *)a1 + 1);
v8 = 0LL;
do
{
v9 = *(unsigned __int8 *)(v7 + 4 * v8 + 3);
*(_DWORD *)(v6 + 4 * v8) = ((v9 << 24) | ((32897 * v9 * (unsigned int)*(unsigned __int8 *)(v7 + 4 * v8)) >> 7) & 0xFF0000 | ((32897 * v9 * (unsigned int)*(unsigned __int8 *)(v7 + 4 * v8 + 1)) >> 15) & 0xFF00)
+ ((32897 * v9 * (unsigned int)*(unsigned __int8 *)(v7 + 4 * v8 + 2)) >> 23);
++v8;
}
while ( (int)v8 < (int)(*a1 * a1[1]) );
}
v10 = (*(long long ( **)(_QWORD, long long))&glfw[33184])(*(_QWORD *)&glfw[32688], v5);
(*(void ( **)(long long))&glfw[33182])(v5);
return v10;
}
| _glfwCreateCursorX11:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
LEA R12,[0x1a8638]
CMP qword ptr [R12 + 0x20668],0x0
JZ 0x0011e657
MOV EBP,EDX
MOV R15D,ESI
MOV RBX,RDI
MOV EDI,dword ptr [RDI]
MOV ESI,dword ptr [RBX + 0x4]
CALL qword ptr [R12 + 0x20670]
TEST RAX,RAX
JZ 0x0011e657
MOV R14,RAX
MOV dword ptr [RAX + 0x10],R15D
MOV dword ptr [RAX + 0x14],EBP
MOV EAX,dword ptr [RBX + 0x4]
IMUL EAX,dword ptr [RBX]
TEST EAX,EAX
JLE 0x0011e631
MOV RAX,qword ptr [R14 + 0x20]
MOV RCX,qword ptr [RBX + 0x8]
XOR EDX,EDX
LAB_0011e5cf:
MOVZX ESI,byte ptr [RCX + RDX*0x4 + 0x3]
MOVZX EDI,byte ptr [RCX + RDX*0x4]
IMUL EDI,ESI
MOVZX R8D,byte ptr [RCX + RDX*0x4 + 0x1]
IMUL R8D,ESI
MOVZX R9D,byte ptr [RCX + RDX*0x4 + 0x2]
IMUL R9D,ESI
SHL ESI,0x18
IMUL EDI,EDI,0x8081
SHR EDI,0x7
AND EDI,0xff0000
OR EDI,ESI
IMUL ESI,R8D,0x8081
SHR ESI,0xf
AND ESI,0xff00
OR ESI,EDI
IMUL EDI,R9D,0x8081
SHR EDI,0x17
ADD EDI,ESI
MOV dword ptr [RAX + RDX*0x4],EDI
MOV ESI,dword ptr [RBX + 0x4]
IMUL ESI,dword ptr [RBX]
INC RDX
CMP EDX,ESI
JL 0x0011e5cf
LAB_0011e631:
MOV RDI,qword ptr [R12 + 0x1fec0]
MOV RSI,R14
CALL qword ptr [R12 + 0x20680]
MOV RBX,RAX
MOV RDI,R14
CALL qword ptr [R12 + 0x20678]
MOV RAX,RBX
JMP 0x0011e659
LAB_0011e657:
XOR EAX,EAX
LAB_0011e659:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 _glfwCreateCursorX11(int *param_1,int4 param_2,int4 param_3)
{
byte bVar1;
long lVar2;
long lVar3;
long lVar4;
int8 uVar5;
long lVar6;
if ((DAT_001c8ca0 != 0) && (lVar4 = (*DAT_001c8ca8)(*param_1,param_1[1]), lVar4 != 0)) {
*(int4 *)(lVar4 + 0x10) = param_2;
*(int4 *)(lVar4 + 0x14) = param_3;
if (0 < param_1[1] * *param_1) {
lVar2 = *(long *)(lVar4 + 0x20);
lVar3 = *(long *)(param_1 + 2);
lVar6 = 0;
do {
bVar1 = *(byte *)(lVar3 + 3 + lVar6 * 4);
*(uint *)(lVar2 + lVar6 * 4) =
((uint)*(byte *)(lVar3 + 2 + lVar6 * 4) * (uint)bVar1) / 0xff +
((uint)*(byte *)(lVar3 + 1 + lVar6 * 4) * (uint)bVar1 * 0x8081 >> 0xf & 0xff00 |
(uint)*(byte *)(lVar3 + lVar6 * 4) * (uint)bVar1 * 0x8081 >> 7 & 0xff0000 |
(uint)bVar1 << 0x18);
lVar6 = lVar6 + 1;
} while ((int)lVar6 < param_1[1] * *param_1);
}
uVar5 = (*DAT_001c8cb8)(DAT_001c84f8,lVar4);
(*DAT_001c8cb0)(lVar4);
return uVar5;
}
return 0;
}
| |
22,492 | my_xml_enter | eloqsql/strings/xml.c | static int my_xml_enter(MY_XML_PARSER *st, const char *str, size_t len)
{
if (my_xml_attr_ensure_space(st, len + 1 /* the separator char */))
return MY_XML_ERROR;
if (st->attr.end > st->attr.start)
{
st->attr.end[0]= '/';
st->attr.end++;
}
memcpy(st->attr.end, str, len);
st->attr.end+= len;
st->attr.end[0]= '\0';
if (st->flags & MY_XML_FLAG_RELATIVE_NAMES)
return st->enter ? st->enter(st, str, len) : MY_XML_OK;
else
return st->enter ?
st->enter(st, st->attr.start, st->attr.end - st->attr.start) : MY_XML_OK;
} | O3 | c | my_xml_enter:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x120(%rdi), %rdi
movq 0x110(%rbx), %rcx
movq 0x118(%rbx), %rax
movq %rdi, %r12
subq %rax, %r12
addq %r12, %rdx
addq $0x2, %rdx
cmpq %rcx, %rdx
jbe 0x5affd
leaq 0x2(%r14), %rax
movq $-0x3, %rdx
subq %r14, %rdx
shrq %rdx
cmpq %rcx, %rdx
leaq (%rax,%rcx,2), %rax
movq $-0x1, %rdx
cmovaq %rax, %rdx
movq %rdx, 0x110(%rbx)
movq 0x108(%rbx), %rsi
xorl %edi, %edi
testq %rsi, %rsi
je 0x5afab
xorl %ecx, %ecx
callq 0x261d0
movq %rax, 0x108(%rbx)
jmp 0x5afe0
movq %rdx, %rsi
xorl %edx, %edx
callq 0x260ad
movq %rax, 0x108(%rbx)
testq %rax, %rax
je 0x5b07b
leaq 0x88(%rbx), %rsi
leaq 0x1(%r12), %rdx
movq %rax, %rdi
callq 0x24240
movq 0x108(%rbx), %rax
movq %rax, 0x118(%rbx)
addq %rax, %r12
movq %r12, 0x120(%rbx)
movq %r12, %rdi
testq %rax, %rax
je 0x5b08d
cmpq %rax, %rdi
jbe 0x5b016
movb $0x2f, (%rdi)
movq 0x120(%rbx), %rdi
incq %rdi
movq %rdi, 0x120(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x24240
movq 0x120(%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, 0x120(%rbx)
movb $0x0, (%rax,%r14)
testb $0x1, (%rbx)
movq 0x148(%rbx), %rax
jne 0x5b05f
testq %rax, %rax
je 0x5b077
movq 0x118(%rbx), %rsi
movq 0x120(%rbx), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
jmp 0x5b06d
testq %rax, %rax
je 0x5b077
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
jmp 0x5b092
movq $0x0, 0x118(%rbx)
movq %r12, 0x120(%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_xml_enter:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, [rdi+120h]
mov rcx, [rbx+110h]
mov rax, [rbx+118h]
mov r12, rdi
sub r12, rax
add rdx, r12
add rdx, 2
cmp rdx, rcx
jbe loc_5AFFD
lea rax, [r14+2]
mov rdx, 0FFFFFFFFFFFFFFFDh
sub rdx, r14
shr rdx, 1
cmp rdx, rcx
lea rax, [rax+rcx*2]
mov rdx, 0FFFFFFFFFFFFFFFFh
cmova rdx, rax
mov [rbx+110h], rdx
mov rsi, [rbx+108h]
xor edi, edi
test rsi, rsi
jz short loc_5AFAB
xor ecx, ecx
call my_realloc
mov [rbx+108h], rax
jmp short loc_5AFE0
loc_5AFAB:
mov rsi, rdx
xor edx, edx
call my_malloc
mov [rbx+108h], rax
test rax, rax
jz loc_5B07B
lea rsi, [rbx+88h]
lea rdx, [r12+1]
mov rdi, rax
call _memcpy
mov rax, [rbx+108h]
loc_5AFE0:
mov [rbx+118h], rax
add r12, rax
mov [rbx+120h], r12
mov rdi, r12
test rax, rax
jz loc_5B08D
loc_5AFFD:
cmp rdi, rax
jbe short loc_5B016
mov byte ptr [rdi], 2Fh ; '/'
mov rdi, [rbx+120h]
inc rdi
mov [rbx+120h], rdi
loc_5B016:
mov rsi, r15
mov rdx, r14
call _memcpy
mov rax, [rbx+120h]
lea rcx, [rax+r14]
mov [rbx+120h], rcx
mov byte ptr [rax+r14], 0
test byte ptr [rbx], 1
mov rax, [rbx+148h]
jnz short loc_5B05F
test rax, rax
jz short loc_5B077
mov rsi, [rbx+118h]
mov rdx, [rbx+120h]
sub rdx, rsi
mov rdi, rbx
jmp short loc_5B06D
loc_5B05F:
test rax, rax
jz short loc_5B077
mov rdi, rbx
mov rsi, r15
mov rdx, r14
loc_5B06D:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp rax
loc_5B077:
xor eax, eax
jmp short loc_5B092
loc_5B07B:
mov qword ptr [rbx+118h], 0
mov [rbx+120h], r12
loc_5B08D:
mov eax, 1
loc_5B092:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_xml_enter(long long a1, long long a2, long long a3)
{
_BYTE *v6; // rdi
unsigned long long v7; // rcx
unsigned long long v8; // rax
_BYTE *v9; // r12
bool v10; // cc
unsigned long long v11; // rdx
long long v12; // rsi
long long v13; // rax
_BYTE *v14; // r12
_BYTE *v15; // rcx
long long ( *v16)(long long, long long, long long); // rax
long long v17; // rsi
long long v18; // rdx
long long v19; // rdi
v6 = *(_BYTE **)(a1 + 288);
v7 = *(_QWORD *)(a1 + 272);
v8 = *(_QWORD *)(a1 + 280);
v9 = &v6[-v8];
if ( (unsigned long long)&v6[a3 - v8 + 2] > v7 )
{
v10 = (unsigned long long)(-3 - a3) >> 1 <= v7;
v11 = -1LL;
if ( !v10 )
v11 = a3 + 2 + 2 * v7;
*(_QWORD *)(a1 + 272) = v11;
v12 = *(_QWORD *)(a1 + 264);
if ( v12 )
{
v8 = my_realloc(0, v12, v11, 0);
*(_QWORD *)(a1 + 264) = v8;
}
else
{
v13 = my_malloc(0, v11, 0);
*(_QWORD *)(a1 + 264) = v13;
if ( !v13 )
{
*(_QWORD *)(a1 + 280) = 0LL;
*(_QWORD *)(a1 + 288) = v9;
return 1LL;
}
memcpy(v13, a1 + 136, v9 + 1);
v8 = *(_QWORD *)(a1 + 264);
}
*(_QWORD *)(a1 + 280) = v8;
v14 = &v9[v8];
*(_QWORD *)(a1 + 288) = v14;
v6 = v14;
if ( v8 )
goto LABEL_9;
return 1LL;
}
LABEL_9:
if ( (unsigned long long)v6 > v8 )
{
*v6 = 47;
v6 = (_BYTE *)(*(_QWORD *)(a1 + 288) + 1LL);
*(_QWORD *)(a1 + 288) = v6;
}
memcpy(v6, a2, a3);
v15 = (_BYTE *)(*(_QWORD *)(a1 + 288) + a3);
*(_QWORD *)(a1 + 288) = v15;
*v15 = 0;
v16 = *(long long ( **)(long long, long long, long long))(a1 + 328);
if ( (*(_BYTE *)a1 & 1) != 0 )
{
if ( v16 )
{
v19 = a1;
v17 = a2;
v18 = a3;
return v16(v19, v17, v18);
}
}
else if ( v16 )
{
v17 = *(_QWORD *)(a1 + 280);
v18 = *(_QWORD *)(a1 + 288) - v17;
v19 = a1;
return v16(v19, v17, v18);
}
return 0LL;
}
| my_xml_enter:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x120]
MOV RCX,qword ptr [RBX + 0x110]
MOV RAX,qword ptr [RBX + 0x118]
MOV R12,RDI
SUB R12,RAX
ADD RDX,R12
ADD RDX,0x2
CMP RDX,RCX
JBE 0x0015affd
LEA RAX,[R14 + 0x2]
MOV RDX,-0x3
SUB RDX,R14
SHR RDX,0x1
CMP RDX,RCX
LEA RAX,[RAX + RCX*0x2]
MOV RDX,-0x1
CMOVA RDX,RAX
MOV qword ptr [RBX + 0x110],RDX
MOV RSI,qword ptr [RBX + 0x108]
XOR EDI,EDI
TEST RSI,RSI
JZ 0x0015afab
XOR ECX,ECX
CALL 0x001261d0
MOV qword ptr [RBX + 0x108],RAX
JMP 0x0015afe0
LAB_0015afab:
MOV RSI,RDX
XOR EDX,EDX
CALL 0x001260ad
MOV qword ptr [RBX + 0x108],RAX
TEST RAX,RAX
JZ 0x0015b07b
LEA RSI,[RBX + 0x88]
LEA RDX,[R12 + 0x1]
MOV RDI,RAX
CALL 0x00124240
MOV RAX,qword ptr [RBX + 0x108]
LAB_0015afe0:
MOV qword ptr [RBX + 0x118],RAX
ADD R12,RAX
MOV qword ptr [RBX + 0x120],R12
MOV RDI,R12
TEST RAX,RAX
JZ 0x0015b08d
LAB_0015affd:
CMP RDI,RAX
JBE 0x0015b016
MOV byte ptr [RDI],0x2f
MOV RDI,qword ptr [RBX + 0x120]
INC RDI
MOV qword ptr [RBX + 0x120],RDI
LAB_0015b016:
MOV RSI,R15
MOV RDX,R14
CALL 0x00124240
MOV RAX,qword ptr [RBX + 0x120]
LEA RCX,[RAX + R14*0x1]
MOV qword ptr [RBX + 0x120],RCX
MOV byte ptr [RAX + R14*0x1],0x0
TEST byte ptr [RBX],0x1
MOV RAX,qword ptr [RBX + 0x148]
JNZ 0x0015b05f
TEST RAX,RAX
JZ 0x0015b077
MOV RSI,qword ptr [RBX + 0x118]
MOV RDX,qword ptr [RBX + 0x120]
SUB RDX,RSI
MOV RDI,RBX
JMP 0x0015b06d
LAB_0015b05f:
TEST RAX,RAX
JZ 0x0015b077
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
LAB_0015b06d:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP RAX
LAB_0015b077:
XOR EAX,EAX
JMP 0x0015b092
LAB_0015b07b:
MOV qword ptr [RBX + 0x118],0x0
MOV qword ptr [RBX + 0x120],R12
LAB_0015b08d:
MOV EAX,0x1
LAB_0015b092:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 my_xml_enter(byte *param_1,void *param_2,size_t param_3)
{
ulong uVar1;
code *UNRECOVERED_JUMPTABLE;
int1 *puVar2;
void *__dest;
int8 uVar3;
long lVar4;
long lVar5;
int1 *__dest_00;
__dest_00 = *(int1 **)(param_1 + 0x120);
uVar1 = *(ulong *)(param_1 + 0x110);
puVar2 = *(int1 **)(param_1 + 0x118);
lVar5 = (long)__dest_00 - (long)puVar2;
if (uVar1 < param_3 + lVar5 + 2) {
lVar4 = -1;
if (uVar1 < -param_3 - 3 >> 1) {
lVar4 = param_3 + 2 + uVar1 * 2;
}
*(long *)(param_1 + 0x110) = lVar4;
if (*(long *)(param_1 + 0x108) == 0) {
__dest = (void *)my_malloc(0,lVar4,0);
*(void **)(param_1 + 0x108) = __dest;
if (__dest != (void *)0x0) {
memcpy(__dest,param_1 + 0x88,lVar5 + 1);
puVar2 = *(int1 **)(param_1 + 0x108);
goto LAB_0015afe0;
}
param_1[0x118] = 0;
param_1[0x119] = 0;
param_1[0x11a] = 0;
param_1[0x11b] = 0;
param_1[0x11c] = 0;
param_1[0x11d] = 0;
param_1[0x11e] = 0;
param_1[0x11f] = 0;
*(long *)(param_1 + 0x120) = lVar5;
}
else {
puVar2 = (int1 *)my_realloc();
*(int1 **)(param_1 + 0x108) = puVar2;
LAB_0015afe0:
*(int1 **)(param_1 + 0x118) = puVar2;
__dest_00 = puVar2 + lVar5;
*(int1 **)(param_1 + 0x120) = __dest_00;
if (puVar2 != (int1 *)0x0) goto LAB_0015affd;
}
uVar3 = 1;
}
else {
LAB_0015affd:
if (puVar2 < __dest_00) {
*__dest_00 = 0x2f;
__dest_00 = (int1 *)(*(long *)(param_1 + 0x120) + 1);
*(int1 **)(param_1 + 0x120) = __dest_00;
}
memcpy(__dest_00,param_2,param_3);
lVar5 = *(long *)(param_1 + 0x120);
*(size_t *)(param_1 + 0x120) = lVar5 + param_3;
*(int1 *)(lVar5 + param_3) = 0;
UNRECOVERED_JUMPTABLE = *(code **)(param_1 + 0x148);
if ((*param_1 & 1) == 0) {
if (UNRECOVERED_JUMPTABLE != (code *)0x0) {
param_2 = *(void **)(param_1 + 0x118);
param_3 = *(long *)(param_1 + 0x120) - (long)param_2;
LAB_0015b06d:
/* WARNING: Could not recover jumptable at 0x0015b075. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(param_1,param_2,param_3);
return uVar3;
}
}
else if (UNRECOVERED_JUMPTABLE != (code *)0x0) goto LAB_0015b06d;
uVar3 = 0;
}
return uVar3;
}
| |
22,493 | my_convert_using_func | eloqsql/strings/ctype.c | uint32
my_convert_using_func(char *to, size_t to_length,
CHARSET_INFO *to_cs, my_charset_conv_wc_mb wc_mb,
const char *from, size_t from_length,
CHARSET_INFO *from_cs, my_charset_conv_mb_wc mb_wc,
uint *errors)
{
int cnvres;
my_wc_t wc;
const uchar *from_end= (const uchar*) from + from_length;
char *to_start= to;
uchar *to_end= (uchar*) to + to_length;
uint error_count= 0;
while (1)
{
if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
from+= cnvres;
else if (cnvres == MY_CS_ILSEQ)
{
error_count++;
from++;
wc= '?';
}
else if (cnvres > MY_CS_TOOSMALL)
{
/*
A correct multibyte sequence detected
But it doesn't have Unicode mapping.
*/
error_count++;
from+= (-cnvres);
wc= '?';
}
else
{
if ((uchar *) from >= from_end)
break; /* End of line */
/* Incomplete byte sequence */
error_count++;
from++;
wc= '?';
}
outp:
if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
to+= cnvres;
else if (cnvres == MY_CS_ILUNI && wc != '?')
{
error_count++;
wc= '?';
goto outp;
}
else
break;
}
*errors= error_count;
return (uint32) (to - to_start);
} | O0 | c | my_convert_using_func:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x48(%rbp), %rcx
leaq -0x40(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x7d074
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x7d0f2
cmpl $0x0, -0x34(%rbp)
jne 0x7d099
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7d0f0
cmpl $-0x65, -0x34(%rbp)
jle 0x7d0c5
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
xorl %ecx, %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7d0ee
movq -0x28(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x7d0d1
jmp 0x7d14c
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7d0f0
jmp 0x7d0f2
jmp 0x7d0f4
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x7d125
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7d147
cmpl $0x0, -0x34(%rbp)
jne 0x7d145
cmpq $0x3f, -0x40(%rbp)
je 0x7d145
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq $0x3f, -0x40(%rbp)
jmp 0x7d0f4
jmp 0x7d14c
jmp 0x7d043
movl -0x5c(%rbp), %ecx
movq 0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_convert_using_func:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_58], rax
mov [rbp+var_5C], 0
loc_7D043:
mov rax, [rbp+arg_8]
mov rdi, [rbp+arg_0]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_48]
lea rsi, [rbp+var_40]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_7D074
mov ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp short loc_7D0F2
loc_7D074:
cmp [rbp+var_34], 0
jnz short loc_7D099
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_7D0F0
loc_7D099:
cmp [rbp+var_34], 0FFFFFF9Bh
jle short loc_7D0C5
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
xor ecx, ecx
sub ecx, [rbp+var_34]
mov rax, [rbp+var_28]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_7D0EE
loc_7D0C5:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_48]
jb short loc_7D0D1
jmp short loc_7D14C
loc_7D0D1:
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov [rbp+var_40], 3Fh ; '?'
loc_7D0EE:
jmp short $+2
loc_7D0F0:
jmp short $+2
loc_7D0F2:
jmp short $+2
loc_7D0F4:
mov rax, [rbp+var_20]
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_8]
mov rcx, [rbp+var_58]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_7D125
mov ecx, [rbp+var_34]
mov rax, [rbp+var_8]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_8], rax
jmp short loc_7D147
loc_7D125:
cmp [rbp+var_34], 0
jnz short loc_7D145
cmp [rbp+var_40], 3Fh ; '?'
jz short loc_7D145
mov eax, [rbp+var_5C]
add eax, 1
mov [rbp+var_5C], eax
mov [rbp+var_40], 3Fh ; '?'
jmp short loc_7D0F4
loc_7D145:
jmp short loc_7D14C
loc_7D147:
jmp loc_7D043
loc_7D14C:
mov ecx, [rbp+var_5C]
mov rax, [rbp+arg_10]
mov [rax], ecx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| long long my_convert_using_func(
long long a1,
long long a2,
long long a3,
long long ( *a4)(long long, long long, long long, long long),
unsigned long long a5,
long long a6,
long long a7,
long long ( *a8)(long long, long long *, unsigned long long, unsigned long long),
_DWORD *a9)
{
int v10; // [rsp+4h] [rbp-5Ch]
unsigned long long v11; // [rsp+18h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-40h] BYREF
int v13; // [rsp+2Ch] [rbp-34h]
long long v14; // [rsp+30h] [rbp-30h]
unsigned long long v15; // [rsp+38h] [rbp-28h]
long long ( *v16)(long long, long long, long long, long long); // [rsp+40h] [rbp-20h]
long long v17; // [rsp+48h] [rbp-18h]
long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v14 = a6;
v11 = a6 + a5;
v10 = 0;
while ( 1 )
{
v13 = a8(a7, &v12, v15, v11);
if ( v13 > 0 )
{
v15 += v13;
goto LABEL_10;
}
if ( !v13 )
{
++v10;
++v15;
v12 = 63LL;
goto LABEL_10;
}
if ( v13 > -101 )
{
++v10;
v15 += -v13;
v12 = 63LL;
goto LABEL_10;
}
if ( v15 >= v11 )
break;
++v10;
++v15;
v12 = 63LL;
LABEL_10:
while ( 1 )
{
v13 = v16(v17, v12, v19, a2 + a1);
if ( v13 > 0 )
break;
if ( v13 || v12 == 63 )
goto LABEL_15;
++v10;
v12 = 63LL;
}
v19 += v13;
}
LABEL_15:
*a9 = v10;
return v19 - a1;
}
| my_convert_using_func:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV dword ptr [RBP + -0x5c],0x0
LAB_0017d043:
MOV RAX,qword ptr [RBP + 0x18]
MOV RDI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x48]
LEA RSI,[RBP + -0x40]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0017d074
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0017d0f2
LAB_0017d074:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0017d099
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x0017d0f0
LAB_0017d099:
CMP dword ptr [RBP + -0x34],-0x65
JLE 0x0017d0c5
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
XOR ECX,ECX
SUB ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x0017d0ee
LAB_0017d0c5:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x0017d0d1
JMP 0x0017d14c
LAB_0017d0d1:
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x40],0x3f
LAB_0017d0ee:
JMP 0x0017d0f0
LAB_0017d0f0:
JMP 0x0017d0f2
LAB_0017d0f2:
JMP 0x0017d0f4
LAB_0017d0f4:
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x58]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0017d125
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017d147
LAB_0017d125:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x0017d145
CMP qword ptr [RBP + -0x40],0x3f
JZ 0x0017d145
MOV EAX,dword ptr [RBP + -0x5c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x5c],EAX
MOV qword ptr [RBP + -0x40],0x3f
JMP 0x0017d0f4
LAB_0017d145:
JMP 0x0017d14c
LAB_0017d147:
JMP 0x0017d043
LAB_0017d14c:
MOV ECX,dword ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + 0x20]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_convert_using_func
(long param_1,long param_2,int8 param_3,code *param_4,ulong param_5,
long param_6,int8 param_7,code *param_8,int *param_9)
{
int local_64;
long local_48;
int local_3c;
long local_38;
ulong local_30;
code *local_28;
int8 local_20;
long local_18;
long local_10;
local_64 = 0;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
do {
local_3c = (*param_8)(param_7,&local_48,local_30);
if (local_3c < 1) {
if (local_3c == 0) {
local_30 = local_30 + 1;
}
else if (local_3c < -100) {
if (param_5 + param_6 <= local_30) {
LAB_0017d14c:
*param_9 = local_64;
return local_10 - param_1;
}
local_30 = local_30 + 1;
}
else {
local_30 = local_30 + (long)-local_3c;
}
local_64 = local_64 + 1;
local_48 = 0x3f;
}
else {
local_30 = local_30 + (long)local_3c;
}
while (local_3c = (*local_28)(local_20,local_48,local_10,param_1 + param_2), local_3c < 1) {
if ((local_3c != 0) || (local_48 == 0x3f)) goto LAB_0017d14c;
local_64 = local_64 + 1;
local_48 = 0x3f;
local_3c = 0;
}
local_10 = local_10 + local_3c;
} while( true );
}
| |
22,494 | my_convert_using_func | eloqsql/strings/ctype.c | uint32
my_convert_using_func(char *to, size_t to_length,
CHARSET_INFO *to_cs, my_charset_conv_wc_mb wc_mb,
const char *from, size_t from_length,
CHARSET_INFO *from_cs, my_charset_conv_mb_wc mb_wc,
uint *errors)
{
int cnvres;
my_wc_t wc;
const uchar *from_end= (const uchar*) from + from_length;
char *to_start= to;
uchar *to_end= (uchar*) to + to_length;
uint error_count= 0;
while (1)
{
if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
from+= cnvres;
else if (cnvres == MY_CS_ILSEQ)
{
error_count++;
from++;
wc= '?';
}
else if (cnvres > MY_CS_TOOSMALL)
{
/*
A correct multibyte sequence detected
But it doesn't have Unicode mapping.
*/
error_count++;
from+= (-cnvres);
wc= '?';
}
else
{
if ((uchar *) from >= from_end)
break; /* End of line */
/* Incomplete byte sequence */
error_count++;
from++;
wc= '?';
}
outp:
if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
to+= cnvres;
else if (cnvres == MY_CS_ILUNI && wc != '?')
{
error_count++;
wc= '?';
goto outp;
}
else
break;
}
*errors= error_count;
return (uint32) (to - to_start);
} | O3 | c | my_convert_using_func:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r13
movq %rcx, -0x40(%rbp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq %r8, %r9
movq %r9, -0x48(%rbp)
addq %rdi, %r14
xorl %r12d, %r12d
movq %rdi, -0x50(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %r13, %rdx
movq -0x48(%rbp), %rcx
callq *0x18(%rbp)
testl %eax, %eax
jle 0x5dc1e
movl %eax, %eax
addq %rax, %r13
movq %r13, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %r13
jmp 0x5dc63
movq %r13, -0x30(%rbp)
je 0x5dc3b
cmpl $-0x64, %eax
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r13
jb 0x5dc51
incl %r12d
negl %eax
addq %rax, %rcx
jmp 0x5dc5d
incl %r12d
incq -0x30(%rbp)
movq $0x3f, -0x38(%rbp)
movl $0x3f, %esi
jmp 0x5dc18
cmpq -0x48(%rbp), %rcx
jae 0x5dc9e
incl %r12d
incq %rcx
movq %rcx, -0x30(%rbp)
jmp 0x5dc81
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *%r13
testl %eax, %eax
jg 0x5dc90
testl %eax, %eax
jne 0x5dc9e
cmpq $0x3f, -0x38(%rbp)
je 0x5dc9e
incl %r12d
movq $0x3f, -0x38(%rbp)
movl $0x3f, %esi
jmp 0x5dc63
movl %eax, %eax
addq %rax, %r15
movq -0x30(%rbp), %r13
jmp 0x5dbf5
movq 0x20(%rbp), %rax
movl %r12d, (%rax)
subl -0x50(%rbp), %r15d
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_convert_using_func:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13, r8
mov [rbp+var_40], rcx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
add r9, r8
mov [rbp+var_48], r9
add r14, rdi
xor r12d, r12d
mov [rbp+var_50], rdi
loc_5DBF5:
mov rdi, [rbp+arg_0]
lea rsi, [rbp+var_38]
mov rdx, r13
mov rcx, [rbp+var_48]
call [rbp+arg_8]
test eax, eax
jle short loc_5DC1E
mov eax, eax
add r13, rax
mov [rbp+var_30], r13
mov rsi, [rbp+var_38]
loc_5DC18:
mov r13, [rbp+var_40]
jmp short loc_5DC63
loc_5DC1E:
mov [rbp+var_30], r13
jz short loc_5DC3B
cmp eax, 0FFFFFF9Ch
mov rcx, [rbp+var_30]
mov r13, [rbp+var_40]
jb short loc_5DC51
inc r12d
neg eax
add rcx, rax
jmp short loc_5DC5D
loc_5DC3B:
inc r12d
inc [rbp+var_30]
mov [rbp+var_38], 3Fh ; '?'
mov esi, 3Fh ; '?'
jmp short loc_5DC18
loc_5DC51:
cmp rcx, [rbp+var_48]
jnb short loc_5DC9E
inc r12d
inc rcx
loc_5DC5D:
mov [rbp+var_30], rcx
jmp short loc_5DC81
loc_5DC63:
mov rdi, rbx
mov rdx, r15
mov rcx, r14
call r13
test eax, eax
jg short loc_5DC90
test eax, eax
jnz short loc_5DC9E
cmp [rbp+var_38], 3Fh ; '?'
jz short loc_5DC9E
inc r12d
loc_5DC81:
mov [rbp+var_38], 3Fh ; '?'
mov esi, 3Fh ; '?'
jmp short loc_5DC63
loc_5DC90:
mov eax, eax
add r15, rax
mov r13, [rbp+var_30]
jmp loc_5DBF5
loc_5DC9E:
mov rax, [rbp+arg_10]
mov [rax], r12d
sub r15d, dword ptr [rbp+var_50]
mov eax, r15d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_convert_using_func(
long long a1,
long long a2,
long long a3,
long long ( *a4)(long long, long long, long long, long long),
long long a5,
long long a6,
long long a7,
long long ( *a8)(long long, long long *, long long, unsigned long long),
_DWORD *a9)
{
long long v9; // r13
long long v11; // r15
long long v12; // r14
int v13; // r12d
int v14; // eax
long long v15; // rsi
long long ( *v16)(long long, long long, long long, long long); // r13
int v17; // eax
unsigned long long v18; // rcx
unsigned long long v20; // [rsp+8h] [rbp-48h]
long long v22; // [rsp+18h] [rbp-38h] BYREF
unsigned long long v23; // [rsp+20h] [rbp-30h]
v9 = a5;
v11 = a1;
v20 = a5 + a6;
v12 = a1 + a2;
v13 = 0;
while ( 1 )
{
v14 = a8(a7, &v22, v9, v20);
if ( v14 > 0 )
{
v23 = (unsigned int)v14 + v9;
v15 = v22;
LABEL_4:
v16 = a4;
v17 = a4(a3, v15, v11, v12);
goto LABEL_12;
}
v23 = v9;
if ( !v14 )
{
++v13;
++v23;
v22 = 63LL;
v15 = 63LL;
goto LABEL_4;
}
v16 = a4;
if ( (unsigned int)v14 < 0xFFFFFF9C )
break;
++v13;
v18 = (unsigned int)-v14 + v23;
LABEL_11:
v23 = v18;
while ( 1 )
{
v22 = 63LL;
v17 = v16(a3, 63LL, v11, v12);
LABEL_12:
if ( v17 > 0 )
break;
if ( v17 || v22 == 63 )
goto LABEL_18;
++v13;
}
v11 += (unsigned int)v17;
v9 = v23;
}
if ( v23 < v20 )
{
++v13;
v18 = v23 + 1;
goto LABEL_11;
}
LABEL_18:
*a9 = v13;
return (unsigned int)(v11 - a1);
}
| my_convert_using_func:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13,R8
MOV qword ptr [RBP + -0x40],RCX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
ADD R9,R8
MOV qword ptr [RBP + -0x48],R9
ADD R14,RDI
XOR R12D,R12D
MOV qword ptr [RBP + -0x50],RDI
LAB_0015dbf5:
MOV RDI,qword ptr [RBP + 0x10]
LEA RSI,[RBP + -0x38]
MOV RDX,R13
MOV RCX,qword ptr [RBP + -0x48]
CALL qword ptr [RBP + 0x18]
TEST EAX,EAX
JLE 0x0015dc1e
MOV EAX,EAX
ADD R13,RAX
MOV qword ptr [RBP + -0x30],R13
MOV RSI,qword ptr [RBP + -0x38]
LAB_0015dc18:
MOV R13,qword ptr [RBP + -0x40]
JMP 0x0015dc63
LAB_0015dc1e:
MOV qword ptr [RBP + -0x30],R13
JZ 0x0015dc3b
CMP EAX,-0x64
MOV RCX,qword ptr [RBP + -0x30]
MOV R13,qword ptr [RBP + -0x40]
JC 0x0015dc51
INC R12D
NEG EAX
ADD RCX,RAX
JMP 0x0015dc5d
LAB_0015dc3b:
INC R12D
INC qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],0x3f
MOV ESI,0x3f
JMP 0x0015dc18
LAB_0015dc51:
CMP RCX,qword ptr [RBP + -0x48]
JNC 0x0015dc9e
INC R12D
INC RCX
LAB_0015dc5d:
MOV qword ptr [RBP + -0x30],RCX
JMP 0x0015dc81
LAB_0015dc63:
MOV RDI,RBX
MOV RDX,R15
MOV RCX,R14
CALL R13
TEST EAX,EAX
JG 0x0015dc90
TEST EAX,EAX
JNZ 0x0015dc9e
CMP qword ptr [RBP + -0x38],0x3f
JZ 0x0015dc9e
INC R12D
LAB_0015dc81:
MOV qword ptr [RBP + -0x38],0x3f
MOV ESI,0x3f
JMP 0x0015dc63
LAB_0015dc90:
MOV EAX,EAX
ADD R15,RAX
MOV R13,qword ptr [RBP + -0x30]
JMP 0x0015dbf5
LAB_0015dc9e:
MOV RAX,qword ptr [RBP + 0x20]
MOV dword ptr [RAX],R12D
SUB R15D,dword ptr [RBP + -0x50]
MOV EAX,R15D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_convert_using_func
(long param_1,long param_2,int8 param_3,code *param_4,ulong param_5,long param_6
,int8 param_7,code *param_8,int *param_9)
{
uint uVar1;
ulong uVar2;
int iVar3;
long lVar4;
int local_58;
long local_40;
ulong local_38;
uVar2 = param_6 + param_5;
iVar3 = 0;
lVar4 = param_1;
do {
uVar1 = (*param_8)(param_7,&local_40,param_5,uVar2);
if ((int)uVar1 < 1) {
if (uVar1 != 0) {
if (0xffffff9b < uVar1) {
local_38 = param_5 + -uVar1;
goto LAB_0015dc81;
}
if (param_5 < uVar2) {
local_38 = param_5 + 1;
goto LAB_0015dc81;
}
LAB_0015dc9e:
*param_9 = iVar3;
local_58 = (int)param_1;
return (int)lVar4 - local_58;
}
iVar3 = iVar3 + 1;
local_38 = param_5 + 1;
local_40 = 0x3f;
}
else {
local_38 = param_5 + uVar1;
}
while (uVar1 = (*param_4)(param_3,local_40,lVar4,param_2 + param_1), (int)uVar1 < 1) {
if ((uVar1 != 0) || (local_40 == 0x3f)) goto LAB_0015dc9e;
LAB_0015dc81:
iVar3 = iVar3 + 1;
local_40 = 0x3f;
}
lVar4 = lVar4 + (ulong)uVar1;
param_5 = local_38;
} while( true );
}
| |
22,495 | my_xml_attr_ensure_space | eloqsql/strings/xml.c | static int my_xml_attr_ensure_space(MY_XML_PARSER *st, size_t len)
{
size_t ofs= st->attr.end - st->attr.start;
len++; // Add terminating zero.
if (ofs + len > st->attr.buffer_size)
{
st->attr.buffer_size= (SIZE_T_MAX - len) / 2 > st->attr.buffer_size ?
st->attr.buffer_size * 2 + len : SIZE_T_MAX;
if (!st->attr.buffer)
{
st->attr.buffer= (char *) my_malloc(PSI_INSTRUMENT_ME, st->attr.buffer_size, MYF(0));
if (st->attr.buffer)
memcpy(st->attr.buffer, st->attr.static_buffer, ofs + 1 /*term. zero */);
}
else
st->attr.buffer= (char *) my_realloc(PSI_INSTRUMENT_ME, st->attr.buffer,
st->attr.buffer_size, MYF(0));
st->attr.start= st->attr.buffer;
st->attr.end= st->attr.start + ofs;
return st->attr.buffer ? MY_XML_OK : MY_XML_ERROR;
}
return MY_XML_OK;
} | O0 | c | my_xml_attr_ensure_space:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x118(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jbe 0x89253
movq $-0x1, %rax
subq -0x18(%rbp), %rax
shrq %rax
movq -0x10(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jbe 0x89155
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
shlq %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x89162
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x89162
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x110(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
jne 0x891d6
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x32270
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x891d4
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x88, %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x25230
jmp 0x89205
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rdx
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %ecx
callq 0x32440
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdx
movl $0x1, %eax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x8925a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_xml_attr_ensure_space:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+118h]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+110h]
jbe loc_89253
mov rax, 0FFFFFFFFFFFFFFFFh
sub rax, [rbp+var_18]
shr rax, 1
mov rcx, [rbp+var_10]
cmp rax, [rcx+110h]
jbe short loc_89155
mov rax, [rbp+var_10]
mov rax, [rax+110h]
shl rax, 1
add rax, [rbp+var_18]
mov [rbp+var_28], rax
jmp short loc_89162
loc_89155:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp short $+2
loc_89162:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+110h], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax+108h], 0
jnz short loc_891D6
mov rax, [rbp+var_10]
mov rsi, [rax+110h]
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+108h], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax+108h], 0
jz short loc_891D4
mov rax, [rbp+var_10]
mov rdi, [rax+108h]
mov rsi, [rbp+var_10]
add rsi, 88h
mov rdx, [rbp+var_20]
add rdx, 1
call _memcpy
loc_891D4:
jmp short loc_89205
loc_891D6:
mov rax, [rbp+var_10]
mov rsi, [rax+108h]
mov rax, [rbp+var_10]
mov rdx, [rax+110h]
xor edi, edi
xor eax, eax
mov ecx, eax
call my_realloc
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+108h], rcx
loc_89205:
mov rax, [rbp+var_10]
mov rcx, [rax+108h]
mov rax, [rbp+var_10]
mov [rax+118h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+118h]
add rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+120h], rcx
mov rax, [rbp+var_10]
mov rdx, [rax+108h]
mov eax, 1
xor ecx, ecx
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
jmp short loc_8925A
loc_89253:
mov [rbp+var_4], 0
loc_8925A:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| _BOOL8 my_xml_attr_ensure_space(_QWORD *a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-28h]
long long v4; // [rsp+10h] [rbp-20h]
long long v5; // [rsp+18h] [rbp-18h]
v4 = a1[36] - a1[35];
v5 = a2 + 1;
if ( (unsigned long long)(a2 + 1 + v4) <= a1[34] )
{
return 0;
}
else
{
if ( (unsigned long long)(-1 - v5) >> 1 <= a1[34] )
v3 = -1LL;
else
v3 = v5 + 2LL * a1[34];
a1[34] = v3;
if ( a1[33] )
{
a1[33] = my_realloc(0, a1[33], a1[34], 0);
}
else
{
a1[33] = my_malloc(0, a1[34], 0);
if ( a1[33] )
memcpy(a1[33], a1 + 17, v4 + 1);
}
a1[35] = a1[33];
a1[36] = v4 + a1[35];
return a1[33] == 0LL;
}
}
| my_xml_attr_ensure_space:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x118]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x110]
JBE 0x00189253
MOV RAX,-0x1
SUB RAX,qword ptr [RBP + -0x18]
SHR RAX,0x1
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x110]
JBE 0x00189155
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x110]
SHL RAX,0x1
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00189162
LAB_00189155:
MOV RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00189162
LAB_00189162:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x110],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x108],0x0
JNZ 0x001891d6
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x110]
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00132270
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x108],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x108],0x0
JZ 0x001891d4
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x108]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x88
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,0x1
CALL 0x00125230
LAB_001891d4:
JMP 0x00189205
LAB_001891d6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x108]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x110]
XOR EDI,EDI
XOR EAX,EAX
MOV ECX,EAX
CALL 0x00132440
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x108],RCX
LAB_00189205:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x108]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x118],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x118]
ADD RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x120],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x108]
MOV EAX,0x1
XOR ECX,ECX
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0018925a
LAB_00189253:
MOV dword ptr [RBP + -0x4],0x0
LAB_0018925a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
bool my_xml_attr_ensure_space(long param_1,long param_2)
{
long lVar1;
int8 uVar2;
bool bVar3;
long local_30;
lVar1 = *(long *)(param_1 + 0x120) - *(long *)(param_1 + 0x118);
param_2 = param_2 + 1;
if (*(ulong *)(param_1 + 0x110) < (ulong)(lVar1 + param_2)) {
if (*(ulong *)(param_1 + 0x110) < -param_2 - 1U >> 1) {
local_30 = *(long *)(param_1 + 0x110) * 2 + param_2;
}
else {
local_30 = -1;
}
*(long *)(param_1 + 0x110) = local_30;
if (*(long *)(param_1 + 0x108) == 0) {
uVar2 = my_malloc(0,*(int8 *)(param_1 + 0x110),0);
*(int8 *)(param_1 + 0x108) = uVar2;
if (*(long *)(param_1 + 0x108) != 0) {
memcpy(*(void **)(param_1 + 0x108),(void *)(param_1 + 0x88),lVar1 + 1);
}
}
else {
uVar2 = my_realloc(0,*(int8 *)(param_1 + 0x108),*(int8 *)(param_1 + 0x110),0);
*(int8 *)(param_1 + 0x108) = uVar2;
}
*(int8 *)(param_1 + 0x118) = *(int8 *)(param_1 + 0x108);
*(long *)(param_1 + 0x120) = *(long *)(param_1 + 0x118) + lVar1;
bVar3 = *(long *)(param_1 + 0x108) == 0;
}
else {
bVar3 = false;
}
return bVar3;
}
| |
22,496 | gguf_get_or_add_key | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static int gguf_get_or_add_key(struct gguf_context * ctx, const char * key) {
const int idx = gguf_find_key(ctx, key);
if (idx >= 0) {
return idx;
}
const int n_kv = gguf_get_n_kv(ctx);
ctx->kv = realloc(ctx->kv, (n_kv + 1) * sizeof(struct gguf_kv));
ctx->kv[n_kv].key.n = strlen(key);
ctx->kv[n_kv].key.data = strdup(key);
ctx->header.n_kv++;
return n_kv;
} | O1 | c | gguf_get_or_add_key:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x9da17
movl %eax, %r14d
testl %eax, %eax
jns 0x9df5a
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %rdi
leal 0x1(%r14), %eax
cltq
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq 0xaa40
movq %rax, %r12
movq %rax, 0x18(%rbx)
movq %r15, %rdi
callq 0xa240
movslq %r14d, %rcx
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
movq %rax, (%r12,%r13)
movq %r15, %rdi
callq 0xab60
movq %rax, 0x8(%r12,%r13)
incq 0x10(%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| gguf_get_or_add_key:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov rbx, rdi
call gguf_find_key
mov r14d, eax
test eax, eax
jns short loc_9DF5A
mov r14, [rbx+10h]
mov rdi, [rbx+18h]
lea eax, [r14+1]
cdqe
shl rax, 4
lea rsi, [rax+rax*2]
call _realloc
mov r12, rax
mov [rbx+18h], rax
mov rdi, r15
call _strlen
movsxd rcx, r14d
lea r13, [rcx+rcx*2]
shl r13, 4
mov [r12+r13], rax
mov rdi, r15
call _strdup
mov [r12+r13+8], rax
inc qword ptr [rbx+10h]
loc_9DF5A:
mov eax, r14d
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long gguf_get_or_add_key(long long a1, long long a2)
{
long long v2; // r14
long long v3; // r12
long long v4; // r13
LODWORD(v2) = gguf_find_key(a1, a2);
if ( (int)v2 < 0 )
{
v2 = *(_QWORD *)(a1 + 16);
v3 = realloc(*(_QWORD *)(a1 + 24), 48LL * ((int)v2 + 1));
*(_QWORD *)(a1 + 24) = v3;
v4 = 48LL * (int)v2;
*(_QWORD *)(v3 + v4) = strlen(a2);
*(_QWORD *)(v3 + v4 + 8) = strdup(a2);
++*(_QWORD *)(a1 + 16);
}
return (unsigned int)v2;
}
| |||
22,497 | gguf_get_or_add_key | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | static int gguf_get_or_add_key(struct gguf_context * ctx, const char * key) {
const int idx = gguf_find_key(ctx, key);
if (idx >= 0) {
return idx;
}
const int n_kv = gguf_get_n_kv(ctx);
ctx->kv = realloc(ctx->kv, (n_kv + 1) * sizeof(struct gguf_kv));
ctx->kv[n_kv].key.n = strlen(key);
ctx->kv[n_kv].key.data = strdup(key);
ctx->header.n_kv++;
return n_kv;
} | O2 | c | gguf_get_or_add_key:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x775f5
movl %eax, %r14d
testl %eax, %eax
jns 0x782f1
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %rdi
leal 0x1(%r14), %eax
cltq
imulq $0x30, %rax, %rsi
callq 0xaa20
movq %rax, %r12
movq %rax, 0x18(%rbx)
movq %r15, %rdi
callq 0xa220
movslq %r14d, %rcx
imulq $0x30, %rcx, %r13
movq %rax, (%r12,%r13)
movq %r15, %rdi
callq 0xab40
movq %rax, 0x8(%r12,%r13)
incq 0x10(%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| gguf_get_or_add_key:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov rbx, rdi
call gguf_find_key
mov r14d, eax
test eax, eax
jns short loc_782F1
mov r14, [rbx+10h]
mov rdi, [rbx+18h]
lea eax, [r14+1]
cdqe
imul rsi, rax, 30h ; '0'
call _realloc
mov r12, rax
mov [rbx+18h], rax
mov rdi, r15
call _strlen
movsxd rcx, r14d
imul r13, rcx, 30h ; '0'
mov [r12+r13], rax
mov rdi, r15
call _strdup
mov [r12+r13+8], rax
inc qword ptr [rbx+10h]
loc_782F1:
mov eax, r14d
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long gguf_get_or_add_key(long long a1, long long a2)
{
long long v2; // r14
long long v3; // r12
long long v4; // r13
LODWORD(v2) = gguf_find_key(a1, a2);
if ( (int)v2 < 0 )
{
v2 = *(_QWORD *)(a1 + 16);
v3 = realloc(*(_QWORD *)(a1 + 24), 48LL * ((int)v2 + 1));
*(_QWORD *)(a1 + 24) = v3;
v4 = 48LL * (int)v2;
*(_QWORD *)(v3 + v4) = strlen(a2);
*(_QWORD *)(v3 + v4 + 8) = strdup(a2);
++*(_QWORD *)(a1 + 16);
}
return (unsigned int)v2;
}
| gguf_get_or_add_key:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV RBX,RDI
CALL 0x001775f5
MOV R14D,EAX
TEST EAX,EAX
JNS 0x001782f1
MOV R14,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RBX + 0x18]
LEA EAX,[R14 + 0x1]
CDQE
IMUL RSI,RAX,0x30
CALL 0x0010aa20
MOV R12,RAX
MOV qword ptr [RBX + 0x18],RAX
MOV RDI,R15
CALL 0x0010a220
MOVSXD RCX,R14D
IMUL R13,RCX,0x30
MOV qword ptr [R12 + R13*0x1],RAX
MOV RDI,R15
CALL 0x0010ab40
MOV qword ptr [R12 + R13*0x1 + 0x8],RAX
INC qword ptr [RBX + 0x10]
LAB_001782f1:
MOV EAX,R14D
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
ulong gguf_get_or_add_key(long param_1,char *param_2)
{
uint uVar1;
void *pvVar2;
size_t sVar3;
char *pcVar4;
long lVar5;
ulong uVar6;
uVar1 = gguf_find_key();
uVar6 = (ulong)uVar1;
if ((int)uVar1 < 0) {
uVar6 = *(ulong *)(param_1 + 0x10);
pvVar2 = realloc(*(void **)(param_1 + 0x18),(long)((int)uVar6 + 1) * 0x30);
*(void **)(param_1 + 0x18) = pvVar2;
sVar3 = strlen(param_2);
lVar5 = (long)(int)uVar6 * 0x30;
*(size_t *)((long)pvVar2 + lVar5) = sVar3;
pcVar4 = strdup(param_2);
*(char **)((long)pvVar2 + lVar5 + 8) = pcVar4;
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + 1;
}
return uVar6 & 0xffffffff;
}
| |
22,498 | minja::ExpressionNode::ExpressionNode(minja::Location const&, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/./minja.hpp | TemplateNode(const Location & location) : location_(location) {} | O3 | cpp | minja::ExpressionNode::ExpressionNode(minja::Location const&, std::shared_ptr<minja::Expression>&&):
leaq 0x8d99d(%rip), %rax # 0xeefe8
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x61677
movq 0x8e937(%rip), %rcx # 0xeffa0
cmpb $0x0, (%rcx)
je 0x61673
incl 0x8(%rax)
jmp 0x61677
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rdi)
leaq 0x8dc42(%rip), %rax # 0xef2c8
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movups (%rdx), %xmm0
movq %rax, 0x8(%rdx)
movups %xmm0, 0x20(%rdi)
movq %rax, (%rdx)
retq
| _ZN5minja14ExpressionNodeC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEE:
lea rax, off_EEFE8
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_61677
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_61673
inc dword ptr [rax+8]
jmp short loc_61677
loc_61673:
lock inc dword ptr [rax+8]
loc_61677:
mov rax, [rsi+10h]
mov [rdi+18h], rax
lea rax, off_EF2C8
mov [rdi], rax
xor eax, eax
mov [rdi+28h], rax
movups xmm0, xmmword ptr [rdx]
mov [rdx+8], rax
movups xmmword ptr [rdi+20h], xmm0
mov [rdx], rax
retn
| long long minja::ExpressionNode::ExpressionNode(long long a1, _QWORD *a2, __int128 *a3)
{
long long v3; // rax
long long result; // rax
__int128 v5; // xmm0
*(_QWORD *)a1 = &off_EEFE8;
*(_QWORD *)(a1 + 8) = *a2;
v3 = a2[1];
*(_QWORD *)(a1 + 16) = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &off_EF2C8;
result = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
v5 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v5;
*(_QWORD *)a3 = 0LL;
return result;
}
| ExpressionNode:
LEA RAX,[0x1eefe8]
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x00161677
MOV RCX,qword ptr [0x001effa0]
CMP byte ptr [RCX],0x0
JZ 0x00161673
INC dword ptr [RAX + 0x8]
JMP 0x00161677
LAB_00161673:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00161677:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x1ef2c8]
MOV qword ptr [RDI],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOV qword ptr [RDX + 0x8],RAX
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV qword ptr [RDX],RAX
RET
|
/* minja::ExpressionNode::ExpressionNode(minja::Location const&,
std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::ExpressionNode::ExpressionNode(ExpressionNode *this,Location *param_1,shared_ptr *param_2)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR___cxa_pure_virtual_001eefe8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001effa0 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_001ef2c8;
*(int8 *)(this + 0x28) = 0;
uVar2 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar2;
*(int8 *)param_2 = 0;
return;
}
| |
22,499 | js_std_loop | bluesky950520[P]quickjs/quickjs-libc.c | JSValue js_std_loop(JSContext *ctx)
{
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
JSContext *ctx1;
JSValue ret;
int err;
for(;;) {
/* execute the pending jobs */
for(;;) {
err = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);
if (err <= 0) {
if (err < 0) {
ts->exc = JS_GetException(ctx1);
goto done;
}
break;
}
}
if (!ts->can_js_os_poll || js_os_poll(ctx))
break;
}
done:
ret = ts->exc;
ts->exc = JS_UNDEFINED;
return ret;
} | O2 | c | js_std_loop:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
callq 0x1a185
movq %rax, %rdi
callq 0x1028a
movq %rax, %rbx
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x1a185
movq %rax, %rdi
movq %r15, %rsi
callq 0x17f5a
testl %eax, %eax
jg 0x10531
js 0x10566
cmpl $0x0, 0x60(%rbx)
je 0x1055c
movq %r14, %rdi
callq 0x1058a
testl %eax, %eax
je 0x10531
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rdx
jmp 0x10574
movq 0x8(%rsp), %rdi
callq 0x1c481
movq %rax, 0x50(%rbx)
andl $0x0, 0x50(%rbx)
movq $0x3, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
| js_std_loop:
push r15
push r14
push rbx
sub rsp, 10h
mov r14, rdi
call JS_GetRuntime
mov rdi, rax
call js_get_thread_state
mov rbx, rax
lea r15, [rsp+28h+var_20]
loc_10531:
mov rdi, r14
call JS_GetRuntime
mov rdi, rax
mov rsi, r15
call JS_ExecutePendingJob
test eax, eax
jg short loc_10531
js short loc_10566
cmp dword ptr [rbx+60h], 0
jz short loc_1055C
mov rdi, r14
call js_os_poll
test eax, eax
jz short loc_10531
loc_1055C:
mov rax, [rbx+50h]
mov rdx, [rbx+58h]
jmp short loc_10574
loc_10566:
mov rdi, [rsp+28h+var_20]
call JS_GetException
mov [rbx+50h], rax
loc_10574:
and dword ptr [rbx+50h], 0
mov qword ptr [rbx+58h], 3
add rsp, 10h
pop rbx
pop r14
pop r15
retn
| long long js_std_loop(long long a1, long long a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long thread_state; // rbx
long long Runtime; // rax
int v9; // eax
long long result; // rax
char v11; // [rsp+0h] [rbp-28h]
_QWORD v12[4]; // [rsp+8h] [rbp-20h] BYREF
v2 = ((long long (*)(void))JS_GetRuntime)();
thread_state = js_get_thread_state(v2, a2, v3, v4, v5, v6, v11);
while ( 1 )
{
do
{
Runtime = JS_GetRuntime(a1);
v9 = JS_ExecutePendingJob(Runtime, v12);
}
while ( v9 > 0 );
if ( v9 < 0 )
break;
if ( !*(_DWORD *)(thread_state + 96) || (unsigned int)js_os_poll(a1) )
{
result = *(_QWORD *)(thread_state + 80);
goto LABEL_8;
}
}
result = JS_GetException(v12[0]);
*(_QWORD *)(thread_state + 80) = result;
LABEL_8:
*(_DWORD *)(thread_state + 80) = 0;
*(_QWORD *)(thread_state + 88) = 3LL;
return result;
}
| js_std_loop:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R14,RDI
CALL 0x0011a185
MOV RDI,RAX
CALL 0x0011028a
MOV RBX,RAX
LEA R15,[RSP + 0x8]
LAB_00110531:
MOV RDI,R14
CALL 0x0011a185
MOV RDI,RAX
MOV RSI,R15
CALL 0x00117f5a
TEST EAX,EAX
JG 0x00110531
JS 0x00110566
CMP dword ptr [RBX + 0x60],0x0
JZ 0x0011055c
MOV RDI,R14
CALL 0x0011058a
TEST EAX,EAX
JZ 0x00110531
LAB_0011055c:
MOV RAX,qword ptr [RBX + 0x50]
MOV RDX,qword ptr [RBX + 0x58]
JMP 0x00110574
LAB_00110566:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011c481
MOV qword ptr [RBX + 0x50],RAX
LAB_00110574:
AND dword ptr [RBX + 0x50],0x0
MOV qword ptr [RBX + 0x58],0x3
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
int8 js_std_loop(int8 param_1)
{
int iVar1;
int8 uVar2;
long lVar3;
int8 local_20;
uVar2 = JS_GetRuntime();
lVar3 = js_get_thread_state(uVar2);
do {
do {
uVar2 = JS_GetRuntime(param_1);
iVar1 = JS_ExecutePendingJob(uVar2,&local_20);
} while (0 < iVar1);
if (iVar1 < 0) {
uVar2 = JS_GetException(local_20);
*(int8 *)(lVar3 + 0x50) = uVar2;
goto LAB_00110574;
}
if (*(int *)(lVar3 + 0x60) == 0) break;
iVar1 = js_os_poll(param_1);
} while (iVar1 == 0);
uVar2 = *(int8 *)(lVar3 + 0x50);
LAB_00110574:
*(int4 *)(lVar3 + 0x50) = 0;
*(int8 *)(lVar3 + 0x58) = 3;
return uVar2;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.