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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
16,000
|
minja::ArgumentsValue::has_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/minja.hpp
|
bool has_named(const std::string & name) {
for (const auto & p : kwargs) {
if (p.first == name) return true;
}
return false;
}
|
O2
|
cpp
|
minja::ArgumentsValue::has_named(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %r15
movq %rcx, %r14
cmpq %r15, %rcx
je 0x84e9b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28594
leaq 0x70(%r14), %rcx
testb %al, %al
je 0x84e80
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZN5minja14ArgumentsValue9has_namedERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push rbx
mov rbx, rsi
mov rcx, [rdi+18h]
mov r15, [rdi+20h]
loc_84E80:
mov r14, rcx
cmp rcx, r15
jz short loc_84E9B
mov rdi, r14
mov rsi, rbx
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
lea rcx, [r14+70h]
test al, al
jz short loc_84E80
loc_84E9B:
cmp r14, r15
setnz al
pop rbx
pop r14
pop r15
retn
|
bool minja::ArgumentsValue::has_named(long long a1, _QWORD *a2)
{
_QWORD *v2; // rcx
_QWORD *v3; // r15
_QWORD *v4; // r14
bool v5; // al
v2 = *(_QWORD **)(a1 + 24);
v3 = *(_QWORD **)(a1 + 32);
do
{
v4 = v2;
if ( v2 == v3 )
break;
v5 = std::operator==<char>(v2, a2);
v2 = v4 + 14;
}
while ( !v5 );
return v4 != v3;
}
|
has_named:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV RCX,qword ptr [RDI + 0x18]
MOV R15,qword ptr [RDI + 0x20]
LAB_00184e80:
MOV R14,RCX
CMP RCX,R15
JZ 0x00184e9b
MOV RDI,R14
MOV RSI,RBX
CALL 0x00128594
LEA RCX,[R14 + 0x70]
TEST AL,AL
JZ 0x00184e80
LAB_00184e9b:
CMP R14,R15
SETNZ AL
POP RBX
POP R14
POP R15
RET
|
/* minja::ArgumentsValue::has_named(std::__cxx11::string const&) */
bool __thiscall minja::ArgumentsValue::has_named(ArgumentsValue *this,string *param_1)
{
string *psVar1;
string *psVar2;
char cVar3;
string *psVar4;
psVar1 = *(string **)(this + 0x20);
psVar2 = *(string **)(this + 0x18);
do {
psVar4 = psVar2;
if (psVar4 == psVar1) break;
cVar3 = std::operator==(psVar4,param_1);
psVar2 = psVar4 + 0x70;
} while (cVar3 == '\0');
return psVar4 != psVar1;
}
|
|
16,001
|
my_charpos_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
}
|
O0
|
c
|
my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x58ff5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5c690
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jne 0x58fd5
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x59028
jmp 0x58fd7
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x58fa0
cmpq $0x0, -0x28(%rbp)
je 0x59011
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x59020
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_charpos_utf16:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_58FA0:
cmp [rbp+var_28], 0
jz short loc_58FF5
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_ismbchar_1
mov [rbp+var_34], eax
cmp eax, 0
jnz short loc_58FD5
mov rax, [rbp+var_20]
add rax, 2
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_59028
loc_58FD5:
jmp short $+2
loc_58FD7:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp short loc_58FA0
loc_58FF5:
cmp [rbp+var_28], 0
jz short loc_59011
mov rax, [rbp+var_20]
add rax, 2
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_40], rax
jmp short loc_59020
loc_59011:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_40], rax
loc_59020:
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
loc_59028:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
unsigned int v5; // [rsp+Ch] [rbp-34h]
long long v8; // [rsp+28h] [rbp-18h]
v8 = a2;
while ( a4 )
{
v5 = my_ismbchar_1(a1, v8, a3);
if ( !v5 )
return a3 + 2 - a2;
v8 += v5;
--a4;
}
return v8 - a2;
}
|
my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
LAB_00158fa0:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00158ff5
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0015c690
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JNZ 0x00158fd5
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00159028
LAB_00158fd5:
JMP 0x00158fd7
LAB_00158fd7:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00158fa0
LAB_00158ff5:
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00159011
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00159020
LAB_00159011:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
LAB_00159020:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
LAB_00159028:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00158ffc) */
long my_charpos_utf16(int8 param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long local_30;
long local_20;
local_30 = param_4;
local_20 = param_2;
while( true ) {
if (local_30 == 0) {
return local_20 - param_2;
}
uVar1 = my_ismbchar(param_1,local_20,param_3);
if (uVar1 == 0) break;
local_20 = local_20 + (ulong)uVar1;
local_30 = local_30 + -1;
}
return (param_3 + 2) - param_2;
}
|
|
16,002
|
ma_delete_static_record
|
eloqsql/storage/maria/ma_statrec.c
|
my_bool _ma_delete_static_record(MARIA_HA *info,
const uchar *record __attribute__ ((unused)))
{
uchar temp[9]; /* 1+sizeof(uint32) */
info->state->del++;
info->state->empty+=info->s->base.pack_reclength;
temp[0]= '\0'; /* Mark that record is deleted */
_ma_dpointer(info->s, temp+1, info->s->state.dellink);
info->s->state.dellink= info->cur_row.lastpos;
info->rec_cache.seek_not_done=1;
return (info->s->file_write(info, temp, 1+info->s->rec_reflength,
info->cur_row.lastpos, MYF(MY_NABP)) != 0);
}
|
O3
|
c
|
ma_delete_static_record:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x10(%rbp)
movq 0x20(%rdi), %rax
incq 0x8(%rax)
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x3a0(%rax), %rax
addq %rax, 0x10(%rcx)
leaq -0x18(%rbp), %rsi
movb $0x0, -0x1(%rsi)
movq (%rdi), %rdi
movq 0xc8(%rdi), %rdx
callq 0x70400
movq (%rbx), %rax
movq 0x98(%rbx), %rcx
movq %rcx, 0xc8(%rax)
movl $0x1, 0x598(%rbx)
movq (%rbx), %rax
movl 0x740(%rax), %edx
incl %edx
leaq -0x19(%rbp), %rsi
movl $0x4, %r8d
movq %rbx, %rdi
callq *0x6e8(%rax)
testq %rax, %rax
setne %al
movq %fs:0x28, %rcx
cmpq -0x10(%rbp), %rcx
jne 0x73114
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
callq 0x2a270
|
_ma_delete_static_record:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_10], rax
mov rax, [rdi+20h]
inc qword ptr [rax+8]
mov rax, [rdi]
mov rcx, [rdi+20h]
mov rax, [rax+3A0h]
add [rcx+10h], rax
lea rsi, [rbp+var_18]
mov byte ptr [rsi-1], 0
mov rdi, [rdi]
mov rdx, [rdi+0C8h]
call _ma_dpointer
mov rax, [rbx]
mov rcx, [rbx+98h]
mov [rax+0C8h], rcx
mov dword ptr [rbx+598h], 1
mov rax, [rbx]
mov edx, [rax+740h]
inc edx
lea rsi, [rbp+var_19]
mov r8d, 4
mov rdi, rbx
call qword ptr [rax+6E8h]
test rax, rax
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_10]
jnz short loc_73114
add rsp, 18h
pop rbx
pop rbp
retn
loc_73114:
call ___stack_chk_fail
|
bool ma_delete_static_record(long long *a1)
{
long long v1; // rcx
char v3; // [rsp+7h] [rbp-19h] BYREF
char v4[8]; // [rsp+8h] [rbp-18h] BYREF
unsigned long long v5; // [rsp+10h] [rbp-10h]
v5 = __readfsqword(0x28u);
++*(_QWORD *)(a1[4] + 8);
*(_QWORD *)(a1[4] + 16) += *(_QWORD *)(*a1 + 928);
v3 = 0;
ma_dpointer(*a1, (long long)v4, *(_QWORD *)(*a1 + 200));
v1 = a1[19];
*(_QWORD *)(*a1 + 200) = v1;
*((_DWORD *)a1 + 358) = 1;
return (*(long long ( **)(long long *, char *, _QWORD, long long, long long))(*a1 + 1768))(
a1,
&v3,
(unsigned int)(*(_DWORD *)(*a1 + 1856) + 1),
v1,
4LL) != 0;
}
|
_ma_delete_static_record:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RDI + 0x20]
INC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x20]
MOV RAX,qword ptr [RAX + 0x3a0]
ADD qword ptr [RCX + 0x10],RAX
LEA RSI,[RBP + -0x18]
MOV byte ptr [RSI + -0x1],0x0
MOV RDI,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0xc8]
CALL 0x00170400
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x98]
MOV qword ptr [RAX + 0xc8],RCX
MOV dword ptr [RBX + 0x598],0x1
MOV RAX,qword ptr [RBX]
MOV EDX,dword ptr [RAX + 0x740]
INC EDX
LEA RSI,[RBP + -0x19]
MOV R8D,0x4
MOV RDI,RBX
CALL qword ptr [RAX + 0x6e8]
TEST RAX,RAX
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x10]
JNZ 0x00173114
ADD RSP,0x18
POP RBX
POP RBP
RET
LAB_00173114:
CALL 0x0012a270
|
bool _ma_delete_static_record(long *param_1)
{
long lVar1;
long in_FS_OFFSET;
int1 local_21;
int1 local_20 [8];
long local_18;
local_18 = *(long *)(in_FS_OFFSET + 0x28);
*(long *)(param_1[4] + 8) = *(long *)(param_1[4] + 8) + 1;
*(long *)(param_1[4] + 0x10) = *(long *)(param_1[4] + 0x10) + *(long *)(*param_1 + 0x3a0);
local_21 = 0;
_ma_dpointer(*param_1,local_20,*(int8 *)(*param_1 + 200));
lVar1 = param_1[0x13];
*(long *)(*param_1 + 200) = lVar1;
*(int4 *)(param_1 + 0xb3) = 1;
lVar1 = (**(code **)(*param_1 + 0x6e8))(param_1,&local_21,*(int *)(*param_1 + 0x740) + 1,lVar1,4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_18) {
return lVar1 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
16,003
|
js_std_file_putByte
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_putByte(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
int c;
if (!f)
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &c, argv[0]))
return JS_EXCEPTION;
c = fputc(c, f);
return JS_NewInt32(ctx, c);
}
|
O0
|
c
|
js_std_file_putByte:
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x13a80
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x139c0
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x13a3c
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x4(%rsp), %rsi
callq 0x38f20
cmpl $0x0, %eax
je 0x139f3
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x13a3c
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0xe420
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rcx
movl 0x4(%rsp), %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x58(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax,%rax)
|
js_std_file_putByte:
sub rsp, 68h
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_38], rdx
mov [rsp+68h+var_48], rdi
mov [rsp+68h+var_4C], ecx
mov [rsp+68h+var_58], r8
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
mov rdx, [rsp+68h+var_38]
call js_std_file_get
mov [rsp+68h+var_60], rax
cmp [rsp+68h+var_60], 0
jnz short loc_139C0
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_13A3C
loc_139C0:
mov rdi, [rsp+68h+var_48]
mov rax, [rsp+68h+var_58]
mov rdx, [rax]
mov rcx, [rax+8]
lea rsi, [rsp+68h+var_64]
call JS_ToInt32
cmp eax, 0
jz short loc_139F3
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_13A3C
loc_139F3:
mov edi, [rsp+68h+var_64]
mov rsi, [rsp+68h+var_60]
call _fputc
mov [rsp+68h+var_64], eax
mov rcx, [rsp+68h+var_48]
mov eax, [rsp+68h+var_64]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_1C], eax
mov eax, [rsp+68h+var_1C]
mov dword ptr [rsp+68h+var_10], eax
mov [rsp+68h+var_8], 0
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_30], rcx
mov [rsp+68h+var_28], rax
loc_13A3C:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
|
long long js_std_file_putByte(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
unsigned int v6; // [rsp+4h] [rbp-64h] BYREF
long long v7; // [rsp+8h] [rbp-60h]
_QWORD *v8; // [rsp+10h] [rbp-58h]
int v9; // [rsp+1Ch] [rbp-4Ch]
long long v10; // [rsp+20h] [rbp-48h]
long long v11; // [rsp+28h] [rbp-40h]
long long v12; // [rsp+30h] [rbp-38h]
long long v13; // [rsp+38h] [rbp-30h]
long long v14; // [rsp+40h] [rbp-28h]
unsigned int v15; // [rsp+4Ch] [rbp-1Ch]
long long v16; // [rsp+50h] [rbp-18h]
long long v17; // [rsp+58h] [rbp-10h]
long long v18; // [rsp+60h] [rbp-8h]
v11 = a2;
v12 = a3;
v10 = a1;
v9 = a4;
v8 = a5;
v7 = js_std_file_get(a1, a2, a3);
if ( v7 )
{
if ( (unsigned int)JS_ToInt32(v10, &v6, *v8, v8[1]) )
{
LODWORD(v13) = 0;
v14 = 6LL;
}
else
{
v6 = fputc(v6, v7);
v16 = v10;
v15 = v6;
LODWORD(v17) = v6;
v18 = 0LL;
v13 = v17;
v14 = 0LL;
}
}
else
{
LODWORD(v13) = 0;
v14 = 6LL;
}
return v13;
}
|
js_std_file_putByte:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00113a80
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001139c0
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x00113a3c
LAB_001139c0:
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RAX]
MOV RCX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x4]
CALL 0x00138f20
CMP EAX,0x0
JZ 0x001139f3
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x00113a3c
LAB_001139f3:
MOV EDI,dword ptr [RSP + 0x4]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0010e420
MOV dword ptr [RSP + 0x4],EAX
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x58],EAX
MOV qword ptr [RSP + 0x60],0x0
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
LAB_00113a3c:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
int1 [16]
js_std_file_putByte(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int1 auVar1 [16];
int iVar2;
int local_64;
FILE *local_60;
int8 *local_58;
int4 local_4c;
int8 local_48;
int8 local_40;
int8 local_38;
int local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
local_58 = param_5;
local_4c = param_4;
local_48 = param_1;
local_40 = param_2;
local_38 = param_3;
local_60 = (FILE *)js_std_file_get(param_1,param_2,param_3);
if (local_60 == (FILE *)0x0) {
local_30 = 0;
local_28 = 6;
}
else {
iVar2 = JS_ToInt32(local_48,&local_64,*local_58,local_58[1]);
if (iVar2 == 0) {
local_30 = fputc(local_64,local_60);
uStack_2c = uStack_c;
local_28 = 0;
}
else {
local_30 = 0;
local_28 = 6;
}
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
|
|
16,004
|
js_std_file_putByte
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_putByte(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
int c;
if (!f)
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &c, argv[0]))
return JS_EXCEPTION;
c = fputc(c, f);
return JS_NewInt32(ctx, c);
}
|
O1
|
c
|
js_std_file_putByte:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rdi, %r15
callq 0x16588
movl $0x6, %ebx
testq %rax, %rax
je 0x16561
movq %rax, %r14
movq (%r12), %rdx
movq 0x8(%r12), %rcx
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x279b0
testl %eax, %eax
je 0x16565
xorl %eax, %eax
jmp 0x16579
movl 0x4(%rsp), %edi
movq %r14, %rsi
callq 0xe420
movl %eax, 0x4(%rsp)
movl %eax, %eax
xorl %ebx, %ebx
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_std_file_putByte:
push r15
push r14
push r12
push rbx
push rax
mov r12, r8
mov r15, rdi
call js_std_file_get
mov ebx, 6
test rax, rax
jz short loc_16561
mov r14, rax
mov rdx, [r12]
mov rcx, [r12+8]
lea rsi, [rsp+28h+var_24]
mov rdi, r15
call JS_ToInt32
test eax, eax
jz short loc_16565
loc_16561:
xor eax, eax
jmp short loc_16579
loc_16565:
mov edi, [rsp+28h+var_24]
mov rsi, r14
call _fputc
mov [rsp+28h+var_24], eax
mov eax, eax
xor ebx, ebx
loc_16579:
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long js_std_file_putByte(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v5; // rax
long long v7; // rax
long long v8; // r14
_DWORD v10[9]; // [rsp+0h] [rbp-24h] BYREF
v10[0] = HIDWORD(v5);
v7 = js_std_file_get(a1);
if ( v7 && (v8 = v7, !(unsigned int)JS_ToInt32(a1, v10, *a5, a5[1])) )
return (unsigned int)fputc(v10[0], v8);
else
return 0LL;
}
|
js_std_file_putByte:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV R15,RDI
CALL 0x00116588
MOV EBX,0x6
TEST RAX,RAX
JZ 0x00116561
MOV R14,RAX
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
LEA RSI,[RSP + 0x4]
MOV RDI,R15
CALL 0x001279b0
TEST EAX,EAX
JZ 0x00116565
LAB_00116561:
XOR EAX,EAX
JMP 0x00116579
LAB_00116565:
MOV EDI,dword ptr [RSP + 0x4]
MOV RSI,R14
CALL 0x0010e420
MOV dword ptr [RSP + 0x4],EAX
MOV EAX,EAX
XOR EBX,EBX
LAB_00116579:
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int js_std_file_putByte(int8 param_1)
{
int iVar1;
int8 in_RAX;
FILE *__stream;
int8 *in_R8;
int local_24;
local_24 = (int)((ulong)in_RAX >> 0x20);
__stream = (FILE *)js_std_file_get();
if ((__stream != (FILE *)0x0) &&
(iVar1 = JS_ToInt32(param_1,&local_24,*in_R8,in_R8[1]), iVar1 == 0)) {
iVar1 = fputc(local_24,__stream);
return iVar1;
}
return 0;
}
|
|
16,005
|
js_std_file_putByte
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static JSValue js_std_file_putByte(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
FILE *f = js_std_file_get(ctx, this_val);
int c;
if (!f)
return JS_EXCEPTION;
if (JS_ToInt32(ctx, &c, argv[0]))
return JS_EXCEPTION;
c = fputc(c, f);
return JS_NewInt32(ctx, c);
}
|
O2
|
c
|
js_std_file_putByte:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rdi, %r15
callq 0x113c6
pushq $0x6
popq %rbx
testq %rax, %rax
je 0x11388
movq %rax, %r14
movq (%r12), %rdx
movq 0x8(%r12), %rcx
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x215d7
testl %eax, %eax
je 0x1138c
xorl %eax, %eax
jmp 0x1139c
movl 0x4(%rsp), %edi
movq %r14, %rsi
callq 0xe430
movl %eax, %eax
xorl %ebx, %ebx
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
js_std_file_putByte:
push r15
push r14
push r12
push rbx
push rax
mov r12, r8
mov r15, rdi
call js_std_file_get
push 6
pop rbx
test rax, rax
jz short loc_11388
mov r14, rax
mov rdx, [r12]
mov rcx, [r12+8]
lea rsi, [rsp+28h+var_24]
mov rdi, r15
call JS_ToInt32
test eax, eax
jz short loc_1138C
loc_11388:
xor eax, eax
jmp short loc_1139C
loc_1138C:
mov edi, [rsp+28h+var_24]
mov rsi, r14
call _fputc
mov eax, eax
xor ebx, ebx
loc_1139C:
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long js_std_file_putByte(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v5; // rax
long long v7; // rax
long long v8; // r14
_DWORD v10[9]; // [rsp+0h] [rbp-24h] BYREF
v10[0] = HIDWORD(v5);
v7 = js_std_file_get(a1);
if ( v7 && (v8 = v7, !(unsigned int)JS_ToInt32(a1, v10, *a5, a5[1])) )
return (unsigned int)fputc(v10[0], v8);
else
return 0LL;
}
|
js_std_file_putByte:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV R15,RDI
CALL 0x001113c6
PUSH 0x6
POP RBX
TEST RAX,RAX
JZ 0x00111388
MOV R14,RAX
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [R12 + 0x8]
LEA RSI,[RSP + 0x4]
MOV RDI,R15
CALL 0x001215d7
TEST EAX,EAX
JZ 0x0011138c
LAB_00111388:
XOR EAX,EAX
JMP 0x0011139c
LAB_0011138c:
MOV EDI,dword ptr [RSP + 0x4]
MOV RSI,R14
CALL 0x0010e430
MOV EAX,EAX
XOR EBX,EBX
LAB_0011139c:
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int js_std_file_putByte(int8 param_1)
{
int iVar1;
int8 in_RAX;
FILE *__stream;
int8 *in_R8;
int local_24;
local_24 = (int)((ulong)in_RAX >> 0x20);
__stream = (FILE *)js_std_file_get();
if ((__stream != (FILE *)0x0) &&
(iVar1 = JS_ToInt32(param_1,&local_24,*in_R8,in_R8[1]), iVar1 == 0)) {
iVar1 = fputc(local_24,__stream);
return iVar1;
}
return 0;
}
|
|
16,006
|
js__gettimeofday_us
|
bluesky950520[P]quickjs/cutils.c
|
int64_t js__gettimeofday_us(void) {
struct timeval tv;
#ifdef _WIN32
gettimeofday_msvc(&tv);
#else
gettimeofday(&tv, NULL);
#endif
return ((int64_t)tv.tv_sec * 1000000) + tv.tv_usec;
}
|
O1
|
c
|
js__gettimeofday_us:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe330
imulq $0xf4240, (%rbx), %rax # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
|
js__gettimeofday_us:
push rbx
sub rsp, 10h
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _gettimeofday
imul rax, [rbx], 0F4240h
add rax, [rbx+8]
add rsp, 10h
pop rbx
retn
|
long long js__gettimeofday_us()
{
_QWORD v1[3]; // [rsp+0h] [rbp-18h] BYREF
gettimeofday(v1, 0LL);
return v1[1] + 1000000LL * v1[0];
}
| |||
16,007
|
js__gettimeofday_us
|
bluesky950520[P]quickjs/cutils.c
|
int64_t js__gettimeofday_us(void) {
struct timeval tv;
#ifdef _WIN32
gettimeofday_msvc(&tv);
#else
gettimeofday(&tv, NULL);
#endif
return ((int64_t)tv.tv_sec * 1000000) + tv.tv_usec;
}
|
O3
|
c
|
js__gettimeofday_us:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xe330
imulq $0xf4240, (%rbx), %rax # imm = 0xF4240
addq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
|
js__gettimeofday_us:
push rbx
sub rsp, 10h
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _gettimeofday
imul rax, [rbx], 0F4240h
add rax, [rbx+8]
add rsp, 10h
pop rbx
retn
|
long long js__gettimeofday_us()
{
_QWORD v1[3]; // [rsp+0h] [rbp-18h] BYREF
gettimeofday(v1, 0LL);
return v1[1] + 1000000LL * v1[0];
}
|
js__gettimeofday_us:
PUSH RBX
SUB RSP,0x10
MOV RBX,RSP
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0010e330
IMUL RAX,qword ptr [RBX],0xf4240
ADD RAX,qword ptr [RBX + 0x8]
ADD RSP,0x10
POP RBX
RET
|
long js__gettimeofday_us(void)
{
timeval local_18;
gettimeofday(&local_18,(__timezone_ptr_t)0x0);
return local_18.tv_sec * 1000000 + local_18.tv_usec;
}
|
|
16,008
|
aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule::RegisterSubscriberGenFunc()
|
aimrt_mujoco_sim/src/module/mujoco_sim_module/mujoco_sim_module.cc
|
void MujocoSimModule::RegisterSubscriberGenFunc() {
auto generator = [this]<typename T>(std::string_view name) {
subscriber_gen_func_map_.emplace(
name,
[]() -> std::unique_ptr<subscriber::SubscriberBase> {
return std::make_unique<T>();
});
};
generator.template operator()<subscriber::JointActuatorSubscriber>("joint_actuator");
#ifdef AIMRT_MUJOCO_SIM_BUILD_WITH_ROS2
generator.template operator()<subscriber::JointActuatorRos2Subscriber>("joint_actuator_ros2");
#endif
}
|
O0
|
cpp
|
aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule::RegisterSubscriberGenFunc():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x31393c(%rip), %rsi # 0x3df24b
callq 0x95260
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0xce1b0
addq $0x28, %rsp
retq
nopl (%rax)
|
_ZN16aimrt_mujoco_sim17mujoco_sim_module15MujocoSimModule25RegisterSubscriberGenFuncEv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_10], rax
lea rdi, [rsp+28h+var_20]
lea rsi, aJointActuator; "joint_actuator"
call __ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc; std::string_view::basic_string_view(char const*)
mov rsi, [rsp+28h+var_20]
mov rdx, [rsp+28h+var_18]
lea rdi, [rsp+28h+var_10]
call _ZZN16aimrt_mujoco_sim17mujoco_sim_module15MujocoSimModule25RegisterSubscriberGenFuncEvENK3$_0clINS0_10subscriber23JointActuatorSubscriberEEEDaSt17basic_string_viewIcSt11char_traitsIcEE
add rsp, 28h
retn
|
long long aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule::RegisterSubscriberGenFunc(
aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule *this)
{
_QWORD v2[2]; // [rsp+8h] [rbp-20h] BYREF
_QWORD v3[2]; // [rsp+18h] [rbp-10h] BYREF
v3[1] = this;
v3[0] = this;
std::string_view::basic_string_view(v2, "joint_actuator");
return aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule::RegisterSubscriberGenFunc(void)::$_0::operator()<aimrt_mujoco_sim::mujoco_sim_module::subscriber::JointActuatorSubscriber>(
v3,
v2[0],
v2[1]);
}
|
RegisterSubscriberGenFunc:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x8]
LEA RSI,[0x4df24b]
CALL 0x00195260
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LEA RDI,[RSP + 0x18]
CALL 0x001ce1b0
ADD RSP,0x28
RET
|
/* aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule::RegisterSubscriberGenFunc() */
void __thiscall
aimrt_mujoco_sim::mujoco_sim_module::MujocoSimModule::RegisterSubscriberGenFunc
(MujocoSimModule *this)
{
int8 local_20;
int8 local_18;
MujocoSimModule *local_10;
MujocoSimModule *local_8;
local_10 = this;
local_8 = this;
std::basic_string_view<char,std::char_traits<char>>::basic_string_view
((basic_string_view<char,std::char_traits<char>> *)&local_20,"joint_actuator");
RegisterSubscriberGenFunc()::$_0::operator()((__0 *)&local_10,local_20,local_18);
return;
}
|
|
16,009
|
utf8_scan
|
bluesky950520[P]quickjs/cutils.c
|
int utf8_scan(const char *buf, size_t buf_len, size_t *plen)
{
const uint8_t *p, *p_end, *p_next;
size_t i, len;
int kind;
uint8_t cbits;
kind = UTF8_PLAIN_ASCII;
cbits = 0;
len = buf_len;
// TODO: handle more than 1 byte at a time
for (i = 0; i < buf_len; i++)
cbits |= buf[i];
if (cbits >= 0x80) {
p = (const uint8_t *)buf;
p_end = p + buf_len;
kind = UTF8_NON_ASCII;
len = 0;
while (p < p_end) {
len++;
if (*p++ >= 0x80) {
/* parse UTF-8 sequence, check for encoding error */
uint32_t c = utf8_decode_len(p - 1, p_end - (p - 1), &p_next);
if (p_next == p)
kind |= UTF8_HAS_ERRORS;
p = p_next;
if (c > 0xFF) {
kind |= UTF8_HAS_16BIT;
if (c > 0xFFFF) {
len++;
kind |= UTF8_HAS_NON_BMP1;
}
}
}
}
}
*plen = len;
return kind;
}
|
O0
|
c
|
utf8_scan:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl $0x0, 0x14(%rsp)
movb $0x0, 0x13(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x48(%rsp), %rax
jae 0x251e8
movq 0x50(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rax,%rcx), %ecx
movzbl 0x13(%rsp), %eax
orl %ecx, %eax
movb %al, 0x13(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x251b3
movzbl 0x13(%rsp), %eax
cmpl $0x80, %eax
jl 0x252eb
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x1, 0x14(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x252e9
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rsp)
movzbl (%rax), %eax
cmpl $0x80, %eax
jl 0x252e4
movq 0x38(%rsp), %rdi
addq $-0x1, %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rax
addq $-0x1, %rax
subq %rax, %rsi
leaq 0x28(%rsp), %rdx
callq 0x250c0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x2529e
movl 0x14(%rsp), %eax
orl $0x8, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0xff, 0xc(%rsp)
jbe 0x252e2
movl 0x14(%rsp), %eax
orl $0x2, %eax
movl %eax, 0x14(%rsp)
cmpl $0xffff, 0xc(%rsp) # imm = 0xFFFF
jbe 0x252e0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
orl $0x4, %eax
movl %eax, 0x14(%rsp)
jmp 0x252e2
jmp 0x252e4
jmp 0x25222
jmp 0x252eb
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
|
utf8_scan:
sub rsp, 58h
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov [rsp+58h+var_18], rdx
mov [rsp+58h+var_44], 0
mov [rsp+58h+var_45], 0
mov rax, [rsp+58h+var_10]
mov [rsp+58h+var_40], rax
mov [rsp+58h+var_38], 0
loc_251B3:
mov rax, [rsp+58h+var_38]
cmp rax, [rsp+58h+var_10]
jnb short loc_251E8
mov rax, [rsp+58h+var_8]
mov rcx, [rsp+58h+var_38]
movzx ecx, byte ptr [rax+rcx]
movzx eax, [rsp+58h+var_45]
or eax, ecx
mov [rsp+58h+var_45], al
mov rax, [rsp+58h+var_38]
add rax, 1
mov [rsp+58h+var_38], rax
jmp short loc_251B3
loc_251E8:
movzx eax, [rsp+58h+var_45]
cmp eax, 80h
jl loc_252EB
mov rax, [rsp+58h+var_8]
mov [rsp+58h+var_20], rax
mov rax, [rsp+58h+var_20]
add rax, [rsp+58h+var_10]
mov [rsp+58h+var_28], rax
mov [rsp+58h+var_44], 1
mov [rsp+58h+var_40], 0
loc_25222:
mov rax, [rsp+58h+var_20]
cmp rax, [rsp+58h+var_28]
jnb loc_252E9
mov rax, [rsp+58h+var_40]
add rax, 1
mov [rsp+58h+var_40], rax
mov rax, [rsp+58h+var_20]
mov rcx, rax
add rcx, 1
mov [rsp+58h+var_20], rcx
movzx eax, byte ptr [rax]
cmp eax, 80h
jl loc_252E4
mov rdi, [rsp+58h+var_20]
add rdi, 0FFFFFFFFFFFFFFFFh
mov rsi, [rsp+58h+var_28]
mov rax, [rsp+58h+var_20]
add rax, 0FFFFFFFFFFFFFFFFh
sub rsi, rax
lea rdx, [rsp+58h+var_30]
call utf8_decode_len
mov [rsp+58h+var_4C], eax
mov rax, [rsp+58h+var_30]
cmp rax, [rsp+58h+var_20]
jnz short loc_2529E
mov eax, [rsp+58h+var_44]
or eax, 8
mov [rsp+58h+var_44], eax
loc_2529E:
mov rax, [rsp+58h+var_30]
mov [rsp+58h+var_20], rax
cmp [rsp+58h+var_4C], 0FFh
jbe short loc_252E2
mov eax, [rsp+58h+var_44]
or eax, 2
mov [rsp+58h+var_44], eax
cmp [rsp+58h+var_4C], 0FFFFh
jbe short loc_252E0
mov rax, [rsp+58h+var_40]
add rax, 1
mov [rsp+58h+var_40], rax
mov eax, [rsp+58h+var_44]
or eax, 4
mov [rsp+58h+var_44], eax
loc_252E0:
jmp short $+2
loc_252E2:
jmp short $+2
loc_252E4:
jmp loc_25222
loc_252E9:
jmp short $+2
loc_252EB:
mov rcx, [rsp+58h+var_40]
mov rax, [rsp+58h+var_18]
mov [rax], rcx
mov eax, [rsp+58h+var_44]
add rsp, 58h
retn
|
long long utf8_scan(unsigned __int8 *a1, unsigned long long a2, unsigned long long *a3)
{
unsigned __int8 *v3; // rax
unsigned int v5; // [rsp+Ch] [rbp-4Ch]
unsigned __int8 v6; // [rsp+13h] [rbp-45h]
unsigned int v7; // [rsp+14h] [rbp-44h]
unsigned long long v8; // [rsp+18h] [rbp-40h]
unsigned long long i; // [rsp+20h] [rbp-38h]
unsigned __int8 *v10; // [rsp+28h] [rbp-30h] BYREF
unsigned long long v11; // [rsp+30h] [rbp-28h]
unsigned __int8 *v12; // [rsp+38h] [rbp-20h]
unsigned long long *v13; // [rsp+40h] [rbp-18h]
unsigned long long v14; // [rsp+48h] [rbp-10h]
unsigned __int8 *v15; // [rsp+50h] [rbp-8h]
v15 = a1;
v14 = a2;
v13 = a3;
v7 = 0;
v6 = 0;
v8 = a2;
for ( i = 0LL; i < v14; ++i )
v6 |= v15[i];
if ( v6 >= 0x80u )
{
v12 = v15;
v11 = (unsigned long long)&v15[v14];
v7 = 1;
v8 = 0LL;
while ( (unsigned long long)v12 < v11 )
{
++v8;
v3 = v12++;
if ( *v3 >= 0x80u )
{
v5 = utf8_decode_len(v12 - 1, v11 - (_QWORD)(v12 - 1), &v10);
if ( v10 == v12 )
v7 |= 8u;
v12 = v10;
if ( v5 > 0xFF )
{
v7 |= 2u;
if ( v5 > 0xFFFF )
{
++v8;
v7 |= 4u;
}
}
}
}
}
*v13 = v8;
return v7;
}
|
utf8_scan:
SUB RSP,0x58
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV dword ptr [RSP + 0x14],0x0
MOV byte ptr [RSP + 0x13],0x0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],0x0
LAB_001251b3:
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RSP + 0x48]
JNC 0x001251e8
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x20]
MOVZX ECX,byte ptr [RAX + RCX*0x1]
MOVZX EAX,byte ptr [RSP + 0x13]
OR EAX,ECX
MOV byte ptr [RSP + 0x13],AL
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001251b3
LAB_001251e8:
MOVZX EAX,byte ptr [RSP + 0x13]
CMP EAX,0x80
JL 0x001252eb
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x30],RAX
MOV dword ptr [RSP + 0x14],0x1
MOV qword ptr [RSP + 0x18],0x0
LAB_00125222:
MOV RAX,qword ptr [RSP + 0x38]
CMP RAX,qword ptr [RSP + 0x30]
JNC 0x001252e9
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0x38],RCX
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x80
JL 0x001252e4
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,-0x1
MOV RSI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x38]
ADD RAX,-0x1
SUB RSI,RAX
LEA RDX,[RSP + 0x28]
CALL 0x001250c0
MOV dword ptr [RSP + 0xc],EAX
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RSP + 0x38]
JNZ 0x0012529e
MOV EAX,dword ptr [RSP + 0x14]
OR EAX,0x8
MOV dword ptr [RSP + 0x14],EAX
LAB_0012529e:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x38],RAX
CMP dword ptr [RSP + 0xc],0xff
JBE 0x001252e2
MOV EAX,dword ptr [RSP + 0x14]
OR EAX,0x2
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0xc],0xffff
JBE 0x001252e0
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
MOV EAX,dword ptr [RSP + 0x14]
OR EAX,0x4
MOV dword ptr [RSP + 0x14],EAX
LAB_001252e0:
JMP 0x001252e2
LAB_001252e2:
JMP 0x001252e4
LAB_001252e4:
JMP 0x00125222
LAB_001252e9:
JMP 0x001252eb
LAB_001252eb:
MOV RCX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x58
RET
|
uint utf8_scan(byte *param_1,ulong param_2,ulong *param_3)
{
byte *pbVar1;
uint uVar2;
byte *pbVar3;
uint uVar4;
ulong uVar5;
long lVar6;
byte local_45;
uint local_44;
ulong local_40;
ulong local_38;
byte *local_30;
byte *local_28;
byte *local_20;
ulong *local_18;
ulong local_10;
byte *local_8;
local_44 = 0;
local_45 = 0;
for (local_38 = 0; local_38 < param_2; local_38 = local_38 + 1) {
local_45 = local_45 | param_1[local_38];
}
local_40 = param_2;
local_18 = param_3;
if (0x7f < local_45) {
local_28 = param_1 + param_2;
local_44 = 1;
local_40 = 0;
uVar2 = local_44;
uVar5 = local_40;
pbVar3 = param_1;
local_10 = param_2;
local_8 = param_1;
while (local_20 = pbVar3, local_40 = uVar5, local_44 = uVar2, pbVar1 = local_20,
local_20 < local_28) {
uVar5 = local_40 + 1;
uVar2 = local_44;
pbVar3 = local_20 + 1;
if (0x7f < *local_20) {
lVar6 = (long)local_28 - (long)local_20;
local_20 = local_20 + 1;
uVar4 = utf8_decode_len(pbVar1,lVar6,&local_30);
if (local_30 == local_20) {
local_44 = local_44 | 8;
}
local_20 = local_30;
uVar2 = local_44;
pbVar3 = local_20;
if ((0xff < uVar4) && (uVar2 = local_44 | 2, 0xffff < uVar4)) {
uVar2 = local_44 | 6;
uVar5 = local_40 + 2;
}
}
}
}
*local_18 = local_40;
return local_44;
}
|
|
16,010
|
utf8_scan
|
bluesky950520[P]quickjs/cutils.c
|
int utf8_scan(const char *buf, size_t buf_len, size_t *plen)
{
const uint8_t *p, *p_end, *p_next;
size_t i, len;
int kind;
uint8_t cbits;
kind = UTF8_PLAIN_ASCII;
cbits = 0;
len = buf_len;
// TODO: handle more than 1 byte at a time
for (i = 0; i < buf_len; i++)
cbits |= buf[i];
if (cbits >= 0x80) {
p = (const uint8_t *)buf;
p_end = p + buf_len;
kind = UTF8_NON_ASCII;
len = 0;
while (p < p_end) {
len++;
if (*p++ >= 0x80) {
/* parse UTF-8 sequence, check for encoding error */
uint32_t c = utf8_decode_len(p - 1, p_end - (p - 1), &p_next);
if (p_next == p)
kind |= UTF8_HAS_ERRORS;
p = p_next;
if (c > 0xFF) {
kind |= UTF8_HAS_16BIT;
if (c > 0xFFFF) {
len++;
kind |= UTF8_HAS_NON_BMP1;
}
}
}
}
}
*plen = len;
return kind;
}
|
O2
|
c
|
utf8_scan:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r8
movq %rsi, %r14
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rax, %r14
je 0x19c9e
orb (%rdi,%rax), %cl
incq %rax
jmp 0x19c91
xorl %ebp, %ebp
testb %cl, %cl
jns 0x19d45
leaq (%rdi,%r14), %r12
leaq (%rdi,%r14), %rbx
incq %rbx
pushq $0x1
popq %rbp
xorl %r9d, %r9d
leaq 0x8(%rsp), %rdx
movq %r9, %r14
xorl %r15d, %r15d
movq %rdi, %rax
cmpq %r12, %rax
jae 0x19d42
leaq 0x1(%rax), %r13
decq %r15
cmpb $0x0, (%rax)
movq %r13, %rax
jns 0x19cc7
movq %rbx, %rsi
subq %rdi, %rsi
addq %r15, %rsi
movq %r15, %rax
notq %rax
addq %rdi, %rax
movq %rax, %rdi
movq %r8, 0x10(%rsp)
callq 0x19c3e
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rdi
movl %ebp, %ecx
orl $0x8, %ecx
cmpq %rdi, %r13
cmovnel %ebp, %ecx
movq %r14, %r9
subq %r15, %r9
movl %ecx, %ebp
cmpl $0x100, %eax # imm = 0x100
jb 0x19cbe
movl %ecx, %ebp
orl $0x2, %ebp
cmpl $0x10000, %eax # imm = 0x10000
jb 0x19cbe
subq %r15, %r14
incq %r14
orl $0x6, %ecx
movq %r14, %r9
movl %ecx, %ebp
jmp 0x19cbe
subq %r15, %r14
movq %r14, (%r8)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
utf8_scan:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r8, rdx
mov r14, rsi
xor eax, eax
xor ecx, ecx
loc_19C91:
cmp r14, rax
jz short loc_19C9E
or cl, [rdi+rax]
inc rax
jmp short loc_19C91
loc_19C9E:
xor ebp, ebp
test cl, cl
jns loc_19D45
lea r12, [rdi+r14]
lea rbx, [rdi+r14]
inc rbx
push 1
pop rbp
xor r9d, r9d
lea rdx, [rsp+48h+var_40]
loc_19CBE:
mov r14, r9
xor r15d, r15d
mov rax, rdi
loc_19CC7:
cmp rax, r12
jnb short loc_19D42
lea r13, [rax+1]
dec r15
cmp byte ptr [rax], 0
mov rax, r13
jns short loc_19CC7
mov rsi, rbx
sub rsi, rdi
add rsi, r15
mov rax, r15
not rax
add rax, rdi
mov rdi, rax
mov [rsp+48h+var_38], r8
call utf8_decode_len
lea rdx, [rsp+48h+var_40]
mov r8, [rsp+48h+var_38]
mov rdi, [rsp+48h+var_40]
mov ecx, ebp
or ecx, 8
cmp r13, rdi
cmovnz ecx, ebp
mov r9, r14
sub r9, r15
mov ebp, ecx
cmp eax, 100h
jb short loc_19CBE
mov ebp, ecx
or ebp, 2
cmp eax, 10000h
jb short loc_19CBE
sub r14, r15
inc r14
or ecx, 6
mov r9, r14
mov ebp, ecx
jmp loc_19CBE
loc_19D42:
sub r14, r15
loc_19D45:
mov [r8], r14
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long utf8_scan(char *a1, long long a2, _QWORD *a3)
{
long long v4; // r14
long long v5; // rax
char v6; // cl
unsigned int v7; // ebp
char *v8; // r12
long long v9; // rbx
long long v10; // r9
long long v11; // r14
long long v12; // r15
char *v13; // rax
char *v14; // r13
unsigned int v16; // eax
int v17; // ecx
char *v19; // [rsp+8h] [rbp-40h] BYREF
_QWORD *v20; // [rsp+10h] [rbp-38h]
v4 = a2;
v5 = 0LL;
v6 = 0;
while ( a2 != v5 )
v6 |= a1[v5++];
v7 = 0;
if ( v6 < 0 )
{
v8 = &a1[a2];
v9 = (long long)&a1[a2 + 1];
v7 = 1;
v10 = 0LL;
LABEL_6:
v11 = v10;
v12 = 0LL;
v13 = a1;
while ( v13 < v8 )
{
v14 = v13 + 1;
--v12;
if ( *v13++ < 0 )
{
v20 = a3;
v16 = utf8_decode_len(&a1[~v12], v12 + v9 - (_QWORD)a1, &v19);
a3 = v20;
a1 = v19;
v17 = v7 | 8;
if ( v14 != v19 )
v17 = v7;
v10 = v11 - v12;
v7 = v17;
if ( v16 >= 0x100 )
{
v7 = v17 | 2;
if ( v16 >= 0x10000 )
{
v10 = v11 - v12 + 1;
v7 = v17 | 6;
}
}
goto LABEL_6;
}
}
v4 = v10 - v12;
}
*a3 = v4;
return v7;
}
|
utf8_scan:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R8,RDX
MOV R14,RSI
XOR EAX,EAX
XOR ECX,ECX
LAB_00119c91:
CMP R14,RAX
JZ 0x00119c9e
OR CL,byte ptr [RDI + RAX*0x1]
INC RAX
JMP 0x00119c91
LAB_00119c9e:
XOR EBP,EBP
TEST CL,CL
JNS 0x00119d45
LEA R12,[RDI + R14*0x1]
LEA RBX,[RDI + R14*0x1]
INC RBX
PUSH 0x1
POP RBP
XOR R9D,R9D
LEA RDX,[RSP + 0x8]
LAB_00119cbe:
MOV R14,R9
XOR R15D,R15D
MOV RAX,RDI
LAB_00119cc7:
CMP RAX,R12
JNC 0x00119d42
LEA R13,[RAX + 0x1]
DEC R15
CMP byte ptr [RAX],0x0
MOV RAX,R13
JNS 0x00119cc7
MOV RSI,RBX
SUB RSI,RDI
ADD RSI,R15
MOV RAX,R15
NOT RAX
ADD RAX,RDI
MOV RDI,RAX
MOV qword ptr [RSP + 0x10],R8
CALL 0x00119c3e
LEA RDX,[RSP + 0x8]
MOV R8,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x8]
MOV ECX,EBP
OR ECX,0x8
CMP R13,RDI
CMOVNZ ECX,EBP
MOV R9,R14
SUB R9,R15
MOV EBP,ECX
CMP EAX,0x100
JC 0x00119cbe
MOV EBP,ECX
OR EBP,0x2
CMP EAX,0x10000
JC 0x00119cbe
SUB R14,R15
INC R14
OR ECX,0x6
MOV R9,R14
MOV EBP,ECX
JMP 0x00119cbe
LAB_00119d42:
SUB R14,R15
LAB_00119d45:
MOV qword ptr [R8],R14
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint utf8_scan(char *param_1,long param_2,long *param_3)
{
char *pcVar1;
char cVar2;
uint uVar3;
long lVar4;
char *pcVar5;
byte bVar6;
uint uVar7;
uint uVar8;
char *pcVar9;
long lVar10;
ulong uVar11;
char *local_40;
long *local_38;
bVar6 = 0;
for (lVar4 = 0; param_2 != lVar4; lVar4 = lVar4 + 1) {
bVar6 = bVar6 | param_1[lVar4];
}
uVar8 = 0;
if ((char)bVar6 < '\0') {
pcVar9 = param_1;
lVar4 = 0;
uVar8 = 1;
do {
lVar10 = lVar4;
uVar11 = 0;
pcVar5 = pcVar9;
do {
if (param_1 + param_2 <= pcVar5) {
param_2 = lVar10 - uVar11;
goto LAB_00119d45;
}
pcVar1 = pcVar5 + 1;
uVar11 = uVar11 - 1;
cVar2 = *pcVar5;
pcVar5 = pcVar1;
} while (-1 < cVar2);
local_38 = param_3;
uVar3 = utf8_decode_len(pcVar9 + ~uVar11,param_1 + uVar11 + ((param_2 + 1) - (long)pcVar9),
&local_40);
uVar7 = uVar8 | 8;
if (pcVar1 != local_40) {
uVar7 = uVar8;
}
pcVar9 = local_40;
param_3 = local_38;
lVar4 = lVar10 - uVar11;
uVar8 = uVar7;
if ((0xff < uVar3) && (uVar8 = uVar7 | 2, 0xffff < uVar3)) {
uVar8 = uVar7 | 6;
lVar4 = (lVar10 - uVar11) + 1;
}
} while( true );
}
LAB_00119d45:
*param_3 = param_2;
return uVar8;
}
|
|
16,011
|
translog_scanner_set_last_page
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_scanner_set_last_page(TRANSLOG_SCANNER_DATA *scanner)
{
my_bool page_ok;
if (LSN_FILE_NO(scanner->page_addr) == LSN_FILE_NO(scanner->horizon))
{
/* It is last file => we can easy find last page address by horizon */
uint pagegrest= LSN_OFFSET(scanner->horizon) % TRANSLOG_PAGE_SIZE;
scanner->last_file_page= (scanner->horizon -
(pagegrest ? pagegrest : TRANSLOG_PAGE_SIZE));
return (0);
}
scanner->last_file_page= scanner->page_addr;
return (translog_get_last_page_addr(&scanner->last_file_page, &page_ok, 0));
}
|
O0
|
c
|
translog_scanner_set_last_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rax
sarq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x2008(%rcx), %rcx
sarq $0x20, %rcx
cmpl %ecx, %eax
jne 0x8ef30
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x2008(%rcx), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2008(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x8ef09
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8ef13
movl $0x2000, %eax # imm = 0x2000
movl %eax, -0x24(%rbp)
jmp 0x8ef13
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %eax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x8ef5f
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x10(%rbp), %rdi
addq $0x2010, %rdi # imm = 0x2010
leaq -0x11(%rbp), %rsi
xorl %edx, %edx
callq 0x8bf20
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
translog_scanner_set_last_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+2000h]
sar rax, 20h
mov rcx, [rbp+var_10]
mov rcx, [rcx+2008h]
sar rcx, 20h
cmp eax, ecx
jnz short loc_8EF30
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx+2008h]
and rax, 1FFFh
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+2008h]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_8EF09
mov eax, [rbp+var_18]
mov [rbp+var_24], eax
jmp short loc_8EF13
loc_8EF09:
mov eax, 2000h
mov [rbp+var_24], eax
jmp short $+2
loc_8EF13:
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov eax, eax
sub rcx, rax
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov [rbp+var_1], 0
jmp short loc_8EF5F
loc_8EF30:
mov rax, [rbp+var_10]
mov rcx, [rax+2000h]
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov rdi, [rbp+var_10]
add rdi, 2010h
lea rsi, [rbp+var_11]
xor edx, edx
call translog_get_last_page_addr
mov [rbp+var_1], al
loc_8EF5F:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char translog_scanner_set_last_page(_QWORD *a1)
{
unsigned int v2; // [rsp+Ch] [rbp-24h]
bool v3; // [rsp+1Fh] [rbp-11h] BYREF
_QWORD *v4; // [rsp+20h] [rbp-10h]
v4 = a1;
if ( HIDWORD(a1[1024]) == HIDWORD(a1[1025]) )
{
if ( (v4[1025] & 0x1FFF) != 0 )
v2 = v4[1025] & 0x1FFF;
else
v2 = 0x2000;
v4[1026] = v4[1025] - v2;
return 0;
}
else
{
v4[1026] = v4[1024];
return translog_get_last_page_addr(v4 + 1026, &v3, 0);
}
}
|
translog_scanner_set_last_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2000]
SAR RAX,0x20
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x2008]
SAR RCX,0x20
CMP EAX,ECX
JNZ 0x0018ef30
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x2008]
AND RAX,0x1fff
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2008]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x18],0x0
JZ 0x0018ef09
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0018ef13
LAB_0018ef09:
MOV EAX,0x2000
MOV dword ptr [RBP + -0x24],EAX
JMP 0x0018ef13
LAB_0018ef13:
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV EAX,EAX
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0018ef5f
LAB_0018ef30:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x2000]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2010
LEA RSI,[RBP + -0x11]
XOR EDX,EDX
CALL 0x0018bf20
MOV byte ptr [RBP + -0x1],AL
LAB_0018ef5f:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 translog_scanner_set_last_page(long param_1)
{
uint local_2c;
int1 local_19;
long local_18;
int1 local_9;
if ((int)((ulong)*(int8 *)(param_1 + 0x2000) >> 0x20) ==
(int)((ulong)*(int8 *)(param_1 + 0x2008) >> 0x20)) {
local_2c = (uint)*(ulong *)(param_1 + 0x2008) & 0x1fff;
if ((*(ulong *)(param_1 + 0x2008) & 0x1fff) == 0) {
local_2c = 0x2000;
}
*(ulong *)(param_1 + 0x2010) = *(long *)(param_1 + 0x2008) - (ulong)local_2c;
local_9 = 0;
}
else {
*(int8 *)(param_1 + 0x2010) = *(int8 *)(param_1 + 0x2000);
local_18 = param_1;
local_9 = translog_get_last_page_addr(param_1 + 0x2010,&local_19,0);
}
return local_9;
}
|
|
16,012
|
ggml_rope_back
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_rope_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int n_dims,
int mode,
int n_ctx,
int n_orig_ctx,
float freq_base,
float freq_scale,
float ext_factor,
float attn_factor,
float beta_fast,
float beta_slow,
float xpos_base,
bool xpos_down) {
GGML_ASSERT(ggml_is_vector(b));
GGML_ASSERT(b->type == GGML_TYPE_I32);
GGML_ASSERT(a->ne[2] == b->ne[0]);
GGML_ASSERT((mode & 4) == 0 && "ggml_rope_back() for ChatGLM not implemented yet");
bool is_node = false;
if (a->grad) {
is_node = false; // TODO: implement backward
}
struct ggml_tensor * result = ggml_dup_tensor(ctx, a);
int32_t params[13] = { /*n_past*/ 0, n_dims, mode, n_ctx, n_orig_ctx };
memcpy(params + 5, &freq_base, sizeof(float));
memcpy(params + 6, &freq_scale, sizeof(float));
memcpy(params + 7, &ext_factor, sizeof(float));
memcpy(params + 8, &attn_factor, sizeof(float));
memcpy(params + 9, &beta_fast, sizeof(float));
memcpy(params + 10, &beta_slow, sizeof(float));
memcpy(params + 11, &xpos_base, sizeof(float));
memcpy(params + 12, &xpos_down, sizeof(bool));
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_ROPE_BACK;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
}
|
O2
|
c
|
ggml_rope_back:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
vmovss %xmm6, 0x1c(%rsp)
vmovss %xmm5, 0x18(%rsp)
vmovss %xmm4, 0x14(%rsp)
vmovss %xmm3, 0x10(%rsp)
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm0, 0x4(%rsp)
movl %r9d, %ebp
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
movq %rdx, %rdi
callq 0x67cf4
testb %al, %al
je 0x6d221
cmpl $0x12, (%rbx)
jne 0x6d259
movq 0x20(%r14), %rax
cmpq 0x10(%rbx), %rax
jne 0x6d28e
testb $0x4, %r15b
jne 0x6d2c3
movq %r13, %rdi
movq %r14, %rsi
callq 0x68a65
leaq 0x20(%rsp), %rsi
andl $0x0, (%rsi)
movq %rax, %r13
movl %r12d, 0x4(%rsi)
movl %r15d, 0x8(%rsi)
movl %ebp, 0xc(%rsi)
movl 0x90(%rsp), %eax
movl %eax, 0x10(%rsi)
andl $0x0, 0x30(%rsi)
vmovss 0x4(%rsp), %xmm0
vmovss %xmm0, 0x14(%rsi)
vmovss 0x8(%rsp), %xmm0
vmovss %xmm0, 0x18(%rsi)
vmovss 0xc(%rsp), %xmm0
vmovss %xmm0, 0x1c(%rsi)
vmovss 0x10(%rsp), %xmm0
vmovss %xmm0, 0x20(%rsi)
vmovss 0x14(%rsp), %xmm0
vmovss %xmm0, 0x24(%rsi)
vmovss 0x18(%rsp), %xmm0
vmovss %xmm0, 0x28(%rsi)
vmovss 0x1c(%rsp), %xmm0
vmovss %xmm0, 0x2c(%rsi)
movb 0x98(%rsp), %al
movb %al, 0x30(%rsi)
pushq $0x34
popq %rdx
movq %r13, %rdi
callq 0x6ab3d
movl $0x2a, 0x50(%r13)
andq $0x0, 0x98(%r13)
movq %r14, 0xa0(%r13)
movq %rbx, 0xa8(%r13)
movq %r13, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x68d20(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x68d71(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2cfdd(%rip), %rsi # 0x9a21e
leaq 0x34636(%rip), %rdx # 0xa187e
leaq 0x34d28(%rip), %r8 # 0xa1f77
movl $0x1419, %ecx # imm = 0x1419
jmp 0x6d2f6
movq 0x68ce8(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x68d39(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2cfa5(%rip), %rsi # 0x9a21e
leaq 0x345fe(%rip), %rdx # 0xa187e
leaq 0x34c9d(%rip), %r8 # 0xa1f24
movl $0x141a, %ecx # imm = 0x141A
jmp 0x6d2f6
movq 0x68cb3(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x68d04(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2cf70(%rip), %rsi # 0x9a21e
leaq 0x345c9(%rip), %rdx # 0xa187e
leaq 0x34ccd(%rip), %r8 # 0xa1f89
movl $0x141b, %ecx # imm = 0x141B
jmp 0x6d2f6
movq 0x68c7e(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x68ccf(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2cf3b(%rip), %rsi # 0x9a21e
leaq 0x34594(%rip), %rdx # 0xa187e
leaq 0x34cad(%rip), %r8 # 0xa1f9e
movl $0x141d, %ecx # imm = 0x141D
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
|
ggml_rope_back:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
vmovss [rsp+88h+var_6C], xmm6
vmovss [rsp+88h+var_70], xmm5
vmovss [rsp+88h+var_74], xmm4
vmovss [rsp+88h+var_78], xmm3
vmovss [rsp+88h+var_7C], xmm2
vmovss [rsp+88h+var_80], xmm1
vmovss [rsp+88h+var_84], xmm0
mov ebp, r9d
mov r15d, r8d
mov r12d, ecx
mov rbx, rdx
mov r14, rsi
mov r13, rdi
mov rdi, rdx
call ggml_is_vector
test al, al
jz loc_6D221
cmp dword ptr [rbx], 12h
jnz loc_6D259
mov rax, [r14+20h]
cmp rax, [rbx+10h]
jnz loc_6D28E
test r15b, 4
jnz loc_6D2C3
mov rdi, r13
mov rsi, r14
call ggml_dup_tensor
lea rsi, [rsp+88h+var_68]
and dword ptr [rsi], 0
mov r13, rax
mov [rsi+4], r12d
mov [rsi+8], r15d
mov [rsi+0Ch], ebp
mov eax, [rsp+88h+arg_0]
mov [rsi+10h], eax
and dword ptr [rsi+30h], 0
vmovss xmm0, [rsp+88h+var_84]
vmovss dword ptr [rsi+14h], xmm0
vmovss xmm0, [rsp+88h+var_80]
vmovss dword ptr [rsi+18h], xmm0
vmovss xmm0, [rsp+88h+var_7C]
vmovss dword ptr [rsi+1Ch], xmm0
vmovss xmm0, [rsp+88h+var_78]
vmovss dword ptr [rsi+20h], xmm0
vmovss xmm0, [rsp+88h+var_74]
vmovss dword ptr [rsi+24h], xmm0
vmovss xmm0, [rsp+88h+var_70]
vmovss dword ptr [rsi+28h], xmm0
vmovss xmm0, [rsp+88h+var_6C]
vmovss dword ptr [rsi+2Ch], xmm0
mov al, [rsp+88h+arg_8]
mov [rsi+30h], al
push 34h ; '4'
pop rdx
mov rdi, r13
call ggml_set_op_params
mov dword ptr [r13+50h], 2Ah ; '*'
and qword ptr [r13+98h], 0
mov [r13+0A0h], r14
mov [r13+0A8h], rbx
mov rax, r13
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6D221:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlIsVectorB; "ggml_is_vector(b)"
mov ecx, 1419h
jmp loc_6D2F6
loc_6D259:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aGgmlIsMatrixAG+2Ah; "b->type == GGML_TYPE_I32"
mov ecx, 141Ah
jmp short loc_6D2F6
loc_6D28E:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aANe2BNe0; "a->ne[2] == b->ne[0]"
mov ecx, 141Bh
jmp short loc_6D2F6
loc_6D2C3:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aMode40GgmlRope; "(mode & 4) == 0 && \"ggml_rope_back() f"...
mov ecx, 141Dh
loc_6D2F6:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
|
long long ggml_rope_back(
long long a1,
long long a2,
_QWORD *a3,
int a4,
int a5,
int a6,
__m128 _XMM0,
__m128 _XMM1,
__m128 _XMM2,
__m128 _XMM3,
__m128 _XMM4,
__m128 _XMM5,
__m128 _XMM6,
int a14,
char a15)
{
long long v20; // rax
long long v22; // r13
long long v31; // rdi
_DWORD v39[12]; // [rsp+20h] [rbp-68h] BYREF
int v40; // [rsp+50h] [rbp-38h]
__asm
{
vmovss [rsp+88h+var_6C], xmm6
vmovss [rsp+88h+var_70], xmm5
vmovss [rsp+88h+var_74], xmm4
vmovss [rsp+88h+var_78], xmm3
vmovss [rsp+88h+var_7C], xmm2
vmovss [rsp+88h+var_80], xmm1
vmovss [rsp+88h+var_84], xmm0
}
if ( !ggml_is_vector(a3) )
{
fflush(stdout);
v31 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
5145LL,
"ggml_is_vector(b)");
goto LABEL_10;
}
if ( *(_DWORD *)a3 != 18 )
{
fflush(stdout);
v31 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
5146LL,
"b->type == GGML_TYPE_I32");
goto LABEL_10;
}
if ( *(_QWORD *)(a2 + 32) != a3[2] )
{
fflush(stdout);
v31 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
5147LL,
"a->ne[2] == b->ne[0]");
goto LABEL_10;
}
if ( (a5 & 4) != 0 )
{
fflush(stdout);
v31 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
5149LL,
"(mode & 4) == 0 && \"ggml_rope_back() for ChatGLM not implemented yet\"");
LABEL_10:
ggml_print_backtrace();
abort(v31);
}
v20 = ggml_dup_tensor(a1, (unsigned int *)a2);
_RSI = v39;
v39[0] = 0;
v22 = v20;
v39[1] = a4;
v39[2] = a5;
v39[3] = a6;
v39[4] = a14;
v40 = 0;
__asm
{
vmovss xmm0, [rsp+88h+var_84]
vmovss dword ptr [rsi+14h], xmm0
vmovss xmm0, [rsp+88h+var_80]
vmovss dword ptr [rsi+18h], xmm0
vmovss xmm0, [rsp+88h+var_7C]
vmovss dword ptr [rsi+1Ch], xmm0
vmovss xmm0, [rsp+88h+var_78]
vmovss dword ptr [rsi+20h], xmm0
vmovss xmm0, [rsp+88h+var_74]
vmovss dword ptr [rsi+24h], xmm0
vmovss xmm0, [rsp+88h+var_70]
vmovss dword ptr [rsi+28h], xmm0
vmovss xmm0, [rsp+88h+var_6C]
vmovss dword ptr [rsi+2Ch], xmm0
}
LOBYTE(v40) = a15;
ggml_set_op_params(v20, (long long)v39, 52LL);
*(_DWORD *)(v22 + 80) = 42;
*(_QWORD *)(v22 + 152) = 0LL;
*(_QWORD *)(v22 + 160) = a2;
*(_QWORD *)(v22 + 168) = a3;
return v22;
}
|
ggml_rope_back:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
VMOVSS dword ptr [RSP + 0x1c],XMM6
VMOVSS dword ptr [RSP + 0x18],XMM5
VMOVSS dword ptr [RSP + 0x14],XMM4
VMOVSS dword ptr [RSP + 0x10],XMM3
VMOVSS dword ptr [RSP + 0xc],XMM2
VMOVSS dword ptr [RSP + 0x8],XMM1
VMOVSS dword ptr [RSP + 0x4],XMM0
MOV EBP,R9D
MOV R15D,R8D
MOV R12D,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R13,RDI
MOV RDI,RDX
CALL 0x00167cf4
TEST AL,AL
JZ 0x0016d221
CMP dword ptr [RBX],0x12
JNZ 0x0016d259
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [RBX + 0x10]
JNZ 0x0016d28e
TEST R15B,0x4
JNZ 0x0016d2c3
MOV RDI,R13
MOV RSI,R14
CALL 0x00168a65
LEA RSI,[RSP + 0x20]
AND dword ptr [RSI],0x0
MOV R13,RAX
MOV dword ptr [RSI + 0x4],R12D
MOV dword ptr [RSI + 0x8],R15D
MOV dword ptr [RSI + 0xc],EBP
MOV EAX,dword ptr [RSP + 0x90]
MOV dword ptr [RSI + 0x10],EAX
AND dword ptr [RSI + 0x30],0x0
VMOVSS XMM0,dword ptr [RSP + 0x4]
VMOVSS dword ptr [RSI + 0x14],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x8]
VMOVSS dword ptr [RSI + 0x18],XMM0
VMOVSS XMM0,dword ptr [RSP + 0xc]
VMOVSS dword ptr [RSI + 0x1c],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x10]
VMOVSS dword ptr [RSI + 0x20],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x14]
VMOVSS dword ptr [RSI + 0x24],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x18]
VMOVSS dword ptr [RSI + 0x28],XMM0
VMOVSS XMM0,dword ptr [RSP + 0x1c]
VMOVSS dword ptr [RSI + 0x2c],XMM0
MOV AL,byte ptr [RSP + 0x98]
MOV byte ptr [RSI + 0x30],AL
PUSH 0x34
POP RDX
MOV RDI,R13
CALL 0x0016ab3d
MOV dword ptr [R13 + 0x50],0x2a
AND qword ptr [R13 + 0x98],0x0
MOV qword ptr [R13 + 0xa0],R14
MOV qword ptr [R13 + 0xa8],RBX
MOV RAX,R13
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016d221:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1f77]
MOV ECX,0x1419
JMP 0x0016d2f6
LAB_0016d259:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1f24]
MOV ECX,0x141a
JMP 0x0016d2f6
LAB_0016d28e:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1f89]
MOV ECX,0x141b
JMP 0x0016d2f6
LAB_0016d2c3:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a1f9e]
MOV ECX,0x141d
LAB_0016d2f6:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
long ggml_rope_back(int4 param_1,int4 param_2,int4 param_3,int4 param_4,
int4 param_5,int4 param_6,int4 param_7,int8 param_8,
long param_9,int *param_10,int4 param_11,uint param_12,int4 param_13,
int4 param_14,byte param_15)
{
char cVar1;
long lVar2;
int8 uVar3;
FILE *__stream;
char *pcVar4;
int4 local_68;
int4 local_64;
uint local_60;
int4 local_5c;
int4 local_58;
int4 local_54;
int4 local_50;
int4 local_4c;
int4 local_48;
int4 local_44;
int4 local_40;
int4 local_3c;
uint local_38;
cVar1 = ggml_is_vector(param_10);
if (cVar1 == '\0') {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "ggml_is_vector(b)";
uVar3 = 0x1419;
}
else if (*param_10 == 0x12) {
if (*(long *)(param_9 + 0x20) == *(long *)(param_10 + 4)) {
if ((param_12 & 4) == 0) {
lVar2 = ggml_dup_tensor(param_8,param_9);
local_68 = 0;
local_58 = param_14;
local_38 = (uint)param_15;
local_64 = param_11;
local_60 = param_12;
local_5c = param_13;
local_54 = param_1;
local_50 = param_2;
local_4c = param_3;
local_48 = param_4;
local_44 = param_5;
local_40 = param_6;
local_3c = param_7;
ggml_set_op_params(lVar2,&local_68,0x34);
*(int4 *)(lVar2 + 0x50) = 0x2a;
*(int8 *)(lVar2 + 0x98) = 0;
*(long *)(lVar2 + 0xa0) = param_9;
*(int **)(lVar2 + 0xa8) = param_10;
return lVar2;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "(mode & 4) == 0 && \"ggml_rope_back() for ChatGLM not implemented yet\"";
uVar3 = 0x141d;
}
else {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "a->ne[2] == b->ne[0]";
uVar3 = 0x141b;
}
}
else {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar4 = "b->type == GGML_TYPE_I32";
uVar3 = 0x141a;
}
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar3,pcVar4);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
|
|
16,013
|
ggml_rope_back
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
struct ggml_tensor * ggml_rope_back(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int n_dims,
int mode,
int n_ctx,
int n_orig_ctx,
float freq_base,
float freq_scale,
float ext_factor,
float attn_factor,
float beta_fast,
float beta_slow,
float xpos_base,
bool xpos_down) {
GGML_ASSERT(ggml_is_vector(b));
GGML_ASSERT(b->type == GGML_TYPE_I32);
GGML_ASSERT(a->ne[2] == b->ne[0]);
GGML_ASSERT((mode & 4) == 0 && "ggml_rope_back() for ChatGLM not implemented yet");
bool is_node = false;
if (a->grad) {
is_node = false; // TODO: implement backward
}
struct ggml_tensor * result = ggml_dup_tensor(ctx, a);
int32_t params[13] = { /*n_past*/ 0, n_dims, mode, n_ctx, n_orig_ctx };
memcpy(params + 5, &freq_base, sizeof(float));
memcpy(params + 6, &freq_scale, sizeof(float));
memcpy(params + 7, &ext_factor, sizeof(float));
memcpy(params + 8, &attn_factor, sizeof(float));
memcpy(params + 9, &beta_fast, sizeof(float));
memcpy(params + 10, &beta_slow, sizeof(float));
memcpy(params + 11, &xpos_base, sizeof(float));
memcpy(params + 12, &xpos_down, sizeof(bool));
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_ROPE_BACK;
result->grad = is_node ? ggml_dup_tensor(ctx, result) : NULL;
result->src[0] = a;
result->src[1] = b;
return result;
}
|
O3
|
c
|
ggml_rope_back:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
cmpq $0x1, 0x18(%rdx)
jne 0x92e33
movq %rdx, %rbx
cmpq $0x1, 0x20(%rdx)
jne 0x92e33
cmpq $0x1, 0x28(%rbx)
jne 0x92e33
cmpl $0x12, (%rbx)
jne 0x92e38
movq %rsi, %r14
movq 0x20(%rsi), %rax
cmpq 0x10(%rbx), %rax
jne 0x92e3d
movl %r8d, %r15d
vmovss %xmm0, 0x4(%rsp)
vmovss %xmm1, 0x8(%rsp)
vmovss %xmm2, 0xc(%rsp)
vmovss %xmm3, 0x10(%rsp)
vmovss %xmm4, 0x14(%rsp)
vmovss %xmm5, 0x18(%rsp)
vmovss %xmm6, 0x1c(%rsp)
testb $0x4, %r15b
jne 0x92e42
movl %ecx, %ebp
movl %r9d, %r12d
movl (%r14), %esi
leaq 0x10(%r14), %rcx
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8d64f
movq %rax, %r13
leaq 0x20(%rsp), %rsi
xorl %ecx, %ecx
movl %ecx, (%rsi)
movl %ebp, 0x4(%rsi)
movl %r15d, 0x8(%rsi)
movl %r12d, 0xc(%rsi)
movl 0x90(%rsp), %eax
movl %eax, 0x10(%rsi)
movl %ecx, 0x30(%rsi)
vmovss 0x4(%rsp), %xmm0
vmovss %xmm0, 0x14(%rsi)
vmovss 0x8(%rsp), %xmm0
vmovss %xmm0, 0x18(%rsi)
vmovss 0xc(%rsp), %xmm0
vmovss %xmm0, 0x1c(%rsi)
vmovss 0x10(%rsp), %xmm0
vmovss %xmm0, 0x20(%rsi)
vmovss 0x14(%rsp), %xmm0
vmovss %xmm0, 0x24(%rsi)
vmovss 0x18(%rsp), %xmm0
vmovss %xmm0, 0x28(%rsi)
vmovss 0x1c(%rsp), %xmm0
vmovss %xmm0, 0x2c(%rsi)
movb 0x98(%rsp), %al
movb %al, 0x30(%rsi)
movl $0x34, %edx
movq %r13, %rdi
callq 0x90cc8
movl $0x2a, 0x50(%r13)
movq $0x0, 0x98(%r13)
movq %r14, 0xa0(%r13)
movq %rbx, 0xa8(%r13)
movq %r13, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xdeeb
callq 0xdf30
callq 0xdf75
callq 0xdfba
|
ggml_rope_back:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
cmp qword ptr [rdx+18h], 1
jnz loc_92E33
mov rbx, rdx
cmp qword ptr [rdx+20h], 1
jnz loc_92E33
cmp qword ptr [rbx+28h], 1
jnz loc_92E33
cmp dword ptr [rbx], 12h
jnz loc_92E38
mov r14, rsi
mov rax, [rsi+20h]
cmp rax, [rbx+10h]
jnz loc_92E3D
mov r15d, r8d
vmovss [rsp+88h+var_84], xmm0
vmovss [rsp+88h+var_80], xmm1
vmovss [rsp+88h+var_7C], xmm2
vmovss [rsp+88h+var_78], xmm3
vmovss [rsp+88h+var_74], xmm4
vmovss [rsp+88h+var_70], xmm5
vmovss [rsp+88h+var_6C], xmm6
test r15b, 4
jnz loc_92E42
mov ebp, ecx
mov r12d, r9d
mov esi, [r14]
lea rcx, [r14+10h]
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
mov r13, rax
lea rsi, [rsp+88h+var_68]
xor ecx, ecx
mov [rsi], ecx
mov [rsi+4], ebp
mov [rsi+8], r15d
mov [rsi+0Ch], r12d
mov eax, [rsp+88h+arg_0]
mov [rsi+10h], eax
mov [rsi+30h], ecx
vmovss xmm0, [rsp+88h+var_84]
vmovss dword ptr [rsi+14h], xmm0
vmovss xmm0, [rsp+88h+var_80]
vmovss dword ptr [rsi+18h], xmm0
vmovss xmm0, [rsp+88h+var_7C]
vmovss dword ptr [rsi+1Ch], xmm0
vmovss xmm0, [rsp+88h+var_78]
vmovss dword ptr [rsi+20h], xmm0
vmovss xmm0, [rsp+88h+var_74]
vmovss dword ptr [rsi+24h], xmm0
vmovss xmm0, [rsp+88h+var_70]
vmovss dword ptr [rsi+28h], xmm0
vmovss xmm0, [rsp+88h+var_6C]
vmovss dword ptr [rsi+2Ch], xmm0
mov al, [rsp+88h+arg_8]
mov [rsi+30h], al
mov edx, 34h ; '4'
mov rdi, r13
call ggml_set_op_params
mov dword ptr [r13+50h], 2Ah ; '*'
mov qword ptr [r13+98h], 0
mov [r13+0A0h], r14
mov [r13+0A8h], rbx
mov rax, r13
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_92E33:
call ggml_rope_back_cold_1
loc_92E38:
call ggml_rope_back_cold_2
loc_92E3D:
call ggml_rope_back_cold_3
loc_92E42:
call ggml_rope_back_cold_4
|
long long ggml_rope_back(
long long a1,
long long a2,
long long a3,
int a4,
int a5,
int a6,
__m128 _XMM0,
__m128 _XMM1,
__m128 _XMM2,
__m128 _XMM3,
__m128 _XMM4,
__m128 _XMM5,
__m128 _XMM6,
int a14,
char a15)
{
long long v20; // r13
_DWORD v37[12]; // [rsp+20h] [rbp-68h] BYREF
int v38; // [rsp+50h] [rbp-38h]
if ( *(_QWORD *)(a3 + 24) != 1LL || *(_QWORD *)(a3 + 32) != 1LL || *(_QWORD *)(a3 + 40) != 1LL )
ggml_rope_back_cold_1();
if ( *(_DWORD *)a3 != 18 )
ggml_rope_back_cold_2();
if ( *(_QWORD *)(a2 + 32) != *(_QWORD *)(a3 + 16) )
ggml_rope_back_cold_3();
__asm
{
vmovss [rsp+88h+var_84], xmm0
vmovss [rsp+88h+var_80], xmm1
vmovss [rsp+88h+var_7C], xmm2
vmovss [rsp+88h+var_78], xmm3
vmovss [rsp+88h+var_74], xmm4
vmovss [rsp+88h+var_70], xmm5
vmovss [rsp+88h+var_6C], xmm6
}
if ( (a5 & 4) != 0 )
ggml_rope_back_cold_4();
v20 = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4, (_QWORD *)(a2 + 16), 0LL, 0LL, _XMM0, _XMM1);
_RSI = v37;
v37[0] = 0;
v37[1] = a4;
v37[2] = a5;
v37[3] = a6;
v37[4] = a14;
v38 = 0;
__asm
{
vmovss xmm0, [rsp+88h+var_84]
vmovss dword ptr [rsi+14h], xmm0
vmovss xmm0, [rsp+88h+var_80]
vmovss dword ptr [rsi+18h], xmm0
vmovss xmm0, [rsp+88h+var_7C]
vmovss dword ptr [rsi+1Ch], xmm0
vmovss xmm0, [rsp+88h+var_78]
vmovss dword ptr [rsi+20h], xmm0
vmovss xmm0, [rsp+88h+var_74]
vmovss dword ptr [rsi+24h], xmm0
vmovss xmm0, [rsp+88h+var_70]
vmovss dword ptr [rsi+28h], xmm0
vmovss xmm0, [rsp+88h+var_6C]
vmovss dword ptr [rsi+2Ch], xmm0
}
LOBYTE(v38) = a15;
ggml_set_op_params(v20, (long long)v37, 52LL);
*(_DWORD *)(v20 + 80) = 42;
*(_QWORD *)(v20 + 152) = 0LL;
*(_QWORD *)(v20 + 160) = a2;
*(_QWORD *)(v20 + 168) = a3;
return v20;
}
| |||
16,014
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const
|
llama.cpp/common/json.hpp
|
pointer operator->() const
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
return &(m_it.object_iterator->second);
}
case value_t::array:
{
JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
return &*m_it.array_iterator;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
{
return m_object;
}
JSON_THROW(invalid_iterator::create(214, "cannot get value", m_object));
}
}
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator->() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x7eb4e
movq %rdi, %r14
movzbl (%rax), %ecx
cmpl $0x2, %ecx
je 0x7eab1
cmpl $0x1, %ecx
jne 0x7eade
movq 0x8(%rax), %rcx
addq $0x8, %rcx
movq 0x8(%r14), %rax
cmpq %rcx, %rax
je 0x7eb6a
addq $0x40, %rax
jmp 0x7eae5
movq 0x8(%rax), %rcx
movq 0x10(%r14), %rax
cmpq 0x8(%rcx), %rax
jne 0x7eae5
leaq 0x9fa42(%rip), %rdi # 0x11e508
leaq 0x97b85(%rip), %rdx # 0x116652
leaq 0xa0ab4(%rip), %rcx # 0x11f588
movl $0x3397, %esi # imm = 0x3397
jmp 0x7eb84
cmpq $0x0, 0x18(%r14)
jne 0x7eaf0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x216a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa0ab8(%rip), %rsi # 0x11f5c5
leaq 0xa0ac1(%rip), %rdx # 0x11f5d5
leaq 0x8(%rsp), %rdi
callq 0x2d702
movq (%r14), %rcx
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xd6, %esi
callq 0x7fac4
xorl %ebp, %ebp
leaq 0xe64b1(%rip), %rsi # 0x164ff0
leaq -0x2a3a(%rip), %rdx # 0x7c10c
movq %rbx, %rdi
callq 0x21ae0
leaq 0x9f9b3(%rip), %rdi # 0x11e508
leaq 0x97af6(%rip), %rdx # 0x116652
leaq 0xa5cc9(%rip), %rcx # 0x12482c
movl $0x338b, %esi # imm = 0x338B
jmp 0x7eb84
leaq 0x9f997(%rip), %rdi # 0x11e508
leaq 0x97ada(%rip), %rdx # 0x116652
leaq 0xa09ca(%rip), %rcx # 0x11f549
movl $0x3391, %esi # imm = 0x3391
xorl %eax, %eax
callq 0x21f80
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7eba5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0x7ebaf
jmp 0x7ebb7
movq %rax, %r14
movq %rbx, %rdi
callq 0x22020
movq %r14, %rdi
callq 0x21b80
nop
|
_ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rax, [rdi]
test rax, rax
jz loc_7EB4E
mov r14, rdi
movzx ecx, byte ptr [rax]
cmp ecx, 2
jz short loc_7EAB1
cmp ecx, 1
jnz short loc_7EADE
mov rcx, [rax+8]
add rcx, 8
mov rax, [r14+8]
cmp rax, rcx
jz loc_7EB6A
add rax, 40h ; '@'
jmp short loc_7EAE5
loc_7EAB1:
mov rcx, [rax+8]
mov rax, [r14+10h]
cmp rax, [rcx+8]
jnz short loc_7EAE5
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItArrayIterat; "m_it.array_iterator != m_object->m_data"...
mov esi, 3397h
jmp loc_7EB84
loc_7EADE:
cmp qword ptr [r14+18h], 0
jnz short loc_7EAF0
loc_7EAE5:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_7EAF0:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+48h+var_30]
mov [r15-10h], r15
lea rsi, aCannotGetValue; "cannot get value"
lea rdx, aCannotGetValue+10h; ""
lea rdi, [rsp+48h+var_40]
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 rcx, [r14]
mov bpl, 1
lea rdx, [rsp+48h+var_40]
mov rdi, rbx; this
mov esi, 0D6h; int
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7EB4E:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 338Bh
jmp short loc_7EB84
loc_7EB6A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMItObjectItera; "m_it.object_iterator != m_object->m_dat"...
mov esi, 3391h
loc_7EB84:
xor eax, eax
call _ggml_abort
mov r14, rax
mov rdi, [rsp+48h+var_40]; void *
cmp rdi, r15
jz short loc_7EBA5
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7EBA5:
test bpl, bpl
jnz short loc_7EBAF
jmp short loc_7EBB7
mov r14, rax
loc_7EBAF:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7EBB7:
mov rdi, r14
call __Unwind_Resume
|
operator->:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0017eb4e
MOV R14,RDI
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x2
JZ 0x0017eab1
CMP ECX,0x1
JNZ 0x0017eade
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,0x8
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,RCX
JZ 0x0017eb6a
ADD RAX,0x40
JMP 0x0017eae5
LAB_0017eab1:
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
CMP RAX,qword ptr [RCX + 0x8]
JNZ 0x0017eae5
LEA RDI,[0x21e508]
LEA RDX,[0x216652]
LEA RCX,[0x21f588]
MOV ESI,0x3397
JMP 0x0017eb84
LAB_0017eade:
CMP qword ptr [R14 + 0x18],0x0
JNZ 0x0017eaf0
LAB_0017eae5:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0017eaf0:
MOV EDI,0x20
CALL 0x001216a0
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0017eb06:
LEA RSI,[0x21f5c5]
LEA RDX,[0x21f5d5]
LEA RDI,[RSP + 0x8]
CALL 0x0012d702
MOV RCX,qword ptr [R14]
MOV BPL,0x1
LAB_0017eb24:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xd6
CALL 0x0017fac4
XOR EBP,EBP
LEA RSI,[0x264ff0]
LEA RDX,[0x17c10c]
MOV RDI,RBX
CALL 0x00121ae0
LAB_0017eb4e:
LEA RDI,[0x21e508]
LEA RDX,[0x216652]
LEA RCX,[0x22482c]
MOV ESI,0x338b
JMP 0x0017eb84
LAB_0017eb6a:
LEA RDI,[0x21e508]
LEA RDX,[0x216652]
LEA RCX,[0x21f549]
MOV ESI,0x3391
LAB_0017eb84:
XOR EAX,EAX
CALL 0x00121f80
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() const */
char * __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
long *plVar1;
char *pcVar2;
int8 uVar3;
int1 *local_40 [2];
int1 local_30 [16];
pcVar2 = *(char **)this;
if (pcVar2 == (char *)0x0) {
pcVar2 = "m_object != nullptr";
uVar3 = 0x338b;
LAB_0017eb84:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
if (*pcVar2 == '\x02') {
plVar1 = (long *)(pcVar2 + 8);
pcVar2 = *(char **)(this + 0x10);
if (pcVar2 == *(char **)(*plVar1 + 8)) {
pcVar2 = "m_it.array_iterator != m_object->m_data.m_value.array->end()";
uVar3 = 0x3397;
goto LAB_0017eb84;
}
}
else if (*pcVar2 == '\x01') {
if (*(long *)(this + 8) == *(long *)(pcVar2 + 8) + 8) {
pcVar2 = "m_it.object_iterator != m_object->m_data.m_value.object->end()";
uVar3 = 0x3391;
goto LAB_0017eb84;
}
pcVar2 = (char *)(*(long *)(this + 8) + 0x40);
}
else if (*(long *)(this + 0x18) != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_40[0] = local_30;
/* try { // try from 0017eb06 to 0017eb1d has its CatchHandler @ 0017ebac */
std::__cxx11::string::_M_construct<char_const*>(local_40,"cannot get value","");
/* try { // try from 0017eb24 to 0017eb4d has its CatchHandler @ 0017eb8b */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xd6,local_40,*(int8 *)this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&invalid_iterator::typeinfo,exception::~exception);
}
return pcVar2;
}
|
||
16,015
|
GenImageGradientLinear
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c
|
Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end)
{
Color *pixels = (Color *)RL_MALLOC(width*height*sizeof(Color));
float radianDirection = (float)(90 - direction)/180.f*3.14159f;
float cosDir = cosf(radianDirection);
float sinDir = sinf(radianDirection);
// Calculate how far the top-left pixel is along the gradient direction from the center of said gradient
float startingPos = 0.5f - (cosDir*width/2) - (sinDir*height/2);
// With directions that lie in the first or third quadrant (i.e. from top-left to
// bottom-right or vice-versa), pixel (0, 0) is the farthest point on the gradient
// (i.e. the pixel which should become one of the gradient's ends color); while for
// directions that lie in the second or fourth quadrant, that point is pixel (width, 0).
float maxPosValue =
((signbit(sinDir) != 0) == (signbit(cosDir) != 0))
? fabsf(startingPos)
: fabsf(startingPos+width*cosDir);
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
// Calculate the relative position of the pixel along the gradient direction
float pos = (startingPos + (i*cosDir + j*sinDir)) / maxPosValue;
float factor = pos;
factor = (factor > 1.0f)? 1.0f : factor; // Clamp to [-1,1]
factor = (factor < -1.0f)? -1.0f : factor; // Clamp to [-1,1]
factor = factor / 2 + 0.5f;
// Generate the color for this pixel
pixels[j*width + i].r = (int)((float)end.r*factor + (float)start.r*(1.0f - factor));
pixels[j*width + i].g = (int)((float)end.g*factor + (float)start.g*(1.0f - factor));
pixels[j*width + i].b = (int)((float)end.b*factor + (float)start.b*(1.0f - factor));
pixels[j*width + i].a = (int)((float)end.a*factor + (float)start.a*(1.0f - factor));
}
}
Image image = {
.data = pixels,
.width = width,
.height = height,
.format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,
.mipmaps = 1
};
return image;
}
|
O2
|
c
|
GenImageGradientLinear:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movd %r8d, %xmm0
movdqa %xmm0, 0x30(%rsp)
movd %r9d, %xmm0
movdqa %xmm0, 0x20(%rsp)
movl %edx, %eax
imull %esi, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x96e0
movq %rax, %r15
pushq $0x5a
popq %rax
subl %r12d, %eax
cvtsi2ss %eax, %xmm0
divss 0x507fb(%rip), %xmm0 # 0xcf55c
mulss 0x507f7(%rip), %xmm0 # 0xcf560
movss %xmm0, 0xc(%rsp)
callq 0x9390
movaps %xmm0, 0x10(%rsp)
movss 0xc(%rsp), %xmm0
callq 0x9410
movaps 0x10(%rsp), %xmm12
cvtsi2ss %r14d, %xmm1
mulss %xmm12, %xmm1
movss 0x3a93c(%rip), %xmm2 # 0xb96d8
movaps %xmm1, %xmm4
mulss %xmm2, %xmm4
movaps %xmm2, %xmm3
cvtsi2ss %ebp, %xmm5
subss %xmm4, %xmm3
mulss %xmm0, %xmm5
mulss %xmm2, %xmm5
subss %xmm5, %xmm3
movaps %xmm0, %xmm4
xorps %xmm12, %xmm4
movd %xmm4, %eax
testl %eax, %eax
js 0x7edce
movaps %xmm3, %xmm1
jmp 0x7edd2
addss %xmm3, %xmm1
andps 0x3ad27(%rip), %xmm1 # 0xb9b00
xorps %xmm5, %xmm5
movdqa 0x20(%rsp), %xmm4
punpcklbw %xmm5, %xmm4 # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1],xmm4[2],xmm5[2],xmm4[3],xmm5[3],xmm4[4],xmm5[4],xmm4[5],xmm5[5],xmm4[6],xmm5[6],xmm4[7],xmm5[7]
punpcklwd %xmm5, %xmm4 # xmm4 = xmm4[0],xmm5[0],xmm4[1],xmm5[1],xmm4[2],xmm5[2],xmm4[3],xmm5[3]
cvtdq2ps %xmm4, %xmm4
movdqa 0x30(%rsp), %xmm6
punpcklbw %xmm5, %xmm6 # xmm6 = xmm6[0],xmm5[0],xmm6[1],xmm5[1],xmm6[2],xmm5[2],xmm6[3],xmm5[3],xmm6[4],xmm5[4],xmm6[5],xmm5[5],xmm6[6],xmm5[6],xmm6[7],xmm5[7]
punpcklwd %xmm5, %xmm6 # xmm6 = xmm6[0],xmm5[0],xmm6[1],xmm5[1],xmm6[2],xmm5[2],xmm6[3],xmm5[3]
cvtdq2ps %xmm6, %xmm5
movslq %r14d, %rax
xorl %ecx, %ecx
testl %ebp, %ebp
movl $0x0, %edx
cmovgl %ebp, %edx
testl %r14d, %r14d
movl $0x0, %esi
cmovgl %r14d, %esi
shlq $0x2, %rax
movss 0x3a877(%rip), %xmm6 # 0xb969c
movss 0x3a873(%rip), %xmm7 # 0xb96a0
movdqa 0x447da(%rip), %xmm8 # 0xc3610
movq %r15, %rdi
cmpq %rsi, %rcx
je 0x7eed8
cvtsi2ss %ecx, %xmm9
mulss %xmm12, %xmm9
movq %rdi, %r8
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x7eecc
cvtsi2ss %r9d, %xmm10
mulss %xmm0, %xmm10
addss %xmm9, %xmm10
addss %xmm3, %xmm10
divss %xmm1, %xmm10
movaps %xmm6, %xmm11
minss %xmm10, %xmm11
movaps %xmm7, %xmm10
maxss %xmm11, %xmm10
mulss %xmm2, %xmm10
addss %xmm2, %xmm10
movaps %xmm6, %xmm11
subss %xmm10, %xmm11
shufps $0x0, %xmm10, %xmm10 # xmm10 = xmm10[0,0,0,0]
mulps %xmm4, %xmm10
shufps $0x0, %xmm11, %xmm11 # xmm11 = xmm11[0,0,0,0]
mulps %xmm5, %xmm11
addps %xmm10, %xmm11
cvttps2dq %xmm11, %xmm10
pand %xmm8, %xmm10
packuswb %xmm10, %xmm10
packuswb %xmm10, %xmm10
movd %xmm10, (%r8)
incq %r9
addq %rax, %r8
jmp 0x7ee52
incq %rcx
addq $0x4, %rdi
jmp 0x7ee39
movq %r15, (%rbx)
movl %r14d, 0x8(%rbx)
movl %ebp, 0xc(%rbx)
movabsq $0x700000001, %rax # imm = 0x700000001
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
GenImageGradientLinear:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r12d, ecx
mov ebp, edx
mov r14d, esi
mov rbx, rdi
movd xmm0, r8d
movdqa [rsp+68h+var_38], xmm0
movd xmm0, r9d
movdqa [rsp+68h+var_48], xmm0
mov eax, edx
imul eax, esi
movsxd rdi, eax
shl rdi, 2
call _malloc
mov r15, rax
push 5Ah ; 'Z'
pop rax
sub eax, r12d
cvtsi2ss xmm0, eax
divss xmm0, cs:dword_CF55C
mulss xmm0, cs:dword_CF560
movss [rsp+68h+var_5C], xmm0
call _cosf
movaps [rsp+68h+var_58], xmm0
movss xmm0, [rsp+68h+var_5C]
call _sinf
movaps xmm12, [rsp+68h+var_58]
cvtsi2ss xmm1, r14d
mulss xmm1, xmm12
movss xmm2, cs:dword_B96D8
movaps xmm4, xmm1
mulss xmm4, xmm2
movaps xmm3, xmm2
cvtsi2ss xmm5, ebp
subss xmm3, xmm4
mulss xmm5, xmm0
mulss xmm5, xmm2
subss xmm3, xmm5
movaps xmm4, xmm0
xorps xmm4, xmm12
movd eax, xmm4
test eax, eax
js short loc_7EDCE
movaps xmm1, xmm3
jmp short loc_7EDD2
loc_7EDCE:
addss xmm1, xmm3
loc_7EDD2:
andps xmm1, cs:xmmword_B9B00
xorps xmm5, xmm5
movdqa xmm4, [rsp+68h+var_48]
punpcklbw xmm4, xmm5
punpcklwd xmm4, xmm5
cvtdq2ps xmm4, xmm4
movdqa xmm6, [rsp+68h+var_38]
punpcklbw xmm6, xmm5
punpcklwd xmm6, xmm5
cvtdq2ps xmm5, xmm6
movsxd rax, r14d
xor ecx, ecx
test ebp, ebp
mov edx, 0
cmovg edx, ebp
test r14d, r14d
mov esi, 0
cmovg esi, r14d
shl rax, 2
movss xmm6, cs:dword_B969C
movss xmm7, cs:dword_B96A0
movdqa xmm8, cs:xmmword_C3610
mov rdi, r15
loc_7EE39:
cmp rcx, rsi
jz loc_7EED8
cvtsi2ss xmm9, ecx
mulss xmm9, xmm12
mov r8, rdi
xor r9d, r9d
loc_7EE52:
cmp rdx, r9
jz short loc_7EECC
cvtsi2ss xmm10, r9d
mulss xmm10, xmm0
addss xmm10, xmm9
addss xmm10, xmm3
divss xmm10, xmm1
movaps xmm11, xmm6
minss xmm11, xmm10
movaps xmm10, xmm7
maxss xmm10, xmm11
mulss xmm10, xmm2
addss xmm10, xmm2
movaps xmm11, xmm6
subss xmm11, xmm10
shufps xmm10, xmm10, 0
mulps xmm10, xmm4
shufps xmm11, xmm11, 0
mulps xmm11, xmm5
addps xmm11, xmm10
cvttps2dq xmm10, xmm11
pand xmm10, xmm8
packuswb xmm10, xmm10
packuswb xmm10, xmm10
movd dword ptr [r8], xmm10
inc r9
add r8, rax
jmp short loc_7EE52
loc_7EECC:
inc rcx
add rdi, 4
jmp loc_7EE39
loc_7EED8:
mov [rbx], r15
mov [rbx+8], r14d
mov [rbx+0Ch], ebp
mov rax, 700000001h
mov [rbx+10h], rax
mov rax, rbx
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long GenImageGradientLinear(long long a1, int a2, int a3, int a4, unsigned int a5, unsigned int a6)
{
__m128i v10; // xmm0
long long v11; // r15
__m128 v12; // xmm0
float v13; // xmm3_4
float v14; // xmm1_4
float v15; // xmm1_4
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // rcx
long long v19; // rdx
long long v20; // rsi
__m128i si128; // xmm8
_DWORD *v22; // rdi
_DWORD *v23; // r8
long long i; // r9
__m128 v25; // xmm10
__m128 v26; // xmm11
__m128i v27; // xmm10
__m128i v28; // xmm10
float v30; // [rsp+Ch] [rbp-5Ch]
__m128 v31; // [rsp+10h] [rbp-58h]
__m128i v32; // [rsp+20h] [rbp-48h] BYREF
__m128i v33[3]; // [rsp+30h] [rbp-38h] BYREF
v33[0] = _mm_cvtsi32_si128(a5);
v10 = _mm_cvtsi32_si128(a6);
v32 = v10;
v11 = malloc(4LL * a2 * a3);
v30 = (float)((float)(90 - a4) / 180.0) * 3.1415901;
*(double *)v10.m128i_i64 = cosf(v30);
v31 = (__m128)v10;
v12 = (__m128)LODWORD(v30);
*(double *)v12.m128_u64 = sinf(v30);
v13 = (float)(0.5 - (float)((float)((float)a2 * v31.m128_f32[0]) * 0.5))
- (float)((float)((float)a3 * v12.m128_f32[0]) * 0.5);
if ( _mm_cvtsi128_si32((__m128i)_mm_xor_ps(v12, v31)) < 0 )
v14 = (float)((float)a2 * v31.m128_f32[0]) + v13;
else
v14 = (float)(0.5 - (float)((float)((float)a2 * v31.m128_f32[0]) * 0.5))
- (float)((float)((float)a3 * v12.m128_f32[0]) * 0.5);
v15 = fabs(v14);
v16 = _mm_cvtepi32_ps(_mm_unpacklo_epi16(_mm_unpacklo_epi8(_mm_load_si128(&v32), (__m128i)0LL), (__m128i)0LL));
v17 = _mm_cvtepi32_ps(_mm_unpacklo_epi16(_mm_unpacklo_epi8(_mm_load_si128(v33), (__m128i)0LL), (__m128i)0LL));
v18 = 0LL;
v19 = 0LL;
if ( a3 > 0 )
v19 = (unsigned int)a3;
v20 = 0LL;
if ( a2 > 0 )
v20 = (unsigned int)a2;
si128 = _mm_load_si128((const __m128i *)&xmmword_C3610);
v22 = (_DWORD *)v11;
while ( v18 != v20 )
{
v23 = v22;
for ( i = 0LL; v19 != i; ++i )
{
v25 = (__m128)0xBF800000;
v25.m128_f32[0] = (float)(fmaxf(
-1.0,
fminf(
1.0,
(float)((float)((float)((float)(int)i * v12.m128_f32[0])
+ (float)((float)(int)v18 * v31.m128_f32[0]))
+ v13)
/ v15))
* 0.5)
+ 0.5;
v26 = (__m128)0x3F800000u;
v26.m128_f32[0] = 1.0 - v25.m128_f32[0];
v27 = _mm_and_si128(
_mm_cvttps_epi32(_mm_add_ps(_mm_mul_ps(_mm_shuffle_ps(v26, v26, 0), v17), _mm_mul_ps(_mm_shuffle_ps(v25, v25, 0), v16))),
si128);
v28 = _mm_packus_epi16(v27, v27);
*v23 = _mm_cvtsi128_si32(_mm_packus_epi16(v28, v28));
v23 += a2;
}
++v18;
++v22;
}
*(_QWORD *)a1 = v11;
*(_DWORD *)(a1 + 8) = a2;
*(_DWORD *)(a1 + 12) = a3;
*(_QWORD *)(a1 + 16) = 0x700000001LL;
return a1;
}
|
GenImageGradientLinear:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R12D,ECX
MOV EBP,EDX
MOV R14D,ESI
MOV RBX,RDI
MOVD XMM0,R8D
MOVDQA xmmword ptr [RSP + 0x30],XMM0
MOVD XMM0,R9D
MOVDQA xmmword ptr [RSP + 0x20],XMM0
MOV EAX,EDX
IMUL EAX,ESI
MOVSXD RDI,EAX
SHL RDI,0x2
CALL 0x001096e0
MOV R15,RAX
PUSH 0x5a
POP RAX
SUB EAX,R12D
CVTSI2SS XMM0,EAX
DIVSS XMM0,dword ptr [0x001cf55c]
MULSS XMM0,dword ptr [0x001cf560]
MOVSS dword ptr [RSP + 0xc],XMM0
CALL 0x00109390
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVSS XMM0,dword ptr [RSP + 0xc]
CALL 0x00109410
MOVAPS XMM12,xmmword ptr [RSP + 0x10]
CVTSI2SS XMM1,R14D
MULSS XMM1,XMM12
MOVSS XMM2,dword ptr [0x001b96d8]
MOVAPS XMM4,XMM1
MULSS XMM4,XMM2
MOVAPS XMM3,XMM2
CVTSI2SS XMM5,EBP
SUBSS XMM3,XMM4
MULSS XMM5,XMM0
MULSS XMM5,XMM2
SUBSS XMM3,XMM5
MOVAPS XMM4,XMM0
XORPS XMM4,XMM12
MOVD EAX,XMM4
TEST EAX,EAX
JS 0x0017edce
MOVAPS XMM1,XMM3
JMP 0x0017edd2
LAB_0017edce:
ADDSS XMM1,XMM3
LAB_0017edd2:
ANDPS XMM1,xmmword ptr [0x001b9b00]
XORPS XMM5,XMM5
MOVDQA XMM4,xmmword ptr [RSP + 0x20]
PUNPCKLBW XMM4,XMM5
PUNPCKLWD XMM4,XMM5
CVTDQ2PS XMM4,XMM4
MOVDQA XMM6,xmmword ptr [RSP + 0x30]
PUNPCKLBW XMM6,XMM5
PUNPCKLWD XMM6,XMM5
CVTDQ2PS XMM5,XMM6
MOVSXD RAX,R14D
XOR ECX,ECX
TEST EBP,EBP
MOV EDX,0x0
CMOVG EDX,EBP
TEST R14D,R14D
MOV ESI,0x0
CMOVG ESI,R14D
SHL RAX,0x2
MOVSS XMM6,dword ptr [0x001b969c]
MOVSS XMM7,dword ptr [0x001b96a0]
MOVDQA XMM8,xmmword ptr [0x001c3610]
MOV RDI,R15
LAB_0017ee39:
CMP RCX,RSI
JZ 0x0017eed8
CVTSI2SS XMM9,ECX
MULSS XMM9,XMM12
MOV R8,RDI
XOR R9D,R9D
LAB_0017ee52:
CMP RDX,R9
JZ 0x0017eecc
CVTSI2SS XMM10,R9D
MULSS XMM10,XMM0
ADDSS XMM10,XMM9
ADDSS XMM10,XMM3
DIVSS XMM10,XMM1
MOVAPS XMM11,XMM6
MINSS XMM11,XMM10
MOVAPS XMM10,XMM7
MAXSS XMM10,XMM11
MULSS XMM10,XMM2
ADDSS XMM10,XMM2
MOVAPS XMM11,XMM6
SUBSS XMM11,XMM10
SHUFPS XMM10,XMM10,0x0
MULPS XMM10,XMM4
SHUFPS XMM11,XMM11,0x0
MULPS XMM11,XMM5
ADDPS XMM11,XMM10
CVTTPS2DQ XMM10,XMM11
PAND XMM10,XMM8
PACKUSWB XMM10,XMM10
PACKUSWB XMM10,XMM10
MOVD dword ptr [R8],XMM10
INC R9
ADD R8,RAX
JMP 0x0017ee52
LAB_0017eecc:
INC RCX
ADD RDI,0x4
JMP 0x0017ee39
LAB_0017eed8:
MOV qword ptr [RBX],R15
MOV dword ptr [RBX + 0x8],R14D
MOV dword ptr [RBX + 0xc],EBP
MOV RAX,0x700000001
MOV qword ptr [RBX + 0x10],RAX
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 *
GenImageGradientLinear
(int8 *param_1,uint param_2,uint param_3,int param_4,int4 param_5,
int4 param_6)
{
char cVar1;
short sVar5;
short sVar6;
short sVar7;
int1 auVar8 [14];
int1 auVar9 [14];
int1 auVar10 [14];
int1 auVar11 [15];
int1 auVar12 [15];
int1 auVar13 [15];
unkuint9 Var14;
int1 auVar15 [11];
int1 auVar16 [13];
int1 auVar17 [14];
int1 auVar18 [11];
int1 auVar19 [14];
int1 auVar20 [15];
int1 auVar21 [15];
int1 auVar22 [15];
int1 auVar23 [15];
uint6 uVar24;
uint6 uVar25;
float fVar26;
float fVar27;
int1 auVar28 [16];
char *pcVar29;
ulong uVar30;
ulong uVar31;
ulong uVar32;
char *pcVar33;
char *pcVar34;
ulong uVar35;
float fVar36;
float fVar37;
float fVar38;
float fVar39;
float fVar40;
ushort uVar41;
short sVar42;
float fVar43;
float fVar44;
int1 auVar47 [16];
char cVar2;
char cVar3;
char cVar4;
int4 uVar45;
int6 uVar46;
pcVar29 = (char *)malloc((long)(int)(param_3 * param_2) << 2);
fVar36 = ((float)(0x5a - param_4) / _DAT_001cf55c) * _DAT_001cf560;
fVar37 = cosf(fVar36);
fVar38 = sinf(fVar36);
auVar28 = _DAT_001c3610;
fVar27 = DAT_001b96d8;
fVar26 = DAT_001b96a0;
fVar36 = DAT_001b969c;
fVar40 = (DAT_001b96d8 - (float)(int)param_2 * fVar37 * DAT_001b96d8) -
(float)(int)param_3 * fVar38 * DAT_001b96d8;
fVar39 = fVar40;
if ((int)((uint)fVar38 ^ (uint)fVar37) < 0) {
fVar39 = (float)(int)param_2 * fVar37 + fVar40;
}
fVar39 = (float)((uint)fVar39 & _DAT_001b9b00);
Var14 = CONCAT81(SUB158(ZEXT815(0),7),(char)((uint)param_6 >> 0x18));
auVar20._9_6_ = 0;
auVar20._0_9_ = Var14;
auVar15._1_10_ = SUB1510(auVar20 << 0x30,5);
auVar15[0] = (char)((uint)param_6 >> 0x10);
auVar21._11_4_ = 0;
auVar21._0_11_ = auVar15;
auVar16._1_12_ = SUB1512(auVar21 << 0x20,3);
auVar16[0] = (char)((uint)param_6 >> 8);
uVar41 = CONCAT11(0,(byte)param_6);
auVar13._2_13_ = auVar16;
auVar13._0_2_ = uVar41;
auVar9._10_2_ = 0;
auVar9._0_10_ = auVar13._0_10_;
auVar9._12_2_ = (short)Var14;
uVar24 = CONCAT42(auVar9._10_4_,auVar15._0_2_);
auVar17._6_8_ = 0;
auVar17._0_6_ = uVar24;
Var14 = CONCAT81(SUB158(ZEXT815(0),7),(char)((uint)param_5 >> 0x18));
auVar22._9_6_ = 0;
auVar22._0_9_ = Var14;
auVar18._1_10_ = SUB1510(auVar22 << 0x30,5);
auVar18[0] = (char)((uint)param_5 >> 0x10);
auVar23._11_4_ = 0;
auVar23._0_11_ = auVar18;
auVar11[2] = (char)((uint)param_5 >> 8);
auVar11._0_2_ = (ushort)param_5;
auVar11._3_12_ = SUB1512(auVar23 << 0x20,3);
auVar12._2_13_ = auVar11._2_13_;
auVar12._0_2_ = (ushort)param_5 & 0xff;
auVar8._10_2_ = 0;
auVar8._0_10_ = auVar12._0_10_;
auVar8._12_2_ = (short)Var14;
uVar25 = CONCAT42(auVar8._10_4_,auVar18._0_2_);
auVar19._6_8_ = 0;
auVar19._0_6_ = uVar25;
auVar10._4_2_ = auVar11._2_2_;
auVar10._0_4_ = auVar12._0_4_;
auVar10._6_8_ = SUB148(auVar19 << 0x40,6);
uVar30 = 0;
uVar31 = 0;
if (0 < (int)param_3) {
uVar31 = (ulong)param_3;
}
uVar32 = 0;
if (0 < (int)param_2) {
uVar32 = (ulong)param_2;
}
pcVar33 = pcVar29;
for (; uVar30 != uVar32; uVar30 = uVar30 + 1) {
pcVar34 = pcVar33;
for (uVar35 = 0; uVar31 != uVar35; uVar35 = uVar35 + 1) {
fVar43 = ((float)(int)uVar35 * fVar38 + (float)(int)uVar30 * fVar37 + fVar40) / fVar39;
fVar44 = fVar36;
if (fVar43 <= fVar36) {
fVar44 = fVar43;
}
fVar43 = fVar26;
if (fVar26 <= fVar44) {
fVar43 = fVar44;
}
fVar44 = fVar43 * fVar27 + fVar27;
fVar43 = fVar36 - fVar44;
auVar47._0_4_ = (int)(fVar43 * (float)(auVar12._0_4_ & 0xffff) + fVar44 * (float)uVar41);
auVar47._4_4_ =
(int)(fVar43 * (float)auVar10._4_4_ +
fVar44 * (float)(int)CONCAT82(SUB148(auVar17 << 0x40,6),auVar16._0_2_));
auVar47._8_4_ = (int)(fVar43 * (float)(int)uVar25 + fVar44 * (float)(int)uVar24);
auVar47._12_4_ =
(int)(fVar43 * (float)(auVar8._10_4_ >> 0x10) + fVar44 * (float)(auVar9._10_4_ >> 0x10));
auVar47 = auVar47 & auVar28;
sVar5 = auVar47._0_2_;
cVar1 = (0 < sVar5) * (sVar5 < 0x100) * auVar47[0] - (0xff < sVar5);
sVar5 = auVar47._2_2_;
sVar42 = CONCAT11((0 < sVar5) * (sVar5 < 0x100) * auVar47[2] - (0xff < sVar5),cVar1);
sVar5 = auVar47._4_2_;
cVar2 = (0 < sVar5) * (sVar5 < 0x100) * auVar47[4] - (0xff < sVar5);
sVar5 = auVar47._6_2_;
uVar45 = CONCAT13((0 < sVar5) * (sVar5 < 0x100) * auVar47[6] - (0xff < sVar5),
CONCAT12(cVar2,sVar42));
sVar5 = auVar47._8_2_;
cVar3 = (0 < sVar5) * (sVar5 < 0x100) * auVar47[8] - (0xff < sVar5);
sVar5 = auVar47._10_2_;
uVar46 = CONCAT15((0 < sVar5) * (sVar5 < 0x100) * auVar47[10] - (0xff < sVar5),
CONCAT14(cVar3,uVar45));
sVar5 = auVar47._12_2_;
cVar4 = (0 < sVar5) * (sVar5 < 0x100) * auVar47[0xc] - (0xff < sVar5);
sVar7 = auVar47._14_2_;
sVar5 = (short)((uint)uVar45 >> 0x10);
sVar6 = (short)((uint6)uVar46 >> 0x20);
sVar7 = (short)(CONCAT17((0 < sVar7) * (sVar7 < 0x100) * auVar47[0xe] - (0xff < sVar7),
CONCAT16(cVar4,uVar46)) >> 0x30);
*pcVar34 = (0 < sVar42) * (sVar42 < 0x100) * cVar1 - (0xff < sVar42);
pcVar34[1] = (0 < sVar5) * (sVar5 < 0x100) * cVar2 - (0xff < sVar5);
pcVar34[2] = (0 < sVar6) * (sVar6 < 0x100) * cVar3 - (0xff < sVar6);
pcVar34[3] = (0 < sVar7) * (sVar7 < 0x100) * cVar4 - (0xff < sVar7);
pcVar34 = pcVar34 + (long)(int)param_2 * 4;
}
pcVar33 = pcVar33 + 4;
}
*param_1 = pcVar29;
*(uint *)(param_1 + 1) = param_2;
*(uint *)((long)param_1 + 0xc) = param_3;
param_1[2] = 0x700000001;
return param_1;
}
|
|
16,016
|
minja::Value::push_back(minja::Value const&)
|
monkey531[P]llama/common/minja.hpp
|
void push_back(const Value& v) {
if (!array_)
throw std::runtime_error("Value is not an array: " + dump());
array_->push_back(v);
}
|
O1
|
cpp
|
minja::Value::push_back(minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x8ff6b
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x90024
movl $0x10, %edi
callq 0x1b450
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x8801c
leaq 0x633ea(%rip), %rsi # 0xf337b
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x79e0f
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be20
xorl %ebp, %ebp
movq 0x9f039(%rip), %rsi # 0x12eff0
movq 0x9efa2(%rip), %rdx # 0x12ef60
movq %rbx, %rdi
callq 0x1bf10
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8ffec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x8ffec
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9000f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0x9000f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9001c
movq %rbx, %rdi
callq 0x1b690
movq %r14, %rdi
callq 0x1bf90
|
_ZN5minja5Value9push_backERKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_8FF6B
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backERKS1_; std::vector<minja::Value>::push_back(minja::Value const&)
loc_8FF6B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr; "Value is not an array: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8FFEC
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8FFEC
mov r14, rax
mov bpl, 1
loc_8FFEC:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9000F
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9000F
mov r14, rax
mov bpl, 1
loc_9000F:
test bpl, bpl
jz short loc_9001C
mov rdi, rbx; void *
call ___cxa_free_exception
loc_9001C:
mov rdi, r14
call __Unwind_Resume
|
long long minja::Value::push_back(minja::Value *this, const minja::Value *a2)
{
long long v3; // rdi
void *exception; // rbx
_BYTE v6[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v7[16]; // [rsp+20h] [rbp-38h] BYREF
v3 = *((_QWORD *)this + 2);
if ( !v3 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v7, (long long)"Value is not an array: ", (long long)v6);
std::runtime_error::runtime_error(exception, v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return std::vector<minja::Value>::push_back(v3, a2);
}
|
push_back:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x0018ff6b
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x00190024
LAB_0018ff6b:
MOV EDI,0x10
CALL 0x0011b450
MOV RBX,RAX
LAB_0018ff78:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0018801c
LAB_0018ff8a:
LEA RSI,[0x1f337b]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00179e0f
MOV BPL,0x1
LAB_0018ffa1:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011be20
XOR EBP,EBP
MOV RSI,qword ptr [0x0022eff0]
MOV RDX,qword ptr [0x0022ef60]
MOV RDI,RBX
CALL 0x0011bf10
|
/* minja::Value::push_back(minja::Value const&) */
void __thiscall minja::Value::push_back(Value *this,Value *param_1)
{
runtime_error *this_00;
int1 auStack_58 [32];
string local_38 [32];
if (*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10) !=
(vector<minja::Value,std::allocator<minja::Value>> *)0x0) {
std::vector<minja::Value,std::allocator<minja::Value>>::push_back
(*(vector<minja::Value,std::allocator<minja::Value>> **)(this + 0x10),param_1);
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018ff78 to 0018ff89 has its CatchHandler @ 00190009 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 0018ff8a to 0018ff9d has its CatchHandler @ 0018ffe6 */
std::operator+((char *)local_38,(string *)"Value is not an array: ");
/* try { // try from 0018ffa1 to 0018ffc5 has its CatchHandler @ 0018ffc6 */
std::runtime_error::runtime_error(this_00,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0022eff0,PTR__runtime_error_0022ef60);
}
|
|
16,017
|
js_create_resolving_functions
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_create_resolving_functions(JSContext *ctx,
JSValue *resolving_funcs,
JSValue promise)
{
JSValue obj;
JSPromiseFunctionData *s;
JSPromiseFunctionDataResolved *sr;
int i, ret;
sr = js_malloc(ctx, sizeof(*sr));
if (!sr)
return -1;
sr->ref_count = 1;
sr->already_resolved = FALSE; /* must be shared between the two functions */
ret = 0;
for(i = 0; i < 2; i++) {
obj = JS_NewObjectProtoClass(ctx, ctx->function_proto,
JS_CLASS_PROMISE_RESOLVE_FUNCTION + i);
if (JS_IsException(obj))
goto fail;
s = js_malloc(ctx, sizeof(*s));
if (!s) {
JS_FreeValue(ctx, obj);
fail:
if (i != 0)
JS_FreeValue(ctx, resolving_funcs[0]);
ret = -1;
break;
}
sr->ref_count++;
s->presolved = sr;
s->promise = js_dup(promise);
JS_SetOpaqueInternal(obj, s);
js_function_set_properties(ctx, obj, JS_ATOM_empty_string, 1);
resolving_funcs[i] = obj;
}
js_promise_resolve_function_free_resolved(ctx->rt, sr);
return ret;
}
|
O0
|
c
|
js_create_resolving_functions:
subq $0x78, %rsp
movq %rdx, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movl $0x8, %esi
callq 0x209f0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x911a1
movl $0xffffffff, 0x74(%rsp) # imm = 0xFFFFFFFF
jmp 0x91353
movq 0x30(%rsp), %rax
movl $0x1, (%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, 0x28(%rsp)
movl $0x0, 0x2c(%rsp)
cmpl $0x2, 0x2c(%rsp)
jge 0x91338
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl $0x32, %ecx
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
callq 0x28be0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x91225
jmp 0x91255
movq 0x58(%rsp), %rdi
movl $0x18, %esi
callq 0x209f0
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x9127f
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x229d0
cmpl $0x0, 0x2c(%rsp)
je 0x91272
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x229d0
movl $0xffffffff, 0x28(%rsp) # imm = 0xFFFFFFFF
jmp 0x91338
movq 0x30(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x20410
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)
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x296e0
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl $0x2f, %ecx
movl $0x1, %r8d
callq 0x29710
movq 0x50(%rsp), %rax
movslq 0x2c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x40(%rsp), %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x911c8
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x908f0
movl 0x28(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax)
|
js_create_resolving_functions:
sub rsp, 78h
mov [rsp+78h+var_18], rdx
mov [rsp+78h+var_10], rcx
mov [rsp+78h+var_20], rdi
mov [rsp+78h+var_28], rsi
mov rdi, [rsp+78h+var_20]
mov esi, 8
call js_malloc
mov [rsp+78h+var_48], rax
cmp [rsp+78h+var_48], 0
jnz short loc_911A1
mov [rsp+78h+var_4], 0FFFFFFFFh
jmp loc_91353
loc_911A1:
mov rax, [rsp+78h+var_48]
mov dword ptr [rax], 1
mov rax, [rsp+78h+var_48]
mov dword ptr [rax+4], 0
mov [rsp+78h+var_50], 0
mov [rsp+78h+var_4C], 0
loc_911C8:
cmp [rsp+78h+var_4C], 2
jge loc_91338
mov rdi, [rsp+78h+var_20]
mov rax, [rsp+78h+var_20]
mov ecx, [rsp+78h+var_4C]
add ecx, 32h ; '2'
mov rsi, [rax+48h]
mov rdx, [rax+50h]
call JS_NewObjectProtoClass
mov [rsp+78h+var_60], rax
mov [rsp+78h+var_58], rdx
mov rax, [rsp+78h+var_60]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_58]
mov [rsp+78h+var_30], rax
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_91225
jmp short loc_91255
loc_91225:
mov rdi, [rsp+78h+var_20]
mov esi, 18h
call js_malloc
mov [rsp+78h+var_40], rax
cmp [rsp+78h+var_40], 0
jnz short loc_9127F
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
call JS_FreeValue
loc_91255:
cmp [rsp+78h+var_4C], 0
jz short loc_91272
mov rdi, [rsp+78h+var_20]
mov rax, [rsp+78h+var_28]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_FreeValue
loc_91272:
mov [rsp+78h+var_50], 0FFFFFFFFh
jmp loc_91338
loc_9127F:
mov rax, [rsp+78h+var_48]
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
mov rcx, [rsp+78h+var_48]
mov rax, [rsp+78h+var_40]
mov [rax+10h], rcx
mov rax, [rsp+78h+var_40]
mov [rsp+78h+var_78], rax
mov rdi, [rsp+78h+var_18]
mov rsi, [rsp+78h+var_10]
call js_dup
mov rcx, rax
mov rax, [rsp+78h+var_78]
mov [rsp+78h+var_70], rcx
mov [rsp+78h+var_68], rdx
mov rcx, [rsp+78h+var_70]
mov [rax], rcx
mov rcx, [rsp+78h+var_68]
mov [rax+8], rcx
mov rdx, [rsp+78h+var_40]
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_30]
call JS_SetOpaqueInternal
mov rdi, [rsp+78h+var_20]
mov rsi, [rsp+78h+var_38]
mov rdx, [rsp+78h+var_30]
mov ecx, 2Fh ; '/'
mov r8d, 1
call js_function_set_properties
mov rax, [rsp+78h+var_28]
movsxd rcx, [rsp+78h+var_4C]
shl rcx, 4
add rax, rcx
mov rcx, [rsp+78h+var_38]
mov [rax], rcx
mov rcx, [rsp+78h+var_30]
mov [rax+8], rcx
mov eax, [rsp+78h+var_4C]
add eax, 1
mov [rsp+78h+var_4C], eax
jmp loc_911C8
loc_91338:
mov rax, [rsp+78h+var_20]
mov rdi, [rax+18h]
mov rsi, [rsp+78h+var_48]
call js_promise_resolve_function_free_resolved
mov eax, [rsp+78h+var_50]
mov [rsp+78h+var_4], eax
loc_91353:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
|
long long js_create_resolving_functions(long long *a1, long long *a2, _DWORD *a3, unsigned int a4)
{
long long v4; // rdx
long long v5; // rdx
long long *v6; // rax
long long v8; // [rsp+18h] [rbp-60h]
unsigned int v9; // [rsp+28h] [rbp-50h]
int i; // [rsp+2Ch] [rbp-4Ch]
int *v11; // [rsp+30h] [rbp-48h]
_QWORD *v12; // [rsp+38h] [rbp-40h]
long long v13; // [rsp+48h] [rbp-30h]
v11 = (int *)js_malloc((long long)a1, 8LL);
if ( v11 )
{
*v11 = 1;
v11[1] = 0;
v9 = 0;
for ( i = 0; i < 2; ++i )
{
v8 = JS_NewObjectProtoClass((long long)a1, a1[9], a1[10], i + 50);
v13 = v4;
if ( JS_IsException_1(v8, v4) )
goto LABEL_8;
v12 = (_QWORD *)js_malloc((long long)a1, 24LL);
if ( !v12 )
{
JS_FreeValue((long long)a1, v8, v13);
LABEL_8:
if ( i )
JS_FreeValue((long long)a1, *a2, a2[1]);
v9 = -1;
break;
}
++*v11;
v12[2] = v11;
*v12 = js_dup(a3, a4);
v12[1] = v5;
JS_SetOpaqueInternal(v8, v13, (long long)v12);
js_function_set_properties((long long)a1, v8, v13, 0x2Fu, 1u);
v6 = &a2[2 * i];
*v6 = v8;
v6[1] = v13;
}
js_promise_resolve_function_free_resolved(a1[3], v11);
return v9;
}
else
{
return (unsigned int)-1;
}
}
|
js_create_resolving_functions:
SUB RSP,0x78
MOV qword ptr [RSP + 0x60],RDX
MOV qword ptr [RSP + 0x68],RCX
MOV qword ptr [RSP + 0x58],RDI
MOV qword ptr [RSP + 0x50],RSI
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,0x8
CALL 0x001209f0
MOV qword ptr [RSP + 0x30],RAX
CMP qword ptr [RSP + 0x30],0x0
JNZ 0x001911a1
MOV dword ptr [RSP + 0x74],0xffffffff
JMP 0x00191353
LAB_001911a1:
MOV RAX,qword ptr [RSP + 0x30]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RSP + 0x30]
MOV dword ptr [RAX + 0x4],0x0
MOV dword ptr [RSP + 0x28],0x0
MOV dword ptr [RSP + 0x2c],0x0
LAB_001911c8:
CMP dword ptr [RSP + 0x2c],0x2
JGE 0x00191338
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x58]
MOV ECX,dword ptr [RSP + 0x2c]
ADD ECX,0x32
MOV RSI,qword ptr [RAX + 0x48]
MOV RDX,qword ptr [RAX + 0x50]
CALL 0x00128be0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00191225
JMP 0x00191255
LAB_00191225:
MOV RDI,qword ptr [RSP + 0x58]
MOV ESI,0x18
CALL 0x001209f0
MOV qword ptr [RSP + 0x38],RAX
CMP qword ptr [RSP + 0x38],0x0
JNZ 0x0019127f
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
CALL 0x001229d0
LAB_00191255:
CMP dword ptr [RSP + 0x2c],0x0
JZ 0x00191272
MOV RDI,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001229d0
LAB_00191272:
MOV dword ptr [RSP + 0x28],0xffffffff
JMP 0x00191338
LAB_0019127f:
MOV RAX,qword ptr [RSP + 0x30]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
MOV RCX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
MOV RDI,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RSP + 0x68]
CALL 0x00120410
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 RDX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x48]
CALL 0x001296e0
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x40]
MOV RDX,qword ptr [RSP + 0x48]
MOV ECX,0x2f
MOV R8D,0x1
CALL 0x00129710
MOV RAX,qword ptr [RSP + 0x50]
MOVSXD RCX,dword ptr [RSP + 0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV RCX,qword ptr [RSP + 0x40]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x48]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x001911c8
LAB_00191338:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x30]
CALL 0x001908f0
MOV EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x74],EAX
LAB_00191353:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4
js_create_resolving_functions
(long param_1,int8 *param_2,int8 param_3,int8 param_4)
{
int iVar1;
int *piVar2;
int8 uVar3;
int1 (*pauVar4) [16];
int8 uVar5;
int1 auVar6 [16];
int1 auVar7 [16];
int4 local_50;
int local_4c;
int4 local_4;
piVar2 = (int *)js_malloc(param_1,8);
if (piVar2 == (int *)0x0) {
local_4 = 0xffffffff;
}
else {
*piVar2 = 1;
piVar2[1] = 0;
local_50 = 0;
for (local_4c = 0; local_4c < 2; local_4c = local_4c + 1) {
auVar6 = JS_NewObjectProtoClass
(param_1,*(int8 *)(param_1 + 0x48),*(int8 *)(param_1 + 0x50),
local_4c + 0x32);
uVar5 = auVar6._8_8_;
uVar3 = auVar6._0_8_;
iVar1 = JS_IsException(uVar3,uVar5);
if (iVar1 != 0) {
LAB_00191255:
if (local_4c != 0) {
JS_FreeValue(param_1,*param_2,param_2[1]);
}
local_50 = 0xffffffff;
break;
}
pauVar4 = (int1 (*) [16])js_malloc(param_1,0x18);
if (pauVar4 == (int1 (*) [16])0x0) {
JS_FreeValue(param_1,uVar3,uVar5);
goto LAB_00191255;
}
*piVar2 = *piVar2 + 1;
*(int **)pauVar4[1] = piVar2;
auVar7 = js_dup(param_3,param_4);
*pauVar4 = auVar7;
JS_SetOpaqueInternal(uVar3,uVar5,pauVar4);
js_function_set_properties(param_1,uVar3,uVar5,0x2f,1);
*(int1 (*) [16])(param_2 + (long)local_4c * 2) = auVar6;
}
js_promise_resolve_function_free_resolved(*(int8 *)(param_1 + 0x18),piVar2);
local_4 = local_50;
}
return local_4;
}
|
|
16,018
|
js_create_resolving_functions
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_create_resolving_functions(JSContext *ctx,
JSValue *resolving_funcs,
JSValue promise)
{
JSValue obj;
JSPromiseFunctionData *s;
JSPromiseFunctionDataResolved *sr;
int i, ret;
sr = js_malloc(ctx, sizeof(*sr));
if (!sr)
return -1;
sr->ref_count = 1;
sr->already_resolved = FALSE; /* must be shared between the two functions */
ret = 0;
for(i = 0; i < 2; i++) {
obj = JS_NewObjectProtoClass(ctx, ctx->function_proto,
JS_CLASS_PROMISE_RESOLVE_FUNCTION + i);
if (JS_IsException(obj))
goto fail;
s = js_malloc(ctx, sizeof(*s));
if (!s) {
JS_FreeValue(ctx, obj);
fail:
if (i != 0)
JS_FreeValue(ctx, resolving_funcs[0]);
ret = -1;
break;
}
sr->ref_count++;
s->presolved = sr;
s->promise = js_dup(promise);
JS_SetOpaqueInternal(obj, s);
js_function_set_properties(ctx, obj, JS_ATOM_empty_string, 1);
resolving_funcs[i] = obj;
}
js_promise_resolve_function_free_resolved(ctx->rt, sr);
return ret;
}
|
O1
|
c
|
js_create_resolving_functions:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0xed5d
testq %rax, %rax
je 0x11878
movq %rax, %r14
movq $0x1, (%rax)
movq %r15, 0x18(%rsp)
leaq 0x8(%r15), %r13
xorl %r12d, %r12d
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movl %r12d, %ecx
orl $0x32, %ecx
movq %rbx, %rdi
callq 0x202f1
movq %rdx, %rbp
cmpl $0x6, %ebp
je 0x1188c
movq %rax, %r15
movq %rbx, %rdi
pushq $0x18
popq %rsi
callq 0xed5d
testq %rax, %rax
je 0x1187d
incl (%r14)
movq %r14, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
cmpl $-0x9, 0x10(%rsp)
jb 0x11831
movq 0x20(%rsp), %rcx
incl (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %rbp, %rdx
pushq $0x2f
popq %rcx
pushq $0x1
popq %r8
callq 0x205e8
movq %r15, -0x8(%r13)
movq %rbp, (%r13)
incq %r12
addq $0x10, %r13
cmpq $0x1, %r12
je 0x117dd
xorl %ebp, %ebp
jmp 0x118a9
pushq $-0x1
popq %rbp
jmp 0x118b5
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1ccb2
pushq $-0x1
popq %rbp
testq %r12, %r12
je 0x118a9
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x18(%rbx), %rdi
callq 0x1ccb2
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x51f3a
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_create_resolving_functions:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_48], rcx
mov [rsp+58h+var_50], rdx
mov r15, rsi
mov rbx, rdi
push 8
pop rsi
call js_malloc
test rax, rax
jz loc_11878
mov r14, rax
mov qword ptr [rax], 1
mov [rsp+58h+var_40], r15
lea r13, [r15+8]
xor r12d, r12d
loc_117DD:
mov rsi, [rbx+48h]
mov rdx, [rbx+50h]
mov ecx, r12d
or ecx, 32h
mov rdi, rbx
call JS_NewObjectProtoClass
mov rbp, rdx
cmp ebp, 6
jz loc_1188C
mov r15, rax
mov rdi, rbx
push 18h
pop rsi
call js_malloc
test rax, rax
jz short loc_1187D
inc dword ptr [r14]
mov [rax+10h], r14
mov rcx, [rsp+58h+var_50]
mov [rsp+58h+var_38], rcx
cmp dword ptr [rsp+58h+var_48], 0FFFFFFF7h
jb short loc_11831
mov rcx, [rsp+58h+var_38]
inc dword ptr [rcx]
loc_11831:
mov rcx, [rsp+58h+var_50]
mov [rax], rcx
mov rcx, [rsp+58h+var_48]
mov [rax+8], rcx
mov [r15+30h], rax
mov rdi, rbx
mov rsi, r15
mov rdx, rbp
push 2Fh ; '/'
pop rcx
push 1
pop r8
call js_function_set_properties
mov [r13-8], r15
mov [r13+0], rbp
inc r12
add r13, 10h
cmp r12, 1
jz loc_117DD
xor ebp, ebp
jmp short loc_118A9
loc_11878:
push 0FFFFFFFFFFFFFFFFh
pop rbp
jmp short loc_118B5
loc_1187D:
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, rbp
call JS_FreeValueRT
loc_1188C:
push 0FFFFFFFFFFFFFFFFh
pop rbp
test r12, r12
jz short loc_118A9
mov rax, [rsp+58h+var_40]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, [rbx+18h]
call JS_FreeValueRT
loc_118A9:
mov rdi, [rbx+18h]
mov rsi, r14
call js_promise_resolve_function_free_resolved
loc_118B5:
mov eax, ebp
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_create_resolving_functions(_QWORD *a1, _QWORD *a2, _DWORD *a3, long long a4)
{
_QWORD *v4; // rax
_DWORD *v5; // r14
_QWORD *v6; // r13
long long v7; // r12
long long v8; // rax
long long v9; // rdx
long long v10; // rbp
long long v11; // r15
_QWORD *v12; // rax
unsigned int v13; // ebp
v4 = (_QWORD *)js_malloc((long long)a1, 8LL);
if ( v4 )
{
v5 = v4;
*v4 = 1LL;
v6 = a2 + 1;
v7 = 0LL;
while ( 1 )
{
v8 = JS_NewObjectProtoClass(a1, a1[9], a1[10], (unsigned int)v7 | 0x32);
v10 = v9;
if ( (_DWORD)v9 == 6 )
break;
v11 = v8;
v12 = (_QWORD *)js_malloc((long long)a1, 24LL);
if ( !v12 )
{
JS_FreeValueRT(a1[3], v11);
break;
}
++*v5;
v12[2] = v5;
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
*v12 = a3;
v12[1] = a4;
*(_QWORD *)(v11 + 48) = v12;
js_function_set_properties(a1, v11, v10, 47LL, 1LL);
*(v6 - 1) = v11;
*v6 = v10;
++v7;
v6 += 2;
if ( v7 != 1 )
{
v13 = 0;
goto LABEL_13;
}
}
v13 = -1;
if ( v7 )
JS_FreeValueRT(a1[3], *a2);
LABEL_13:
js_promise_resolve_function_free_resolved(a1[3], v5);
}
else
{
return (unsigned int)-1;
}
return v13;
}
|
js_create_resolving_functions:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RCX
MOV qword ptr [RSP + 0x8],RDX
MOV R15,RSI
MOV RBX,RDI
PUSH 0x8
POP RSI
CALL 0x0010ed5d
TEST RAX,RAX
JZ 0x00111878
MOV R14,RAX
MOV qword ptr [RAX],0x1
MOV qword ptr [RSP + 0x18],R15
LEA R13,[R15 + 0x8]
XOR R12D,R12D
LAB_001117dd:
MOV RSI,qword ptr [RBX + 0x48]
MOV RDX,qword ptr [RBX + 0x50]
MOV ECX,R12D
OR ECX,0x32
MOV RDI,RBX
CALL 0x001202f1
MOV RBP,RDX
CMP EBP,0x6
JZ 0x0011188c
MOV R15,RAX
MOV RDI,RBX
PUSH 0x18
POP RSI
CALL 0x0010ed5d
TEST RAX,RAX
JZ 0x0011187d
INC dword ptr [R14]
MOV qword ptr [RAX + 0x10],R14
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RCX
CMP dword ptr [RSP + 0x10],-0x9
JC 0x00111831
MOV RCX,qword ptr [RSP + 0x20]
INC dword ptr [RCX]
LAB_00111831:
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [R15 + 0x30],RAX
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RBP
PUSH 0x2f
POP RCX
PUSH 0x1
POP R8
CALL 0x001205e8
MOV qword ptr [R13 + -0x8],R15
MOV qword ptr [R13],RBP
INC R12
ADD R13,0x10
CMP R12,0x1
JZ 0x001117dd
XOR EBP,EBP
JMP 0x001118a9
LAB_00111878:
PUSH -0x1
POP RBP
JMP 0x001118b5
LAB_0011187d:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R15
MOV RDX,RBP
CALL 0x0011ccb2
LAB_0011188c:
PUSH -0x1
POP RBP
TEST R12,R12
JZ 0x001118a9
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBX + 0x18]
CALL 0x0011ccb2
LAB_001118a9:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
CALL 0x00151f3a
LAB_001118b5:
MOV EAX,EBP
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
js_create_resolving_functions(long param_1,int8 *param_2,int *param_3,int8 param_4)
{
int *piVar1;
long lVar2;
int8 *puVar3;
int8 uVar4;
int4 uVar5;
long lVar6;
int8 *puVar7;
int1 auVar8 [16];
uint local_48;
piVar1 = (int *)js_malloc(param_1,8);
if (piVar1 == (int *)0x0) {
uVar5 = 0xffffffff;
}
else {
piVar1[0] = 1;
piVar1[1] = 0;
puVar7 = param_2 + 1;
lVar6 = 0;
do {
auVar8 = JS_NewObjectProtoClass
(param_1,*(int8 *)(param_1 + 0x48),*(int8 *)(param_1 + 0x50),
(uint)lVar6 | 0x32);
uVar4 = auVar8._8_8_;
lVar2 = auVar8._0_8_;
if (auVar8._8_4_ == 6) {
LAB_0011188c:
uVar5 = 0xffffffff;
if (lVar6 != 0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),*param_2,param_2[1]);
}
goto LAB_001118a9;
}
puVar3 = (int8 *)js_malloc(param_1,0x18);
if (puVar3 == (int8 *)0x0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar2,uVar4);
goto LAB_0011188c;
}
*piVar1 = *piVar1 + 1;
puVar3[2] = piVar1;
local_48 = (uint)param_4;
if (0xfffffff6 < local_48) {
*param_3 = *param_3 + 1;
}
*puVar3 = param_3;
puVar3[1] = param_4;
*(int8 **)(lVar2 + 0x30) = puVar3;
js_function_set_properties(param_1,lVar2,uVar4,0x2f,1);
puVar7[-1] = lVar2;
*puVar7 = uVar4;
lVar6 = lVar6 + 1;
puVar7 = puVar7 + 2;
} while (lVar6 == 1);
uVar5 = 0;
LAB_001118a9:
js_promise_resolve_function_free_resolved(*(int8 *)(param_1 + 0x18),piVar1);
}
return uVar5;
}
|
|
16,019
|
js_create_resolving_functions
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_create_resolving_functions(JSContext *ctx,
JSValue *resolving_funcs,
JSValue promise)
{
JSValue obj;
JSPromiseFunctionData *s;
JSPromiseFunctionDataResolved *sr;
int i, ret;
sr = js_malloc(ctx, sizeof(*sr));
if (!sr)
return -1;
sr->ref_count = 1;
sr->already_resolved = FALSE; /* must be shared between the two functions */
ret = 0;
for(i = 0; i < 2; i++) {
obj = JS_NewObjectProtoClass(ctx, ctx->function_proto,
JS_CLASS_PROMISE_RESOLVE_FUNCTION + i);
if (JS_IsException(obj))
goto fail;
s = js_malloc(ctx, sizeof(*s));
if (!s) {
JS_FreeValue(ctx, obj);
fail:
if (i != 0)
JS_FreeValue(ctx, resolving_funcs[0]);
ret = -1;
break;
}
sr->ref_count++;
s->presolved = sr;
s->promise = js_dup(promise);
JS_SetOpaqueInternal(obj, s);
js_function_set_properties(ctx, obj, JS_ATOM_empty_string, 1);
resolving_funcs[i] = obj;
}
js_promise_resolve_function_free_resolved(ctx->rt, sr);
return ret;
}
|
O3
|
c
|
js_create_resolving_functions:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0xed89
testq %rax, %rax
je 0x11cbf
movq %rax, (%rsp)
movq $0x1, (%rax)
movb $0x1, %r15b
xorl %r12d, %r12d
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdx
movl %r12d, %ecx
orl $0x32, %ecx
movq %rbx, %rdi
callq 0x20a15
movq %rdx, %rbp
cmpl $0x6, %ebp
je 0x11ce8
movq %rax, %r13
movq %rbx, %rdi
pushq $0x18
popq %rsi
callq 0xed89
testq %rax, %rax
je 0x11cc4
movq (%rsp), %rcx
incl (%rcx)
movq %rcx, 0x10(%rax)
cmpl $-0x9, 0x10(%rsp)
jb 0x11c70
movq 0x8(%rsp), %rcx
incl (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x30(%r13)
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
pushq $0x2f
popq %rcx
pushq $0x1
popq %r8
callq 0x20cfd
shlq $0x4, %r12
movq %r13, (%r14,%r12)
movq %rbp, 0x8(%r14,%r12)
xorl %ebp, %ebp
pushq $0x1
popq %r12
testb $0x1, %r15b
movl $0x0, %r15d
jne 0x11c23
jmp 0x11d12
pushq $-0x1
popq %rbp
jmp 0x11d1f
cmpl $-0x9, %ebp
jb 0x11ce8
movq 0x18(%rbx), %rdi
movl (%r13), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r13)
cmpl $0x1, %eax
jg 0x11ce8
movq %r13, %rsi
movq %rbp, %rdx
callq 0x20d90
pushq $-0x1
popq %rbp
testb $0x1, %r15b
jne 0x11d12
movq 0x8(%r14), %rdx
cmpl $-0x9, %edx
jb 0x11d12
movq (%r14), %rsi
movq 0x18(%rbx), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x11d12
callq 0x20d90
movq 0x18(%rbx), %rdi
movq (%rsp), %rsi
callq 0x54962
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
js_create_resolving_functions:
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], rdx
mov r14, rsi
mov rbx, rdi
push 8
pop rsi
call js_malloc
test rax, rax
jz loc_11CBF
mov [rsp+48h+var_48], rax
mov qword ptr [rax], 1
mov r15b, 1
xor r12d, r12d
loc_11C23:
mov rsi, [rbx+48h]
mov rdx, [rbx+50h]
mov ecx, r12d
or ecx, 32h
mov rdi, rbx
call JS_NewObjectProtoClass
mov rbp, rdx
cmp ebp, 6
jz loc_11CE8
mov r13, rax
mov rdi, rbx
push 18h
pop rsi
call js_malloc
test rax, rax
jz short loc_11CC4
mov rcx, [rsp+48h+var_48]
inc dword ptr [rcx]
mov [rax+10h], rcx
cmp dword ptr [rsp+48h+var_38], 0FFFFFFF7h
jb short loc_11C70
mov rcx, [rsp+48h+var_40]
inc dword ptr [rcx]
loc_11C70:
mov rcx, [rsp+48h+var_40]
mov [rax], rcx
mov rcx, [rsp+48h+var_38]
mov [rax+8], rcx
mov [r13+30h], rax
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
push 2Fh ; '/'
pop rcx
push 1
pop r8
call js_function_set_properties
shl r12, 4
mov [r14+r12], r13
mov [r14+r12+8], rbp
xor ebp, ebp
push 1
pop r12
test r15b, 1
mov r15d, 0
jnz loc_11C23
jmp short loc_11D12
loc_11CBF:
push 0FFFFFFFFFFFFFFFFh
pop rbp
jmp short loc_11D1F
loc_11CC4:
cmp ebp, 0FFFFFFF7h
jb short loc_11CE8
mov rdi, [rbx+18h]
mov eax, [r13+0]
lea ecx, [rax-1]
mov [r13+0], ecx
cmp eax, 1
jg short loc_11CE8
mov rsi, r13
mov rdx, rbp
call js_free_value_rt
loc_11CE8:
push 0FFFFFFFFFFFFFFFFh
pop rbp
test r15b, 1
jnz short loc_11D12
mov rdx, [r14+8]
cmp edx, 0FFFFFFF7h
jb short loc_11D12
mov rsi, [r14]
mov rdi, [rbx+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_11D12
call js_free_value_rt
loc_11D12:
mov rdi, [rbx+18h]
mov rsi, [rsp+48h+var_48]
call js_promise_resolve_function_free_resolved
loc_11D1F:
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long js_create_resolving_functions(_QWORD *a1, long long a2, _DWORD *a3, long long a4)
{
_QWORD *v6; // rax
char v7; // r15
long long v8; // r12
long long v9; // rax
long long v10; // rdx
long long v11; // rbp
long long v12; // r13
_QWORD *v13; // rax
long long v14; // r12
unsigned int v15; // ebp
bool v16; // zf
long long v17; // rdi
int v18; // eax
int *v19; // rsi
long long v20; // rdi
int v21; // eax
_DWORD *v23; // [rsp+0h] [rbp-48h]
v6 = (_QWORD *)js_malloc((long long)a1, 8LL);
if ( v6 )
{
v23 = v6;
*v6 = 1LL;
v7 = 1;
v8 = 0LL;
while ( 1 )
{
v9 = JS_NewObjectProtoClass(a1, a1[9], a1[10], (unsigned int)v8 | 0x32);
v11 = v10;
if ( (_DWORD)v10 == 6 )
break;
v12 = v9;
v13 = (_QWORD *)js_malloc((long long)a1, 24LL);
if ( !v13 )
{
if ( (unsigned int)v11 >= 0xFFFFFFF7 )
{
v17 = a1[3];
v18 = (*(_DWORD *)v12)--;
if ( v18 <= 1 )
js_free_value_rt(v17, v12);
}
break;
}
++*v23;
v13[2] = v23;
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
*v13 = a3;
v13[1] = a4;
*(_QWORD *)(v12 + 48) = v13;
js_function_set_properties(a1, v12, v11, 47LL, 1LL);
v14 = 16 * v8;
*(_QWORD *)(a2 + v14) = v12;
*(_QWORD *)(a2 + v14 + 8) = v11;
v15 = 0;
v8 = 1LL;
v16 = (v7 & 1) == 0;
v7 = 0;
if ( v16 )
goto LABEL_17;
}
v15 = -1;
if ( (v7 & 1) == 0 && (unsigned int)*(_QWORD *)(a2 + 8) >= 0xFFFFFFF7 )
{
v19 = *(int **)a2;
v20 = a1[3];
v21 = **(_DWORD **)a2;
**(_DWORD **)a2 = v21 - 1;
if ( v21 <= 1 )
js_free_value_rt(v20, v19);
}
LABEL_17:
js_promise_resolve_function_free_resolved(a1[3], v23);
}
else
{
return (unsigned int)-1;
}
return v15;
}
|
js_create_resolving_functions:
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],RDX
MOV R14,RSI
MOV RBX,RDI
PUSH 0x8
POP RSI
CALL 0x0010ed89
TEST RAX,RAX
JZ 0x00111cbf
MOV qword ptr [RSP],RAX
MOV qword ptr [RAX],0x1
MOV R15B,0x1
XOR R12D,R12D
LAB_00111c23:
MOV RSI,qword ptr [RBX + 0x48]
MOV RDX,qword ptr [RBX + 0x50]
MOV ECX,R12D
OR ECX,0x32
MOV RDI,RBX
CALL 0x00120a15
MOV RBP,RDX
CMP EBP,0x6
JZ 0x00111ce8
MOV R13,RAX
MOV RDI,RBX
PUSH 0x18
POP RSI
CALL 0x0010ed89
TEST RAX,RAX
JZ 0x00111cc4
MOV RCX,qword ptr [RSP]
INC dword ptr [RCX]
MOV qword ptr [RAX + 0x10],RCX
CMP dword ptr [RSP + 0x10],-0x9
JC 0x00111c70
MOV RCX,qword ptr [RSP + 0x8]
INC dword ptr [RCX]
LAB_00111c70:
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [R13 + 0x30],RAX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
PUSH 0x2f
POP RCX
PUSH 0x1
POP R8
CALL 0x00120cfd
SHL R12,0x4
MOV qword ptr [R14 + R12*0x1],R13
MOV qword ptr [R14 + R12*0x1 + 0x8],RBP
XOR EBP,EBP
PUSH 0x1
POP R12
TEST R15B,0x1
MOV R15D,0x0
JNZ 0x00111c23
JMP 0x00111d12
LAB_00111cbf:
PUSH -0x1
POP RBP
JMP 0x00111d1f
LAB_00111cc4:
CMP EBP,-0x9
JC 0x00111ce8
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [R13]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R13],ECX
CMP EAX,0x1
JG 0x00111ce8
MOV RSI,R13
MOV RDX,RBP
CALL 0x00120d90
LAB_00111ce8:
PUSH -0x1
POP RBP
TEST R15B,0x1
JNZ 0x00111d12
MOV RDX,qword ptr [R14 + 0x8]
CMP EDX,-0x9
JC 0x00111d12
MOV RSI,qword ptr [R14]
MOV RDI,qword ptr [RBX + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00111d12
CALL 0x00120d90
LAB_00111d12:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,qword ptr [RSP]
CALL 0x00154962
LAB_00111d1f:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4
js_create_resolving_functions(long param_1,int8 *param_2,int *param_3,int8 param_4)
{
int iVar1;
int8 uVar2;
bool bVar3;
bool bVar4;
int *piVar5;
int *piVar6;
int8 *puVar7;
int8 uVar8;
int4 uVar9;
int1 auVar10 [16];
long lStack_50;
uint local_38;
piVar5 = (int *)js_malloc(param_1,8);
if (piVar5 == (int *)0x0) {
uVar9 = 0xffffffff;
}
else {
piVar5[0] = 1;
piVar5[1] = 0;
lStack_50 = 0;
bVar4 = true;
do {
bVar3 = bVar4;
auVar10 = JS_NewObjectProtoClass
(param_1,*(int8 *)(param_1 + 0x48),*(int8 *)(param_1 + 0x50),
(uint)lStack_50 | 0x32);
uVar8 = auVar10._8_8_;
piVar6 = auVar10._0_8_;
if (auVar10._8_4_ == 6) {
LAB_00111ce8:
uVar9 = 0xffffffff;
if ((!bVar3) && (0xfffffff6 < (uint)param_2[1])) {
uVar8 = *(int8 *)(param_1 + 0x18);
iVar1 = *(int *)*param_2;
*(int *)*param_2 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar8);
}
}
break;
}
puVar7 = (int8 *)js_malloc(param_1,0x18);
if (puVar7 == (int8 *)0x0) {
if (0xfffffff6 < auVar10._8_4_) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar6;
*piVar6 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar2,piVar6,uVar8);
}
}
goto LAB_00111ce8;
}
*piVar5 = *piVar5 + 1;
puVar7[2] = piVar5;
local_38 = (uint)param_4;
if (0xfffffff6 < local_38) {
*param_3 = *param_3 + 1;
}
*puVar7 = param_3;
puVar7[1] = param_4;
*(int8 **)(piVar6 + 0xc) = puVar7;
js_function_set_properties(param_1,piVar6,uVar8,0x2f,1);
param_2[lStack_50 * 2] = piVar6;
param_2[lStack_50 * 2 + 1] = uVar8;
uVar9 = 0;
lStack_50 = 1;
bVar4 = false;
} while (bVar3);
js_promise_resolve_function_free_resolved(*(int8 *)(param_1 + 0x18),piVar5);
}
return uVar9;
}
|
|
16,020
|
nglog::(anonymous namespace)::DumpStackFrameInfo(char const*, void*)
|
ng-log[P]ng-log/src/signalhandler.cc
|
void DumpStackFrameInfo(const char* prefix, void* pc) {
// Get the symbol name.
const char* symbol = "(unknown)";
#if defined(HAVE_SYMBOLIZE)
char symbolized[1024]; // Big enough for a sane symbol.
// Symbolizes the previous address of pc because pc may be in the
// next function.
if (Symbolize(reinterpret_cast<char*>(pc) - 1, symbolized,
sizeof(symbolized))) {
symbol = symbolized;
}
#else
# pragma message( \
"Symbolize functionality is not available for target platform: stack dump will contain empty frames.")
#endif // defined(HAVE_SYMBOLIZE)
char buf[1024]; // Big enough for stack frame info.
MinimalFormatter formatter(buf, sizeof(buf));
formatter.AppendString(prefix);
formatter.AppendString("@ ");
const int width = 2 * sizeof(void*) + 2; // + 2 for "0x".
formatter.AppendHexWithPadding(reinterpret_cast<uintptr_t>(pc), width);
formatter.AppendString(" ");
formatter.AppendString(symbol);
formatter.AppendString("\n");
g_failure_writer(buf, formatter.num_bytes_written());
}
|
O1
|
cpp
|
nglog::(anonymous namespace)::DumpStackFrameInfo(char const*, void*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x820, %rsp # imm = 0x820
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x1(%rsi), %rdi
leaq 0x420(%rsp), %r15
xorl %r13d, %r13d
movl $0x400, %edx # imm = 0x400
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2243e
leaq 0x2874(%rip), %r12 # 0x246f0
testb %al, %al
cmovneq %r15, %r12
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x420(%rsp), %rax
movq %rax, 0x18(%rsp)
movb (%r14), %al
testb %al, %al
je 0x21eca
xorl %r13d, %r13d
cmpq $0x400, %r13 # imm = 0x400
je 0x21ec4
movb %al, 0x20(%rsp,%r13)
movb 0x1(%r14,%r13), %al
incq %r13
testb %al, %al
jne 0x21ea8
jmp 0x21eca
movl $0x400, %r13d # imm = 0x400
leaq (%rsp,%r13), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movb $0x40, %cl
xorl %eax, %eax
leaq 0x3f8c(%rip), %rdx # 0x25e6e
movq %r13, %rsi
cmpq $0x3ff, %rsi # imm = 0x3FF
ja 0x21f02
movb %cl, 0x20(%rsp,%rsi)
movb 0x1(%rax,%rdx), %cl
incq %rax
incq %rsi
cmpq $0x2, %rax
jne 0x21ee5
addq %r13, %rax
leaq (%rsp,%rax), %r14
addq $0x20, %r14
movq %r14, 0x10(%rsp)
movb $0x30, %dl
xorl %ecx, %ecx
leaq 0x4056(%rip), %rsi # 0x25f73
cmpq $0x3ff, %rax # imm = 0x3FF
ja 0x21f3e
movb %dl, 0x20(%rsp,%rax)
movb 0x1(%rcx,%rsi), %dl
incq %rcx
incq %rax
cmpq $0x2, %rcx
jne 0x21f1d
movl $0x2, %ecx
addq %r14, %rcx
leaq 0x8(%rsp), %r15
movq %rcx, 0x8(%r15)
movq %r15, %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x22020
movq 0x8(%r15), %r13
leaq 0x12(%r14), %r15
cmpq %r15, %r13
jae 0x21f9b
movq %r15, %rbx
subq %r13, %rbx
movq %r13, %rdx
subq %r14, %rdx
je 0x21f81
leaq (%r14,%rbx), %rdi
movq %r14, %rsi
callq 0x7880
cmpq %r13, %r15
je 0x21f96
movq %r14, %rdi
movl $0x20, %esi
movq %rbx, %rdx
callq 0x7290
movq %r15, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
cmpq %rax, %rsi
jae 0x21fb4
movb $0x20, (%rsi)
movl $0x1, %ecx
jmp 0x21fb6
xorl %ecx, %ecx
addq %rcx, %rsi
movq %rsi, 0x10(%rsp)
movb (%r12), %dl
xorl %ecx, %ecx
testb %dl, %dl
je 0x21fdd
leaq (%rsi,%rcx), %rdi
cmpq %rax, %rdi
jae 0x21fdd
movb %dl, (%rdi)
movb 0x1(%r12,%rcx), %dl
incq %rcx
jmp 0x21fc4
addq %rcx, %rsi
movq %rsi, 0x10(%rsp)
cmpq %rax, %rsi
jae 0x21ff4
movb $0xa, (%rsi)
movl $0x1, %eax
jmp 0x21ff6
xorl %eax, %eax
addq %rax, %rsi
movq %rsi, 0x10(%rsp)
subq 0x8(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq *0x10942(%rip) # 0x32950
addq $0x820, %rsp # imm = 0x820
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN5nglog12_GLOBAL__N_118DumpStackFrameInfoEPKcPv:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 820h
mov rbx, rsi
mov r14, rdi
lea rdi, [rsi-1]
lea r15, [rsp+848h+var_428]
xor r13d, r13d
mov edx, 400h
mov rsi, r15
xor ecx, ecx
call _ZN5nglog5tools9SymbolizeEPvPcmNS0_16SymbolizeOptionsE; nglog::tools::Symbolize(void *,char *,ulong,nglog::tools::SymbolizeOptions)
lea r12, aUnknown; "(unknown)"
test al, al
cmovnz r12, r15
lea rax, [rsp+848h+var_828]
mov [rsp+848h+var_840], rax
mov [rsp+848h+var_838], rax
lea rax, [rsp+848h+var_428]
mov [rsp+848h+var_830], rax
mov al, [r14]
test al, al
jz short loc_21ECA
xor r13d, r13d
loc_21EA8:
cmp r13, 400h
jz short loc_21EC4
mov [rsp+r13+848h+var_828], al
mov al, [r14+r13+1]
inc r13
test al, al
jnz short loc_21EA8
jmp short loc_21ECA
loc_21EC4:
mov r13d, 400h
loc_21ECA:
lea rax, [rsp+r13+848h+var_848]
add rax, 20h ; ' '
mov [rsp+848h+var_838], rax
mov cl, 40h ; '@'
xor eax, eax
lea rdx, asc_25E6E; "@ "
mov rsi, r13
loc_21EE5:
cmp rsi, 3FFh
ja short loc_21F02
mov [rsp+rsi+848h+var_828], cl
mov cl, [rax+rdx+1]
inc rax
inc rsi
cmp rax, 2
jnz short loc_21EE5
loc_21F02:
add rax, r13
lea r14, [rsp+rax+848h+var_848]
add r14, 20h ; ' '
mov [rsp+848h+var_838], r14
mov dl, 30h ; '0'
xor ecx, ecx
lea rsi, a0x_0+1; "0x"
loc_21F1D:
cmp rax, 3FFh
ja short loc_21F3E
mov [rsp+rax+848h+var_828], dl
mov dl, [rcx+rsi+1]
inc rcx
inc rax
cmp rcx, 2
jnz short loc_21F1D
mov ecx, 2
loc_21F3E:
add rcx, r14
lea r15, [rsp+848h+var_840]
mov [r15+8], rcx
mov rdi, r15; this
mov rsi, rbx; unsigned __int64
mov edx, 10h; unsigned int
call _ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj; nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(ulong,uint)
mov r13, [r15+8]
lea r15, [r14+12h]
cmp r13, r15
jnb short loc_21F9B
mov rbx, r15
sub rbx, r13
mov rdx, r13
sub rdx, r14
jz short loc_21F81
lea rdi, [r14+rbx]
mov rsi, r14
call _memmove
loc_21F81:
cmp r15, r13
jz short loc_21F96
mov rdi, r14
mov esi, 20h ; ' '
mov rdx, rbx
call _memset
loc_21F96:
mov [rsp+848h+var_838], r15
loc_21F9B:
mov rsi, [rsp+848h+var_838]
mov rax, [rsp+848h+var_830]
cmp rsi, rax
jnb short loc_21FB4
mov byte ptr [rsi], 20h ; ' '
mov ecx, 1
jmp short loc_21FB6
loc_21FB4:
xor ecx, ecx
loc_21FB6:
add rsi, rcx
mov [rsp+848h+var_838], rsi
mov dl, [r12]; unsigned __int64
xor ecx, ecx
loc_21FC4:
test dl, dl
jz short loc_21FDD
lea rdi, [rsi+rcx]
cmp rdi, rax
jnb short loc_21FDD
mov [rdi], dl
mov dl, [r12+rcx+1]
inc rcx
jmp short loc_21FC4
loc_21FDD:
add rsi, rcx
mov [rsp+848h+var_838], rsi
cmp rsi, rax
jnb short loc_21FF4
mov byte ptr [rsi], 0Ah
mov eax, 1
jmp short loc_21FF6
loc_21FF4:
xor eax, eax
loc_21FF6:
add rsi, rax
mov [rsp+848h+var_838], rsi
sub rsi, [rsp+848h+var_840]; char *
lea rdi, [rsp+848h+var_828]; this
call cs:_ZN5nglog12_GLOBAL__N_116g_failure_writerE; nglog::`anonymous namespace'::WriteToStderr(char const*,ulong)
add rsp, 820h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long nglog::`anonymous namespace'::DumpStackFrameInfo(
nglog::_anonymous_namespace_ *this,
const char *a2,
void *a3)
{
long long v4; // r13
const char *v5; // r12
char v6; // al
char v7; // cl
long long v8; // rax
unsigned long long v9; // rsi
unsigned long long v10; // rax
_BYTE *v11; // r14
char v12; // dl
long long v13; // rcx
unsigned long long v14; // rdx
_BYTE *v15; // r13
_BYTE *v16; // r15
_BYTE *v17; // rsi
_BYTE *v18; // rax
long long v19; // rcx
_BYTE *v20; // rsi
long long i; // rcx
_BYTE *v22; // rsi
long long v23; // rax
_BYTE *v25; // [rsp+8h] [rbp-840h] BYREF
_BYTE *v26; // [rsp+10h] [rbp-838h]
_BYTE *v27; // [rsp+18h] [rbp-830h]
_BYTE v28[1024]; // [rsp+20h] [rbp-828h] BYREF
_BYTE v29[1064]; // [rsp+420h] [rbp-428h] BYREF
v4 = 0LL;
v5 = "(unknown)";
if ( (unsigned __int8)nglog::tools::Symbolize(a2 - 1, v29, 1024LL, 0LL) )
v5 = v29;
v25 = v28;
v26 = v28;
v27 = v29;
v6 = *(_BYTE *)this;
if ( *(_BYTE *)this )
{
v4 = 0LL;
while ( v4 != 1024 )
{
v28[v4] = v6;
v6 = *((_BYTE *)this + ++v4);
if ( !v6 )
goto LABEL_9;
}
v4 = 1024LL;
}
LABEL_9:
v26 = &v28[v4];
v7 = 64;
v8 = 0LL;
v9 = v4;
do
{
if ( v9 > 0x3FF )
break;
v28[v9] = v7;
v7 = asc_25E6E[++v8];
++v9;
}
while ( v8 != 2 );
v10 = v4 + v8;
v11 = &v28[v10];
v26 = &v28[v10];
v12 = 48;
v13 = 0LL;
while ( v10 <= 0x3FF )
{
v28[v10] = v12;
v12 = a0x_0[v13 + 2];
++v13;
++v10;
if ( v13 == 2 )
{
v13 = 2LL;
break;
}
}
v26 = &v11[v13];
nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
(nglog::_anonymous_namespace_::MinimalFormatter *)&v25,
(unsigned long long)a2,
0x10u);
v15 = v26;
v16 = v11 + 18;
if ( v26 < v11 + 18 )
{
v14 = v26 - v11;
if ( v26 != v11 )
memmove(&v11[v16 - v26], v11, v14);
if ( v16 != v15 )
memset(v11, 32LL, v16 - v15);
v26 = v11 + 18;
}
v17 = v26;
v18 = v27;
if ( v26 >= v27 )
{
v19 = 0LL;
}
else
{
*v26 = 32;
v19 = 1LL;
}
v20 = &v17[v19];
v26 = v20;
LOBYTE(v14) = *v5;
for ( i = 0LL; (_BYTE)v14 && &v20[i] < v18; ++i )
{
v20[i] = v14;
LOBYTE(v14) = v5[i + 1];
}
v22 = &v20[i];
v26 = v22;
if ( v22 >= v18 )
{
v23 = 0LL;
}
else
{
*v22 = 10;
v23 = 1LL;
}
v26 = &v22[v23];
return nglog::`anonymous namespace'::g_failure_writer(
(nglog::_anonymous_namespace_ *)v28,
(const char *)(&v22[v23] - v25),
v14);
}
|
DumpStackFrameInfo:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x820
MOV RBX,RSI
MOV R14,RDI
LEA RDI,[RSI + -0x1]
LEA R15,[RSP + 0x420]
XOR R13D,R13D
MOV EDX,0x400
MOV RSI,R15
XOR ECX,ECX
CALL 0x0012243e
LEA R12,[0x1246f0]
TEST AL,AL
CMOVNZ R12,R15
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RAX
LEA RAX,[RSP + 0x420]
MOV qword ptr [RSP + 0x18],RAX
MOV AL,byte ptr [R14]
TEST AL,AL
JZ 0x00121eca
XOR R13D,R13D
LAB_00121ea8:
CMP R13,0x400
JZ 0x00121ec4
MOV byte ptr [RSP + R13*0x1 + 0x20],AL
MOV AL,byte ptr [R14 + R13*0x1 + 0x1]
INC R13
TEST AL,AL
JNZ 0x00121ea8
JMP 0x00121eca
LAB_00121ec4:
MOV R13D,0x400
LAB_00121eca:
LEA RAX,[RSP + R13*0x1]
ADD RAX,0x20
MOV qword ptr [RSP + 0x10],RAX
MOV CL,0x40
XOR EAX,EAX
LEA RDX,[0x125e6e]
MOV RSI,R13
LAB_00121ee5:
CMP RSI,0x3ff
JA 0x00121f02
MOV byte ptr [RSP + RSI*0x1 + 0x20],CL
MOV CL,byte ptr [RAX + RDX*0x1 + 0x1]
INC RAX
INC RSI
CMP RAX,0x2
JNZ 0x00121ee5
LAB_00121f02:
ADD RAX,R13
LEA R14,[RSP + RAX*0x1]
ADD R14,0x20
MOV qword ptr [RSP + 0x10],R14
MOV DL,0x30
XOR ECX,ECX
LEA RSI,[0x125f73]
LAB_00121f1d:
CMP RAX,0x3ff
JA 0x00121f3e
MOV byte ptr [RSP + RAX*0x1 + 0x20],DL
MOV DL,byte ptr [RCX + RSI*0x1 + 0x1]
INC RCX
INC RAX
CMP RCX,0x2
JNZ 0x00121f1d
MOV ECX,0x2
LAB_00121f3e:
ADD RCX,R14
LEA R15,[RSP + 0x8]
MOV qword ptr [R15 + 0x8],RCX
MOV RDI,R15
MOV RSI,RBX
MOV EDX,0x10
CALL 0x00122020
MOV R13,qword ptr [R15 + 0x8]
LEA R15,[R14 + 0x12]
CMP R13,R15
JNC 0x00121f9b
MOV RBX,R15
SUB RBX,R13
MOV RDX,R13
SUB RDX,R14
JZ 0x00121f81
LEA RDI,[R14 + RBX*0x1]
MOV RSI,R14
CALL 0x00107880
LAB_00121f81:
CMP R15,R13
JZ 0x00121f96
MOV RDI,R14
MOV ESI,0x20
MOV RDX,RBX
CALL 0x00107290
LAB_00121f96:
MOV qword ptr [RSP + 0x10],R15
LAB_00121f9b:
MOV RSI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
CMP RSI,RAX
JNC 0x00121fb4
MOV byte ptr [RSI],0x20
MOV ECX,0x1
JMP 0x00121fb6
LAB_00121fb4:
XOR ECX,ECX
LAB_00121fb6:
ADD RSI,RCX
MOV qword ptr [RSP + 0x10],RSI
MOV DL,byte ptr [R12]
XOR ECX,ECX
LAB_00121fc4:
TEST DL,DL
JZ 0x00121fdd
LEA RDI,[RSI + RCX*0x1]
CMP RDI,RAX
JNC 0x00121fdd
MOV byte ptr [RDI],DL
MOV DL,byte ptr [R12 + RCX*0x1 + 0x1]
INC RCX
JMP 0x00121fc4
LAB_00121fdd:
ADD RSI,RCX
MOV qword ptr [RSP + 0x10],RSI
CMP RSI,RAX
JNC 0x00121ff4
MOV byte ptr [RSI],0xa
MOV EAX,0x1
JMP 0x00121ff6
LAB_00121ff4:
XOR EAX,EAX
LAB_00121ff6:
ADD RSI,RAX
MOV qword ptr [RSP + 0x10],RSI
SUB RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x20]
CALL qword ptr [0x00132950]
ADD RSP,0x820
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* nglog::(anonymous namespace)::DumpStackFrameInfo(char const*, void*) */
void nglog::(anonymous_namespace)::DumpStackFrameInfo(char *param_1,void *param_2)
{
char *pcVar1;
char *pcVar2;
char *pcVar3;
char cVar4;
long lVar5;
size_t __n;
ulong uVar6;
char *pcVar7;
ulong uVar8;
char *__src;
bool bVar9;
char acStack_103e [2030];
int8 uStack_850;
char *local_840;
char *local_838;
char *local_830;
char local_828 [2048];
uVar8 = 0;
uStack_850 = 0x121e75;
cVar4 = tools::Symbolize((long)param_2 + -1,local_828 + 0x400,0x400,0);
pcVar7 = "(unknown)";
if (cVar4 != '\0') {
pcVar7 = local_828 + 0x400;
}
local_840 = local_828;
local_830 = local_828 + 0x400;
cVar4 = *param_1;
if (cVar4 != '\0') {
uVar8 = 0;
do {
if (uVar8 == 0x400) {
uVar8 = 0x400;
break;
}
local_828[uVar8] = cVar4;
cVar4 = param_1[uVar8 + 1];
uVar8 = uVar8 + 1;
} while (cVar4 != '\0');
}
cVar4 = '@';
lVar5 = 0;
uVar6 = uVar8;
do {
if (0x3ff < uVar6) break;
local_828[uVar6] = cVar4;
cVar4 = (&DAT_00125e6f)[lVar5];
lVar5 = lVar5 + 1;
uVar6 = uVar6 + 1;
} while (lVar5 != 2);
uVar8 = lVar5 + uVar8;
__src = local_828 + uVar8;
cVar4 = '0';
lVar5 = 0;
uVar6 = uVar8;
do {
if (0x3ff < uVar6) goto LAB_00121f3e;
local_828[uVar6] = cVar4;
cVar4 = (&DAT_00125f74)[lVar5];
lVar5 = lVar5 + 1;
uVar6 = uVar6 + 1;
} while (lVar5 != 2);
lVar5 = 2;
LAB_00121f3e:
local_838 = __src + lVar5;
uStack_850 = 0x121f5a;
MinimalFormatter::AppendUint64((MinimalFormatter *)&local_840,(ulong)param_2,0x10);
pcVar2 = local_838;
pcVar1 = local_828 + uVar8 + 0x12;
pcVar3 = local_838;
if (local_838 < pcVar1) {
__n = (long)pcVar1 - (long)local_838;
if ((long)local_838 - (long)__src != 0) {
uStack_850 = 0x121f81;
memmove(__src + __n,__src,(long)local_838 - (long)__src);
}
pcVar3 = pcVar1;
if (pcVar1 != pcVar2) {
uStack_850 = 0x121f96;
memset(__src,0x20,__n);
}
}
local_838 = pcVar3;
bVar9 = local_838 < local_830;
if (bVar9) {
*local_838 = ' ';
}
cVar4 = *pcVar7;
for (lVar5 = 0; (cVar4 != '\0' && (local_838 + lVar5 + (ulong)bVar9 < local_830));
lVar5 = lVar5 + 1) {
local_838[lVar5 + (ulong)bVar9] = cVar4;
cVar4 = pcVar7[lVar5 + 1];
}
local_838 = local_838 + lVar5 + (ulong)bVar9;
if (local_838 < local_830) {
*local_838 = '\n';
}
local_838 = local_838 + (local_838 < local_830);
uStack_850 = 0x12200e;
(*(code *)g_failure_writer)(local_828,(long)local_838 - (long)local_840);
return;
}
|
|
16,021
|
postprocess_cpu_params(cpu_params&, cpu_params const*)
|
monkey531[P]llama/common/common.cpp
|
void postprocess_cpu_params(cpu_params& cpuparams, const cpu_params* role_model) {
int32_t n_set = 0;
if (cpuparams.n_threads < 0) {
// Assuming everything about cpuparams is invalid
if (role_model != nullptr) {
cpuparams = *role_model;
} else {
cpuparams.n_threads = cpu_get_num_math();
}
}
for (int32_t i = 0; i < GGML_MAX_N_THREADS; i++) {
if (cpuparams.cpumask[i]) {
n_set++;
}
}
if (n_set && n_set < cpuparams.n_threads) {
// Not enough set bits, may experience performance issues.
LOG_WRN("Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n", n_set, cpuparams.n_threads);
}
}
|
O3
|
cpp
|
postprocess_cpu_params(cpu_params&, cpu_params const*):
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jns 0x1edda
testq %rsi, %rsi
je 0x1edd3
movl $0x214, %edx # imm = 0x214
movq %rbx, %rdi
callq 0x18580
jmp 0x1edda
callq 0x1ebc6
movl %eax, (%rbx)
pxor %xmm1, %xmm1
movl $0x4, %eax
pxor %xmm0, %xmm0
movd (%rbx,%rax), %xmm2
punpcklbw %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3],xmm2[4],xmm1[4],xmm2[5],xmm1[5],xmm2[6],xmm1[6],xmm2[7],xmm1[7]
punpcklwd %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1],xmm2[2],xmm1[2],xmm2[3],xmm1[3]
paddd %xmm2, %xmm0
addq $0x4, %rax
cmpq $0x204, %rax # imm = 0x204
jne 0x1ede7
pshufd $0xee, %xmm0, %xmm1 # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0 # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %ebp
testl %ebp, %ebp
je 0x1ee54
cmpl (%rbx), %ebp
jge 0x1ee54
leaq 0xc01d7(%rip), %rax # 0xdf000
cmpl $0x0, (%rax)
js 0x1ee54
callq 0x80403
movl (%rbx), %r8d
leaq 0x89faa(%rip), %rdx # 0xa8de7
movq %rax, %rdi
movl $0x3, %esi
movl %ebp, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x804a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_Z22postprocess_cpu_paramsR10cpu_paramsPKS_:
push rbp
push rbx
push rax
mov rbx, rdi
cmp dword ptr [rdi], 0
jns short loc_1EDDA
test rsi, rsi
jz short loc_1EDD3
mov edx, 214h
mov rdi, rbx
call _memcpy
jmp short loc_1EDDA
loc_1EDD3:
call _Z16cpu_get_num_mathv; cpu_get_num_math(void)
mov [rbx], eax
loc_1EDDA:
pxor xmm1, xmm1
mov eax, 4
pxor xmm0, xmm0
loc_1EDE7:
movd xmm2, dword ptr [rbx+rax]
punpcklbw xmm2, xmm1
punpcklwd xmm2, xmm1
paddd xmm0, xmm2
add rax, 4
cmp rax, 204h
jnz short loc_1EDE7
pshufd xmm1, xmm0, 0EEh
paddd xmm1, xmm0
pshufd xmm0, xmm1, 55h ; 'U'
paddd xmm0, xmm1
movd ebp, xmm0
test ebp, ebp
jz short loc_1EE54
cmp ebp, [rbx]
jge short loc_1EE54
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_1EE54
call _Z15common_log_mainv; common_log_main(void)
mov r8d, [rbx]
lea rdx, aNotEnoughSetBi; "Not enough set bits in CPU mask (%d) to"...
mov rdi, rax
mov esi, 3
mov ecx, ebp
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_1EE54:
add rsp, 8
pop rbx
pop rbp
retn
|
int * postprocess_cpu_params(int *a1, long long a2, long long a3, long long a4, long long a5, long long a6, char a7)
{
int *result; // rax
__m128i v8; // xmm0
__m128i v9; // xmm1
int v10; // ebp
int v11; // eax
int v12; // r9d
if ( *a1 < 0 )
{
if ( a2 )
memcpy(a1, a2, 532LL);
else
*a1 = cpu_get_num_math();
}
result = (_DWORD *)&byte_4;
v8 = 0LL;
do
v8 = _mm_add_epi32(
v8,
_mm_unpacklo_epi16(
_mm_unpacklo_epi8(_mm_cvtsi32_si128(*(int *)((char *)result++ + (_QWORD)a1)), (__m128i)0LL),
(__m128i)0LL));
while ( result != &dword_204 );
v9 = _mm_add_epi32(_mm_shuffle_epi32(v8, 238), v8);
v10 = _mm_cvtsi128_si32(_mm_add_epi32(_mm_shuffle_epi32(v9, 85), v9));
if ( v10 && v10 < *a1 )
{
result = (int *)&common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v11 = common_log_main();
return (int *)common_log_add(
v11,
3,
(unsigned int)"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
v10,
*a1,
v12,
a7);
}
}
return result;
}
|
postprocess_cpu_params:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP dword ptr [RDI],0x0
JNS 0x0011edda
TEST RSI,RSI
JZ 0x0011edd3
MOV EDX,0x214
MOV RDI,RBX
CALL 0x00118580
JMP 0x0011edda
LAB_0011edd3:
CALL 0x0011ebc6
MOV dword ptr [RBX],EAX
LAB_0011edda:
PXOR XMM1,XMM1
MOV EAX,0x4
PXOR XMM0,XMM0
LAB_0011ede7:
MOVD XMM2,dword ptr [RBX + RAX*0x1]
PUNPCKLBW XMM2,XMM1
PUNPCKLWD XMM2,XMM1
PADDD XMM0,XMM2
ADD RAX,0x4
CMP RAX,0x204
JNZ 0x0011ede7
PSHUFD XMM1,XMM0,0xee
PADDD XMM1,XMM0
PSHUFD XMM0,XMM1,0x55
PADDD XMM0,XMM1
MOVD EBP,XMM0
TEST EBP,EBP
JZ 0x0011ee54
CMP EBP,dword ptr [RBX]
JGE 0x0011ee54
LEA RAX,[0x1df000]
CMP dword ptr [RAX],0x0
JS 0x0011ee54
CALL 0x00180403
MOV R8D,dword ptr [RBX]
LEA RDX,[0x1a8de7]
MOV RDI,RAX
MOV ESI,0x3
MOV ECX,EBP
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001804a0
LAB_0011ee54:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* postprocess_cpu_params(cpu_params&, cpu_params const*) */
void postprocess_cpu_params(cpu_params *param_1,cpu_params *param_2)
{
int1 auVar1 [13];
int1 auVar2 [13];
int1 auVar3 [13];
ulong uVar4;
int1 auVar5 [13];
int4 uVar6;
long lVar7;
int8 uVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
if (*(int *)param_1 < 0) {
if (param_2 == (cpu_params *)0x0) {
uVar6 = cpu_get_num_math();
*(int4 *)param_1 = uVar6;
}
else {
memcpy(param_1,param_2,0x214);
}
}
lVar7 = 4;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
do {
uVar6 = *(int4 *)(param_1 + lVar7);
uVar4 = (ulong)(ushort)uVar6 & 0xffffffffffff00ff;
auVar1._8_4_ = 0;
auVar1._0_8_ = uVar4;
auVar1[0xc] = (char)((uint)uVar6 >> 0x18);
auVar2[8] = (char)((uint)uVar6 >> 0x10);
auVar2._0_8_ = uVar4;
auVar2[9] = 0;
auVar2._10_3_ = auVar1._10_3_;
auVar5._5_8_ = 0;
auVar5._0_5_ = auVar2._8_5_;
auVar3[4] = (char)((uint)uVar6 >> 8);
auVar3._0_4_ = (int)uVar4;
auVar3[5] = 0;
auVar3._6_7_ = SUB137(auVar5 << 0x40,6);
iVar9 = iVar9 + (int)uVar4;
iVar10 = iVar10 + auVar3._4_4_;
iVar11 = iVar11 + auVar2._8_4_;
iVar12 = iVar12 + (uint)(uint3)(auVar1._10_3_ >> 0x10);
lVar7 = lVar7 + 4;
} while (lVar7 != 0x204);
iVar9 = iVar12 + iVar10 + iVar11 + iVar9;
if (((iVar9 != 0) && (iVar9 < *(int *)param_1)) && (-1 < common_log_verbosity_thold)) {
uVar8 = common_log_main();
common_log_add(uVar8,3,
"Not enough set bits in CPU mask (%d) to satisfy requested thread count: %d\n",
iVar9,*(int4 *)param_1);
return;
}
return;
}
|
|
16,022
|
add_plugin
|
eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c
|
static struct st_mysql_client_plugin *
add_plugin(MYSQL *mysql, struct st_mysql_client_plugin *plugin, void *dlhandle,
int argc, va_list args)
{
const char *errmsg;
struct st_client_plugin_int plugin_int, *p;
char errbuf[1024];
int plugin_nr;
DBUG_ASSERT(initialized);
plugin_int.plugin= plugin;
plugin_int.dlhandle= dlhandle;
if ((plugin_nr= get_plugin_nr(plugin->type)) == -1)
{
errmsg= "Unknown client plugin type";
goto err1;
}
if ((errmsg= check_plugin_version(plugin, valid_plugins[plugin_nr][1])))
goto err1;
/* Call the plugin initialization function, if any */
if (plugin->init && plugin->init(errbuf, sizeof(errbuf), argc, args))
{
errmsg= errbuf;
goto err1;
}
p= (struct st_client_plugin_int *)
ma_memdup_root(&mem_root, (char *)&plugin_int, sizeof(plugin_int));
if (!p)
{
errmsg= "Out of memory";
goto err2;
}
p->next= plugin_list[plugin_nr];
plugin_list[plugin_nr]= p;
return plugin;
err2:
if (plugin->deinit)
plugin->deinit();
err1:
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), plugin->name, errmsg);
if (dlhandle)
(void)dlclose(dlhandle);
return NULL;
}
|
O0
|
c
|
add_plugin:
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp # imm = 0x480
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x420(%rbp)
movq %rsi, -0x428(%rbp)
movq %rdx, -0x430(%rbp)
movl %ecx, -0x434(%rbp)
movq %r8, -0x440(%rbp)
movq -0x428(%rbp), %rax
movq %rax, -0x450(%rbp)
movq -0x430(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x428(%rbp), %rax
movl (%rax), %edi
callq 0x5a1b0
movl %eax, -0x46c(%rbp)
cmpl $-0x1, %eax
jne 0x59772
leaq 0x71b3b(%rip), %rax # 0xcb2a1
movq %rax, -0x448(%rbp)
jmp 0x59886
movq -0x428(%rbp), %rdi
movslq -0x46c(%rbp), %rcx
leaq 0x1d8dd9(%rip), %rax # 0x232560
movl 0x4(%rax,%rcx,8), %esi
callq 0x5a210
movq %rax, -0x448(%rbp)
cmpq $0x0, %rax
je 0x597a2
jmp 0x59886
movq -0x428(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x597ee
movq -0x428(%rbp), %rax
movq 0x40(%rax), %rax
leaq -0x410(%rbp), %rdi
movl -0x434(%rbp), %edx
movq -0x440(%rbp), %rcx
movl $0x400, %esi # imm = 0x400
callq *%rax
cmpl $0x0, %eax
je 0x597ee
leaq -0x410(%rbp), %rax
movq %rax, -0x448(%rbp)
jmp 0x59886
leaq 0x39380b(%rip), %rdi # 0x3ed000
leaq -0x460(%rbp), %rsi
movl $0x18, %edx
callq 0x48c70
movq %rax, -0x468(%rbp)
cmpq $0x0, -0x468(%rbp)
jne 0x59827
leaq 0x71a9e(%rip), %rax # 0xcb2bc
movq %rax, -0x448(%rbp)
jmp 0x5986c
movslq -0x46c(%rbp), %rcx
leaq 0x39380b(%rip), %rax # 0x3ed040
movq (%rax,%rcx,8), %rcx
movq -0x468(%rbp), %rax
movq %rcx, (%rax)
movq -0x468(%rbp), %rdx
movslq -0x46c(%rbp), %rcx
leaq 0x3937e8(%rip), %rax # 0x3ed040
movq %rdx, (%rax,%rcx,8)
movq -0x428(%rbp), %rax
movq %rax, -0x418(%rbp)
jmp 0x598e4
movq -0x428(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x59884
movq -0x428(%rbp), %rax
callq *0x48(%rax)
jmp 0x59886
movq -0x420(%rbp), %rdi
leaq 0x1d9d9c(%rip), %rax # 0x233630
movq (%rax), %rdx
leaq 0x1d9da2(%rip), %rax # 0x233640
movq 0x1d8(%rax), %rcx
movq -0x428(%rbp), %rax
movq 0x8(%rax), %r8
movq -0x448(%rbp), %r9
movl $0x80b, %esi # imm = 0x80B
movb $0x0, %al
callq 0x39eb0
cmpq $0x0, -0x430(%rbp)
je 0x598d9
movq -0x430(%rbp), %rdi
callq 0x36a30
movq $0x0, -0x418(%rbp)
movq -0x418(%rbp), %rax
movq %rax, -0x478(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x59914
movq -0x478(%rbp), %rax
addq $0x480, %rsp # imm = 0x480
popq %rbp
retq
callq 0x362a0
nopl (%rax)
|
add_plugin:
push rbp
mov rbp, rsp
sub rsp, 480h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_420], rdi
mov [rbp+var_428], rsi
mov [rbp+var_430], rdx
mov [rbp+var_434], ecx
mov [rbp+var_440], r8
mov rax, [rbp+var_428]
mov [rbp+var_450], rax
mov rax, [rbp+var_430]
mov [rbp+var_458], rax
mov rax, [rbp+var_428]
mov edi, [rax]
call get_plugin_nr
mov [rbp+var_46C], eax
cmp eax, 0FFFFFFFFh
jnz short loc_59772
lea rax, aUnknownClientP; "Unknown client plugin type"
mov [rbp+var_448], rax
jmp loc_59886
loc_59772:
mov rdi, [rbp+var_428]
movsxd rcx, [rbp+var_46C]
lea rax, valid_plugins
mov esi, [rax+rcx*8+4]
call check_plugin_version
mov [rbp+var_448], rax
cmp rax, 0
jz short loc_597A2
jmp loc_59886
loc_597A2:
mov rax, [rbp+var_428]
cmp qword ptr [rax+40h], 0
jz short loc_597EE
mov rax, [rbp+var_428]
mov rax, [rax+40h]
lea rdi, [rbp+var_410]
mov edx, [rbp+var_434]
mov rcx, [rbp+var_440]
mov esi, 400h
call rax
cmp eax, 0
jz short loc_597EE
lea rax, [rbp+var_410]
mov [rbp+var_448], rax
jmp loc_59886
loc_597EE:
lea rdi, mem_root
lea rsi, [rbp+var_460]
mov edx, 18h
call ma_memdup_root
mov [rbp+var_468], rax
cmp [rbp+var_468], 0
jnz short loc_59827
lea rax, aOutOfMemory; "Out of memory"
mov [rbp+var_448], rax
jmp short loc_5986C
loc_59827:
movsxd rcx, [rbp+var_46C]
lea rax, plugin_list
mov rcx, [rax+rcx*8]
mov rax, [rbp+var_468]
mov [rax], rcx
mov rdx, [rbp+var_468]
movsxd rcx, [rbp+var_46C]
lea rax, plugin_list
mov [rax+rcx*8], rdx
mov rax, [rbp+var_428]
mov [rbp+var_418], rax
jmp short loc_598E4
loc_5986C:
mov rax, [rbp+var_428]
cmp qword ptr [rax+48h], 0
jz short loc_59884
mov rax, [rbp+var_428]
call qword ptr [rax+48h]
loc_59884:
jmp short $+2
loc_59886:
mov rdi, [rbp+var_420]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
mov rax, [rbp+var_428]
mov r8, [rax+8]
mov r9, [rbp+var_448]
mov esi, 80Bh
mov al, 0
call my_set_error
cmp [rbp+var_430], 0
jz short loc_598D9
mov rdi, [rbp+var_430]
call _dlclose
loc_598D9:
mov [rbp+var_418], 0
loc_598E4:
mov rax, [rbp+var_418]
mov [rbp+var_478], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_59914
mov rax, [rbp+var_478]
add rsp, 480h
pop rbp
retn
loc_59914:
call ___stack_chk_fail
|
void (** add_plugin(long long a1, void (**a2)(void), long long a3, unsigned int a4, long long a5))(void)
{
int plugin_nr; // [rsp+14h] [rbp-46Ch]
char *v7; // [rsp+18h] [rbp-468h]
char v8[8]; // [rsp+20h] [rbp-460h] BYREF
long long v9; // [rsp+28h] [rbp-458h]
void (**v10)(void); // [rsp+30h] [rbp-450h]
const char *v11; // [rsp+38h] [rbp-448h]
long long v12; // [rsp+40h] [rbp-440h]
unsigned int v13; // [rsp+4Ch] [rbp-434h]
long long v14; // [rsp+50h] [rbp-430h]
void (**v15)(void); // [rsp+58h] [rbp-428h]
long long v16; // [rsp+60h] [rbp-420h]
_BYTE v18[1032]; // [rsp+70h] [rbp-410h] BYREF
unsigned long long v19; // [rsp+478h] [rbp-8h]
v19 = __readfsqword(0x28u);
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12 = a5;
v10 = a2;
v9 = a3;
plugin_nr = get_plugin_nr(*(unsigned int *)a2);
if ( plugin_nr == -1 )
{
v11 = "Unknown client plugin type";
}
else
{
v11 = (const char *)check_plugin_version(v15, valid_plugins[2 * plugin_nr + 1]);
if ( !v11 )
{
if ( v15[8] && ((unsigned int ( *)(_BYTE *, long long, _QWORD, long long))v15[8])(v18, 1024LL, v13, v12) )
{
v11 = v18;
}
else
{
v7 = ma_memdup_root((_QWORD **)mem_root, (long long)v8, 24LL);
if ( v7 )
{
*(_QWORD *)v7 = plugin_list[plugin_nr];
plugin_list[plugin_nr] = v7;
return v15;
}
v11 = "Out of memory";
if ( v15[9] )
v15[9]();
}
}
}
my_set_error(v16, 0x80Bu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[59], v15[1], v11);
if ( v14 )
dlclose(v14);
return 0LL;
}
|
add_plugin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x480
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x420],RDI
MOV qword ptr [RBP + -0x428],RSI
MOV qword ptr [RBP + -0x430],RDX
MOV dword ptr [RBP + -0x434],ECX
MOV qword ptr [RBP + -0x440],R8
MOV RAX,qword ptr [RBP + -0x428]
MOV qword ptr [RBP + -0x450],RAX
MOV RAX,qword ptr [RBP + -0x430]
MOV qword ptr [RBP + -0x458],RAX
MOV RAX,qword ptr [RBP + -0x428]
MOV EDI,dword ptr [RAX]
CALL 0x0015a1b0
MOV dword ptr [RBP + -0x46c],EAX
CMP EAX,-0x1
JNZ 0x00159772
LEA RAX,[0x1cb2a1]
MOV qword ptr [RBP + -0x448],RAX
JMP 0x00159886
LAB_00159772:
MOV RDI,qword ptr [RBP + -0x428]
MOVSXD RCX,dword ptr [RBP + -0x46c]
LEA RAX,[0x332560]
MOV ESI,dword ptr [RAX + RCX*0x8 + 0x4]
CALL 0x0015a210
MOV qword ptr [RBP + -0x448],RAX
CMP RAX,0x0
JZ 0x001597a2
JMP 0x00159886
LAB_001597a2:
MOV RAX,qword ptr [RBP + -0x428]
CMP qword ptr [RAX + 0x40],0x0
JZ 0x001597ee
MOV RAX,qword ptr [RBP + -0x428]
MOV RAX,qword ptr [RAX + 0x40]
LEA RDI,[RBP + -0x410]
MOV EDX,dword ptr [RBP + -0x434]
MOV RCX,qword ptr [RBP + -0x440]
MOV ESI,0x400
CALL RAX
CMP EAX,0x0
JZ 0x001597ee
LEA RAX,[RBP + -0x410]
MOV qword ptr [RBP + -0x448],RAX
JMP 0x00159886
LAB_001597ee:
LEA RDI,[0x4ed000]
LEA RSI,[RBP + -0x460]
MOV EDX,0x18
CALL 0x00148c70
MOV qword ptr [RBP + -0x468],RAX
CMP qword ptr [RBP + -0x468],0x0
JNZ 0x00159827
LEA RAX,[0x1cb2bc]
MOV qword ptr [RBP + -0x448],RAX
JMP 0x0015986c
LAB_00159827:
MOVSXD RCX,dword ptr [RBP + -0x46c]
LEA RAX,[0x4ed040]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RBP + -0x468]
MOV qword ptr [RAX],RCX
MOV RDX,qword ptr [RBP + -0x468]
MOVSXD RCX,dword ptr [RBP + -0x46c]
LEA RAX,[0x4ed040]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RBP + -0x428]
MOV qword ptr [RBP + -0x418],RAX
JMP 0x001598e4
LAB_0015986c:
MOV RAX,qword ptr [RBP + -0x428]
CMP qword ptr [RAX + 0x48],0x0
JZ 0x00159884
MOV RAX,qword ptr [RBP + -0x428]
CALL qword ptr [RAX + 0x48]
LAB_00159884:
JMP 0x00159886
LAB_00159886:
MOV RDI,qword ptr [RBP + -0x420]
LEA RAX,[0x333630]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x333640]
MOV RCX,qword ptr [RAX + 0x1d8]
MOV RAX,qword ptr [RBP + -0x428]
MOV R8,qword ptr [RAX + 0x8]
MOV R9,qword ptr [RBP + -0x448]
MOV ESI,0x80b
MOV AL,0x0
CALL 0x00139eb0
CMP qword ptr [RBP + -0x430],0x0
JZ 0x001598d9
MOV RDI,qword ptr [RBP + -0x430]
CALL 0x00136a30
LAB_001598d9:
MOV qword ptr [RBP + -0x418],0x0
LAB_001598e4:
MOV RAX,qword ptr [RBP + -0x418]
MOV qword ptr [RBP + -0x478],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00159914
MOV RAX,qword ptr [RBP + -0x478]
ADD RSP,0x480
POP RBP
RET
LAB_00159914:
CALL 0x001362a0
|
int4 *
add_plugin(int8 param_1,int4 *param_2,long param_3,int4 param_4,int8 param_5
)
{
int iVar1;
int iVar2;
int8 *puVar3;
long in_FS_OFFSET;
int1 local_468 [8];
long local_460;
int4 *local_458;
char *local_450;
int8 local_448;
int4 local_43c;
long local_438;
int4 *local_430;
int8 local_428;
int4 *local_420;
char local_418 [1032];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_460 = param_3;
local_458 = param_2;
local_448 = param_5;
local_43c = param_4;
local_438 = param_3;
local_430 = param_2;
local_428 = param_1;
iVar1 = get_plugin_nr(*param_2);
if (iVar1 == -1) {
local_450 = "Unknown client plugin type";
}
else {
local_450 = (char *)check_plugin_version
(local_430,*(int4 *)(valid_plugins + (long)iVar1 * 8 + 4));
if (local_450 == (char *)0x0) {
if ((*(long *)(local_430 + 0x10) == 0) ||
(iVar2 = (**(code **)(local_430 + 0x10))(local_418,0x400,local_43c,local_448), iVar2 == 0))
{
puVar3 = (int8 *)ma_memdup_root(mem_root,local_468,0x18);
if (puVar3 != (int8 *)0x0) {
*puVar3 = *(int8 *)(plugin_list + (long)iVar1 * 8);
*(int8 **)(plugin_list + (long)iVar1 * 8) = puVar3;
local_420 = local_430;
goto LAB_001598e4;
}
local_450 = "Out of memory";
if (*(long *)(local_430 + 0x12) != 0) {
(**(code **)(local_430 + 0x12))();
}
}
else {
local_450 = local_418;
}
}
}
my_set_error(local_428,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____00333818,
*(int8 *)(local_430 + 2),local_450);
if (local_438 != 0) {
dlclose(local_438);
}
local_420 = (int4 *)0x0;
LAB_001598e4:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_420;
}
|
|
16,023
|
handler::disable_pushed_rowid_filter()
|
eloqsql/sql/handler.h
|
virtual void disable_pushed_rowid_filter()
{
DBUG_ASSERT(pushed_rowid_filter != NULL &&
save_pushed_rowid_filter == NULL);
save_pushed_rowid_filter= pushed_rowid_filter;
if (rowid_filter_is_active)
save_rowid_filter_is_active= rowid_filter_is_active;
pushed_rowid_filter= NULL;
rowid_filter_is_active= false;
}
|
O3
|
c
|
handler::disable_pushed_rowid_filter():
pushq %rbp
movq %rsp, %rbp
movq 0x430(%rdi), %rax
movq %rax, 0x440(%rdi)
cmpb $0x1, 0x438(%rdi)
jne 0xc37c
movb $0x1, 0x448(%rdi)
movq $0x0, 0x430(%rdi)
movb $0x0, 0x438(%rdi)
popq %rbp
retq
|
_ZN7handler27disable_pushed_rowid_filterEv:
push rbp
mov rbp, rsp
mov rax, [rdi+430h]
mov [rdi+440h], rax
cmp byte ptr [rdi+438h], 1
jnz short loc_C37C
mov byte ptr [rdi+448h], 1
loc_C37C:
mov qword ptr [rdi+430h], 0
mov byte ptr [rdi+438h], 0
pop rbp
retn
|
long long handler::disable_pushed_rowid_filter(handler *this)
{
long long result; // rax
result = *((_QWORD *)this + 134);
*((_QWORD *)this + 136) = result;
if ( *((_BYTE *)this + 1080) == 1 )
*((_BYTE *)this + 1096) = 1;
*((_QWORD *)this + 134) = 0LL;
*((_BYTE *)this + 1080) = 0;
return result;
}
|
disable_pushed_rowid_filter:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x430]
MOV qword ptr [RDI + 0x440],RAX
CMP byte ptr [RDI + 0x438],0x1
JNZ 0x0010c37c
MOV byte ptr [RDI + 0x448],0x1
LAB_0010c37c:
MOV qword ptr [RDI + 0x430],0x0
MOV byte ptr [RDI + 0x438],0x0
POP RBP
RET
|
/* handler::disable_pushed_rowid_filter() */
void __thiscall handler::disable_pushed_rowid_filter(handler *this)
{
*(int8 *)(this + 0x440) = *(int8 *)(this + 0x430);
if (this[0x438] == (handler)0x1) {
this[0x448] = (handler)0x1;
}
*(int8 *)(this + 0x430) = 0;
this[0x438] = (handler)0x0;
return;
}
|
|
16,024
|
fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/common.cpp
|
std::string fs_get_cache_file(const std::string & filename) {
GGML_ASSERT(filename.find(DIRECTORY_SEPARATOR) == std::string::npos);
std::string cache_directory = fs_get_cache_directory();
const bool success = fs_create_directory_with_parents(cache_directory);
if (!success) {
throw std::runtime_error("failed to create cache directory: " + cache_directory);
}
return cache_directory + filename;
}
|
O3
|
cpp
|
fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x1bbe0
cmpq $-0x1, %rax
jne 0x78bb6
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x787c8
movq %r15, %rdi
callq 0x786ca
testb %al, %al
je 0x78bd7
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7da0a
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78ba8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b930
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7ae00(%rip), %rdi # 0xf39bd
leaq 0x71a31(%rip), %rdx # 0xea5f5
leaq 0x7afcb(%rip), %rcx # 0xf3b96
movl $0x378, %esi # imm = 0x378
xorl %eax, %eax
callq 0x1bfb0
movl $0x10, %edi
callq 0x1b480
movq %rax, %rbx
leaq 0x7afe3(%rip), %rsi # 0xf3bce
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x59295
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bf20
xorl %ebp, %ebp
movq 0xb83d5(%rip), %rsi # 0x130fe8
movq 0xb8336(%rip), %rdx # 0x130f50
movq %rbx, %rdi
callq 0x1c040
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78c40
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1b930
testb %bpl, %bpl
jne 0x78c4a
jmp 0x78c57
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b6c0
jmp 0x78c57
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x78c72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b930
movq %r14, %rdi
callq 0x1c0d0
|
_Z17fs_get_cache_fileRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp; int
push r15; int
push r14; int
push rbx; __int64
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
mov esi, 2Fh ; '/'
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_78BB6
lea r15, [rsp+68h+var_60]
mov rdi, r15; int
call _Z22fs_get_cache_directoryB5cxx11v; fs_get_cache_directory(void)
mov rdi, r15
call _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; fs_create_directory_with_parents(std::string const&)
test al, al
jz short loc_78BD7
lea rsi, [rsp+68h+var_60]
mov rdi, rbx
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_SA_; std::operator+<char>(std::string const&,std::string const&)
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_78BA8
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_78BA8:
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_78BB6:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFilenameFindDi; "filename.find(DIRECTORY_SEPARATOR) == s"...
mov esi, 378h
xor eax, eax
call _ggml_abort
loc_78BD7:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToCreate; "failed to create cache directory: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_78C40
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_78C40:
test bpl, bpl
jnz short loc_78C4A
jmp short loc_78C57
mov r14, rax
loc_78C4A:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_78C57
mov r14, rax
loc_78C57:
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_78C72
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_78C72:
mov rdi, r14
call __Unwind_Resume
|
long long fs_get_cache_file(long long a1, long long a2)
{
void *exception; // rbx
int v4[4]; // [rsp+8h] [rbp-60h] BYREF
long long v5; // [rsp+18h] [rbp-50h] BYREF
_BYTE v6[16]; // [rsp+28h] [rbp-40h] BYREF
if ( std::string::find(a2, 47LL, 0LL) != -1 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
888LL,
"GGML_ASSERT(%s) failed",
"filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
LABEL_7:
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v6, (long long)"failed to create cache directory: ", v4);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
fs_get_cache_directory[abi:cxx11]((long long)v4);
if ( !(unsigned __int8)fs_create_directory_with_parents(v4) )
goto LABEL_7;
std::operator+<char>(a1, v4, a2);
if ( *(long long **)v4 != &v5 )
operator delete(*(void **)v4, v5 + 1);
return a1;
}
|
fs_get_cache_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
MOV ESI,0x2f
XOR EDX,EDX
CALL 0x0011bbe0
CMP RAX,-0x1
JNZ 0x00178bb6
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x001787c8
LAB_00178b71:
MOV RDI,R15
CALL 0x001786ca
TEST AL,AL
JZ 0x00178bd7
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x0017da0a
LAB_00178b8d:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00178ba8
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b930
LAB_00178ba8:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00178bb6:
LEA RDI,[0x1f39bd]
LEA RDX,[0x1ea5f5]
LEA RCX,[0x1f3b96]
MOV ESI,0x378
XOR EAX,EAX
CALL 0x0011bfb0
LAB_00178bd7:
MOV EDI,0x10
CALL 0x0011b480
MOV RBX,RAX
LAB_00178be4:
LEA RSI,[0x1f3bce]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00159295
MOV BPL,0x1
LAB_00178bfd:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x0011bf20
XOR EBP,EBP
MOV RSI,qword ptr [0x00230fe8]
MOV RDX,qword ptr [0x00230f50]
MOV RDI,RBX
CALL 0x0011c040
|
/* fs_get_cache_file(std::__cxx11::string const&) */
string * fs_get_cache_file(string *param_1)
{
char cVar1;
long lVar2;
runtime_error *this;
char in_SIL;
long *local_60 [2];
long local_50 [2];
string local_40 [32];
lVar2 = std::__cxx11::string::find(in_SIL,0x2f);
if (lVar2 != -1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x378,
"GGML_ASSERT(%s) failed","filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
}
fs_get_cache_directory_abi_cxx11_();
/* try { // try from 00178b71 to 00178b8c has its CatchHandler @ 00178c54 */
cVar1 = fs_create_directory_with_parents((string *)local_60);
if (cVar1 != '\0') {
std::operator+(param_1,(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00178be4 to 00178bf9 has its CatchHandler @ 00178c47 */
std::operator+((char *)local_40,(string *)"failed to create cache directory: ");
/* try { // try from 00178bfd to 00178c21 has its CatchHandler @ 00178c22 */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00230fe8,PTR__runtime_error_00230f50);
}
|
|
16,025
|
pem_aes_decrypt
|
msxemulator/build_O3/_deps/pico_sdk-src/lib/mbedtls/library/pem.c
|
static int pem_aes_decrypt(unsigned char aes_iv[16], unsigned int keylen,
unsigned char *buf, size_t buflen,
const unsigned char *pwd, size_t pwdlen)
{
mbedtls_aes_context aes_ctx;
unsigned char aes_key[32];
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_aes_init(&aes_ctx);
if ((ret = pem_pbkdf1(aes_key, keylen, aes_iv, pwd, pwdlen)) != 0) {
goto exit;
}
if ((ret = mbedtls_aes_setkey_dec(&aes_ctx, aes_key, keylen * 8)) != 0) {
goto exit;
}
ret = mbedtls_aes_crypt_cbc(&aes_ctx, MBEDTLS_AES_DECRYPT, buflen,
aes_iv, buf, buf);
exit:
mbedtls_aes_free(&aes_ctx);
mbedtls_platform_zeroize(aes_key, keylen);
return ret;
}
|
O3
|
c
|
pem_aes_decrypt:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, %rbp
movq %r8, %r15
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %r12
leaq 0x38(%rsp), %rdi
callq 0x7b5f8
movl %r13d, %ebx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbp, %r8
callq 0x9899f
testl %eax, %eax
jne 0x98789
movq %r14, %r15
movq 0x8(%rsp), %r14
shll $0x3, %r13d
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl %r13d, %edx
callq 0x7bcd9
testl %eax, %eax
jne 0x98789
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r15, %r9
callq 0x7c933
movl %eax, %ebp
leaq 0x38(%rsp), %rdi
callq 0x7b604
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8db8c
movl %ebp, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
pem_aes_decrypt:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 158h
mov rbp, r9
mov r15, r8
mov [rsp+188h+var_180], rcx
mov r14, rdx
mov r13d, esi
mov r12, rdi
lea rdi, [rsp+188h+var_150]
call mbedtls_aes_init
mov ebx, r13d
lea rdi, [rsp+188h+var_178]
mov rsi, rbx
mov rdx, r12
mov rcx, r15
mov r8, rbp
call pem_pbkdf1
test eax, eax
jnz short loc_98789
mov r15, r14
mov r14, [rsp+188h+var_180]
shl r13d, 3
lea rdi, [rsp+188h+var_150]
lea rsi, [rsp+188h+var_178]
mov edx, r13d
call mbedtls_aes_setkey_dec
test eax, eax
jnz short loc_98789
lea rdi, [rsp+188h+var_150]
xor esi, esi
mov rdx, r14
mov rcx, r12
mov r8, r15
mov r9, r15
call mbedtls_aes_crypt_cbc
loc_98789:
mov ebp, eax
lea rdi, [rsp+188h+var_150]
call mbedtls_aes_free
lea rdi, [rsp+188h+var_178]
mov rsi, rbx
call mbedtls_platform_zeroize
mov eax, ebp
add rsp, 158h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long pem_aes_decrypt(_OWORD *a1, unsigned int a2, _DWORD *a3, long long a4, long long a5, long long a6)
{
unsigned int v9; // eax
unsigned int v10; // ebp
_BYTE v13[40]; // [rsp+10h] [rbp-178h] BYREF
unsigned int v14[84]; // [rsp+38h] [rbp-150h] BYREF
mbedtls_aes_init((long long)v14);
v9 = pem_pbkdf1(v13, a2, a1, a5, a6);
if ( !v9 )
{
v9 = mbedtls_aes_setkey_dec(v14, (long long)v13, 8 * a2);
if ( !v9 )
v9 = mbedtls_aes_crypt_cbc((long long)v14, 0, a4, a1, a3, a3);
}
v10 = v9;
mbedtls_aes_free((long long)v14);
mbedtls_platform_zeroize((long long)v13, a2);
return v10;
}
|
pem_aes_decrypt:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x158
MOV RBP,R9
MOV R15,R8
MOV qword ptr [RSP + 0x8],RCX
MOV R14,RDX
MOV R13D,ESI
MOV R12,RDI
LEA RDI,[RSP + 0x38]
CALL 0x0017b5f8
MOV EBX,R13D
LEA RDI,[RSP + 0x10]
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R15
MOV R8,RBP
CALL 0x0019899f
TEST EAX,EAX
JNZ 0x00198789
MOV R15,R14
MOV R14,qword ptr [RSP + 0x8]
SHL R13D,0x3
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x10]
MOV EDX,R13D
CALL 0x0017bcd9
TEST EAX,EAX
JNZ 0x00198789
LEA RDI,[RSP + 0x38]
XOR ESI,ESI
MOV RDX,R14
MOV RCX,R12
MOV R8,R15
MOV R9,R15
CALL 0x0017c933
LAB_00198789:
MOV EBP,EAX
LEA RDI,[RSP + 0x38]
CALL 0x0017b604
LEA RDI,[RSP + 0x10]
MOV RSI,RBX
CALL 0x0018db8c
MOV EAX,EBP
ADD RSP,0x158
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int pem_aes_decrypt(int8 param_1,int param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int iVar1;
int1 local_178 [40];
int1 local_150 [288];
mbedtls_aes_init(local_150);
iVar1 = pem_pbkdf1(local_178,param_2,param_1,param_5,param_6);
if (iVar1 == 0) {
iVar1 = mbedtls_aes_setkey_dec(local_150,local_178,param_2 << 3);
if (iVar1 == 0) {
iVar1 = mbedtls_aes_crypt_cbc(local_150,0,param_4,param_1,param_3,param_3);
}
}
mbedtls_aes_free(local_150);
mbedtls_platform_zeroize(local_178,param_2);
return iVar1;
}
|
|
16,026
|
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(void const*, int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc
|
bool FileOutputStream::CopyingFileOutputStream::Write(const void* buffer,
int size) {
GOOGLE_CHECK(!is_closed_);
int total_written = 0;
const uint8_t* buffer_base = reinterpret_cast<const uint8_t*>(buffer);
while (total_written < size) {
int bytes;
do {
bytes = write(file_, buffer_base + total_written, size - total_written);
} while (bytes < 0 && errno == EINTR);
if (bytes <= 0) {
// Write error.
// FIXME(kenton): According to the man page, if write() returns zero,
// there was no error; write() simply did not write anything. It's
// unclear under what circumstances this might happen, but presumably
// errno won't be set in this case. I am confused as to how such an
// event should be handled. For now I'm treating it as an error, since
// retrying seems like it could lead to an infinite loop. I suspect
// this never actually happens anyway.
if (bytes < 0) {
errno_ = errno;
}
return false;
}
total_written += bytes;
}
return true;
}
|
O0
|
cpp
|
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(void const*, int):
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0xd(%rax), %al
movb $0x0, 0x4f(%rsp)
testb $0x1, %al
jne 0x23ac09
jmp 0x23ac59
leaq 0x1b0b34(%rip), %rdx # 0x3eb744
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0xd8, %ecx
callq 0x19a670
movq 0x8(%rsp), %rdi
movb $0x1, 0x4f(%rsp)
leaq 0x1b0b90(%rip), %rsi # 0x3eb7ca
callq 0x199f30
movq %rax, 0x10(%rsp)
jmp 0x23ac46
movq 0x10(%rsp), %rsi
leaq 0x3b(%rsp), %rdi
callq 0x19a0e0
jmp 0x23ac57
jmp 0x23ac59
testb $0x1, 0x4f(%rsp)
jne 0x23ac62
jmp 0x23ac6c
leaq 0x50(%rsp), %rdi
callq 0x19a6b0
movl $0x0, 0x34(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x8c(%rsp), %eax
jge 0x23ad44
jmp 0x23ac94
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edi
movq 0x28(%rsp), %rsi
movslq 0x34(%rsp), %rax
addq %rax, %rsi
movl 0x8c(%rsp), %eax
subl 0x34(%rsp), %eax
movslq %eax, %rdx
callq 0x94e90
movl %eax, 0x24(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x24(%rsp)
movb %al, 0x7(%rsp)
jge 0x23acdc
callq 0x94c40
cmpl $0x4, (%rax)
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x23ac94
cmpl $0x0, 0x24(%rsp)
jg 0x23ad33
cmpl $0x0, 0x24(%rsp)
jge 0x23ad29
callq 0x94c40
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x10(%rax)
jmp 0x23ad29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x23ad1d
jmp 0x23ad27
leaq 0x50(%rsp), %rdi
callq 0x19a6b0
jmp 0x23ad5d
movb $0x0, 0xa7(%rsp)
jmp 0x23ad4c
movl 0x24(%rsp), %eax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x23ac81
movb $0x1, 0xa7(%rsp)
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x90db0
nopw (%rax,%rax)
|
_ZN6google8protobuf2io16FileOutputStream23CopyingFileOutputStream5WriteEPKvi:
sub rsp, 0A8h
mov [rsp+0A8h+var_10], rdi
mov [rsp+0A8h+var_18], rsi
mov [rsp+0A8h+var_1C], edx
mov rax, [rsp+0A8h+var_10]
mov [rsp+0A8h+var_90], rax
mov al, [rax+0Dh]
mov [rsp+0A8h+var_59], 0
test al, 1
jnz short loc_23AC09
jmp short loc_23AC59
loc_23AC09:
lea rdx, aWorkspaceLlm4b_50; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+0A8h+var_58]
mov [rsp+0A8h+var_A0], rdi
mov esi, 3
mov ecx, 0D8h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+0A8h+var_A0]
mov [rsp+0A8h+var_59], 1
lea rsi, aCheckFailedIsC; "CHECK failed: !is_closed_: "
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+0A8h+var_98], rax
jmp short $+2
loc_23AC46:
mov rsi, [rsp+0A8h+var_98]
lea rdi, [rsp+0A8h+var_6D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_23AC57:
jmp short $+2
loc_23AC59:
test [rsp+0A8h+var_59], 1
jnz short loc_23AC62
jmp short loc_23AC6C
loc_23AC62:
lea rdi, [rsp+0A8h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_23AC6C:
mov [rsp+0A8h+var_74], 0
mov rax, [rsp+0A8h+var_18]
mov [rsp+0A8h+var_80], rax
loc_23AC81:
mov eax, [rsp+0A8h+var_74]
cmp eax, [rsp+0A8h+var_1C]
jge loc_23AD44
jmp short $+2
loc_23AC94:
mov rax, [rsp+0A8h+var_90]
mov edi, [rax+8]
mov rsi, [rsp+0A8h+var_80]
movsxd rax, [rsp+0A8h+var_74]
add rsi, rax
mov eax, [rsp+0A8h+var_1C]
sub eax, [rsp+0A8h+var_74]
movsxd rdx, eax
call _write
mov [rsp+0A8h+var_84], eax
xor eax, eax
cmp [rsp+0A8h+var_84], 0
mov [rsp+0A8h+var_A1], al
jge short loc_23ACDC
call ___errno_location
cmp dword ptr [rax], 4
setz al
mov [rsp+0A8h+var_A1], al
loc_23ACDC:
mov al, [rsp+0A8h+var_A1]
test al, 1
jnz short loc_23AC94
cmp [rsp+0A8h+var_84], 0
jg short loc_23AD33
cmp [rsp+0A8h+var_84], 0
jge short loc_23AD29
call ___errno_location
mov rcx, rax
mov rax, [rsp+0A8h+var_90]
mov ecx, [rcx]
mov [rax+10h], ecx
jmp short loc_23AD29
mov rcx, rax
mov eax, edx
mov [rsp+arg_38], rcx
mov [rsp+arg_34], eax
test [rsp+arg_47], 1
jnz short loc_23AD1D
jmp short loc_23AD27
loc_23AD1D:
lea rdi, [rsp+arg_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_23AD27:
jmp short loc_23AD5D
loc_23AD29:
mov [rsp+0A8h+var_1], 0
jmp short loc_23AD4C
loc_23AD33:
mov eax, [rsp+0A8h+var_84]
add eax, [rsp+0A8h+var_74]
mov [rsp+0A8h+var_74], eax
jmp loc_23AC81
loc_23AD44:
mov [rsp+0A8h+var_1], 1
loc_23AD4C:
mov al, [rsp+0A8h+var_1]
and al, 1
add rsp, 0A8h
retn
loc_23AD5D:
mov rdi, [rsp+arg_38]
call __Unwind_Resume
|
char google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(
google::protobuf::io::FileOutputStream::CopyingFileOutputStream *this,
char *a2,
int a3)
{
char v3; // al
long long v4; // rdi
char *v5; // rsi
long long v6; // rdx
bool v8; // [rsp+7h] [rbp-A1h]
google::protobuf::internal::LogMessage *v9; // [rsp+10h] [rbp-98h]
int v11; // [rsp+24h] [rbp-84h]
char *v12; // [rsp+28h] [rbp-80h]
int v13; // [rsp+34h] [rbp-74h]
char v14[20]; // [rsp+3Bh] [rbp-6Dh] BYREF
char v15; // [rsp+4Fh] [rbp-59h]
_BYTE v16[60]; // [rsp+50h] [rbp-58h] BYREF
int v17; // [rsp+8Ch] [rbp-1Ch]
char *v18; // [rsp+90h] [rbp-18h]
google::protobuf::io::FileOutputStream::CopyingFileOutputStream *v19; // [rsp+98h] [rbp-10h]
v19 = this;
v18 = a2;
v17 = a3;
v3 = *((_BYTE *)this + 13);
v15 = 0;
if ( (v3 & 1) != 0 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v16,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc",
216);
v15 = 1;
v9 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v16,
(long long)"CHECK failed: !is_closed_: ");
google::protobuf::internal::LogFinisher::operator=((long long)v14, v9);
}
if ( (v15 & 1) != 0 )
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v16);
v13 = 0;
v12 = v18;
while ( 1 )
{
if ( v13 >= v17 )
return 1;
do
{
v4 = *((unsigned int *)this + 2);
v5 = &v12[v13];
v11 = write(v4, v5, v17 - v13);
v8 = 0;
if ( v11 < 0 )
v8 = *(_DWORD *)__errno_location(v4, v5, v6) == 4;
}
while ( v8 );
if ( v11 <= 0 )
break;
v13 += v11;
}
if ( v11 < 0 )
*((_DWORD *)this + 4) = *(_DWORD *)__errno_location(v4, v5, v6);
return 0;
}
| |||
16,027
|
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(void const*, int)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc
|
bool FileOutputStream::CopyingFileOutputStream::Write(const void* buffer,
int size) {
GOOGLE_CHECK(!is_closed_);
int total_written = 0;
const uint8_t* buffer_base = reinterpret_cast<const uint8_t*>(buffer);
while (total_written < size) {
int bytes;
do {
bytes = write(file_, buffer_base + total_written, size - total_written);
} while (bytes < 0 && errno == EINTR);
if (bytes <= 0) {
// Write error.
// FIXME(kenton): According to the man page, if write() returns zero,
// there was no error; write() simply did not write anything. It's
// unclear under what circumstances this might happen, but presumably
// errno won't be set in this case. I am confused as to how such an
// event should be handled. For now I'm treating it as an error, since
// retrying seems like it could lead to an infinite loop. I suspect
// this never actually happens anyway.
if (bytes < 0) {
errno_ = errno;
}
return false;
}
total_written += bytes;
}
return true;
}
|
O3
|
cpp
|
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(void const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0xd(%rdi)
jne 0xbc2e6
leaq 0xaf37a(%rip), %rdx # 0x16b623
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movl $0x3, %esi
movl $0xd8, %ecx
callq 0x857c2
leaq 0xaf3e2(%rip), %rsi # 0x16b6a9
movq %r12, %rdi
callq 0x852c0
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x8539a
leaq 0x10(%rsp), %rdi
callq 0x857e0
testl %ebx, %ebx
jle 0xbc332
xorl %ebp, %ebp
movl %ebp, %r12d
addq %r15, %r12
movl %ebx, %eax
subl %ebp, %eax
movslq %eax, %r13
movl 0x8(%r14), %edi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2c550
movq %rax, %rcx
testl %ecx, %ecx
jns 0xbc31d
callq 0x2c0a0
movl (%rax), %eax
cmpl $0x4, %eax
je 0xbc2f9
jmp 0xbc32a
setne %al
je 0xbc334
addl %ecx, %ebp
cmpl %ebx, %ebp
jl 0xbc2ec
jmp 0xbc334
movl %eax, 0x10(%r14)
xorl %eax, %eax
jmp 0xbc334
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc345
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x857e0
movq %rbx, %rdi
callq 0x2e220
|
_ZN6google8protobuf2io16FileOutputStream23CopyingFileOutputStream5WriteEPKvi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov ebx, edx
mov r15, rsi
mov r14, rdi
cmp byte ptr [rdi+0Dh], 1
jnz short loc_BC2E6
lea rdx, aWorkspaceLlm4b_31; "/workspace/llm4binary/github2025/aimrt_"...
lea r12, [rsp+78h+var_68]
mov rdi, r12
mov esi, 3
mov ecx, 0D8h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedIsC; "CHECK failed: !is_closed_: "
mov rdi, r12
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+78h+var_69]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+78h+var_68]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_BC2E6:
test ebx, ebx
jle short loc_BC332
xor ebp, ebp
loc_BC2EC:
mov r12d, ebp
add r12, r15
mov eax, ebx
sub eax, ebp
movsxd r13, eax
loc_BC2F9:
mov edi, [r14+8]
mov rsi, r12
mov rdx, r13
call _write
mov rcx, rax
test ecx, ecx
jns short loc_BC31D
call ___errno_location
mov eax, [rax]
cmp eax, 4
jz short loc_BC2F9
jmp short loc_BC32A
loc_BC31D:
setnz al
jz short loc_BC334
add ebp, ecx
cmp ebp, ebx
jl short loc_BC2EC
jmp short loc_BC334
loc_BC32A:
mov [r14+10h], eax
xor eax, eax
jmp short loc_BC334
loc_BC332:
mov al, 1
loc_BC334:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short $+2
loc_BC345:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
|
bool google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(
google::protobuf::io::FileOutputStream::CopyingFileOutputStream *this,
char *a2,
int a3)
{
google::protobuf::internal::LogMessage *v5; // rax
int v6; // ebp
long long v7; // rdi
int v8; // eax
int v9; // ecx
bool v10; // zf
int v11; // eax
bool result; // al
char v13; // [rsp+Fh] [rbp-69h] BYREF
_BYTE v14[104]; // [rsp+10h] [rbp-68h] BYREF
if ( *((_BYTE *)this + 13) == 1 )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v14,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc",
216);
v5 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v14,
(long long)"CHECK failed: !is_closed_: ");
google::protobuf::internal::LogFinisher::operator=((long long)&v13, v5);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v14);
}
if ( a3 <= 0 )
return 1;
v6 = 0;
do
{
while ( 1 )
{
v7 = *((unsigned int *)this + 2);
v8 = write(v7, &a2[v6], a3 - v6);
v9 = v8;
v10 = v8 == 0;
if ( v8 < 0 )
break;
result = v8 != 0;
if ( !v10 )
{
v6 += v9;
if ( v6 < a3 )
continue;
}
return result;
}
v11 = *(_DWORD *)__errno_location(v7);
}
while ( v11 == 4 );
*((_DWORD *)this + 4) = v11;
return 0;
}
|
Write:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,EDX
MOV R15,RSI
MOV R14,RDI
CMP byte ptr [RDI + 0xd],0x1
JNZ 0x001bc2e6
LEA RDX,[0x26b623]
LEA R12,[RSP + 0x10]
MOV RDI,R12
MOV ESI,0x3
MOV ECX,0xd8
CALL 0x001857c2
LAB_001bc2c0:
LEA RSI,[0x26b6a9]
MOV RDI,R12
CALL 0x001852c0
LAB_001bc2cf:
LEA RDI,[RSP + 0xf]
MOV RSI,RAX
CALL 0x0018539a
LAB_001bc2dc:
LEA RDI,[RSP + 0x10]
CALL 0x001857e0
LAB_001bc2e6:
TEST EBX,EBX
JLE 0x001bc332
XOR EBP,EBP
LAB_001bc2ec:
MOV R12D,EBP
ADD R12,R15
MOV EAX,EBX
SUB EAX,EBP
MOVSXD R13,EAX
LAB_001bc2f9:
MOV EDI,dword ptr [R14 + 0x8]
MOV RSI,R12
MOV RDX,R13
CALL 0x0012c550
MOV RCX,RAX
TEST ECX,ECX
JNS 0x001bc31d
CALL 0x0012c0a0
MOV EAX,dword ptr [RAX]
CMP EAX,0x4
JZ 0x001bc2f9
JMP 0x001bc32a
LAB_001bc31d:
SETNZ AL
JZ 0x001bc334
ADD EBP,ECX
CMP EBP,EBX
JL 0x001bc2ec
JMP 0x001bc334
LAB_001bc32a:
MOV dword ptr [R14 + 0x10],EAX
XOR EAX,EAX
JMP 0x001bc334
LAB_001bc332:
MOV AL,0x1
LAB_001bc334:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write(void const*, int) */
bool __thiscall
google::protobuf::io::FileOutputStream::CopyingFileOutputStream::Write
(CopyingFileOutputStream *this,void *param_1,int param_2)
{
LogMessage *pLVar1;
ssize_t sVar2;
int *piVar3;
int iVar4;
uint uVar5;
bool bVar6;
LogFinisher local_69;
LogMessage local_68 [56];
if (this[0xd] == (CopyingFileOutputStream)0x1) {
internal::LogMessage::LogMessage
(local_68,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl.cc"
,0xd8);
/* try { // try from 001bc2c0 to 001bc2ce has its CatchHandler @ 001bc345 */
pLVar1 = (LogMessage *)internal::LogMessage::operator<<(local_68,"CHECK failed: !is_closed_: ");
/* try { // try from 001bc2cf to 001bc2db has its CatchHandler @ 001bc343 */
internal::LogFinisher::operator=(&local_69,pLVar1);
internal::LogMessage::~LogMessage(local_68);
}
if (param_2 < 1) {
bVar6 = true;
}
else {
uVar5 = 0;
do {
while( true ) {
sVar2 = write(*(int *)(this + 8),(void *)((ulong)uVar5 + (long)param_1),
(long)(int)(param_2 - uVar5));
iVar4 = (int)sVar2;
bVar6 = iVar4 != 0;
if (-1 < iVar4) break;
piVar3 = __errno_location();
if (*piVar3 != 4) {
*(int *)(this + 0x10) = *piVar3;
return false;
}
}
} while ((bVar6) && (uVar5 = uVar5 + iVar4, (int)uVar5 < param_2));
}
return bVar6;
}
|
|
16,028
|
my_uni_ucs2
|
eloqsql/strings/ctype-ucs2.c
|
static int my_uni_ucs2(CHARSET_INFO *cs __attribute__((unused)) ,
my_wc_t wc, uchar *r, uchar *e)
{
if ( r+2 > e )
return MY_CS_TOOSMALL2;
if (wc > 0xFFFF) /* UCS2 does not support characters outside BMP */
return MY_CS_ILUNI;
r[0]= (uchar) (wc >> 8);
r[1]= (uchar) (wc & 0xFF);
return 2;
}
|
O3
|
c
|
my_uni_ucs2:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xcb080
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0xcb080
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
popq %rbp
retq
|
my_uni_ucs2:
push rbp
mov rbp, rsp
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_CB080
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_CB080
rol si, 8
mov [rdx], si
mov eax, 2
loc_CB080:
pop rbp
retn
|
long long my_uni_ucs2(long long a1, unsigned long long a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
result = 0LL;
if ( a2 <= 0xFFFF )
{
*a3 = __ROL2__(a2, 8);
return 2LL;
}
}
return result;
}
|
my_uni_ucs2:
PUSH RBP
MOV RBP,RSP
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001cb080
XOR EAX,EAX
CMP RSI,0xffff
JA 0x001cb080
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
LAB_001cb080:
POP RBP
RET
|
int8 my_uni_ucs2(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
int8 uVar1;
uVar1 = 0xffffff9a;
if ((param_3 + 1 <= param_4) && (uVar1 = 0, param_2 < 0x10000)) {
*param_3 = (ushort)param_2 << 8 | (ushort)param_2 >> 8;
uVar1 = 2;
}
return uVar1;
}
|
|
16,029
|
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
}
|
O1
|
c
|
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int):
movq %rdi, %rax
testl %ecx, %ecx
jle 0x429eb
movl %r8d, %edx
movl %ecx, %ecx
xorl %edi, %edi
movq %rax, %r9
testl %r8d, %r8d
jle 0x429e0
xorl %r10d, %r10d
movb (%rsi,%rdi), %r11b
movb %r11b, (%r9,%r10)
incq %r10
cmpq %r10, %rdx
jne 0x429d0
incq %rdi
addq %rdx, %r9
cmpq %rcx, %rdi
jne 0x429c8
retq
|
_ZL26stbi__resample_row_genericPhS_S_ii:
mov rax, rdi
test ecx, ecx
jle short locret_429EB
mov edx, r8d
mov ecx, ecx
xor edi, edi
mov r9, rax
loc_429C8:
test r8d, r8d
jle short loc_429E0
xor r10d, r10d
loc_429D0:
mov r11b, [rsi+rdi]
mov [r9+r10], r11b
inc r10
cmp rdx, r10
jnz short loc_429D0
loc_429E0:
inc rdi
add r9, rdx
cmp rdi, rcx
jnz short loc_429C8
locret_429EB:
retn
|
unsigned __int8 * stbi__resample_row_generic(
unsigned __int8 *a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
int a4,
int a5)
{
unsigned __int8 *result; // rax
long long v6; // rdi
unsigned __int8 *v7; // r9
long long i; // r10
result = a1;
if ( a4 > 0 )
{
v6 = 0LL;
v7 = result;
do
{
if ( a5 > 0 )
{
for ( i = 0LL; i != a5; v7[i++] = a2[v6] )
;
}
++v6;
v7 += (unsigned int)a5;
}
while ( v6 != a4 );
}
return result;
}
|
stbi__resample_row_generic:
MOV RAX,RDI
TEST ECX,ECX
JLE 0x001429eb
MOV EDX,R8D
MOV ECX,ECX
XOR EDI,EDI
MOV R9,RAX
LAB_001429c8:
TEST R8D,R8D
JLE 0x001429e0
XOR R10D,R10D
LAB_001429d0:
MOV R11B,byte ptr [RSI + RDI*0x1]
MOV byte ptr [R9 + R10*0x1],R11B
INC R10
CMP RDX,R10
JNZ 0x001429d0
LAB_001429e0:
INC RDI
ADD R9,RDX
CMP RDI,RCX
JNZ 0x001429c8
LAB_001429eb:
RET
|
/* stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int) */
void stbi__resample_row_generic
(uchar *param_1,uchar *param_2,uchar *param_3,int param_4,int param_5)
{
ulong uVar1;
ulong uVar2;
if (0 < param_4) {
uVar1 = 0;
do {
if (0 < param_5) {
uVar2 = 0;
do {
param_1[uVar2] = param_2[uVar1];
uVar2 = uVar2 + 1;
} while ((uint)param_5 != uVar2);
}
uVar1 = uVar1 + 1;
param_1 = param_1 + (uint)param_5;
} while (uVar1 != (uint)param_4);
}
return;
}
|
|
16,030
|
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int)
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
}
|
O2
|
c
|
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int):
movq %rdi, %rax
xorl %edx, %edx
testl %r8d, %r8d
movl $0x0, %edi
cmovgl %r8d, %edi
movslq %r8d, %r8
testl %ecx, %ecx
cmovlel %edx, %ecx
movq %rax, %r9
cmpq %rcx, %rdx
je 0x416f8
xorl %r10d, %r10d
cmpq %r10, %rdi
je 0x416f0
movb (%rsi,%rdx), %r11b
movb %r11b, (%r9,%r10)
incq %r10
jmp 0x416de
incq %rdx
addq %r8, %r9
jmp 0x416d6
retq
|
_ZL26stbi__resample_row_genericPhS_S_ii:
mov rax, rdi
xor edx, edx
test r8d, r8d
mov edi, 0
cmovg edi, r8d
movsxd r8, r8d
test ecx, ecx
cmovle ecx, edx
mov r9, rax
loc_416D6:
cmp rdx, rcx
jz short locret_416F8
xor r10d, r10d
loc_416DE:
cmp rdi, r10
jz short loc_416F0
mov r11b, [rsi+rdx]
mov [r9+r10], r11b
inc r10
jmp short loc_416DE
loc_416F0:
inc rdx
add r9, r8
jmp short loc_416D6
locret_416F8:
retn
|
unsigned __int8 * stbi__resample_row_generic(
unsigned __int8 *a1,
unsigned __int8 *a2,
unsigned __int8 *a3,
long long a4,
int a5)
{
unsigned __int8 *result; // rax
long long v6; // rdx
long long v7; // rdi
unsigned __int8 *v8; // r9
long long i; // r10
result = a1;
v6 = 0LL;
v7 = 0LL;
if ( a5 > 0 )
v7 = (unsigned int)a5;
if ( (int)a4 <= 0 )
a4 = 0LL;
v8 = result;
while ( v6 != a4 )
{
for ( i = 0LL; v7 != i; ++i )
v8[i] = a2[v6];
++v6;
v8 += a5;
}
return result;
}
|
stbi__resample_row_generic:
MOV RAX,RDI
XOR EDX,EDX
TEST R8D,R8D
MOV EDI,0x0
CMOVG EDI,R8D
MOVSXD R8,R8D
TEST ECX,ECX
CMOVLE ECX,EDX
MOV R9,RAX
LAB_001416d6:
CMP RDX,RCX
JZ 0x001416f8
XOR R10D,R10D
LAB_001416de:
CMP RDI,R10
JZ 0x001416f0
MOV R11B,byte ptr [RSI + RDX*0x1]
MOV byte ptr [R9 + R10*0x1],R11B
INC R10
JMP 0x001416de
LAB_001416f0:
INC RDX
ADD R9,R8
JMP 0x001416d6
LAB_001416f8:
RET
|
/* stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int) */
void stbi__resample_row_generic
(uchar *param_1,uchar *param_2,uchar *param_3,int param_4,int param_5)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
uVar2 = 0;
uVar3 = 0;
if (0 < param_5) {
uVar3 = (ulong)(uint)param_5;
}
uVar1 = (ulong)(uint)param_4;
if (param_4 < 1) {
uVar1 = uVar2;
}
for (; uVar2 != uVar1; uVar2 = uVar2 + 1) {
for (uVar4 = 0; uVar3 != uVar4; uVar4 = uVar4 + 1) {
param_1[uVar4] = param_2[uVar2];
}
param_1 = param_1 + param_5;
}
return;
}
|
|
16,031
|
delete_property
|
bluesky950520[P]quickjs/quickjs.c
|
static int delete_property(JSContext *ctx, JSObject *p, JSAtom atom)
{
JSShape *sh;
JSShapeProperty *pr, *lpr, *prop;
JSProperty *pr1;
uint32_t lpr_idx;
intptr_t h, h1;
redo:
sh = p->shape;
h1 = atom & sh->prop_hash_mask;
h = prop_hash_end(sh)[-h1 - 1];
prop = get_shape_prop(sh);
lpr = NULL;
lpr_idx = 0; /* prevent warning */
while (h != 0) {
pr = &prop[h - 1];
if (likely(pr->atom == atom)) {
/* found ! */
if (!(pr->flags & JS_PROP_CONFIGURABLE))
return FALSE;
/* realloc the shape if needed */
if (lpr)
lpr_idx = lpr - get_shape_prop(sh);
if (js_shape_prepare_update(ctx, p, &pr))
return -1;
sh = p->shape;
/* remove property */
if (lpr) {
lpr = get_shape_prop(sh) + lpr_idx;
lpr->hash_next = pr->hash_next;
} else {
prop_hash_end(sh)[-h1 - 1] = pr->hash_next;
}
sh->deleted_prop_count++;
/* free the entry */
pr1 = &p->prop[h - 1];
free_property(ctx->rt, pr1, pr->flags);
JS_FreeAtom(ctx, pr->atom);
/* put default values */
pr->flags = 0;
pr->atom = JS_ATOM_NULL;
pr1->u.value = JS_UNDEFINED;
/* compact the properties if too many deleted properties */
if (sh->deleted_prop_count >= 8 &&
sh->deleted_prop_count >= ((unsigned)sh->prop_count / 2)) {
compact_properties(ctx, p);
}
return TRUE;
}
lpr = pr;
h = pr->hash_next;
}
if (p->is_exotic) {
if (p->fast_array) {
uint32_t idx;
if (JS_AtomIsArrayIndex(ctx, &idx, atom) &&
idx < p->u.array.count) {
if (p->class_id == JS_CLASS_ARRAY ||
p->class_id == JS_CLASS_ARGUMENTS) {
/* Special case deleting the last element of a fast Array */
if (idx == p->u.array.count - 1) {
JS_FreeValue(ctx, p->u.array.u.values[idx]);
p->u.array.count = idx;
return TRUE;
}
if (convert_fast_array_to_array(ctx, p))
return -1;
goto redo;
} else {
return FALSE;
}
}
} else {
const JSClassExoticMethods *em = ctx->rt->class_array[p->class_id].exotic;
if (em && em->delete_property) {
return em->delete_property(ctx, JS_MKPTR(JS_TAG_OBJECT, p), atom);
}
}
}
/* not found */
return TRUE;
}
|
O2
|
c
|
delete_property:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, %r8
pushq $0x1
popq %rdx
leaq 0x1c(%rsp), %rsi
pushq $-0x1
popq %rbp
movq 0x18(%r8), %r12
movl 0x20(%r12), %r13d
andl %r15d, %r13d
notq %r13
movl (%r12,%r13,4), %eax
addq $0x40, %r12
xorl %ebx, %ebx
testl %eax, %eax
je 0x2489c
movl %eax, %r14d
leaq (%r12,%r14,8), %rcx
addq $-0x8, %rcx
movq %rcx, (%rsp)
movl (%rcx), %eax
cmpl %r15d, 0x4(%rcx)
je 0x2491d
andl $0x3ffffff, %eax # imm = 0x3FFFFFF
movq %rcx, %rbx
jmp 0x24873
movb 0x5(%r8), %al
testb $0x4, %al
je 0x24c2c
testb $0x8, %al
je 0x24bea
movq %rdi, %r13
movq %rsi, %r12
movl %r15d, %edx
movq %r8, %r14
callq 0x39c38
testl %eax, %eax
je 0x24bd6
movq %r14, %r8
movl 0x1c(%rsp), %ebx
movl 0x40(%r14), %eax
cmpl %eax, %ebx
jae 0x24bd6
movzwl 0x6(%r8), %ecx
cmpl $0x8, %ecx
je 0x248ef
cmpl $0x2, %ecx
jne 0x24c55
decl %eax
cmpl %eax, %ebx
je 0x24c30
movq %r13, %rdi
movq %r8, %rsi
callq 0x23de7
testl %eax, %eax
jne 0x24bd9
movq %r14, %r8
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %r12, %rsi
jmp 0x2485a
xorl %ebp, %ebp
btl $0x1a, %eax
jae 0x24bd9
movq %rsp, %rdx
movq %rdi, %r15
movq %r8, %rsi
movq %r8, %rbp
callq 0x239e5
testl %eax, %eax
je 0x24945
pushq $-0x1
jmp 0x24bd8
movq %r15, 0x10(%rsp)
decq %r14
movq 0x18(%rbp), %r15
testq %rbx, %rbx
movq %rbp, %rsi
je 0x24984
subq %r12, %rbx
shrq $0x3, %rbx
movq (%rsp), %rax
movl $0x3ffffff, %ecx # imm = 0x3FFFFFF
andl (%rax), %ecx
movl %ebx, %eax
movl $0xfc000000, %edx # imm = 0xFC000000
andl 0x40(%r15,%rax,8), %edx
orl %ecx, %edx
movl %edx, 0x40(%r15,%rax,8)
movq (%rsp), %rax
jmp 0x24993
movq (%rsp), %rax
movl $0x3ffffff, %ecx # imm = 0x3FFFFFF
andl (%rax), %ecx
movl %ecx, (%r15,%r13,4)
incl 0x2c(%r15)
movq %rsi, 0x8(%rsp)
movq 0x20(%rsi), %rbx
shlq $0x4, %r14
leaq (%rbx,%r14), %rsi
movq 0x10(%rsp), %r12
movq 0x18(%r12), %rdi
movl (%rax), %edx
shrl $0x1a, %edx
callq 0x390ff
movq (%rsp), %rax
movl 0x4(%rax), %esi
movq %r12, %rdi
callq 0x1e545
movq (%rsp), %rax
andl $0x3ffffff, (%rax) # imm = 0x3FFFFFF
movq (%rsp), %rax
andl $0x0, 0x4(%rax)
andl $0x0, (%rbx,%r14)
movq $0x3, 0x8(%rbx,%r14)
movl 0x2c(%r15), %eax
cmpl $0x8, %eax
jl 0x24bd6
movl 0x28(%r15), %ecx
shrl %ecx
cmpl %ecx, %eax
pushq $0x1
popq %rbp
jb 0x24bd9
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rbp
movl 0x20(%rbp), %eax
movl 0x28(%rbp), %ecx
subl 0x2c(%rbp), %ecx
cmpl $0x3, %ecx
pushq $0x2
popq %r15
cmovgel %ecx, %r15d
incl %eax
movl %eax, %r12d
shrl %eax
cmpl %r15d, %eax
jae 0x24a28
movl %r12d, %ebx
movl %r15d, %r14d
leaq (,%rbx,4), %rax
movq %rax, 0x30(%rsp)
leaq (%rax,%r14,8), %rsi
addq $0x40, %rsi
movq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x1adc4
testq %rax, %rax
je 0x24bd6
movq %r14, 0x28(%rsp)
decl %r12d
leaq (%rax,%rbx,4), %r14
movq %rbx, %rdx
movq %rax, %rbx
movq 0x8(%rbp), %rax
movq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbp)
movups 0x20(%rbp), %xmm0
movups 0x30(%rbp), %xmm1
movups %xmm1, 0x30(%rbx,%rdx,4)
movups %xmm0, 0x20(%rbx,%rdx,4)
movups (%rbp), %xmm0
movups 0x10(%rbp), %xmm1
movups %xmm1, 0x10(%rbx,%rdx,4)
movups %xmm0, (%rbx,%rdx,4)
leaq 0x8(%rbx,%rdx,4), %rax
movq %rdx, %rdi
movq %rdx, 0x20(%rsp)
movq 0x18(%r13), %rcx
leaq 0x98(%rcx), %rdx
movq 0x98(%rcx), %rsi
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%rbx,%rdi,4)
movq %rdx, 0x10(%rbx,%rdi,4)
movq %rax, 0x98(%rcx)
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
movq 0x30(%rsp), %rdx
callq 0xe390
movq 0x20(%rsp), %rax
leaq (%rbx,%rax,4), %rax
addq $0x40, %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movl $0xfc000000, %edx # imm = 0xFC000000
movl $0x3ffffff, %esi # imm = 0x3FFFFFF
movq %rcx, %rdi
xorl %r8d, %r8d
movl 0x28(%r14), %r9d
cmpq %r9, %r13
jae 0x24b80
movl 0x44(%rbp,%r13,8), %r9d
testl %r9d, %r9d
je 0x24b77
movl %r9d, 0x4(%rax)
movl 0x40(%rbp,%r13,8), %r9d
andl %edx, %r9d
movl (%rax), %r10d
andl %esi, %r10d
orl %r9d, %r10d
movl %r10d, (%rax)
movl 0x44(%rbp,%r13,8), %r10d
andl %r12d, %r10d
notq %r10
movl (%r14,%r10,4), %r11d
andl %esi, %r11d
orl %r9d, %r11d
movl %r11d, (%rax)
movl %r8d, %r9d
incl %r8d
movl %r8d, (%r14,%r10,4)
shlq $0x4, %r9
movups (%rdi), %xmm0
movups %xmm0, (%rcx,%r9)
addq $0x8, %rax
incq %r13
addq $0x10, %rdi
jmp 0x24b1a
movl %r12d, 0x20(%r14)
movl %r15d, 0x24(%r14)
andl $0x0, 0x2c(%r14)
movl %r8d, 0x28(%r14)
movq 0x8(%rsp), %rbx
movq %r14, 0x18(%rbx)
movl 0x20(%rbp), %eax
notq %rax
leaq (,%rax,4), %rsi
addq %rbp, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x1ae1e
movq 0x20(%rbx), %rsi
movq 0x28(%rsp), %rdx
shlq $0x4, %rdx
movq %r14, %rdi
callq 0x1ae27
testq %rax, %rax
je 0x24bd6
movq %rax, 0x20(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%rdi), %rax
movq 0x80(%rax), %rax
movzwl 0x6(%r8), %ecx
imulq $0x28, %rcx, %rcx
movq 0x20(%rax,%rcx), %rax
testq %rax, %rax
je 0x24c2c
movq 0x10(%rax), %rax
movl %edx, %ebp
testq %rax, %rax
je 0x24bd9
pushq $-0x1
popq %rdx
movq %r8, %rsi
movl %r15d, %ecx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movl %edx, %ebp
jmp 0x24bd9
movq 0x38(%r8), %rax
movq %rbx, %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r13, %rdi
movq %r8, %r14
callq 0x1bbce
movl %ebx, 0x40(%r14)
jmp 0x24bd6
xorl %ebp, %ebp
jmp 0x24bd9
|
delete_property:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15d, edx
mov r8, rsi
push 1
pop rdx
lea rsi, [rsp+68h+var_4C]
push 0FFFFFFFFFFFFFFFFh
pop rbp
loc_2485A:
mov r12, [r8+18h]
mov r13d, [r12+20h]
and r13d, r15d
not r13
mov eax, [r12+r13*4]
add r12, 40h ; '@'
xor ebx, ebx
loc_24873:
test eax, eax
jz short loc_2489C
mov r14d, eax
lea rcx, [r12+r14*8]
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rsp+68h+var_68], rcx
mov eax, [rcx]
cmp [rcx+4], r15d
jz loc_2491D
and eax, 3FFFFFFh
mov rbx, rcx
jmp short loc_24873
loc_2489C:
mov al, [r8+5]
test al, 4
jz loc_24C2C
test al, 8
jz loc_24BEA
mov r13, rdi
mov r12, rsi
mov edx, r15d
mov r14, r8
call JS_AtomIsArrayIndex
test eax, eax
jz loc_24BD6
mov r8, r14
mov ebx, [rsp+68h+var_4C]
mov eax, [r14+40h]
cmp ebx, eax
jnb loc_24BD6
movzx ecx, word ptr [r8+6]
cmp ecx, 8
jz short loc_248EF
cmp ecx, 2
jnz loc_24C55
loc_248EF:
dec eax
cmp ebx, eax
jz loc_24C30
mov rdi, r13
mov rsi, r8
call convert_fast_array_to_array
test eax, eax
jnz loc_24BD9
mov r8, r14
push 1
pop rdx
mov rdi, r13
mov rsi, r12
jmp loc_2485A
loc_2491D:
xor ebp, ebp
bt eax, 1Ah
jnb loc_24BD9
mov rdx, rsp
mov r15, rdi
mov rsi, r8
mov rbp, r8
call js_shape_prepare_update
test eax, eax
jz short loc_24945
push 0FFFFFFFFFFFFFFFFh
jmp loc_24BD8
loc_24945:
mov [rsp+68h+var_58], r15
dec r14
mov r15, [rbp+18h]
test rbx, rbx
mov rsi, rbp
jz short loc_24984
sub rbx, r12
shr rbx, 3
mov rax, [rsp+68h+var_68]
mov ecx, 3FFFFFFh
and ecx, [rax]
mov eax, ebx
mov edx, 0FC000000h
and edx, [r15+rax*8+40h]
or edx, ecx
mov [r15+rax*8+40h], edx
mov rax, [rsp+68h+var_68]
jmp short loc_24993
loc_24984:
mov rax, [rsp+68h+var_68]
mov ecx, 3FFFFFFh
and ecx, [rax]
mov [r15+r13*4], ecx
loc_24993:
inc dword ptr [r15+2Ch]
mov [rsp+68h+var_60], rsi
mov rbx, [rsi+20h]
shl r14, 4
lea rsi, [rbx+r14]
mov r12, [rsp+68h+var_58]
mov rdi, [r12+18h]
mov edx, [rax]
shr edx, 1Ah
call free_property
mov rax, [rsp+68h+var_68]
mov esi, [rax+4]
mov rdi, r12
call JS_FreeAtom
mov rax, [rsp+68h+var_68]
and dword ptr [rax], 3FFFFFFh
mov rax, [rsp+68h+var_68]
and dword ptr [rax+4], 0
and dword ptr [rbx+r14], 0
mov qword ptr [rbx+r14+8], 3
mov eax, [r15+2Ch]
cmp eax, 8
jl loc_24BD6
mov ecx, [r15+28h]
shr ecx, 1
cmp eax, ecx
push 1
pop rbp
jb loc_24BD9
mov rax, [rsp+68h+var_60]
mov rbp, [rax+18h]
mov eax, [rbp+20h]
mov ecx, [rbp+28h]
sub ecx, [rbp+2Ch]
cmp ecx, 3
push 2
pop r15
cmovge r15d, ecx
inc eax
loc_24A28:
mov r12d, eax
shr eax, 1
cmp eax, r15d
jnb short loc_24A28
mov ebx, r12d
mov r14d, r15d
lea rax, ds:0[rbx*4]
mov [rsp+68h+var_38], rax
lea rsi, [rax+r14*8]
add rsi, 40h ; '@'
mov r13, [rsp+68h+var_58]
mov rdi, r13
call js_malloc
test rax, rax
jz loc_24BD6
mov [rsp+68h+var_40], r14
dec r12d
lea r14, [rax+rbx*4]
mov rdx, rbx
mov rbx, rax
mov rax, [rbp+8]
mov rcx, [rbp+10h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rbp+8], xmm0
movups xmm0, xmmword ptr [rbp+20h]
movups xmm1, xmmword ptr [rbp+30h]
movups xmmword ptr [rbx+rdx*4+30h], xmm1
movups xmmword ptr [rbx+rdx*4+20h], xmm0
movups xmm0, xmmword ptr [rbp+0]
movups xmm1, xmmword ptr [rbp+10h]
movups xmmword ptr [rbx+rdx*4+10h], xmm1
movups xmmword ptr [rbx+rdx*4], xmm0
lea rax, [rbx+rdx*4+8]
mov rdi, rdx
mov [rsp+68h+var_48], rdx
mov rcx, [r13+18h]
lea rdx, [rcx+98h]
mov rsi, [rcx+98h]
mov [rsi+8], rax
mov [rbx+rdi*4+8], rsi
mov [rbx+rdi*4+10h], rdx
mov [rcx+98h], rax
xor r13d, r13d
mov rdi, rbx
xor esi, esi
mov rdx, [rsp+68h+var_38]
call _memset
mov rax, [rsp+68h+var_48]
lea rax, [rbx+rax*4]
add rax, 40h ; '@'
mov rcx, [rsp+68h+var_60]
mov rcx, [rcx+20h]
mov edx, 0FC000000h
mov esi, 3FFFFFFh
mov rdi, rcx
xor r8d, r8d
loc_24B1A:
mov r9d, [r14+28h]
cmp r13, r9
jnb short loc_24B80
mov r9d, [rbp+r13*8+44h]
test r9d, r9d
jz short loc_24B77
mov [rax+4], r9d
mov r9d, [rbp+r13*8+40h]
and r9d, edx
mov r10d, [rax]
and r10d, esi
or r10d, r9d
mov [rax], r10d
mov r10d, [rbp+r13*8+44h]
and r10d, r12d
not r10
mov r11d, [r14+r10*4]
and r11d, esi
or r11d, r9d
mov [rax], r11d
mov r9d, r8d
inc r8d
mov [r14+r10*4], r8d
shl r9, 4
movups xmm0, xmmword ptr [rdi]
movups xmmword ptr [rcx+r9], xmm0
add rax, 8
loc_24B77:
inc r13
add rdi, 10h
jmp short loc_24B1A
loc_24B80:
mov [r14+20h], r12d
mov [r14+24h], r15d
and dword ptr [r14+2Ch], 0
mov [r14+28h], r8d
mov rbx, [rsp+68h+var_60]
mov [rbx+18h], r14
mov eax, [rbp+20h]
not rax
lea rsi, ds:0[rax*4]
add rsi, rbp
mov r14, [rsp+68h+var_58]
mov rdi, r14
call js_free
mov rsi, [rbx+20h]
mov rdx, [rsp+68h+var_40]
shl rdx, 4
mov rdi, r14
call js_realloc
test rax, rax
jz short loc_24BD6
mov [rbx+20h], rax
loc_24BD6:
push 1
loc_24BD8:
pop rbp
loc_24BD9:
mov eax, ebp
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_24BEA:
mov rax, [rdi+18h]
mov rax, [rax+80h]
movzx ecx, word ptr [r8+6]
imul rcx, 28h ; '('
mov rax, [rax+rcx+20h]
test rax, rax
jz short loc_24C2C
mov rax, [rax+10h]
mov ebp, edx
test rax, rax
jz short loc_24BD9
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r8
mov ecx, r15d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_24C2C:
mov ebp, edx
jmp short loc_24BD9
loc_24C30:
mov rax, [r8+38h]
mov rcx, rbx
shl rcx, 4
mov rsi, [rax+rcx]
mov rdx, [rax+rcx+8]
mov rdi, r13
mov r14, r8
call JS_FreeValue
mov [r14+40h], ebx
jmp short loc_24BD6
loc_24C55:
xor ebp, ebp
jmp short loc_24BD9
|
long long delete_property(long long a1, long long a2, unsigned int a3)
{
unsigned int v5; // ebp
long long v6; // r12
unsigned long long v7; // r13
unsigned int v8; // eax
long long v9; // r12
_DWORD *v10; // rbx
long long v11; // r14
_DWORD *v12; // rcx
int v13; // eax
char v14; // al
long long v15; // r14
unsigned int v16; // ebx
unsigned int v17; // eax
int v18; // ecx
long long v19; // rbp
long long v20; // r14
long long v21; // r15
_DWORD *v22; // rax
long long v23; // rbx
long long v24; // r14
long long v25; // r12
int v26; // eax
__int128 *v27; // rbp
unsigned int v28; // r15d
unsigned int v29; // eax
unsigned int v30; // r12d
long long v31; // rbx
long long v32; // r13
long long v33; // rax
unsigned int v34; // r12d
_DWORD *v35; // r14
long long v36; // rdx
long long v37; // rbx
long long v38; // rax
_QWORD *v39; // rcx
__int128 v40; // xmm0
__int128 v41; // xmm0
_QWORD *v42; // rax
long long v43; // rcx
long long v44; // rsi
unsigned long long v45; // r13
unsigned int *v46; // rax
_OWORD *v47; // rcx
_OWORD *v48; // rdi
unsigned int v49; // r8d
unsigned int v50; // r9d
unsigned int v51; // r9d
unsigned long long v52; // r10
long long v53; // r9
long long v54; // rbx
long long v55; // r14
long long v56; // rax
long long v58; // rax
long long ( *v59)(long long, long long, long long, _QWORD); // rax
_DWORD *v61; // [rsp+0h] [rbp-68h] BYREF
long long v62; // [rsp+8h] [rbp-60h]
long long v63; // [rsp+10h] [rbp-58h]
unsigned int v64; // [rsp+1Ch] [rbp-4Ch] BYREF
long long v65; // [rsp+20h] [rbp-48h]
long long v66; // [rsp+28h] [rbp-40h]
long long v67; // [rsp+30h] [rbp-38h]
v5 = -1;
while ( 2 )
{
v6 = *(_QWORD *)(a2 + 24);
v7 = ~(unsigned long long)(a3 & *(_DWORD *)(v6 + 32));
v8 = *(_DWORD *)(v6 + 4 * v7);
v9 = v6 + 64;
v10 = 0LL;
while ( v8 )
{
v11 = v8;
v12 = (_DWORD *)(v9 + 8LL * v8 - 8);
v61 = v12;
v13 = *v12;
if ( v12[1] == a3 )
{
v5 = 0;
if ( (v13 & 0x4000000) == 0 )
return v5;
v19 = a2;
if ( (unsigned int)js_shape_prepare_update(a1, a2, &v61) )
return (unsigned int)-1;
v63 = a1;
v20 = v11 - 1;
v21 = *(_QWORD *)(v19 + 24);
if ( v10 )
{
*(_DWORD *)(v21 + 8LL * (unsigned int)(((unsigned long long)v10 - v9) >> 3) + 64) = *v61 & 0x3FFFFFF | *(_DWORD *)(v21 + 8LL * (unsigned int)(((unsigned long long)v10 - v9) >> 3) + 64) & 0xFC000000;
v22 = v61;
}
else
{
v22 = v61;
*(_DWORD *)(v21 + 4 * v7) = *v61 & 0x3FFFFFF;
}
++*(_DWORD *)(v21 + 44);
v62 = v19;
v23 = *(_QWORD *)(v19 + 32);
v24 = 16 * v20;
v25 = v63;
free_property(*(_QWORD *)(v63 + 24), v23 + v24, *v22 >> 26);
JS_FreeAtom(v25, v61[1]);
*v61 &= 0x3FFFFFFu;
v61[1] = 0;
*(_DWORD *)(v23 + v24) = 0;
*(_QWORD *)(v23 + v24 + 8) = 3LL;
v26 = *(_DWORD *)(v21 + 44);
if ( v26 >= 8 )
{
v5 = 1;
if ( (unsigned int)v26 >= *(_DWORD *)(v21 + 40) >> 1 )
{
v27 = *(__int128 **)(v62 + 24);
v28 = 2;
if ( *((_DWORD *)v27 + 10) - *((_DWORD *)v27 + 11) >= 3 )
v28 = *((_DWORD *)v27 + 10) - *((_DWORD *)v27 + 11);
v29 = *((_DWORD *)v27 + 8) + 1;
do
{
v30 = v29;
v29 >>= 1;
}
while ( v29 >= v28 );
v31 = v30;
v67 = 4LL * v30;
v32 = v63;
v33 = js_malloc(v63, v67 + 8LL * v28 + 64);
if ( v33 )
{
v66 = v28;
v34 = v30 - 1;
v35 = (_DWORD *)(v33 + 4 * v31);
v36 = v31;
v37 = v33;
v38 = *((_QWORD *)v27 + 1);
v39 = (_QWORD *)*((_QWORD *)v27 + 2);
*(_QWORD *)(v38 + 8) = v39;
*v39 = v38;
*(__int128 *)((char *)v27 + 8) = 0LL;
v40 = v27[2];
*(_OWORD *)(v37 + 4 * v36 + 48) = v27[3];
*(_OWORD *)(v37 + 4 * v36 + 32) = v40;
v41 = *v27;
*(_OWORD *)(v37 + 4 * v36 + 16) = v27[1];
*(_OWORD *)(v37 + 4 * v36) = v41;
v42 = (_QWORD *)(v37 + 4 * v36 + 8);
v65 = v36;
v43 = *(_QWORD *)(v32 + 24);
v44 = *(_QWORD *)(v43 + 152);
*(_QWORD *)(v44 + 8) = v42;
*v42 = v44;
*(_QWORD *)(v37 + 4 * v36 + 16) = v43 + 152;
*(_QWORD *)(v43 + 152) = v42;
v45 = 0LL;
memset(v37, 0LL, v67);
v46 = (unsigned int *)(v37 + 4 * v65 + 64);
v47 = *(_OWORD **)(v62 + 32);
v48 = v47;
v49 = 0;
while ( v45 < (unsigned int)v35[10] )
{
v50 = *((_DWORD *)v27 + 2 * v45 + 17);
if ( v50 )
{
v46[1] = v50;
v51 = *((_DWORD *)v27 + 2 * v45 + 16) & 0xFC000000;
*v46 = v51 | *v46 & 0x3FFFFFF;
v52 = ~(unsigned long long)(v34 & *((_DWORD *)v27 + 2 * v45 + 17));
*v46 = v51 | v35[v52] & 0x3FFFFFF;
v53 = v49++;
v35[v52] = v49;
v47[v53] = *v48;
v46 += 2;
}
++v45;
++v48;
}
v35[8] = v34;
v35[9] = v28;
v35[11] = 0;
v35[10] = v49;
v54 = v62;
*(_QWORD *)(v62 + 24) = v35;
v55 = v63;
js_free(v63, (long long)v27 + 4 * ~(unsigned long long)*((unsigned int *)v27 + 8));
v56 = js_realloc(v55, *(_QWORD *)(v54 + 32), 16 * v66);
if ( v56 )
*(_QWORD *)(v54 + 32) = v56;
}
return 1;
}
return v5;
}
return 1;
}
v8 = v13 & 0x3FFFFFF;
v10 = v12;
}
v14 = *(_BYTE *)(a2 + 5);
if ( (v14 & 4) == 0 )
return 1;
if ( (v14 & 8) != 0 )
{
v15 = a2;
if ( (unsigned int)JS_AtomIsArrayIndex(a1, &v64, a3) )
{
v16 = v64;
v17 = *(_DWORD *)(v15 + 64);
if ( v64 < v17 )
{
v18 = *(unsigned __int16 *)(v15 + 6);
if ( v18 != 8 && v18 != 2 )
return 0;
if ( v64 != v17 - 1 )
{
if ( !(unsigned int)convert_fast_array_to_array(a1, v15) )
{
a2 = v15;
continue;
}
return v5;
}
JS_FreeValue(
a1,
*(_QWORD *)(*(_QWORD *)(v15 + 56) + 16LL * v64),
*(_QWORD *)(*(_QWORD *)(v15 + 56) + 16LL * v64 + 8));
*(_DWORD *)(v15 + 64) = v16;
}
}
return 1;
}
break;
}
v58 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40LL * *(unsigned __int16 *)(a2 + 6) + 32);
if ( !v58 )
return 1;
v59 = *(long long ( **)(long long, long long, long long, _QWORD))(v58 + 16);
v5 = 1;
if ( !v59 )
return v5;
return v59(a1, a2, -1LL, a3);
}
|
delete_property:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15D,EDX
MOV R8,RSI
PUSH 0x1
POP RDX
LEA RSI,[RSP + 0x1c]
PUSH -0x1
POP RBP
LAB_0012485a:
MOV R12,qword ptr [R8 + 0x18]
MOV R13D,dword ptr [R12 + 0x20]
AND R13D,R15D
NOT R13
MOV EAX,dword ptr [R12 + R13*0x4]
ADD R12,0x40
XOR EBX,EBX
LAB_00124873:
TEST EAX,EAX
JZ 0x0012489c
MOV R14D,EAX
LEA RCX,[R12 + R14*0x8]
ADD RCX,-0x8
MOV qword ptr [RSP],RCX
MOV EAX,dword ptr [RCX]
CMP dword ptr [RCX + 0x4],R15D
JZ 0x0012491d
AND EAX,0x3ffffff
MOV RBX,RCX
JMP 0x00124873
LAB_0012489c:
MOV AL,byte ptr [R8 + 0x5]
TEST AL,0x4
JZ 0x00124c2c
TEST AL,0x8
JZ 0x00124bea
MOV R13,RDI
MOV R12,RSI
MOV EDX,R15D
MOV R14,R8
CALL 0x00139c38
TEST EAX,EAX
JZ 0x00124bd6
MOV R8,R14
MOV EBX,dword ptr [RSP + 0x1c]
MOV EAX,dword ptr [R14 + 0x40]
CMP EBX,EAX
JNC 0x00124bd6
MOVZX ECX,word ptr [R8 + 0x6]
CMP ECX,0x8
JZ 0x001248ef
CMP ECX,0x2
JNZ 0x00124c55
LAB_001248ef:
DEC EAX
CMP EBX,EAX
JZ 0x00124c30
MOV RDI,R13
MOV RSI,R8
CALL 0x00123de7
TEST EAX,EAX
JNZ 0x00124bd9
MOV R8,R14
PUSH 0x1
POP RDX
MOV RDI,R13
MOV RSI,R12
JMP 0x0012485a
LAB_0012491d:
XOR EBP,EBP
BT EAX,0x1a
JNC 0x00124bd9
MOV RDX,RSP
MOV R15,RDI
MOV RSI,R8
MOV RBP,R8
CALL 0x001239e5
TEST EAX,EAX
JZ 0x00124945
PUSH -0x1
JMP 0x00124bd8
LAB_00124945:
MOV qword ptr [RSP + 0x10],R15
DEC R14
MOV R15,qword ptr [RBP + 0x18]
TEST RBX,RBX
MOV RSI,RBP
JZ 0x00124984
SUB RBX,R12
SHR RBX,0x3
MOV RAX,qword ptr [RSP]
MOV ECX,0x3ffffff
AND ECX,dword ptr [RAX]
MOV EAX,EBX
MOV EDX,0xfc000000
AND EDX,dword ptr [R15 + RAX*0x8 + 0x40]
OR EDX,ECX
MOV dword ptr [R15 + RAX*0x8 + 0x40],EDX
MOV RAX,qword ptr [RSP]
JMP 0x00124993
LAB_00124984:
MOV RAX,qword ptr [RSP]
MOV ECX,0x3ffffff
AND ECX,dword ptr [RAX]
MOV dword ptr [R15 + R13*0x4],ECX
LAB_00124993:
INC dword ptr [R15 + 0x2c]
MOV qword ptr [RSP + 0x8],RSI
MOV RBX,qword ptr [RSI + 0x20]
SHL R14,0x4
LEA RSI,[RBX + R14*0x1]
MOV R12,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [R12 + 0x18]
MOV EDX,dword ptr [RAX]
SHR EDX,0x1a
CALL 0x001390ff
MOV RAX,qword ptr [RSP]
MOV ESI,dword ptr [RAX + 0x4]
MOV RDI,R12
CALL 0x0011e545
MOV RAX,qword ptr [RSP]
AND dword ptr [RAX],0x3ffffff
MOV RAX,qword ptr [RSP]
AND dword ptr [RAX + 0x4],0x0
AND dword ptr [RBX + R14*0x1],0x0
MOV qword ptr [RBX + R14*0x1 + 0x8],0x3
MOV EAX,dword ptr [R15 + 0x2c]
CMP EAX,0x8
JL 0x00124bd6
MOV ECX,dword ptr [R15 + 0x28]
SHR ECX,0x1
CMP EAX,ECX
PUSH 0x1
POP RBP
JC 0x00124bd9
MOV RAX,qword ptr [RSP + 0x8]
MOV RBP,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [RBP + 0x20]
MOV ECX,dword ptr [RBP + 0x28]
SUB ECX,dword ptr [RBP + 0x2c]
CMP ECX,0x3
PUSH 0x2
POP R15
CMOVGE R15D,ECX
INC EAX
LAB_00124a28:
MOV R12D,EAX
SHR EAX,0x1
CMP EAX,R15D
JNC 0x00124a28
MOV EBX,R12D
MOV R14D,R15D
LEA RAX,[RBX*0x4]
MOV qword ptr [RSP + 0x30],RAX
LEA RSI,[RAX + R14*0x8]
ADD RSI,0x40
MOV R13,qword ptr [RSP + 0x10]
MOV RDI,R13
CALL 0x0011adc4
TEST RAX,RAX
JZ 0x00124bd6
MOV qword ptr [RSP + 0x28],R14
DEC R12D
LEA R14,[RAX + RBX*0x4]
MOV RDX,RBX
MOV RBX,RAX
MOV RAX,qword ptr [RBP + 0x8]
MOV RCX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBP + 0x8],XMM0
MOVUPS XMM0,xmmword ptr [RBP + 0x20]
MOVUPS XMM1,xmmword ptr [RBP + 0x30]
MOVUPS xmmword ptr [RBX + RDX*0x4 + 0x30],XMM1
MOVUPS xmmword ptr [RBX + RDX*0x4 + 0x20],XMM0
MOVUPS XMM0,xmmword ptr [RBP]
MOVUPS XMM1,xmmword ptr [RBP + 0x10]
MOVUPS xmmword ptr [RBX + RDX*0x4 + 0x10],XMM1
MOVUPS xmmword ptr [RBX + RDX*0x4],XMM0
LEA RAX,[RBX + RDX*0x4 + 0x8]
MOV RDI,RDX
MOV qword ptr [RSP + 0x20],RDX
MOV RCX,qword ptr [R13 + 0x18]
LEA RDX,[RCX + 0x98]
MOV RSI,qword ptr [RCX + 0x98]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RBX + RDI*0x4 + 0x8],RSI
MOV qword ptr [RBX + RDI*0x4 + 0x10],RDX
MOV qword ptr [RCX + 0x98],RAX
XOR R13D,R13D
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x0010e390
MOV RAX,qword ptr [RSP + 0x20]
LEA RAX,[RBX + RAX*0x4]
ADD RAX,0x40
MOV RCX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RCX + 0x20]
MOV EDX,0xfc000000
MOV ESI,0x3ffffff
MOV RDI,RCX
XOR R8D,R8D
LAB_00124b1a:
MOV R9D,dword ptr [R14 + 0x28]
CMP R13,R9
JNC 0x00124b80
MOV R9D,dword ptr [RBP + R13*0x8 + 0x44]
TEST R9D,R9D
JZ 0x00124b77
MOV dword ptr [RAX + 0x4],R9D
MOV R9D,dword ptr [RBP + R13*0x8 + 0x40]
AND R9D,EDX
MOV R10D,dword ptr [RAX]
AND R10D,ESI
OR R10D,R9D
MOV dword ptr [RAX],R10D
MOV R10D,dword ptr [RBP + R13*0x8 + 0x44]
AND R10D,R12D
NOT R10
MOV R11D,dword ptr [R14 + R10*0x4]
AND R11D,ESI
OR R11D,R9D
MOV dword ptr [RAX],R11D
MOV R9D,R8D
INC R8D
MOV dword ptr [R14 + R10*0x4],R8D
SHL R9,0x4
MOVUPS XMM0,xmmword ptr [RDI]
MOVUPS xmmword ptr [RCX + R9*0x1],XMM0
ADD RAX,0x8
LAB_00124b77:
INC R13
ADD RDI,0x10
JMP 0x00124b1a
LAB_00124b80:
MOV dword ptr [R14 + 0x20],R12D
MOV dword ptr [R14 + 0x24],R15D
AND dword ptr [R14 + 0x2c],0x0
MOV dword ptr [R14 + 0x28],R8D
MOV RBX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x18],R14
MOV EAX,dword ptr [RBP + 0x20]
NOT RAX
LEA RSI,[RAX*0x4]
ADD RSI,RBP
MOV R14,qword ptr [RSP + 0x10]
MOV RDI,R14
CALL 0x0011ae1e
MOV RSI,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
SHL RDX,0x4
MOV RDI,R14
CALL 0x0011ae27
TEST RAX,RAX
JZ 0x00124bd6
MOV qword ptr [RBX + 0x20],RAX
LAB_00124bd6:
PUSH 0x1
LAB_00124bd8:
POP RBP
LAB_00124bd9:
MOV EAX,EBP
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00124bea:
MOV RAX,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOVZX ECX,word ptr [R8 + 0x6]
IMUL RCX,RCX,0x28
MOV RAX,qword ptr [RAX + RCX*0x1 + 0x20]
TEST RAX,RAX
JZ 0x00124c2c
MOV RAX,qword ptr [RAX + 0x10]
MOV EBP,EDX
TEST RAX,RAX
JZ 0x00124bd9
PUSH -0x1
POP RDX
MOV RSI,R8
MOV ECX,R15D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
LAB_00124c2c:
MOV EBP,EDX
JMP 0x00124bd9
LAB_00124c30:
MOV RAX,qword ptr [R8 + 0x38]
MOV RCX,RBX
SHL RCX,0x4
MOV RSI,qword ptr [RAX + RCX*0x1]
MOV RDX,qword ptr [RAX + RCX*0x1 + 0x8]
MOV RDI,R13
MOV R14,R8
CALL 0x0011bbce
MOV dword ptr [R14 + 0x40],EBX
JMP 0x00124bd6
LAB_00124c55:
XOR EBP,EBP
JMP 0x00124bd9
|
ulong delete_property(long param_1,long param_2,uint param_3)
{
void *pvVar1;
int8 *puVar2;
int8 *puVar3;
long lVar4;
int8 *puVar5;
long *plVar6;
long lVar7;
code *UNRECOVERED_JUMPTABLE;
int8 uVar8;
int8 uVar9;
int8 uVar10;
uint uVar11;
int iVar12;
uint uVar13;
void *__s;
uint *puVar14;
long lVar15;
uint uVar16;
int8 *puVar17;
ulong uVar18;
ulong uVar19;
ulong uVar20;
ulong uVar21;
long lVar22;
ulong uStack_70;
uint *local_68;
long local_60;
long local_58;
uint local_4c;
ulong local_48;
ulong local_40;
size_t local_38;
do {
uStack_70 = 1;
lVar4 = *(long *)(param_2 + 0x18);
uVar20 = ~(ulong)(*(uint *)(lVar4 + 0x20) & param_3);
uVar11 = *(uint *)(lVar4 + uVar20 * 4);
puVar14 = (uint *)0x0;
LAB_00124873:
if (uVar11 != 0) {
lVar15 = lVar4 + 0x40 + (ulong)uVar11 * 8;
local_68 = (uint *)(lVar15 + -8);
if (*(uint *)(lVar15 + -4) != param_3) break;
uStack_70 = 0;
if ((*local_68 >> 0x1a & 1) == 0) goto LAB_00124bd9;
iVar12 = js_shape_prepare_update(param_1,param_2,&local_68);
if (iVar12 != 0) {
uStack_70 = 0xffffffffffffffff;
goto LAB_00124bd9;
}
lVar15 = *(long *)(param_2 + 0x18);
if (puVar14 == (uint *)0x0) {
*(uint *)(lVar15 + uVar20 * 4) = *local_68 & 0x3ffffff;
}
else {
uVar20 = (ulong)((long)puVar14 - (lVar4 + 0x40)) >> 3 & 0xffffffff;
*(uint *)(lVar15 + 0x40 + uVar20 * 8) =
*(uint *)(lVar15 + 0x40 + uVar20 * 8) & 0xfc000000 | *local_68 & 0x3ffffff;
}
*(int *)(lVar15 + 0x2c) = *(int *)(lVar15 + 0x2c) + 1;
lVar4 = *(long *)(param_2 + 0x20);
lVar22 = ((ulong)uVar11 - 1) * 0x10;
local_60 = param_2;
local_58 = param_1;
free_property(*(int8 *)(param_1 + 0x18),lVar4 + lVar22,*local_68 >> 0x1a);
JS_FreeAtom(param_1,local_68[1]);
lVar7 = local_58;
*local_68 = *local_68 & 0x3ffffff;
local_68[1] = 0;
*(int4 *)(lVar4 + lVar22) = 0;
*(int8 *)(lVar4 + 8 + lVar22) = 3;
if ((int)*(uint *)(lVar15 + 0x2c) < 8) goto LAB_00124bd6;
uStack_70 = 1;
if (*(uint *)(lVar15 + 0x28) >> 1 <= *(uint *)(lVar15 + 0x2c)) {
puVar5 = *(int8 **)(local_60 + 0x18);
uVar16 = *(int *)(puVar5 + 5) - *(int *)((long)puVar5 + 0x2c);
uVar11 = 2;
if (2 < (int)uVar16) {
uVar11 = uVar16;
}
uVar16 = *(int *)(puVar5 + 4) + 1;
do {
uVar13 = uVar16;
uVar20 = (ulong)uVar13;
uVar16 = uVar13 >> 1;
} while (uVar11 <= uVar13 >> 1);
local_38 = uVar20 * 4;
__s = (void *)js_malloc(local_58,local_38 + (ulong)uVar11 * 8 + 0x40);
if (__s != (void *)0x0) {
pvVar1 = (void *)((long)__s + uVar20 * 4);
lVar4 = puVar5[1];
plVar6 = (long *)puVar5[2];
*(long **)(lVar4 + 8) = plVar6;
*plVar6 = lVar4;
puVar5[1] = 0;
puVar5[2] = 0;
uVar8 = puVar5[4];
uVar9 = puVar5[5];
uVar10 = puVar5[7];
puVar3 = (int8 *)((long)__s + uVar20 * 4 + 0x30);
*puVar3 = puVar5[6];
puVar3[1] = uVar10;
puVar3 = (int8 *)((long)__s + uVar20 * 4 + 0x20);
*puVar3 = uVar8;
puVar3[1] = uVar9;
uVar8 = *puVar5;
uVar9 = puVar5[1];
uVar10 = puVar5[3];
puVar3 = (int8 *)((long)__s + uVar20 * 4 + 0x10);
*puVar3 = puVar5[2];
puVar3[1] = uVar10;
puVar3 = (int8 *)((long)__s + uVar20 * 4);
*puVar3 = uVar8;
puVar3[1] = uVar9;
lVar4 = (long)__s + uVar20 * 4 + 8;
lVar15 = *(long *)(lVar7 + 0x18);
lVar7 = *(long *)(lVar15 + 0x98);
*(long *)(lVar7 + 8) = lVar4;
*(long *)((long)__s + uVar20 * 4 + 8) = lVar7;
*(long *)((long)__s + uVar20 * 4 + 0x10) = lVar15 + 0x98;
*(long *)(lVar15 + 0x98) = lVar4;
local_48 = uVar20;
local_40 = (ulong)uVar11;
memset(__s,0,local_38);
lVar15 = local_58;
lVar4 = local_60;
puVar14 = (uint *)((long)__s + local_48 * 4 + 0x40);
puVar3 = *(int8 **)(local_60 + 0x20);
puVar17 = puVar3;
uVar20 = 0;
for (uVar21 = 0; uVar21 < *(uint *)((long)pvVar1 + 0x28); uVar21 = uVar21 + 1) {
uVar16 = *(uint *)((long)puVar5 + uVar21 * 8 + 0x44);
uVar18 = uVar20;
if (uVar16 != 0) {
puVar14[1] = uVar16;
uVar16 = *(uint *)(puVar5 + uVar21 + 8);
*puVar14 = *puVar14 & 0x3ffffff | uVar16 & 0xfc000000;
uVar19 = ~(ulong)(*(uint *)((long)puVar5 + uVar21 * 8 + 0x44) & uVar13 - 1);
*puVar14 = *(uint *)((long)pvVar1 + uVar19 * 4) & 0x3ffffff | uVar16 & 0xfc000000;
uVar16 = (int)uVar20 + 1;
uVar18 = (ulong)uVar16;
*(uint *)((long)pvVar1 + uVar19 * 4) = uVar16;
uVar8 = puVar17[1];
puVar2 = puVar3 + uVar20 * 2;
*puVar2 = *puVar17;
puVar2[1] = uVar8;
puVar14 = puVar14 + 2;
}
puVar17 = puVar17 + 2;
uVar20 = uVar18;
}
*(uint *)((long)pvVar1 + 0x20) = uVar13 - 1;
*(uint *)((long)pvVar1 + 0x24) = uVar11;
*(int4 *)((long)pvVar1 + 0x2c) = 0;
*(int *)((long)pvVar1 + 0x28) = (int)uVar20;
*(void **)(local_60 + 0x18) = pvVar1;
js_free(local_58,~(ulong)*(uint *)(puVar5 + 4) * 4 + (long)puVar5);
lVar15 = js_realloc(lVar15,*(int8 *)(lVar4 + 0x20),local_40 << 4);
if (lVar15 != 0) {
*(long *)(lVar4 + 0x20) = lVar15;
}
}
goto LAB_00124bd6;
}
goto LAB_00124bd9;
}
if ((*(byte *)(param_2 + 5) & 4) == 0) {
LAB_00124c2c:
uStack_70 = 1;
goto LAB_00124bd9;
}
if ((*(byte *)(param_2 + 5) & 8) == 0) {
lVar4 = *(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 0x20 +
(ulong)*(ushort *)(param_2 + 6) * 0x28);
if (lVar4 == 0) goto LAB_00124c2c;
UNRECOVERED_JUMPTABLE = *(code **)(lVar4 + 0x10);
if (UNRECOVERED_JUMPTABLE != (code *)0x0) {
/* WARNING: Could not recover jumptable at 0x00124c2a. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar20 = (*UNRECOVERED_JUMPTABLE)(param_1,param_2,0xffffffffffffffff,param_3);
return uVar20;
}
goto LAB_00124bd9;
}
iVar12 = JS_AtomIsArrayIndex(param_1,&local_4c,param_3);
if (iVar12 == 0) goto LAB_00124bd6;
if (*(uint *)(param_2 + 0x40) <= local_4c) goto LAB_00124bd6;
if ((*(short *)(param_2 + 6) != 8) && (*(short *)(param_2 + 6) != 2)) {
uStack_70 = 0;
goto LAB_00124bd9;
}
if (local_4c == *(uint *)(param_2 + 0x40) - 1) {
JS_FreeValue(param_1,*(int8 *)(*(long *)(param_2 + 0x38) + (ulong)local_4c * 0x10),
*(int8 *)(*(long *)(param_2 + 0x38) + 8 + (ulong)local_4c * 0x10));
*(uint *)(param_2 + 0x40) = local_4c;
LAB_00124bd6:
uStack_70 = 1;
LAB_00124bd9:
return uStack_70 & 0xffffffff;
}
iVar12 = convert_fast_array_to_array(param_1,param_2);
uStack_70 = 0xffffffffffffffff;
if (iVar12 != 0) goto LAB_00124bd9;
} while( true );
uVar11 = *local_68 & 0x3ffffff;
puVar14 = local_68;
goto LAB_00124873;
}
|
|
16,032
|
test_bug19671
|
eloqsql/tests/mysql_client_test.c
|
static void test_bug19671()
{
MYSQL_RES *result;
int rc;
myheader("test_bug19671");
mysql_query(mysql, "set sql_mode=''");
rc= mysql_query(mysql, "drop table if exists t1");
myquery(rc);
rc= mysql_query(mysql, "drop view if exists v1");
myquery(rc);
rc= mysql_query(mysql, "create table t1(f1 int)");
myquery(rc);
rc= mysql_query(mysql, "create view v1 as select va.* from t1 va");
myquery(rc);
result= mysql_list_fields(mysql, "v1", NULL);
mytest(result);
rc= my_process_result_set(result);
DIE_UNLESS(rc == 0);
verify_prepare_field(result, 0, "f1", "f1", MYSQL_TYPE_LONG,
"v1", "v1", current_db, 11, NULL);
mysql_free_result(result);
myquery(mysql_query(mysql, "drop view v1"));
myquery(mysql_query(mysql, "drop table t1"));
}
|
O0
|
c
|
test_bug19671:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
jmp 0x7fa9a
movsbl 0x3eaa30(%rip), %eax # 0x46a4d1
cmpl $0x2, %eax
jge 0x7fb22
movq 0x22f52b(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0xae86d(%rip), %rsi # 0x12e324
movb $0x0, %al
callq 0x3a1c0
movq 0x22f513(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
movl 0x3eac4e(%rip), %edx # 0x46a71c
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x3eac43(%rip) # 0x46a71c
movl 0x3eac39(%rip), %ecx # 0x46a718
movl 0x3eaa16(%rip), %r8d # 0x46a4fc
leaq 0xafb3f(%rip), %rsi # 0x12f62c
leaq 0xaf64d(%rip), %r9 # 0x12f141
movb $0x0, %al
callq 0x3a1c0
movq 0x22f4d6(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
leaq 0xae850(%rip), %rsi # 0x12e35c
movb $0x0, %al
callq 0x3a1c0
movq 0x22f4be(%rip), %rax # 0x2aefd8
movq (%rax), %rdi
callq 0x3a4a0
movq 0x3ea9af(%rip), %rdi # 0x46a4d8
leaq 0xbb62c(%rip), %rsi # 0x13b15c
callq 0x3b3d0
movq 0x3ea99c(%rip), %rdi # 0x46a4d8
leaq 0xb01ea(%rip), %rsi # 0x12fd2d
callq 0x3b3d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x7fb60
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x10(%rbp)
jne 0x7fb68
jmp 0x7fb80
leaq 0xae09d(%rip), %rdi # 0x12dc0c
movl $0x2193, %esi # imm = 0x2193
leaq 0xc43f4(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3ea951(%rip), %rdi # 0x46a4d8
leaq 0xc0ee3(%rip), %rsi # 0x140a71
callq 0x3b3d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x7fbab
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x14(%rbp)
jne 0x7fbb3
jmp 0x7fbcb
leaq 0xae052(%rip), %rdi # 0x12dc0c
movl $0x2196, %esi # imm = 0x2196
leaq 0xc43a9(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3ea906(%rip), %rdi # 0x46a4d8
leaq 0xc0eaf(%rip), %rsi # 0x140a88
callq 0x3b3d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x7fbf6
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x18(%rbp)
jne 0x7fbfe
jmp 0x7fc16
leaq 0xae007(%rip), %rdi # 0x12dc0c
movl $0x2199, %esi # imm = 0x2199
leaq 0xc435e(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3ea8bb(%rip), %rdi # 0x46a4d8
leaq 0xc0e7c(%rip), %rsi # 0x140aa0
callq 0x3b3d0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7fc41
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x1c(%rbp)
jne 0x7fc49
jmp 0x7fc61
leaq 0xadfbc(%rip), %rdi # 0x12dc0c
movl $0x219c, %esi # imm = 0x219C
leaq 0xc4313(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3ea870(%rip), %rdi # 0x46a4d8
leaq 0xbcb74(%rip), %rsi # 0x13c7e3
xorl %eax, %eax
movl %eax, %edx
callq 0xa87a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7fca4
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
leaq 0xadf79(%rip), %rdi # 0x12dc0c
movl $0x219f, %esi # imm = 0x219F
leaq 0xadd3d(%rip), %rdx # 0x12d9dc
callq 0x3c010
movq -0x8(%rbp), %rdi
callq 0x3c860
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x7fcb8
jmp 0x7fcd0
leaq 0xadf4d(%rip), %rdi # 0x12dc0c
movl $0x21a2, %esi # imm = 0x21A2
leaq 0xb9b41(%rip), %rdx # 0x13980c
callq 0x3c010
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0xafd0f(%rip), %rcx # 0x12f9ec
movl $0x3, %r8d
leaq 0xbcaf9(%rip), %r11 # 0x13c7e3
leaq 0x22fd23(%rip), %r10 # 0x2afa14
xorl %eax, %eax
leaq 0xadf12(%rip), %rax # 0x12dc0c
movq %rcx, %rdx
movq %r11, %r9
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq $0xb, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movl $0x21a5, 0x28(%rsp) # imm = 0x21A5
callq 0x51600
movq -0x8(%rbp), %rdi
callq 0x3b280
movq 0x3ea79b(%rip), %rdi # 0x46a4d8
leaq 0xbdd45(%rip), %rsi # 0x13da89
callq 0x3b3d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x7fd5b
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x20(%rbp)
jne 0x7fd63
jmp 0x7fd7b
leaq 0xadea2(%rip), %rdi # 0x12dc0c
movl $0x21a8, %esi # imm = 0x21A8
leaq 0xc41f9(%rip), %rdx # 0x143f6f
callq 0x3c010
movq 0x3ea756(%rip), %rdi # 0x46a4d8
leaq 0xafdef(%rip), %rsi # 0x12fb78
callq 0x3b3d0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x7fda0
xorl %eax, %eax
movl %eax, %edi
callq 0x3bf10
cmpl $0x0, -0x24(%rbp)
jne 0x7fda8
jmp 0x7fdc0
leaq 0xade5d(%rip), %rdi # 0x12dc0c
movl $0x21a9, %esi # imm = 0x21A9
leaq 0xc41b4(%rip), %rdx # 0x143f6f
callq 0x3c010
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
test_bug19671:
push rbp
mov rbp, rsp
sub rsp, 60h
jmp short $+2
loc_7FA9A:
movsx eax, cs:opt_silent
cmp eax, 2
jge short loc_7FB22
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E324; "\n\n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov edx, cs:test_count
mov eax, edx
add eax, 1
mov cs:test_count, eax
mov ecx, cs:iter_count
mov r8d, cs:opt_count
lea rsi, aUOfUUS; "%u of (%u/%u): %s"
lea r9, aTestBug19671; "test_bug19671"
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
lea rsi, asc_12E35C; " \n###################################"...
mov al, 0
call _fprintf
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
loc_7FB22:
mov rdi, cs:mysql
lea rsi, aSetSqlMode_1; "set sql_mode=''"
call wrap_mysql_query
mov rdi, cs:mysql
lea rsi, aDropTableIfExi_2; "drop table if exists t1"
call wrap_mysql_query
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
mov [rbp+var_10], eax
cmp [rbp+var_10], 0
jz short loc_7FB60
xor eax, eax
mov edi, eax
call print_error
loc_7FB60:
cmp [rbp+var_10], 0
jnz short loc_7FB68
jmp short loc_7FB80
loc_7FB68:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 2193h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_7FB80:
mov rdi, cs:mysql
lea rsi, aDropViewIfExis_9; "drop view if exists v1"
call wrap_mysql_query
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jz short loc_7FBAB
xor eax, eax
mov edi, eax
call print_error
loc_7FBAB:
cmp [rbp+var_14], 0
jnz short loc_7FBB3
jmp short loc_7FBCB
loc_7FBB3:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 2196h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_7FBCB:
mov rdi, cs:mysql
lea rsi, aCreateTableT1F_6; "create table t1(f1 int)"
call wrap_mysql_query
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
mov [rbp+var_18], eax
cmp [rbp+var_18], 0
jz short loc_7FBF6
xor eax, eax
mov edi, eax
call print_error
loc_7FBF6:
cmp [rbp+var_18], 0
jnz short loc_7FBFE
jmp short loc_7FC16
loc_7FBFE:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 2199h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_7FC16:
mov rdi, cs:mysql
lea rsi, aCreateViewV1As_5; "create view v1 as select va.* from t1 v"...
call wrap_mysql_query
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_7FC41
xor eax, eax
mov edi, eax
call print_error
loc_7FC41:
cmp [rbp+var_1C], 0
jnz short loc_7FC49
jmp short loc_7FC61
loc_7FC49:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 219Ch
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_7FC61:
mov rdi, cs:mysql
lea rsi, aDropTableIfExi_71+19h; "v1"
xor eax, eax
mov edx, eax
call mysql_list_fields
mov [rbp+var_8], rax
cmp [rbp+var_8], 0
jnz short loc_7FCA4
xor eax, eax
mov edi, eax
call print_error
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 219Fh
lea rdx, aFalse; "FALSE"
call die
loc_7FCA4:
mov rdi, [rbp+var_8]
call my_process_result_set
mov [rbp+var_C], eax
cmp [rbp+var_C], 0
jnz short loc_7FCB8
jmp short loc_7FCD0
loc_7FCB8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 21A2h
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
call die
loc_7FCD0:
mov rdi, [rbp+var_8]
xor esi, esi
lea rcx, aDropFunctionF1+0Eh; "f1"
mov r8d, 3
lea r11, aDropTableIfExi_71+19h; "v1"
lea r10, current_db; "client_test_db"
xor eax, eax
lea rax, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rdx, rcx
mov r9, r11
mov [rsp+60h+var_60], r11
mov [rsp+60h+var_58], r10
mov [rsp+60h+var_50], 0Bh
mov [rsp+60h+var_48], 0
mov [rsp+60h+var_40], rax
mov [rsp+60h+var_38], 21A5h
call do_verify_prepare_field
mov rdi, [rbp+var_8]
call wrap_mysql_free_result
mov rdi, cs:mysql
lea rsi, aDropViewV1_0; "drop view v1"
call wrap_mysql_query
mov [rbp+var_20], eax
cmp [rbp+var_20], 0
jz short loc_7FD5B
xor eax, eax
mov edi, eax
call print_error
loc_7FD5B:
cmp [rbp+var_20], 0
jnz short loc_7FD63
jmp short loc_7FD7B
loc_7FD63:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 21A8h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_7FD7B:
mov rdi, cs:mysql
lea rsi, aDropTableT1_0; "drop table t1"
call wrap_mysql_query
mov [rbp+var_24], eax
cmp [rbp+var_24], 0
jz short loc_7FDA0
xor eax, eax
mov edi, eax
call print_error
loc_7FDA0:
cmp [rbp+var_24], 0
jnz short loc_7FDA8
jmp short loc_7FDC0
loc_7FDA8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 21A9h
lea rdx, aTmIYear0+9; "r == 0"
call die
loc_7FDC0:
add rsp, 60h
pop rbp
retn
|
void test_bug19671()
{
int v0; // edx
long long v1; // [rsp+58h] [rbp-8h]
if ( opt_silent < 2 )
{
fprintf(stdout, "\n\n#####################################\n");
v0 = test_count++;
fprintf(stdout, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_bug19671");
fprintf(stdout, " \n#####################################\n");
fflush(stdout);
}
wrap_mysql_query(mysql, (long long)"set sql_mode=''");
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"drop table if exists t1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8595, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"drop view if exists v1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8598, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"create table t1(f1 int)") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8601, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"create view v1 as select va.* from t1 va") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8604, "r == 0");
}
v1 = mysql_list_fields(mysql, "v1", 0LL);
if ( !v1 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8607, "FALSE");
}
if ( (unsigned int)my_process_result_set(v1) )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8610, "rc == 0");
do_verify_prepare_field(
v1,
0,
"f1",
"f1",
3,
"v1",
"v1",
current_db,
11LL,
0LL,
"/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",
8613);
wrap_mysql_free_result(v1);
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"drop view v1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8616, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"drop table t1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8617, "r == 0");
}
}
|
test_bug19671:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
JMP 0x0017fa9a
LAB_0017fa9a:
MOVSX EAX,byte ptr [0x0056a4d1]
CMP EAX,0x2
JGE 0x0017fb22
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e324]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
MOV EDX,dword ptr [0x0056a71c]
MOV EAX,EDX
ADD EAX,0x1
MOV dword ptr [0x0056a71c],EAX
MOV ECX,dword ptr [0x0056a718]
MOV R8D,dword ptr [0x0056a4fc]
LEA RSI,[0x22f62c]
LEA R9,[0x22f141]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x22e35c]
MOV AL,0x0
CALL 0x0013a1c0
MOV RAX,qword ptr [0x003aefd8]
MOV RDI,qword ptr [RAX]
CALL 0x0013a4a0
LAB_0017fb22:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x23b15c]
CALL 0x0013b3d0
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x22fd2d]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x10],EAX
CMP dword ptr [RBP + -0x10],0x0
JZ 0x0017fb60
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0017fb60:
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0017fb68
JMP 0x0017fb80
LAB_0017fb68:
LEA RDI,[0x22dc0c]
MOV ESI,0x2193
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0017fb80:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x240a71]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x0017fbab
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0017fbab:
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0017fbb3
JMP 0x0017fbcb
LAB_0017fbb3:
LEA RDI,[0x22dc0c]
MOV ESI,0x2196
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0017fbcb:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x240a88]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x18],0x0
JZ 0x0017fbf6
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0017fbf6:
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x0017fbfe
JMP 0x0017fc16
LAB_0017fbfe:
LEA RDI,[0x22dc0c]
MOV ESI,0x2199
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0017fc16:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x240aa0]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0017fc41
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0017fc41:
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x0017fc49
JMP 0x0017fc61
LAB_0017fc49:
LEA RDI,[0x22dc0c]
MOV ESI,0x219c
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0017fc61:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x23c7e3]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001a87a0
MOV qword ptr [RBP + -0x8],RAX
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0017fca4
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LEA RDI,[0x22dc0c]
MOV ESI,0x219f
LEA RDX,[0x22d9dc]
CALL 0x0013c010
LAB_0017fca4:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013c860
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0017fcb8
JMP 0x0017fcd0
LAB_0017fcb8:
LEA RDI,[0x22dc0c]
MOV ESI,0x21a2
LEA RDX,[0x23980c]
CALL 0x0013c010
LAB_0017fcd0:
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
LEA RCX,[0x22f9ec]
MOV R8D,0x3
LEA R11,[0x23c7e3]
LEA R10,[0x3afa14]
XOR EAX,EAX
LEA RAX,[0x22dc0c]
MOV RDX,RCX
MOV R9,R11
MOV qword ptr [RSP],R11
MOV qword ptr [RSP + 0x8],R10
MOV qword ptr [RSP + 0x10],0xb
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x28],0x21a5
CALL 0x00151600
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0013b280
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x23da89]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x20],EAX
CMP dword ptr [RBP + -0x20],0x0
JZ 0x0017fd5b
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0017fd5b:
CMP dword ptr [RBP + -0x20],0x0
JNZ 0x0017fd63
JMP 0x0017fd7b
LAB_0017fd63:
LEA RDI,[0x22dc0c]
MOV ESI,0x21a8
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0017fd7b:
MOV RDI,qword ptr [0x0056a4d8]
LEA RSI,[0x22fb78]
CALL 0x0013b3d0
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0017fda0
XOR EAX,EAX
MOV EDI,EAX
CALL 0x0013bf10
LAB_0017fda0:
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x0017fda8
JMP 0x0017fdc0
LAB_0017fda8:
LEA RDI,[0x22dc0c]
MOV ESI,0x21a9
LEA RDX,[0x243f6f]
CALL 0x0013c010
LAB_0017fdc0:
ADD RSP,0x60
POP RBP
RET
|
void test_bug19671(void)
{
int iVar1;
long lVar2;
ulong uVar3;
if (opt_silent < '\x02') {
fprintf(*(FILE **)PTR_stdout_003aefd8,"\n\n#####################################\n");
uVar3 = (ulong)test_count;
test_count = test_count + 1;
fprintf(*(FILE **)PTR_stdout_003aefd8,"%u of (%u/%u): %s",uVar3,(ulong)iter_count,
(ulong)opt_count,"test_bug19671");
fprintf(*(FILE **)PTR_stdout_003aefd8," \n#####################################\n");
fflush(*(FILE **)PTR_stdout_003aefd8);
}
wrap_mysql_query(mysql,"set sql_mode=\'\'");
iVar1 = wrap_mysql_query(mysql,"drop table if exists t1");
if (iVar1 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2193,"r == 0");
}
iVar1 = wrap_mysql_query(mysql,"drop view if exists v1");
if (iVar1 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2196,"r == 0");
}
iVar1 = wrap_mysql_query(mysql,"create table t1(f1 int)");
if (iVar1 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2199,"r == 0");
}
iVar1 = wrap_mysql_query(mysql,"create view v1 as select va.* from t1 va");
if (iVar1 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x219c,"r == 0");
}
lVar2 = mysql_list_fields(mysql,"v1",0);
if (lVar2 == 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x219f,"FALSE");
}
iVar1 = my_process_result_set(lVar2);
if (iVar1 != 0) {
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x21a2,"rc == 0");
}
do_verify_prepare_field
(lVar2,0,"f1","f1",3,"v1","v1",current_db,0xb,0,
"/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x21a5);
wrap_mysql_free_result(lVar2);
iVar1 = wrap_mysql_query(mysql,"drop view v1");
if (iVar1 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x21a8,"r == 0");
}
iVar1 = wrap_mysql_query(mysql,"drop table t1");
if (iVar1 != 0) {
print_error(0);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x21a9,"r == 0");
}
return;
}
|
|
16,033
|
mthd_my_send_cmd
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int
mthd_my_send_cmd(MYSQL *mysql,enum enum_server_command command, const char *arg,
size_t length, my_bool skip_check, void *opt_arg)
{
NET *net= &mysql->net;
int result= -1;
if (mysql->net.pvio == 0)
{
/* Do reconnect if possible */
if (mariadb_reconnect(mysql))
return(1);
}
if (mysql->status != MYSQL_STATUS_READY ||
mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
goto end;
}
if (IS_CONNHDLR_ACTIVE(mysql))
{
result= mysql->extension->conn_hdlr->plugin->set_connection(mysql, command, arg, length, skip_check, opt_arg);
if (result== -1)
return(result);
}
CLEAR_CLIENT_ERROR(mysql);
if (command == COM_QUERY ||
command == COM_STMT_PREPARE)
{
if ((mysql->options.client_flag & CLIENT_LOCAL_FILES) &&
mysql->options.extension && mysql->extension->auto_local_infile == WAIT_FOR_QUERY &&
arg && (*arg == 'l' || *arg == 'L'))
{
if (strncasecmp(arg, "load", 4) == 0)
mysql->extension->auto_local_infile= ACCEPT_FILE_REQUEST;
}
}
mysql->info=0;
mysql->affected_rows= ~(unsigned long long) 0;
ma_net_clear(net); /* Clear receive buffer */
if (!arg)
arg="";
if (net->extension->multi_status== COM_MULTI_ENABLED)
{
return net_add_multi_command(net, command, (const uchar *)arg, length);
}
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
{
my_set_error(mysql, CR_NET_PACKET_TOO_LARGE, SQLSTATE_UNKNOWN, 0);
goto end;
}
end_server(mysql);
if (mariadb_reconnect(mysql))
goto end;
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
goto end;
}
}
result=0;
if (net->extension->multi_status > COM_MULTI_OFF)
skip_check= 1;
if (!skip_check)
{
result= ((mysql->packet_length=ma_net_safe_read(mysql)) == packet_error ?
1 : 0);
}
end:
return(result);
}
|
O3
|
c
|
mthd_my_send_cmd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x15d35
cmpl $0x0, 0x488(%rbx)
jne 0x15cdb
testb $0x8, 0x380(%rbx)
jne 0x15cdb
movq 0x4f0(%rbx), %rax
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
testq %rax, %rax
movq %rcx, -0x30(%rbp)
je 0x15be3
movq (%rax), %rax
testq %rax, %rax
je 0x15be3
movq (%rax), %rax
movl %r8d, %r14d
movsbl %r14b, %r8d
movq %rbx, %rdi
movl %esi, %r13d
movq %r12, %rdx
callq *0x70(%rax)
movl %r13d, %esi
movl %r14d, %r8d
movl %eax, %r13d
cmpl $-0x1, %eax
je 0x15d2d
movl %r8d, -0x34(%rbp)
movl $0x0, 0x90(%rbx)
movl $0x30303030, 0x297(%rbx) # imm = 0x30303030
movw $0x30, 0x29b(%rbx)
movb $0x0, 0x97(%rbx)
movq 0x2a0(%rbx), %rax
testq %rax, %rax
je 0x15c1e
movl $0x0, 0x4(%rax)
cmpl $0x16, %esi
je 0x15c28
cmpl $0x3, %esi
jne 0x15c7e
testb $-0x80, 0x3a8(%rbx)
je 0x15c7e
cmpq $0x0, 0x480(%rbx)
je 0x15c7e
testq %r12, %r12
je 0x15c7e
movq 0x4f0(%rbx), %r14
cmpb $0x1, 0x78(%r14)
jne 0x15c7e
movzbl (%r12), %eax
orl $0x20, %eax
cmpl $0x6c, %eax
jne 0x15c7e
movl %esi, %r15d
leaq 0x1ebf9(%rip), %rsi # 0x3485e
movl $0x4, %edx
movq %r12, %rdi
callq 0x135c0
movl %r15d, %esi
testl %eax, %eax
jne 0x15c7e
movb $0x2, 0x78(%r14)
movl %esi, %r14d
movq $0x0, 0x2e0(%rbx)
movq $-0x1, 0x338(%rbx)
movq %rbx, %rdi
callq 0x31384
testq %r12, %r12
leaq 0x1e936(%rip), %rdx # 0x345df
cmovneq %r12, %rdx
movq 0x2a0(%rbx), %rax
cmpl $0x2, (%rax)
jne 0x15d7d
movzbl %r14b, %esi
movq %rbx, %rdi
movq -0x30(%rbp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x31d26
movl $0x7de, 0x90(%rbx) # imm = 0x7DE
leaq 0x297(%rbx), %rdi
leaq 0x32dcd(%rip), %rax # 0x48ac0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x29c(%rbx)
leaq 0x97(%rbx), %rdi
leaq 0x32db8(%rip), %rax # 0x48ad0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r14b, 0x296(%rbx)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x15d6b
movq %rbx, %rdi
movl %r8d, %r14d
movq %rcx, %r13
movq %r12, -0x40(%rbp)
movl %esi, %r12d
movq %r9, %r15
callq 0x15e7c
movq %r15, %r9
movl %r12d, %esi
movq -0x40(%rbp), %r12
movq %r13, %rcx
movl %r14d, %r8d
movl $0x1, %r14d
testb %al, %al
je 0x15b83
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rax
movq %rax, %rcx
testq %rax, %rax
movl %r14d, %esi
movq %rdx, %r12
jne 0x15da0
movq %rdx, %rdi
callq 0x131c0
movq %r12, %rdx
movl %r14d, %esi
movq %rax, %rcx
movzbl %sil, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r15d, %esi
xorl %r8d, %r8d
callq 0x31805
testl %eax, %eax
je 0x15e3f
cmpl $0x481, 0x90(%rbx) # imm = 0x481
jne 0x15de6
leaq 0x32cf0(%rip), %rax # 0x48ac0
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x7e4, %esi # imm = 0x7E4
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x15981
jmp 0x15dfa
movq %rbx, %rdi
callq 0x1594e
movq %rbx, %rdi
callq 0x15e7c
testb %al, %al
je 0x15e02
movl %r13d, %r14d
jmp 0x15d6b
movq -0x30(%rbp), %rcx
testq %rcx, %rcx
jne 0x15e16
movq %r12, %rdi
callq 0x131c0
movq %rax, %rcx
movq %rbx, %rdi
movl %r15d, %esi
movq %r12, %rdx
xorl %r8d, %r8d
callq 0x31805
testl %eax, %eax
je 0x15e3f
leaq 0x32c8e(%rip), %rax # 0x48ac0
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x7d6, %esi # imm = 0x7D6
jmp 0x15ddb
cmpb $0x0, -0x34(%rbp)
jne 0x15d6b
movq 0x2a0(%rbx), %rax
cmpl $0x0, (%rax)
jne 0x15d6b
movq %rbx, %rdi
callq 0x156e7
movq %rax, 0x358(%rbx)
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
xorl %r14d, %r14d
cmpq %rcx, %rax
sete %r14b
jmp 0x15d6b
|
mthd_my_send_cmd:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r12, rdx
mov rbx, rdi
cmp qword ptr [rdi], 0
jz loc_15D35
loc_15B83:
cmp dword ptr [rbx+488h], 0
jnz loc_15CDB
test byte ptr [rbx+380h], 8
jnz loc_15CDB
mov rax, [rbx+4F0h]
mov r13d, 0FFFFFFFFh
test rax, rax
mov [rbp+var_30], rcx
jz short loc_15BE3
mov rax, [rax]
test rax, rax
jz short loc_15BE3
mov rax, [rax]
mov r14d, r8d
movsx r8d, r14b
mov rdi, rbx
mov r13d, esi
mov rdx, r12
call qword ptr [rax+70h]
mov esi, r13d
mov r8d, r14d
mov r13d, eax
cmp eax, 0FFFFFFFFh
jz loc_15D2D
loc_15BE3:
mov [rbp+var_34], r8d
mov dword ptr [rbx+90h], 0
mov dword ptr [rbx+297h], 30303030h
mov word ptr [rbx+29Bh], 30h ; '0'
mov byte ptr [rbx+97h], 0
mov rax, [rbx+2A0h]
test rax, rax
jz short loc_15C1E
mov dword ptr [rax+4], 0
loc_15C1E:
cmp esi, 16h
jz short loc_15C28
cmp esi, 3
jnz short loc_15C7E
loc_15C28:
test byte ptr [rbx+3A8h], 80h
jz short loc_15C7E
cmp qword ptr [rbx+480h], 0
jz short loc_15C7E
test r12, r12
jz short loc_15C7E
mov r14, [rbx+4F0h]
cmp byte ptr [r14+78h], 1
jnz short loc_15C7E
movzx eax, byte ptr [r12]
or eax, 20h
cmp eax, 6Ch ; 'l'
jnz short loc_15C7E
mov r15d, esi
lea rsi, aLoad; "load"
mov edx, 4
mov rdi, r12
call _strncasecmp
mov esi, r15d
test eax, eax
jnz short loc_15C7E
mov byte ptr [r14+78h], 2
loc_15C7E:
mov r14d, esi
mov qword ptr [rbx+2E0h], 0
mov qword ptr [rbx+338h], 0FFFFFFFFFFFFFFFFh
mov rdi, rbx
call ma_net_clear
test r12, r12
lea rdx, aExecuteTestWit+29h; ""
cmovnz rdx, r12
mov rax, [rbx+2A0h]
cmp dword ptr [rax], 2
jnz loc_15D7D
movzx esi, r14b
mov rdi, rbx
mov rcx, [rbp+var_30]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp net_add_multi_command
loc_15CDB:
mov dword ptr [rbx+90h], 7DEh
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+29Ch], r14b
lea rdi, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov [rbx+296h], r14b
loc_15D2D:
mov r14d, 0FFFFFFFFh
jmp short loc_15D6B
loc_15D35:
mov rdi, rbx
mov r14d, r8d
mov r13, rcx
mov [rbp+var_40], r12
mov r12d, esi
mov r15, r9
call mariadb_reconnect
mov r9, r15
mov esi, r12d
mov r12, [rbp+var_40]
mov rcx, r13
mov r8d, r14d
mov r14d, 1
test al, al
jz loc_15B83
loc_15D6B:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_15D7D:
mov rax, [rbp+var_30]
mov rcx, rax
test rax, rax
mov esi, r14d
mov r12, rdx
jnz short loc_15DA0
mov rdi, rdx
call _strlen
mov rdx, r12
mov esi, r14d
mov rcx, rax
loc_15DA0:
movzx r15d, sil
xor r14d, r14d
mov rdi, rbx
mov esi, r15d
xor r8d, r8d
call ma_net_write_command
test eax, eax
jz loc_15E3F
cmp dword ptr [rbx+90h], 481h
jnz short loc_15DE6
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov rdi, rbx
mov esi, 7E4h
loc_15DDB:
xor ecx, ecx
xor eax, eax
call my_set_error
jmp short loc_15DFA
loc_15DE6:
mov rdi, rbx
call end_server
mov rdi, rbx
call mariadb_reconnect
test al, al
jz short loc_15E02
loc_15DFA:
mov r14d, r13d
jmp loc_15D6B
loc_15E02:
mov rcx, [rbp+var_30]
test rcx, rcx
jnz short loc_15E16
mov rdi, r12
call _strlen
mov rcx, rax
loc_15E16:
mov rdi, rbx
mov esi, r15d
mov rdx, r12
xor r8d, r8d
call ma_net_write_command
test eax, eax
jz short loc_15E3F
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov rdi, rbx
mov esi, 7D6h
jmp short loc_15DDB
loc_15E3F:
cmp byte ptr [rbp+var_34], 0
jnz loc_15D6B
mov rax, [rbx+2A0h]
cmp dword ptr [rax], 0
jnz loc_15D6B
mov rdi, rbx
call ma_net_safe_read
mov [rbx+358h], rax
mov ecx, 0FFFFFFFFh
xor r14d, r14d
cmp rax, rcx
setz r14b
jmp loc_15D6B
|
long long mthd_my_send_cmd(long long a1, long long a2, char *a3, long long a4, char a5)
{
char *v5; // r12
long long *v6; // rax
unsigned int v7; // r13d
long long v8; // rax
char v9; // r14
unsigned int v10; // eax
long long v11; // rax
long long v12; // r14
char *v13; // rdx
unsigned int v15; // r14d
char v16; // r14
long long v17; // r13
char v18; // al
long long v19; // rcx
char *v20; // r12
long long v21; // rax
long long v22; // rdx
long long v23; // rcx
unsigned long long v24; // r8
int v25; // r9d
char *v26; // rdx
int v27; // esi
long long v28; // rcx
unsigned long long v29; // rax
char v31; // [rsp+Ch] [rbp-34h]
long long v32; // [rsp+10h] [rbp-30h]
v5 = a3;
if ( !*(_QWORD *)a1 )
{
v16 = a5;
v17 = a4;
v18 = mariadb_reconnect(a1);
a2 = (unsigned int)a2;
v5 = a3;
a4 = v17;
a5 = v16;
v15 = 1;
if ( v18 )
return v15;
}
if ( *(_DWORD *)(a1 + 1160) || (*(_BYTE *)(a1 + 896) & 8) != 0 )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[14], 511LL);
*(_BYTE *)(a1 + 662) = 0;
}
else
{
v6 = *(long long **)(a1 + 1264);
v7 = -1;
v32 = a4;
if ( !v6
|| (v8 = *v6) == 0
|| (v9 = a5,
v10 = (*(long long ( **)(long long, long long, char *, long long, _QWORD))(*(_QWORD *)v8 + 112LL))(
a1,
a2,
v5,
a4,
(unsigned int)a5),
a5 = v9,
v7 = v10,
v10 != -1) )
{
v31 = a5;
*(_DWORD *)(a1 + 144) = 0;
strcpy((char *)(a1 + 663), "00000");
*(_BYTE *)(a1 + 151) = 0;
v11 = *(_QWORD *)(a1 + 672);
if ( v11 )
*(_DWORD *)(v11 + 4) = 0;
if ( ((_DWORD)a2 == 22 || (_DWORD)a2 == 3) && *(char *)(a1 + 936) < 0 )
{
if ( *(_QWORD *)(a1 + 1152) )
{
if ( v5 )
{
v12 = *(_QWORD *)(a1 + 1264);
if ( *(_BYTE *)(v12 + 120) == 1
&& ((unsigned __int8)*v5 | 0x20) == 0x6C
&& !(unsigned int)strncasecmp(v5, "load", 4LL) )
{
*(_BYTE *)(v12 + 120) = 2;
}
}
}
}
*(_QWORD *)(a1 + 736) = 0LL;
*(_QWORD *)(a1 + 824) = -1LL;
ma_net_clear(a1);
v13 = "";
if ( v5 )
v13 = v5;
if ( **(_DWORD **)(a1 + 672) == 2 )
return net_add_multi_command(a1, (unsigned __int8)a2, v13, v32);
v19 = v32;
v20 = v13;
if ( !v32 )
{
v21 = strlen(v13);
v13 = v20;
v19 = v21;
}
v15 = 0;
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, v13, v19, 0LL) )
{
if ( *(_DWORD *)(a1 + 144) == 1153 )
{
v26 = SQLSTATE_UNKNOWN;
v27 = 2020;
LABEL_31:
my_set_error(a1, v27, (long long)v26, 0LL);
return v7;
}
end_server((long long *)a1);
if ( (unsigned __int8)mariadb_reconnect(a1) )
return v7;
v28 = v32;
if ( !v32 )
v28 = strlen(v20);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, v20, v28, 0LL) )
{
v26 = SQLSTATE_UNKNOWN;
v27 = 2006;
goto LABEL_31;
}
}
if ( !v31 && !**(_DWORD **)(a1 + 672) )
{
v29 = ma_net_safe_read(a1, a2, v22, v23, v24, v25);
*(_QWORD *)(a1 + 856) = v29;
return v29 == 0xFFFFFFFF;
}
return v15;
}
}
return (unsigned int)-1;
}
|
mthd_my_send_cmd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RDX
MOV RBX,RDI
CMP qword ptr [RDI],0x0
JZ 0x00115d35
LAB_00115b83:
CMP dword ptr [RBX + 0x488],0x0
JNZ 0x00115cdb
TEST byte ptr [RBX + 0x380],0x8
JNZ 0x00115cdb
MOV RAX,qword ptr [RBX + 0x4f0]
MOV R13D,0xffffffff
TEST RAX,RAX
MOV qword ptr [RBP + -0x30],RCX
JZ 0x00115be3
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x00115be3
MOV RAX,qword ptr [RAX]
MOV R14D,R8D
MOVSX R8D,R14B
MOV RDI,RBX
MOV R13D,ESI
MOV RDX,R12
CALL qword ptr [RAX + 0x70]
MOV ESI,R13D
MOV R8D,R14D
MOV R13D,EAX
CMP EAX,-0x1
JZ 0x00115d2d
LAB_00115be3:
MOV dword ptr [RBP + -0x34],R8D
MOV dword ptr [RBX + 0x90],0x0
MOV dword ptr [RBX + 0x297],0x30303030
MOV word ptr [RBX + 0x29b],0x30
MOV byte ptr [RBX + 0x97],0x0
MOV RAX,qword ptr [RBX + 0x2a0]
TEST RAX,RAX
JZ 0x00115c1e
MOV dword ptr [RAX + 0x4],0x0
LAB_00115c1e:
CMP ESI,0x16
JZ 0x00115c28
CMP ESI,0x3
JNZ 0x00115c7e
LAB_00115c28:
TEST byte ptr [RBX + 0x3a8],0x80
JZ 0x00115c7e
CMP qword ptr [RBX + 0x480],0x0
JZ 0x00115c7e
TEST R12,R12
JZ 0x00115c7e
MOV R14,qword ptr [RBX + 0x4f0]
CMP byte ptr [R14 + 0x78],0x1
JNZ 0x00115c7e
MOVZX EAX,byte ptr [R12]
OR EAX,0x20
CMP EAX,0x6c
JNZ 0x00115c7e
MOV R15D,ESI
LEA RSI,[0x13485e]
MOV EDX,0x4
MOV RDI,R12
CALL 0x001135c0
MOV ESI,R15D
TEST EAX,EAX
JNZ 0x00115c7e
MOV byte ptr [R14 + 0x78],0x2
LAB_00115c7e:
MOV R14D,ESI
MOV qword ptr [RBX + 0x2e0],0x0
MOV qword ptr [RBX + 0x338],-0x1
MOV RDI,RBX
CALL 0x00131384
TEST R12,R12
LEA RDX,[0x1345df]
CMOVNZ RDX,R12
MOV RAX,qword ptr [RBX + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x00115d7d
MOVZX ESI,R14B
MOV RDI,RBX
MOV RCX,qword ptr [RBP + -0x30]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00131d26
LAB_00115cdb:
MOV dword ptr [RBX + 0x90],0x7de
LEA RDI,[RBX + 0x297]
LEA RAX,[0x148ac0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x29c],R14B
LEA RDI,[RBX + 0x97]
LEA RAX,[0x148ad0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [RBX + 0x296],R14B
LAB_00115d2d:
MOV R14D,0xffffffff
JMP 0x00115d6b
LAB_00115d35:
MOV RDI,RBX
MOV R14D,R8D
MOV R13,RCX
MOV qword ptr [RBP + -0x40],R12
MOV R12D,ESI
MOV R15,R9
CALL 0x00115e7c
MOV R9,R15
MOV ESI,R12D
MOV R12,qword ptr [RBP + -0x40]
MOV RCX,R13
MOV R8D,R14D
MOV R14D,0x1
TEST AL,AL
JZ 0x00115b83
LAB_00115d6b:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00115d7d:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,RAX
TEST RAX,RAX
MOV ESI,R14D
MOV R12,RDX
JNZ 0x00115da0
MOV RDI,RDX
CALL 0x001131c0
MOV RDX,R12
MOV ESI,R14D
MOV RCX,RAX
LAB_00115da0:
MOVZX R15D,SIL
XOR R14D,R14D
MOV RDI,RBX
MOV ESI,R15D
XOR R8D,R8D
CALL 0x00131805
TEST EAX,EAX
JZ 0x00115e3f
CMP dword ptr [RBX + 0x90],0x481
JNZ 0x00115de6
LEA RAX,[0x148ac0]
MOV RDX,qword ptr [RAX]
MOV RDI,RBX
MOV ESI,0x7e4
LAB_00115ddb:
XOR ECX,ECX
XOR EAX,EAX
CALL 0x00115981
JMP 0x00115dfa
LAB_00115de6:
MOV RDI,RBX
CALL 0x0011594e
MOV RDI,RBX
CALL 0x00115e7c
TEST AL,AL
JZ 0x00115e02
LAB_00115dfa:
MOV R14D,R13D
JMP 0x00115d6b
LAB_00115e02:
MOV RCX,qword ptr [RBP + -0x30]
TEST RCX,RCX
JNZ 0x00115e16
MOV RDI,R12
CALL 0x001131c0
MOV RCX,RAX
LAB_00115e16:
MOV RDI,RBX
MOV ESI,R15D
MOV RDX,R12
XOR R8D,R8D
CALL 0x00131805
TEST EAX,EAX
JZ 0x00115e3f
LEA RAX,[0x148ac0]
MOV RDX,qword ptr [RAX]
MOV RDI,RBX
MOV ESI,0x7d6
JMP 0x00115ddb
LAB_00115e3f:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x00115d6b
MOV RAX,qword ptr [RBX + 0x2a0]
CMP dword ptr [RAX],0x0
JNZ 0x00115d6b
MOV RDI,RBX
CALL 0x001156e7
MOV qword ptr [RBX + 0x358],RAX
MOV ECX,0xffffffff
XOR R14D,R14D
CMP RAX,RCX
SETZ R14B
JMP 0x00115d6b
|
ulong mthd_my_send_cmd(long *param_1,ulong param_2,byte *param_3,size_t param_4,char param_5,
int8 param_6)
{
long *plVar1;
char cVar2;
uint uVar3;
int iVar4;
ulong uVar5;
size_t sVar6;
long lVar7;
byte *__s;
int8 uVar8;
if (*param_1 == 0) {
param_2 = param_2 & 0xffffffff;
cVar2 = mariadb_reconnect(param_1);
if (cVar2 != '\0') {
return 1;
}
}
if (((int)param_1[0x91] != 0) || ((*(byte *)(param_1 + 0x70) & 8) != 0)) {
*(int4 *)(param_1 + 0x12) = 0x7de;
strncpy((char *)((long)param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)((long)param_1 + 0x29c) = 0;
strncpy((char *)((long)param_1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_00148b40,0x1ff);
*(int1 *)((long)param_1 + 0x296) = 0;
return 0xffffffff;
}
uVar3 = 0xffffffff;
uVar5 = param_2;
if (((long *)param_1[0x9e] != (long *)0x0) &&
(plVar1 = *(long **)param_1[0x9e], plVar1 != (long *)0x0)) {
uVar5 = param_2 & 0xffffffff;
uVar3 = (**(code **)(*plVar1 + 0x70))(param_1,param_2,param_3,param_4,(int)param_5,param_6);
if (uVar3 == 0xffffffff) {
return 0xffffffff;
}
}
*(int4 *)(param_1 + 0x12) = 0;
*(int4 *)((long)param_1 + 0x297) = 0x30303030;
*(int2 *)((long)param_1 + 0x29b) = 0x30;
*(int1 *)((long)param_1 + 0x97) = 0;
if (param_1[0x54] != 0) {
*(int4 *)(param_1[0x54] + 4) = 0;
}
if (((((int)uVar5 == 0x16) || ((int)uVar5 == 3)) && ((*(byte *)(param_1 + 0x75) & 0x80) != 0)) &&
(((param_1[0x90] != 0 && (param_3 != (byte *)0x0)) &&
((lVar7 = param_1[0x9e], *(char *)(lVar7 + 0x78) == '\x01' && ((*param_3 | 0x20) == 0x6c))))))
{
uVar5 = uVar5 & 0xffffffff;
iVar4 = strncasecmp((char *)param_3,"load",4);
if (iVar4 == 0) {
*(int1 *)(lVar7 + 0x78) = 2;
}
}
param_1[0x5c] = 0;
param_1[0x67] = -1;
ma_net_clear(param_1);
__s = (byte *)0x1345df;
if (param_3 != (byte *)0x0) {
__s = param_3;
}
if (*(int *)param_1[0x54] == 2) {
uVar5 = net_add_multi_command(param_1,uVar5 & 0xff,__s,param_4);
return uVar5;
}
sVar6 = param_4;
if (param_4 == 0) {
sVar6 = strlen((char *)__s);
}
iVar4 = ma_net_write_command(param_1,uVar5 & 0xff,__s,sVar6,0);
if (iVar4 == 0) {
LAB_00115e3f:
if (param_5 != '\0') {
return 0;
}
if (*(int *)param_1[0x54] == 0) {
lVar7 = ma_net_safe_read(param_1);
param_1[0x6b] = lVar7;
return (ulong)(lVar7 == 0xffffffff);
}
return 0;
}
if ((int)param_1[0x12] == 0x481) {
uVar8 = 0x7e4;
}
else {
end_server(param_1);
cVar2 = mariadb_reconnect(param_1);
if (cVar2 != '\0') goto LAB_00115dfa;
if (param_4 == 0) {
param_4 = strlen((char *)__s);
}
iVar4 = ma_net_write_command(param_1,uVar5 & 0xff,__s,param_4,0);
if (iVar4 == 0) goto LAB_00115e3f;
uVar8 = 0x7d6;
}
my_set_error(param_1,uVar8,SQLSTATE_UNKNOWN,0);
LAB_00115dfa:
return (ulong)uVar3;
}
|
|
16,034
|
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*, float const*) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/sdc/crease.cpp
|
float
Crease::ComputeFractionalWeightAtVertex(float parentVertexSharpness,
float childVertexSharpness,
int incidentEdgeCount,
float const* parentSharpness,
float const* childSharpness) const {
int transitionCount = 0;
float transitionSum = 0.0f;
if (IsSharp(parentVertexSharpness) && IsSmooth(childVertexSharpness)) {
transitionCount = 1;
transitionSum = parentVertexSharpness;
}
//
// We need the child-edge sharpness values for non-simple methods to ensure
// that the sharpness went from a non-zero value (potentially greater than
// 1.0) to zero...
//
if (IsUniform() || (childSharpness == 0)) {
for (int i = 0; i < incidentEdgeCount; ++i) {
if (IsSharp(parentSharpness[i]) && (parentSharpness[i] <= 1.0f)) {
transitionSum += parentSharpness[i];
transitionCount ++;
}
}
} else {
for (int i = 0; i < incidentEdgeCount; ++i) {
if (IsSharp(parentSharpness[i]) && IsSmooth(childSharpness[i])) {
transitionSum += parentSharpness[i];
transitionCount ++;
}
}
}
if (transitionCount == 0) return 0.0f;
float fractionalWeight = transitionSum / (float)transitionCount;
return (fractionalWeight > 1.0f) ? 1.0f : fractionalWeight;
}
|
O0
|
cpp
|
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*, float const*) const:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movss %xmm1, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x14(%rbp), %xmm0
callq 0xc8ea0
testb $0x1, %al
jne 0xd80e8
jmp 0xd8109
movss -0x18(%rbp), %xmm0
callq 0xcf1f0
testb $0x1, %al
jne 0xd80f8
jmp 0xd8109
movl $0x1, -0x34(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movq -0x50(%rbp), %rdi
callq 0xd1df0
testb $0x1, %al
jne 0xd811d
cmpq $0x0, -0x30(%rbp)
jne 0xd8189
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xd8187
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
callq 0xc8ea0
testb $0x1, %al
jne 0xd8144
jmp 0xd817a
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss 0x111eac(%rip), %xmm0 # 0x1ea000
ucomiss (%rax,%rcx,4), %xmm0
jb 0xd817a
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addss -0x38(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd817c
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xd8124
jmp 0xd81f7
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xd81f5
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
callq 0xc8ea0
testb $0x1, %al
jne 0xd81b0
jmp 0xd81e8
movq -0x30(%rbp), %rax
movslq -0x40(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
callq 0xcf1f0
testb $0x1, %al
jne 0xd81c8
jmp 0xd81e8
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
addss -0x38(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd81ea
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xd8190
jmp 0xd81f7
cmpl $0x0, -0x34(%rbp)
jne 0xd8207
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0xd824f
movss -0x38(%rbp), %xmm0
cvtsi2ssl -0x34(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x44(%rbp), %xmm0
movss 0x111dd9(%rip), %xmm1 # 0x1ea000
ucomiss %xmm1, %xmm0
jbe 0xd823b
movss 0x111dcc(%rip), %xmm0 # 0x1ea000
movss %xmm0, -0x54(%rbp)
jmp 0xd8245
movss -0x44(%rbp), %xmm0
movss %xmm0, -0x54(%rbp)
movss -0x54(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZNK10OpenSubdiv6v3_6_03Sdc6Crease31ComputeFractionalWeightAtVertexEffiPKfS4_:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
movss [rbp+var_14], xmm0
movss [rbp+var_18], xmm1
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov [rbp+var_34], 0
xorps xmm0, xmm0
movss [rbp+var_38], xmm0
movss xmm0, [rbp+var_14]; float
call __ZN10OpenSubdiv6v3_6_03Sdc6Crease7IsSharpEf; OpenSubdiv::v3_6_0::Sdc::Crease::IsSharp(float)
test al, 1
jnz short loc_D80E8
jmp short loc_D8109
loc_D80E8:
movss xmm0, [rbp+var_18]; float
call __ZN10OpenSubdiv6v3_6_03Sdc6Crease8IsSmoothEf; OpenSubdiv::v3_6_0::Sdc::Crease::IsSmooth(float)
test al, 1
jnz short loc_D80F8
jmp short loc_D8109
loc_D80F8:
mov [rbp+var_34], 1
movss xmm0, [rbp+var_14]
movss [rbp+var_38], xmm0
loc_D8109:
mov rdi, [rbp+var_50]; this
call __ZNK10OpenSubdiv6v3_6_03Sdc6Crease9IsUniformEv; OpenSubdiv::v3_6_0::Sdc::Crease::IsUniform(void)
test al, 1
jnz short loc_D811D
cmp [rbp+var_30], 0
jnz short loc_D8189
loc_D811D:
mov [rbp+var_3C], 0
loc_D8124:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_1C]
jge short loc_D8187
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_3C]
movss xmm0, dword ptr [rax+rcx*4]; float
call __ZN10OpenSubdiv6v3_6_03Sdc6Crease7IsSharpEf; OpenSubdiv::v3_6_0::Sdc::Crease::IsSharp(float)
test al, 1
jnz short loc_D8144
jmp short loc_D817A
loc_D8144:
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_3C]
movss xmm0, cs:dword_1EA000
ucomiss xmm0, dword ptr [rax+rcx*4]
jb short loc_D817A
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_3C]
movss xmm0, dword ptr [rax+rcx*4]
addss xmm0, [rbp+var_38]
movss [rbp+var_38], xmm0
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
loc_D817A:
jmp short $+2
loc_D817C:
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp short loc_D8124
loc_D8187:
jmp short loc_D81F7
loc_D8189:
mov [rbp+var_40], 0
loc_D8190:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_1C]
jge short loc_D81F5
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_40]
movss xmm0, dword ptr [rax+rcx*4]; float
call __ZN10OpenSubdiv6v3_6_03Sdc6Crease7IsSharpEf; OpenSubdiv::v3_6_0::Sdc::Crease::IsSharp(float)
test al, 1
jnz short loc_D81B0
jmp short loc_D81E8
loc_D81B0:
mov rax, [rbp+var_30]
movsxd rcx, [rbp+var_40]
movss xmm0, dword ptr [rax+rcx*4]; float
call __ZN10OpenSubdiv6v3_6_03Sdc6Crease8IsSmoothEf; OpenSubdiv::v3_6_0::Sdc::Crease::IsSmooth(float)
test al, 1
jnz short loc_D81C8
jmp short loc_D81E8
loc_D81C8:
mov rax, [rbp+var_28]
movsxd rcx, [rbp+var_40]
movss xmm0, dword ptr [rax+rcx*4]
addss xmm0, [rbp+var_38]
movss [rbp+var_38], xmm0
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
loc_D81E8:
jmp short $+2
loc_D81EA:
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_40], eax
jmp short loc_D8190
loc_D81F5:
jmp short $+2
loc_D81F7:
cmp [rbp+var_34], 0
jnz short loc_D8207
xorps xmm0, xmm0
movss [rbp+var_4], xmm0
jmp short loc_D824F
loc_D8207:
movss xmm0, [rbp+var_38]
cvtsi2ss xmm1, [rbp+var_34]
divss xmm0, xmm1
movss [rbp+var_44], xmm0
movss xmm0, [rbp+var_44]
movss xmm1, cs:dword_1EA000
ucomiss xmm0, xmm1
jbe short loc_D823B
movss xmm0, cs:dword_1EA000
movss [rbp+var_54], xmm0
jmp short loc_D8245
loc_D823B:
movss xmm0, [rbp+var_44]
movss [rbp+var_54], xmm0
loc_D8245:
movss xmm0, [rbp+var_54]
movss [rbp+var_4], xmm0
loc_D824F:
movss xmm0, [rbp+var_4]
add rsp, 60h
pop rbp
retn
|
float OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(
OpenSubdiv::v3_6_0::Sdc::Crease *this,
float a2,
float a3,
int a4,
const float *a5,
const float *a6)
{
int i; // [rsp+20h] [rbp-40h]
int j; // [rsp+24h] [rbp-3Ch]
float v10; // [rsp+28h] [rbp-38h]
int v11; // [rsp+2Ch] [rbp-34h]
v11 = 0;
v10 = 0.0;
if ( (OpenSubdiv::v3_6_0::Sdc::Crease::IsSharp(this, a2) & 1) != 0
&& (OpenSubdiv::v3_6_0::Sdc::Crease::IsSmooth(this, a3) & 1) != 0 )
{
v11 = 1;
v10 = a2;
}
if ( (OpenSubdiv::v3_6_0::Sdc::Crease::IsUniform(this) & 1) == 0 && a6 )
{
for ( i = 0; i < a4; ++i )
{
if ( (OpenSubdiv::v3_6_0::Sdc::Crease::IsSharp(this, a5[i]) & 1) != 0
&& (OpenSubdiv::v3_6_0::Sdc::Crease::IsSmooth(this, a6[i]) & 1) != 0 )
{
v10 = a5[i] + v10;
++v11;
}
}
}
else
{
for ( j = 0; j < a4; ++j )
{
if ( (OpenSubdiv::v3_6_0::Sdc::Crease::IsSharp(this, a5[j]) & 1) != 0 && a5[j] <= 1.0 )
{
v10 = a5[j] + v10;
++v11;
}
}
}
if ( !v11 )
return 0.0;
if ( (float)(v10 / (float)v11) <= 1.0 )
return v10 / (float)v11;
else
return 1.0;
}
|
ComputeFractionalWeightAtVertex:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOVSS dword ptr [RBP + -0x14],XMM0
MOVSS dword ptr [RBP + -0x18],XMM1
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV dword ptr [RBP + -0x34],0x0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x38],XMM0
MOVSS XMM0,dword ptr [RBP + -0x14]
CALL 0x001c8ea0
TEST AL,0x1
JNZ 0x001d80e8
JMP 0x001d8109
LAB_001d80e8:
MOVSS XMM0,dword ptr [RBP + -0x18]
CALL 0x001cf1f0
TEST AL,0x1
JNZ 0x001d80f8
JMP 0x001d8109
LAB_001d80f8:
MOV dword ptr [RBP + -0x34],0x1
MOVSS XMM0,dword ptr [RBP + -0x14]
MOVSS dword ptr [RBP + -0x38],XMM0
LAB_001d8109:
MOV RDI,qword ptr [RBP + -0x50]
CALL 0x001d1df0
TEST AL,0x1
JNZ 0x001d811d
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001d8189
LAB_001d811d:
MOV dword ptr [RBP + -0x3c],0x0
LAB_001d8124:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x001d8187
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
CALL 0x001c8ea0
TEST AL,0x1
JNZ 0x001d8144
JMP 0x001d817a
LAB_001d8144:
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOVSS XMM0,dword ptr [0x002ea000]
UCOMISS XMM0,dword ptr [RAX + RCX*0x4]
JC 0x001d817a
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
ADDSS XMM0,dword ptr [RBP + -0x38]
MOVSS dword ptr [RBP + -0x38],XMM0
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
LAB_001d817a:
JMP 0x001d817c
LAB_001d817c:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001d8124
LAB_001d8187:
JMP 0x001d81f7
LAB_001d8189:
MOV dword ptr [RBP + -0x40],0x0
LAB_001d8190:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x001d81f5
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
CALL 0x001c8ea0
TEST AL,0x1
JNZ 0x001d81b0
JMP 0x001d81e8
LAB_001d81b0:
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,dword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
CALL 0x001cf1f0
TEST AL,0x1
JNZ 0x001d81c8
JMP 0x001d81e8
LAB_001d81c8:
MOV RAX,qword ptr [RBP + -0x28]
MOVSXD RCX,dword ptr [RBP + -0x40]
MOVSS XMM0,dword ptr [RAX + RCX*0x4]
ADDSS XMM0,dword ptr [RBP + -0x38]
MOVSS dword ptr [RBP + -0x38],XMM0
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
LAB_001d81e8:
JMP 0x001d81ea
LAB_001d81ea:
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001d8190
LAB_001d81f5:
JMP 0x001d81f7
LAB_001d81f7:
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x001d8207
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x4],XMM0
JMP 0x001d824f
LAB_001d8207:
MOVSS XMM0,dword ptr [RBP + -0x38]
CVTSI2SS XMM1,dword ptr [RBP + -0x34]
DIVSS XMM0,XMM1
MOVSS dword ptr [RBP + -0x44],XMM0
MOVSS XMM0,dword ptr [RBP + -0x44]
MOVSS XMM1,dword ptr [0x002ea000]
UCOMISS XMM0,XMM1
JBE 0x001d823b
MOVSS XMM0,dword ptr [0x002ea000]
MOVSS dword ptr [RBP + -0x54],XMM0
JMP 0x001d8245
LAB_001d823b:
MOVSS XMM0,dword ptr [RBP + -0x44]
MOVSS dword ptr [RBP + -0x54],XMM0
LAB_001d8245:
MOVSS XMM0,dword ptr [RBP + -0x54]
MOVSS dword ptr [RBP + -0x4],XMM0
LAB_001d824f:
MOVSS XMM0,dword ptr [RBP + -0x4]
ADD RSP,0x60
POP RBP
RET
|
/* OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*,
float const*) const */
float __thiscall
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex
(Crease *this,float param_1,float param_2,int param_3,float *param_4,float *param_5)
{
ulong uVar1;
float local_5c;
int local_48;
int local_44;
float local_40;
int local_3c;
float local_c;
local_3c = 0;
local_40 = 0.0;
uVar1 = IsSharp(param_1);
if (((uVar1 & 1) != 0) && (uVar1 = IsSmooth(param_2), (uVar1 & 1) != 0)) {
local_3c = 1;
local_40 = param_1;
}
uVar1 = IsUniform(this);
if (((uVar1 & 1) == 0) && (param_5 != (float *)0x0)) {
for (local_48 = 0; local_48 < param_3; local_48 = local_48 + 1) {
uVar1 = IsSharp(param_4[local_48]);
if (((uVar1 & 1) != 0) && (uVar1 = IsSmooth(param_5[local_48]), (uVar1 & 1) != 0)) {
local_40 = param_4[local_48] + local_40;
local_3c = local_3c + 1;
}
}
}
else {
for (local_44 = 0; local_44 < param_3; local_44 = local_44 + 1) {
uVar1 = IsSharp(param_4[local_44]);
if (((uVar1 & 1) != 0) && (param_4[local_44] <= DAT_002ea000)) {
local_40 = param_4[local_44] + local_40;
local_3c = local_3c + 1;
}
}
}
if (local_3c == 0) {
local_c = 0.0;
}
else {
local_5c = local_40 / (float)local_3c;
if (DAT_002ea000 < local_5c) {
local_5c = DAT_002ea000;
}
local_c = local_5c;
}
return local_c;
}
|
|
16,035
|
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*, float const*) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/sdc/crease.cpp
|
float
Crease::ComputeFractionalWeightAtVertex(float parentVertexSharpness,
float childVertexSharpness,
int incidentEdgeCount,
float const* parentSharpness,
float const* childSharpness) const {
int transitionCount = 0;
float transitionSum = 0.0f;
if (IsSharp(parentVertexSharpness) && IsSmooth(childVertexSharpness)) {
transitionCount = 1;
transitionSum = parentVertexSharpness;
}
//
// We need the child-edge sharpness values for non-simple methods to ensure
// that the sharpness went from a non-zero value (potentially greater than
// 1.0) to zero...
//
if (IsUniform() || (childSharpness == 0)) {
for (int i = 0; i < incidentEdgeCount; ++i) {
if (IsSharp(parentSharpness[i]) && (parentSharpness[i] <= 1.0f)) {
transitionSum += parentSharpness[i];
transitionCount ++;
}
}
} else {
for (int i = 0; i < incidentEdgeCount; ++i) {
if (IsSharp(parentSharpness[i]) && IsSmooth(childSharpness[i])) {
transitionSum += parentSharpness[i];
transitionCount ++;
}
}
}
if (transitionCount == 0) return 0.0f;
float fractionalWeight = transitionSum / (float)transitionCount;
return (fractionalWeight > 1.0f) ? 1.0f : fractionalWeight;
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*, float const*) const:
xorps %xmm2, %xmm2
cmpleps %xmm2, %xmm1
cmpltps %xmm0, %xmm2
andps %xmm1, %xmm2
movd %xmm2, %eax
testb $0x1, %al
jne 0x3d28d
xorps %xmm0, %xmm0
andl $0x1, %eax
testq %rcx, %rcx
je 0x3d2c6
cmpb $0x0, 0x2(%rdi)
je 0x3d2c6
testl %esi, %esi
jle 0x3d304
movl %esi, %esi
xorl %edi, %edi
xorps %xmm1, %xmm1
movss (%rdx,%rdi,4), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x3d2bc
ucomiss (%rcx,%rdi,4), %xmm1
jb 0x3d2bc
addss %xmm2, %xmm0
incl %eax
incq %rdi
cmpq %rdi, %rsi
jne 0x3d2a6
jmp 0x3d304
testl %esi, %esi
jle 0x3d304
movl %esi, %ecx
xorl %esi, %esi
movss 0x74d2a(%rip), %xmm1 # 0xb2000
movss (%rdx,%rsi,4), %xmm2
movaps %xmm2, %xmm3
cmpleps %xmm1, %xmm3
xorps %xmm4, %xmm4
cmpltps %xmm2, %xmm4
andps %xmm3, %xmm4
movd %xmm4, %edi
testb $0x1, %dil
je 0x3d2fa
addss %xmm2, %xmm0
subl %edi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x3d2d6
testl %eax, %eax
je 0x3d321
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss 0x74ce5(%rip), %xmm1 # 0xb2000
minss %xmm0, %xmm1
jmp 0x3d324
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
retq
|
_ZNK10OpenSubdiv6v3_6_03Sdc6Crease31ComputeFractionalWeightAtVertexEffiPKfS4_:
xorps xmm2, xmm2
cmpleps xmm1, xmm2
cmpltps xmm2, xmm0
andps xmm2, xmm1
movd eax, xmm2
test al, 1
jnz short loc_3D28D
xorps xmm0, xmm0
loc_3D28D:
and eax, 1
test rcx, rcx
jz short loc_3D2C6
cmp byte ptr [rdi+2], 0
jz short loc_3D2C6
test esi, esi
jle short loc_3D304
mov esi, esi
xor edi, edi
xorps xmm1, xmm1
loc_3D2A6:
movss xmm2, dword ptr [rdx+rdi*4]
ucomiss xmm2, xmm1
jbe short loc_3D2BC
ucomiss xmm1, dword ptr [rcx+rdi*4]
jb short loc_3D2BC
addss xmm0, xmm2
inc eax
loc_3D2BC:
inc rdi
cmp rsi, rdi
jnz short loc_3D2A6
jmp short loc_3D304
loc_3D2C6:
test esi, esi
jle short loc_3D304
mov ecx, esi
xor esi, esi
movss xmm1, cs:dword_B2000
loc_3D2D6:
movss xmm2, dword ptr [rdx+rsi*4]
movaps xmm3, xmm2
cmpleps xmm3, xmm1
xorps xmm4, xmm4
cmpltps xmm4, xmm2
andps xmm4, xmm3
movd edi, xmm4
test dil, 1
jz short loc_3D2FA
addss xmm0, xmm2
loc_3D2FA:
sub eax, edi
inc rsi
cmp rcx, rsi
jnz short loc_3D2D6
loc_3D304:
test eax, eax
jz short loc_3D321
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
divss xmm0, xmm1
movss xmm1, cs:dword_B2000
minss xmm1, xmm0
jmp short loc_3D324
loc_3D321:
xorps xmm1, xmm1
loc_3D324:
movaps xmm0, xmm1
retn
|
__int128 __usercall OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex@<xmm0>(
OpenSubdiv::v3_6_0::Sdc::Crease *this@<rdi>,
__m128 a2@<xmm0>,
__m128 a3@<xmm1>,
int a4@<esi>,
const float *a5@<rdx>,
const float *a6@<rcx>)
{
char v6; // al
int v7; // eax
long long i; // rdi
float v9; // xmm2_4
long long v10; // rcx
long long j; // rsi
__m128 v12; // xmm2
int v13; // edi
__int128 v14; // xmm1
v6 = _mm_cvtsi128_si32((__m128i)_mm_and_ps(_mm_cmplt_ps((__m128)0LL, a2), _mm_cmple_ps(a3, (__m128)0LL)));
if ( (v6 & 1) == 0 )
a2.m128_i32[0] = 0;
v7 = v6 & 1;
if ( a6 && *((_BYTE *)this + 2) )
{
if ( a4 > 0 )
{
for ( i = 0LL; i != a4; ++i )
{
v9 = a5[i];
if ( v9 > 0.0 && a6[i] <= 0.0 )
{
a2.m128_f32[0] = a2.m128_f32[0] + v9;
++v7;
}
}
}
}
else if ( a4 > 0 )
{
v10 = (unsigned int)a4;
for ( j = 0LL; j != v10; ++j )
{
v12 = (__m128)LODWORD(a5[j]);
v13 = _mm_cvtsi128_si32((__m128i)_mm_and_ps(
_mm_cmplt_ps((__m128)0LL, v12),
_mm_cmple_ps(v12, (__m128)0x3F800000u)));
if ( (v13 & 1) != 0 )
a2.m128_f32[0] = a2.m128_f32[0] + v12.m128_f32[0];
v7 -= v13;
}
}
if ( !v7 )
return 0LL;
v14 = 0x3F800000u;
*(float *)&v14 = fminf(1.0, a2.m128_f32[0] / (float)v7);
return v14;
}
|
ComputeFractionalWeightAtVertex:
XORPS XMM2,XMM2
CMPLEPS XMM1,XMM2
CMPLTPS XMM2,XMM0
ANDPS XMM2,XMM1
MOVD EAX,XMM2
TEST AL,0x1
JNZ 0x0013d28d
XORPS XMM0,XMM0
LAB_0013d28d:
AND EAX,0x1
TEST RCX,RCX
JZ 0x0013d2c6
CMP byte ptr [RDI + 0x2],0x0
JZ 0x0013d2c6
TEST ESI,ESI
JLE 0x0013d304
MOV ESI,ESI
XOR EDI,EDI
XORPS XMM1,XMM1
LAB_0013d2a6:
MOVSS XMM2,dword ptr [RDX + RDI*0x4]
UCOMISS XMM2,XMM1
JBE 0x0013d2bc
UCOMISS XMM1,dword ptr [RCX + RDI*0x4]
JC 0x0013d2bc
ADDSS XMM0,XMM2
INC EAX
LAB_0013d2bc:
INC RDI
CMP RSI,RDI
JNZ 0x0013d2a6
JMP 0x0013d304
LAB_0013d2c6:
TEST ESI,ESI
JLE 0x0013d304
MOV ECX,ESI
XOR ESI,ESI
MOVSS XMM1,dword ptr [0x001b2000]
LAB_0013d2d6:
MOVSS XMM2,dword ptr [RDX + RSI*0x4]
MOVAPS XMM3,XMM2
CMPLEPS XMM3,XMM1
XORPS XMM4,XMM4
CMPLTPS XMM4,XMM2
ANDPS XMM4,XMM3
MOVD EDI,XMM4
TEST DIL,0x1
JZ 0x0013d2fa
ADDSS XMM0,XMM2
LAB_0013d2fa:
SUB EAX,EDI
INC RSI
CMP RCX,RSI
JNZ 0x0013d2d6
LAB_0013d304:
TEST EAX,EAX
JZ 0x0013d321
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
DIVSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x001b2000]
MINSS XMM1,XMM0
JMP 0x0013d324
LAB_0013d321:
XORPS XMM1,XMM1
LAB_0013d324:
MOVAPS XMM0,XMM1
RET
|
/* OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*,
float const*) const */
float __thiscall
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex
(Crease *this,float param_1,float param_2,int param_3,float *param_4,float *param_5)
{
bool bVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
float fVar5;
bVar1 = 0.0 < param_1;
if (!bVar1 || param_2 > 0.0) {
param_1 = 0.0;
}
uVar3 = (uint)(bVar1 && param_2 <= 0.0);
if ((param_5 == (float *)0x0) || (this[2] == (Crease)0x0)) {
if (0 < param_3) {
uVar4 = 0;
do {
fVar5 = param_4[uVar4];
uVar2 = (uint)(0.0 < fVar5 && fVar5 <= DAT_001b2000);
if ((-uVar2 & 1) != 0) {
param_1 = param_1 + fVar5;
}
uVar3 = uVar3 + uVar2;
uVar4 = uVar4 + 1;
} while ((uint)param_3 != uVar4);
}
}
else if (0 < param_3) {
uVar4 = 0;
do {
if ((0.0 < param_4[uVar4]) && (param_5[uVar4] <= 0.0)) {
param_1 = param_1 + param_4[uVar4];
uVar3 = uVar3 + 1;
}
uVar4 = uVar4 + 1;
} while ((uint)param_3 != uVar4);
}
if (uVar3 == 0) {
fVar5 = 0.0;
}
else {
fVar5 = DAT_001b2000;
if (param_1 / (float)(int)uVar3 <= DAT_001b2000) {
fVar5 = param_1 / (float)(int)uVar3;
}
}
return fVar5;
}
|
|
16,036
|
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*, float const*) const
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/sdc/crease.cpp
|
float
Crease::ComputeFractionalWeightAtVertex(float parentVertexSharpness,
float childVertexSharpness,
int incidentEdgeCount,
float const* parentSharpness,
float const* childSharpness) const {
int transitionCount = 0;
float transitionSum = 0.0f;
if (IsSharp(parentVertexSharpness) && IsSmooth(childVertexSharpness)) {
transitionCount = 1;
transitionSum = parentVertexSharpness;
}
//
// We need the child-edge sharpness values for non-simple methods to ensure
// that the sharpness went from a non-zero value (potentially greater than
// 1.0) to zero...
//
if (IsUniform() || (childSharpness == 0)) {
for (int i = 0; i < incidentEdgeCount; ++i) {
if (IsSharp(parentSharpness[i]) && (parentSharpness[i] <= 1.0f)) {
transitionSum += parentSharpness[i];
transitionCount ++;
}
}
} else {
for (int i = 0; i < incidentEdgeCount; ++i) {
if (IsSharp(parentSharpness[i]) && IsSmooth(childSharpness[i])) {
transitionSum += parentSharpness[i];
transitionCount ++;
}
}
}
if (transitionCount == 0) return 0.0f;
float fractionalWeight = transitionSum / (float)transitionCount;
return (fractionalWeight > 1.0f) ? 1.0f : fractionalWeight;
}
|
O2
|
cpp
|
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*, float const*) const:
xorps %xmm2, %xmm2
cmpleps %xmm2, %xmm1
cmpltps %xmm0, %xmm2
andps %xmm1, %xmm2
movd %xmm2, %eax
testb $0x1, %al
jne 0x5635d
xorps %xmm0, %xmm0
andl $0x1, %eax
xorl %r8d, %r8d
testl %esi, %esi
cmovgl %esi, %r8d
testq %rcx, %rcx
je 0x56399
cmpb $0x0, 0x2(%rdi)
je 0x56399
xorl %esi, %esi
xorps %xmm1, %xmm1
cmpq %rsi, %r8
je 0x563d3
movss (%rdx,%rsi,4), %xmm2
ucomiss %xmm1, %xmm2
jbe 0x56394
ucomiss (%rcx,%rsi,4), %xmm1
jb 0x56394
addss %xmm2, %xmm0
incl %eax
incq %rsi
jmp 0x56379
xorl %ecx, %ecx
movss 0x65c5d(%rip), %xmm1 # 0xbc000
cmpq %rcx, %r8
je 0x563d3
movss (%rdx,%rcx,4), %xmm2
movaps %xmm2, %xmm3
cmpleps %xmm1, %xmm3
xorps %xmm4, %xmm4
cmpltps %xmm2, %xmm4
andps %xmm3, %xmm4
movd %xmm4, %esi
testb $0x1, %sil
je 0x563cc
addss %xmm2, %xmm0
subl %esi, %eax
incq %rcx
jmp 0x563a3
testl %eax, %eax
je 0x563ed
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movss 0x65c19(%rip), %xmm1 # 0xbc000
minss %xmm0, %xmm1
jmp 0x563f0
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
retq
|
_ZNK10OpenSubdiv6v3_6_03Sdc6Crease31ComputeFractionalWeightAtVertexEffiPKfS4_:
xorps xmm2, xmm2
cmpleps xmm1, xmm2
cmpltps xmm2, xmm0
andps xmm2, xmm1
movd eax, xmm2
test al, 1
jnz short loc_5635D
xorps xmm0, xmm0
loc_5635D:
and eax, 1
xor r8d, r8d
test esi, esi
cmovg r8d, esi
test rcx, rcx
jz short loc_56399
cmp byte ptr [rdi+2], 0
jz short loc_56399
xor esi, esi
xorps xmm1, xmm1
loc_56379:
cmp r8, rsi
jz short loc_563D3
movss xmm2, dword ptr [rdx+rsi*4]
ucomiss xmm2, xmm1
jbe short loc_56394
ucomiss xmm1, dword ptr [rcx+rsi*4]
jb short loc_56394
addss xmm0, xmm2
inc eax
loc_56394:
inc rsi
jmp short loc_56379
loc_56399:
xor ecx, ecx
movss xmm1, cs:dword_BC000
loc_563A3:
cmp r8, rcx
jz short loc_563D3
movss xmm2, dword ptr [rdx+rcx*4]
movaps xmm3, xmm2
cmpleps xmm3, xmm1
xorps xmm4, xmm4
cmpltps xmm4, xmm2
andps xmm4, xmm3
movd esi, xmm4
test sil, 1
jz short loc_563CC
addss xmm0, xmm2
loc_563CC:
sub eax, esi
inc rcx
jmp short loc_563A3
loc_563D3:
test eax, eax
jz short loc_563ED
cvtsi2ss xmm1, eax
divss xmm0, xmm1
movss xmm1, cs:dword_BC000
minss xmm1, xmm0
jmp short loc_563F0
loc_563ED:
xorps xmm1, xmm1
loc_563F0:
movaps xmm0, xmm1
retn
|
__int128 __usercall OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex@<xmm0>(
OpenSubdiv::v3_6_0::Sdc::Crease *this@<rdi>,
__m128 a2@<xmm0>,
__m128 a3@<xmm1>,
int a4@<esi>,
const float *a5@<rdx>,
const float *a6@<rcx>)
{
char v6; // al
int v7; // eax
long long v8; // r8
long long i; // rsi
float v10; // xmm2_4
long long j; // rcx
__m128 v12; // xmm2
int v13; // esi
__int128 v14; // xmm1
v6 = _mm_cvtsi128_si32((__m128i)_mm_and_ps(_mm_cmplt_ps((__m128)0LL, a2), _mm_cmple_ps(a3, (__m128)0LL)));
if ( (v6 & 1) == 0 )
a2.m128_i32[0] = 0;
v7 = v6 & 1;
v8 = 0LL;
if ( a4 > 0 )
v8 = (unsigned int)a4;
if ( a6 && *((_BYTE *)this + 2) )
{
for ( i = 0LL; v8 != i; ++i )
{
v10 = a5[i];
if ( v10 > 0.0 && a6[i] <= 0.0 )
{
a2.m128_f32[0] = a2.m128_f32[0] + v10;
++v7;
}
}
}
else
{
for ( j = 0LL; v8 != j; ++j )
{
v12 = (__m128)LODWORD(a5[j]);
v13 = _mm_cvtsi128_si32((__m128i)_mm_and_ps(
_mm_cmplt_ps((__m128)0LL, v12),
_mm_cmple_ps(v12, (__m128)0x3F800000u)));
if ( (v13 & 1) != 0 )
a2.m128_f32[0] = a2.m128_f32[0] + v12.m128_f32[0];
v7 -= v13;
}
}
if ( !v7 )
return 0LL;
v14 = 0x3F800000u;
*(float *)&v14 = fminf(1.0, a2.m128_f32[0] / (float)v7);
return v14;
}
|
ComputeFractionalWeightAtVertex:
XORPS XMM2,XMM2
CMPLEPS XMM1,XMM2
CMPLTPS XMM2,XMM0
ANDPS XMM2,XMM1
MOVD EAX,XMM2
TEST AL,0x1
JNZ 0x0015635d
XORPS XMM0,XMM0
LAB_0015635d:
AND EAX,0x1
XOR R8D,R8D
TEST ESI,ESI
CMOVG R8D,ESI
TEST RCX,RCX
JZ 0x00156399
CMP byte ptr [RDI + 0x2],0x0
JZ 0x00156399
XOR ESI,ESI
XORPS XMM1,XMM1
LAB_00156379:
CMP R8,RSI
JZ 0x001563d3
MOVSS XMM2,dword ptr [RDX + RSI*0x4]
UCOMISS XMM2,XMM1
JBE 0x00156394
UCOMISS XMM1,dword ptr [RCX + RSI*0x4]
JC 0x00156394
ADDSS XMM0,XMM2
INC EAX
LAB_00156394:
INC RSI
JMP 0x00156379
LAB_00156399:
XOR ECX,ECX
MOVSS XMM1,dword ptr [0x001bc000]
LAB_001563a3:
CMP R8,RCX
JZ 0x001563d3
MOVSS XMM2,dword ptr [RDX + RCX*0x4]
MOVAPS XMM3,XMM2
CMPLEPS XMM3,XMM1
XORPS XMM4,XMM4
CMPLTPS XMM4,XMM2
ANDPS XMM4,XMM3
MOVD ESI,XMM4
TEST SIL,0x1
JZ 0x001563cc
ADDSS XMM0,XMM2
LAB_001563cc:
SUB EAX,ESI
INC RCX
JMP 0x001563a3
LAB_001563d3:
TEST EAX,EAX
JZ 0x001563ed
CVTSI2SS XMM1,EAX
DIVSS XMM0,XMM1
MOVSS XMM1,dword ptr [0x001bc000]
MINSS XMM1,XMM0
JMP 0x001563f0
LAB_001563ed:
XORPS XMM1,XMM1
LAB_001563f0:
MOVAPS XMM0,XMM1
RET
|
/* OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex(float, float, int, float const*,
float const*) const */
float __thiscall
OpenSubdiv::v3_6_0::Sdc::Crease::ComputeFractionalWeightAtVertex
(Crease *this,float param_1,float param_2,int param_3,float *param_4,float *param_5)
{
bool bVar1;
uint uVar2;
uint uVar3;
ulong uVar4;
ulong uVar5;
float fVar6;
bVar1 = 0.0 < param_1;
if (!bVar1 || param_2 > 0.0) {
param_1 = 0.0;
}
uVar3 = (uint)(bVar1 && param_2 <= 0.0);
uVar5 = 0;
if (0 < param_3) {
uVar5 = (ulong)(uint)param_3;
}
if ((param_5 == (float *)0x0) || (this[2] == (Crease)0x0)) {
for (uVar4 = 0; uVar5 != uVar4; uVar4 = uVar4 + 1) {
fVar6 = param_4[uVar4];
uVar2 = (uint)(0.0 < fVar6 && fVar6 <= DAT_001bc000);
if ((-uVar2 & 1) != 0) {
param_1 = param_1 + fVar6;
}
uVar3 = uVar3 + uVar2;
}
}
else {
for (uVar4 = 0; uVar5 != uVar4; uVar4 = uVar4 + 1) {
if ((0.0 < param_4[uVar4]) && (param_5[uVar4] <= 0.0)) {
param_1 = param_1 + param_4[uVar4];
uVar3 = uVar3 + 1;
}
}
}
if (uVar3 == 0) {
fVar6 = 0.0;
}
else {
fVar6 = DAT_001bc000;
if (param_1 / (float)(int)uVar3 <= DAT_001bc000) {
fVar6 = param_1 / (float)(int)uVar3;
}
}
return fVar6;
}
|
|
16,037
|
inflateBackInit_
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/infback.c
|
int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
z_streamp strm;
int windowBits;
unsigned char FAR *window;
const char *version;
int stream_size;
{
struct inflate_state FAR *state;
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
stream_size != (int)(sizeof(z_stream)))
return Z_VERSION_ERROR;
if (strm == Z_NULL || window == Z_NULL ||
windowBits < 8 || windowBits > 15)
return Z_STREAM_ERROR;
strm->msg = Z_NULL; /* in case we return an error */
if (strm->zalloc == (alloc_func)0) {
#ifdef Z_SOLO
return Z_STREAM_ERROR;
#else
strm->zalloc = zcalloc;
strm->opaque = (voidpf)0;
#endif
}
if (strm->zfree == (free_func)0)
#ifdef Z_SOLO
return Z_STREAM_ERROR;
#else
strm->zfree = zcfree;
#endif
state = (struct inflate_state FAR *)ZALLOC(strm, 1,
sizeof(struct inflate_state));
if (state == Z_NULL) return Z_MEM_ERROR;
Tracev((stderr, "inflate: allocated\n"));
strm->state = (struct internal_state FAR *)state;
state->dmax = 32768U;
state->wbits = (uInt)windowBits;
state->wsize = 1U << windowBits;
state->window = window;
state->wnext = 0;
state->whave = 0;
state->sane = 1;
return Z_OK;
}
|
O3
|
c
|
inflateBackInit_:
movl $0xfffffffa, %eax # imm = 0xFFFFFFFA
testq %rcx, %rcx
je 0xb0f5
cmpl $0x70, %r8d
jne 0xb0f5
cmpb $0x31, (%rcx)
jne 0xb0f5
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
leal -0x10(%r14), %ecx
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpl $-0x8, %ecx
jb 0xb0eb
movq %rdi, %r15
testq %rdi, %rdi
je 0xb0eb
movq %rdx, %rbx
testq %rdx, %rdx
je 0xb0eb
movq $0x0, 0x30(%r15)
movq 0x40(%r15), %rax
testq %rax, %rax
jne 0xb089
leaq 0x3c02(%rip), %rax # 0xec7f
movq %rax, 0x40(%r15)
movq $0x0, 0x50(%r15)
cmpq $0x0, 0x48(%r15)
jne 0xb09b
leaq 0x3bf2(%rip), %rcx # 0xec89
movq %rcx, 0x48(%r15)
movq 0x50(%r15), %rdi
movl $0x1, %ebp
movl $0x1, %esi
movl $0x1bf8, %edx # imm = 0x1BF8
callq *%rax
testq %rax, %rax
je 0xb0e6
movq %rax, 0x38(%r15)
movl $0x8000, 0x1c(%rax) # imm = 0x8000
movl %r14d, 0x38(%rax)
movl %r14d, %ecx
shll %cl, %ebp
movl %ebp, 0x3c(%rax)
movq %rbx, 0x48(%rax)
movq $0x0, 0x40(%rax)
movl $0x1, 0x1be8(%rax)
xorl %eax, %eax
jmp 0xb0eb
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
inflateBackInit_:
mov eax, 0FFFFFFFAh
test rcx, rcx
jz locret_B0F5
cmp r8d, 70h ; 'p'
jnz locret_B0F5
cmp byte ptr [rcx], 31h ; '1'
jnz locret_B0F5
push rbp
push r15
push r14
push rbx
push rax
mov r14d, esi
lea ecx, [r14-10h]
mov eax, 0FFFFFFFEh
cmp ecx, 0FFFFFFF8h
jb loc_B0EB
mov r15, rdi
test rdi, rdi
jz loc_B0EB
mov rbx, rdx
test rdx, rdx
jz loc_B0EB
mov qword ptr [r15+30h], 0
mov rax, [r15+40h]
test rax, rax
jnz short loc_B089
lea rax, zcalloc
mov [r15+40h], rax
mov qword ptr [r15+50h], 0
loc_B089:
cmp qword ptr [r15+48h], 0
jnz short loc_B09B
lea rcx, zcfree
mov [r15+48h], rcx
loc_B09B:
mov rdi, [r15+50h]
mov ebp, 1
mov esi, 1
mov edx, 1BF8h
call rax
test rax, rax
jz short loc_B0E6
mov [r15+38h], rax
mov dword ptr [rax+1Ch], 8000h
mov [rax+38h], r14d
mov ecx, r14d
shl ebp, cl
mov [rax+3Ch], ebp
mov [rax+48h], rbx
mov qword ptr [rax+40h], 0
mov dword ptr [rax+1BE8h], 1
xor eax, eax
jmp short loc_B0EB
loc_B0E6:
mov eax, 0FFFFFFFCh
loc_B0EB:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
locret_B0F5:
retn
|
long long inflateBackInit_(_QWORD *a1, int a2, long long a3, _BYTE *a4, int a5)
{
long long result; // rax
long long ( *v7)(); // rax
long long v8; // rax
result = 4294967290LL;
if ( a4 )
{
if ( a5 == 112 && *a4 == 49 )
{
result = 4294967294LL;
if ( (unsigned int)(a2 - 16) >= 0xFFFFFFF8 && a1 && a3 )
{
a1[6] = 0LL;
v7 = (long long ( *)())a1[8];
if ( !v7 )
{
v7 = zcalloc;
a1[8] = zcalloc;
a1[10] = 0LL;
}
if ( !a1[9] )
a1[9] = zcfree;
v8 = ((long long ( *)(_QWORD, long long, long long))v7)(a1[10], 1LL, 7160LL);
if ( v8 )
{
a1[7] = v8;
*(_DWORD *)(v8 + 28) = 0x8000;
*(_DWORD *)(v8 + 56) = a2;
*(_DWORD *)(v8 + 60) = 1 << a2;
*(_QWORD *)(v8 + 72) = a3;
*(_QWORD *)(v8 + 64) = 0LL;
*(_DWORD *)(v8 + 7144) = 1;
return 0LL;
}
else
{
return 4294967292LL;
}
}
}
}
return result;
}
|
inflateBackInit_:
MOV EAX,0xfffffffa
TEST RCX,RCX
JZ 0x0010b0f5
CMP R8D,0x70
JNZ 0x0010b0f5
CMP byte ptr [RCX],0x31
JNZ 0x0010b0f5
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14D,ESI
LEA ECX,[R14 + -0x10]
MOV EAX,0xfffffffe
CMP ECX,-0x8
JC 0x0010b0eb
MOV R15,RDI
TEST RDI,RDI
JZ 0x0010b0eb
MOV RBX,RDX
TEST RDX,RDX
JZ 0x0010b0eb
MOV qword ptr [R15 + 0x30],0x0
MOV RAX,qword ptr [R15 + 0x40]
TEST RAX,RAX
JNZ 0x0010b089
LEA RAX,[0x10ec7f]
MOV qword ptr [R15 + 0x40],RAX
MOV qword ptr [R15 + 0x50],0x0
LAB_0010b089:
CMP qword ptr [R15 + 0x48],0x0
JNZ 0x0010b09b
LEA RCX,[0x10ec89]
MOV qword ptr [R15 + 0x48],RCX
LAB_0010b09b:
MOV RDI,qword ptr [R15 + 0x50]
MOV EBP,0x1
MOV ESI,0x1
MOV EDX,0x1bf8
CALL RAX
TEST RAX,RAX
JZ 0x0010b0e6
MOV qword ptr [R15 + 0x38],RAX
MOV dword ptr [RAX + 0x1c],0x8000
MOV dword ptr [RAX + 0x38],R14D
MOV ECX,R14D
SHL EBP,CL
MOV dword ptr [RAX + 0x3c],EBP
MOV qword ptr [RAX + 0x48],RBX
MOV qword ptr [RAX + 0x40],0x0
MOV dword ptr [RAX + 0x1be8],0x1
XOR EAX,EAX
JMP 0x0010b0eb
LAB_0010b0e6:
MOV EAX,0xfffffffc
LAB_0010b0eb:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
LAB_0010b0f5:
RET
|
int8 inflateBackInit_(long param_1,int param_2,long param_3,char *param_4,int param_5)
{
int8 uVar1;
code *pcVar2;
long lVar3;
uVar1 = 0xfffffffa;
if ((((param_4 != (char *)0x0) && (param_5 == 0x70)) && (*param_4 == '1')) &&
(((uVar1 = 0xfffffffe, 0xfffffff7 < param_2 - 0x10U && (param_1 != 0)) && (param_3 != 0)))) {
*(int8 *)(param_1 + 0x30) = 0;
pcVar2 = *(code **)(param_1 + 0x40);
if (pcVar2 == (code *)0x0) {
pcVar2 = zcalloc;
*(code **)(param_1 + 0x40) = zcalloc;
*(int8 *)(param_1 + 0x50) = 0;
}
if (*(long *)(param_1 + 0x48) == 0) {
*(code **)(param_1 + 0x48) = zcfree;
}
lVar3 = (*pcVar2)(*(int8 *)(param_1 + 0x50),1,0x1bf8);
if (lVar3 == 0) {
uVar1 = 0xfffffffc;
}
else {
*(long *)(param_1 + 0x38) = lVar3;
*(int4 *)(lVar3 + 0x1c) = 0x8000;
*(int *)(lVar3 + 0x38) = param_2;
*(int *)(lVar3 + 0x3c) = 1 << ((byte)param_2 & 0x1f);
*(long *)(lVar3 + 0x48) = param_3;
*(int8 *)(lVar3 + 0x40) = 0;
*(int4 *)(lVar3 + 0x1be8) = 1;
uVar1 = 0;
}
}
return uVar1;
}
|
|
16,038
|
FTB_WORD_cmp_list
|
eloqsql/storage/myisam/ft_boolean_search.c
|
static int FTB_WORD_cmp_list(CHARSET_INFO *cs, FTB_WORD **a, FTB_WORD **b)
{
/* ORDER BY word, ndepth */
int i= ha_compare_text(cs, (uchar*) (*a)->word + 1, (*a)->len - 1,
(uchar*) (*b)->word + 1, (*b)->len - 1, 0);
if (!i)
i= CMP_NUM((*a)->ndepth, (*b)->ndepth);
return i;
}
|
O3
|
c
|
FTB_WORD_cmp_list:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rsi
movl 0x48(%rsi), %edx
addq $0x4e, %rsi
decl %edx
movq (%rbx), %rcx
movl 0x48(%rcx), %r8d
addq $0x4e, %rcx
decl %r8d
xorl %r9d, %r9d
callq 0x9e350
testl %eax, %eax
jne 0x717da
movq (%r14), %rax
movl 0x44(%rax), %eax
movq (%rbx), %rcx
xorl %edx, %edx
cmpl 0x44(%rcx), %eax
setne %dl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovael %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
FTB_WORD_cmp_list:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov rsi, [rsi]
mov edx, [rsi+48h]
add rsi, 4Eh ; 'N'
dec edx
mov rcx, [rbx]
mov r8d, [rcx+48h]
add rcx, 4Eh ; 'N'
dec r8d
xor r9d, r9d
call ha_compare_text
test eax, eax
jnz short loc_717DA
mov rax, [r14]
mov eax, [rax+44h]
mov rcx, [rbx]
xor edx, edx
cmp eax, [rcx+44h]
setnz dl
mov eax, 0FFFFFFFFh
cmovnb eax, edx
loc_717DA:
pop rbx
pop r14
pop rbp
retn
|
long long FTB_WORD_cmp_list(long long a1, long long a2, long long a3)
{
long long result; // rax
unsigned int v5; // eax
bool v6; // cf
BOOL v7; // edx
result = ha_compare_text(
a1,
*(_QWORD *)a2 + 78LL,
(unsigned int)(*(_DWORD *)(*(_QWORD *)a2 + 72LL) - 1),
*(_QWORD *)a3 + 78LL,
(unsigned int)(*(_DWORD *)(*(_QWORD *)a3 + 72LL) - 1),
0LL);
if ( !(_DWORD)result )
{
v5 = *(_DWORD *)(*(_QWORD *)a2 + 68LL);
v6 = v5 < *(_DWORD *)(*(_QWORD *)a3 + 68LL);
v7 = v5 != *(_DWORD *)(*(_QWORD *)a3 + 68LL);
result = 0xFFFFFFFFLL;
if ( !v6 )
return v7;
}
return result;
}
|
FTB_WORD_cmp_list:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV RSI,qword ptr [RSI]
MOV EDX,dword ptr [RSI + 0x48]
ADD RSI,0x4e
DEC EDX
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RCX + 0x48]
ADD RCX,0x4e
DEC R8D
XOR R9D,R9D
CALL 0x0019e350
TEST EAX,EAX
JNZ 0x001717da
MOV RAX,qword ptr [R14]
MOV EAX,dword ptr [RAX + 0x44]
MOV RCX,qword ptr [RBX]
XOR EDX,EDX
CMP EAX,dword ptr [RCX + 0x44]
SETNZ DL
MOV EAX,0xffffffff
CMOVNC EAX,EDX
LAB_001717da:
POP RBX
POP R14
POP RBP
RET
|
ulong FTB_WORD_cmp_list(int8 param_1,long *param_2,long *param_3)
{
ulong uVar1;
uVar1 = ha_compare_text(param_1,*param_2 + 0x4e,*(int *)(*param_2 + 0x48) + -1,*param_3 + 0x4e,
*(int *)(*param_3 + 0x48) + -1,0);
if ((int)uVar1 == 0) {
uVar1 = 0xffffffff;
if (*(uint *)(*param_3 + 0x44) <= *(uint *)(*param_2 + 0x44)) {
uVar1 = (ulong)(*(uint *)(*param_2 + 0x44) != *(uint *)(*param_3 + 0x44));
}
}
return uVar1;
}
|
|
16,039
|
JS_SetModuleExport
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
JSValue val)
{
JSExportEntry *me;
JSAtom name;
name = JS_NewAtom(ctx, export_name);
if (name == JS_ATOM_NULL)
goto fail;
me = find_export_entry(ctx, m, name);
JS_FreeAtom(ctx, name);
if (!me)
goto fail;
set_value(ctx, me->u.local.var_ref->pvalue, val);
return 0;
fail:
JS_FreeValue(ctx, val);
return -1;
}
|
O0
|
c
|
JS_SetModuleExport:
subq $0x48, %rsp
movq %rcx, 0x30(%rsp)
movq %r8, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x27200
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x48739
jmp 0x48794
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x487c0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x27d80
cmpq $0x0, 0x10(%rsp)
jne 0x48769
jmp 0x48794
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x26780
movl $0x0, 0x44(%rsp)
jmp 0x487b0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x229d0
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
|
JS_SetModuleExport:
sub rsp, 48h
mov [rsp+48h+var_18], rcx
mov [rsp+48h+var_10], r8
mov [rsp+48h+var_20], rdi
mov [rsp+48h+var_28], rsi
mov [rsp+48h+var_30], rdx
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_30]
call JS_NewAtom
mov [rsp+48h+var_3C], eax
cmp [rsp+48h+var_3C], 0
jnz short loc_48739
jmp short loc_48794
loc_48739:
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_28]
mov edx, [rsp+48h+var_3C]
call find_export_entry
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_20]
mov esi, [rsp+48h+var_3C]
call JS_FreeAtom
cmp [rsp+48h+var_38], 0
jnz short loc_48769
jmp short loc_48794
loc_48769:
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_38]
mov rax, [rax+8]
mov rsi, [rax+18h]
mov rdx, [rsp+48h+var_18]
mov rcx, [rsp+48h+var_10]
call set_value
mov [rsp+48h+var_4], 0
jmp short loc_487B0
loc_48794:
mov rdi, [rsp+48h+var_20]
mov rsi, [rsp+48h+var_18]
mov rdx, [rsp+48h+var_10]
call JS_FreeValue
mov [rsp+48h+var_4], 0FFFFFFFFh
loc_487B0:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
|
long long JS_SetModuleExport(long long a1, long long a2, unsigned __int8 *a3, long long a4, long long a5)
{
unsigned int v6; // [rsp+Ch] [rbp-3Ch]
long long export_entry; // [rsp+10h] [rbp-38h]
v6 = JS_NewAtom(a1, a3);
if ( v6 && (export_entry = find_export_entry(a1, a2, v6), JS_FreeAtom(a1, v6), export_entry) )
{
set_value(a1, *(long long **)(*(_QWORD *)(export_entry + 8) + 24LL), a4, a5);
return 0;
}
else
{
JS_FreeValue(a1, a4, a5);
return (unsigned int)-1;
}
}
|
JS_SetModuleExport:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RCX
MOV qword ptr [RSP + 0x38],R8
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00127200
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x0
JNZ 0x00148739
JMP 0x00148794
LAB_00148739:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x20]
MOV EDX,dword ptr [RSP + 0xc]
CALL 0x001487c0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x00127d80
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x00148769
JMP 0x00148794
LAB_00148769:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x18]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
CALL 0x00126780
MOV dword ptr [RSP + 0x44],0x0
JMP 0x001487b0
LAB_00148794:
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
CALL 0x001229d0
MOV dword ptr [RSP + 0x44],0xffffffff
LAB_001487b0:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4
JS_SetModuleExport(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
long lVar2;
iVar1 = JS_NewAtom(param_1,param_3);
if (iVar1 != 0) {
lVar2 = find_export_entry(param_1,param_2,iVar1);
JS_FreeAtom(param_1,iVar1);
if (lVar2 != 0) {
set_value(param_1,*(int8 *)(*(long *)(lVar2 + 8) + 0x18),param_4,param_5);
return 0;
}
}
JS_FreeValue(param_1,param_4,param_5);
return 0xffffffff;
}
|
|
16,040
|
JS_SetModuleExport
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
JSValue val)
{
JSExportEntry *me;
JSAtom name;
name = JS_NewAtom(ctx, export_name);
if (name == JS_ATOM_NULL)
goto fail;
me = find_export_entry(ctx, m, name);
JS_FreeAtom(ctx, name);
if (!me)
goto fail;
set_value(ctx, me->u.local.var_ref->pvalue, val);
return 0;
fail:
JS_FreeValue(ctx, val);
return -1;
}
|
O1
|
c
|
JS_SetModuleExport:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0xe240
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1f1ac
testl %eax, %eax
je 0x2feaf
movslq 0x30(%r12), %rcx
testq %rcx, %rcx
jle 0x2fe79
movq 0x28(%r12), %r12
cmpl %eax, 0x18(%r12)
je 0x2fe7c
addq $0x20, %r12
decq %rcx
jne 0x2fe69
xorl %r12d, %r12d
movq %r15, %rdi
movl %eax, %esi
callq 0x1fbc4
testq %r12, %r12
je 0x2feaf
movq 0x8(%r12), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq 0x18(%r15), %rdi
callq 0x1ccb2
xorl %eax, %eax
jmp 0x2fec3
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ccb2
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
JS_SetModuleExport:
push r15
push r14
push r13
push r12
push rbx
mov rbx, r8
mov r14, rcx
mov r13, rdx
mov r12, rsi
mov r15, rdi
mov rdi, rdx
call _strlen
mov rdi, r15
mov rsi, r13
mov rdx, rax
call JS_NewAtomLen
test eax, eax
jz short loc_2FEAF
movsxd rcx, dword ptr [r12+30h]
test rcx, rcx
jle short loc_2FE79
mov r12, [r12+28h]
loc_2FE69:
cmp [r12+18h], eax
jz short loc_2FE7C
add r12, 20h ; ' '
dec rcx
jnz short loc_2FE69
loc_2FE79:
xor r12d, r12d
loc_2FE7C:
mov rdi, r15
mov esi, eax
call JS_FreeAtom
test r12, r12
jz short loc_2FEAF
mov rax, [r12+8]
mov rax, [rax+18h]
mov rsi, [rax]
mov rdx, [rax+8]
mov [rax], r14
mov [rax+8], rbx
mov rdi, [r15+18h]
call JS_FreeValueRT
xor eax, eax
jmp short loc_2FEC3
loc_2FEAF:
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov eax, 0FFFFFFFFh
loc_2FEC3:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long JS_SetModuleExport(long long a1, long long a2, unsigned __int8 *a3, _DWORD *a4, long long a5)
{
long long v8; // rax
int v9; // eax
long long v10; // rcx
long long v11; // r12
long long v12; // rax
_DWORD *v13; // rsi
long long v14; // rdx
v8 = strlen(a3);
v9 = JS_NewAtomLen(a1, a3, v8);
if ( !v9 )
goto LABEL_9;
v10 = *(int *)(a2 + 48);
if ( v10 <= 0 )
{
LABEL_6:
v11 = 0LL;
}
else
{
v11 = *(_QWORD *)(a2 + 40);
while ( *(_DWORD *)(v11 + 24) != v9 )
{
v11 += 32LL;
if ( !--v10 )
goto LABEL_6;
}
}
JS_FreeAtom(a1, v9);
if ( v11 )
{
v12 = *(_QWORD *)(*(_QWORD *)(v11 + 8) + 24LL);
v13 = *(_DWORD **)v12;
v14 = *(_QWORD *)(v12 + 8);
*(_QWORD *)v12 = a4;
*(_QWORD *)(v12 + 8) = a5;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v13, v14);
return 0LL;
}
else
{
LABEL_9:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), a4, a5);
return 0xFFFFFFFFLL;
}
}
|
JS_SetModuleExport:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,R8
MOV R14,RCX
MOV R13,RDX
MOV R12,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x0010e240
MOV RDI,R15
MOV RSI,R13
MOV RDX,RAX
CALL 0x0011f1ac
TEST EAX,EAX
JZ 0x0012feaf
MOVSXD RCX,dword ptr [R12 + 0x30]
TEST RCX,RCX
JLE 0x0012fe79
MOV R12,qword ptr [R12 + 0x28]
LAB_0012fe69:
CMP dword ptr [R12 + 0x18],EAX
JZ 0x0012fe7c
ADD R12,0x20
DEC RCX
JNZ 0x0012fe69
LAB_0012fe79:
XOR R12D,R12D
LAB_0012fe7c:
MOV RDI,R15
MOV ESI,EAX
CALL 0x0011fbc4
TEST R12,R12
JZ 0x0012feaf
MOV RAX,qword ptr [R12 + 0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX],R14
MOV qword ptr [RAX + 0x8],RBX
MOV RDI,qword ptr [R15 + 0x18]
CALL 0x0011ccb2
XOR EAX,EAX
JMP 0x0012fec3
LAB_0012feaf:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011ccb2
MOV EAX,0xffffffff
LAB_0012fec3:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int8
JS_SetModuleExport(long param_1,long param_2,char *param_3,int8 param_4,int8 param_5)
{
int8 *puVar1;
int8 uVar2;
int8 uVar3;
int iVar4;
size_t sVar5;
long lVar6;
long lVar7;
sVar5 = strlen(param_3);
iVar4 = JS_NewAtomLen(param_1,param_3,sVar5);
if (iVar4 != 0) {
lVar6 = (long)*(int *)(param_2 + 0x30);
if (0 < lVar6) {
lVar7 = *(long *)(param_2 + 0x28);
do {
if (*(int *)(lVar7 + 0x18) == iVar4) goto LAB_0012fe7c;
lVar7 = lVar7 + 0x20;
lVar6 = lVar6 + -1;
} while (lVar6 != 0);
}
lVar7 = 0;
LAB_0012fe7c:
JS_FreeAtom(param_1,iVar4);
if (lVar7 != 0) {
puVar1 = *(int8 **)(*(long *)(lVar7 + 8) + 0x18);
uVar2 = *puVar1;
uVar3 = puVar1[1];
*puVar1 = param_4;
puVar1[1] = param_5;
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar2,uVar3);
return 0;
}
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),param_4,param_5);
return 0xffffffff;
}
|
|
16,041
|
JS_SetModuleExport
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
JSValue val)
{
JSExportEntry *me;
JSAtom name;
name = JS_NewAtom(ctx, export_name);
if (name == JS_ATOM_NULL)
goto fail;
me = find_export_entry(ctx, m, name);
JS_FreeAtom(ctx, name);
if (!me)
goto fail;
set_value(ctx, me->u.local.var_ref->pvalue, val);
return 0;
fail:
JS_FreeValue(ctx, val);
return -1;
}
|
O2
|
c
|
JS_SetModuleExport:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rsi
callq 0x198f5
testl %eax, %eax
je 0x28578
movl %eax, %ebp
movq %r12, %rdi
movl %eax, %esi
callq 0x28592
movq %rax, %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0x19e19
testq %r12, %r12
je 0x28578
movq 0x8(%r12), %rax
movq 0x18(%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x19370
xorl %eax, %eax
jmp 0x28589
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x174a2
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
JS_SetModuleExport:
push rbp
push r15
push r14
push r12
push rbx
mov rbx, r8
mov r14, rcx
mov r12, rsi
mov r15, rdi
mov rsi, rdx
call JS_NewAtom
test eax, eax
jz short loc_28578
mov ebp, eax
mov rdi, r12
mov esi, eax
call find_export_entry
mov r12, rax
mov rdi, r15
mov esi, ebp
call JS_FreeAtom
test r12, r12
jz short loc_28578
mov rax, [r12+8]
mov rsi, [rax+18h]
mov rdi, r15
mov rdx, r14
mov rcx, rbx
call set_value
xor eax, eax
jmp short loc_28589
loc_28578:
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_FreeValue
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_28589:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long JS_SetModuleExport(long long a1, long long a2, unsigned __int8 *a3, long long a4, long long a5)
{
unsigned int v7; // eax
int v8; // ebp
long long export_entry; // r12
v7 = JS_NewAtom(a1, a3);
if ( v7 && (v8 = v7, export_entry = find_export_entry(a2, v7), JS_FreeAtom(a1, v8), export_entry) )
{
set_value(a1, *(long long **)(*(_QWORD *)(export_entry + 8) + 24LL), a4, a5);
return 0LL;
}
else
{
JS_FreeValue(a1, a4, a5);
return -1LL;
}
}
|
JS_SetModuleExport:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,R8
MOV R14,RCX
MOV R12,RSI
MOV R15,RDI
MOV RSI,RDX
CALL 0x001198f5
TEST EAX,EAX
JZ 0x00128578
MOV EBP,EAX
MOV RDI,R12
MOV ESI,EAX
CALL 0x00128592
MOV R12,RAX
MOV RDI,R15
MOV ESI,EBP
CALL 0x00119e19
TEST R12,R12
JZ 0x00128578
MOV RAX,qword ptr [R12 + 0x8]
MOV RSI,qword ptr [RAX + 0x18]
MOV RDI,R15
MOV RDX,R14
MOV RCX,RBX
CALL 0x00119370
XOR EAX,EAX
JMP 0x00128589
LAB_00128578:
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x001174a2
PUSH -0x1
POP RAX
LAB_00128589:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8
JS_SetModuleExport(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int iVar1;
long lVar2;
iVar1 = JS_NewAtom(param_1,param_3);
if (iVar1 != 0) {
lVar2 = find_export_entry(param_2,iVar1);
JS_FreeAtom(param_1,iVar1);
if (lVar2 != 0) {
set_value(param_1,*(int8 *)(*(long *)(lVar2 + 8) + 0x18),param_4,param_5);
return 0;
}
}
JS_FreeValue(param_1,param_4,param_5);
return 0xffffffffffffffff;
}
|
|
16,042
|
JS_SetModuleExport
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_SetModuleExport(JSContext *ctx, JSModuleDef *m, const char *export_name,
JSValue val)
{
JSExportEntry *me;
JSAtom name;
name = JS_NewAtom(ctx, export_name);
if (name == JS_ATOM_NULL)
goto fail;
me = find_export_entry(ctx, m, name);
JS_FreeAtom(ctx, name);
if (!me)
goto fail;
set_value(ctx, me->u.local.var_ref->pvalue, val);
return 0;
fail:
JS_FreeValue(ctx, val);
return -1;
}
|
O3
|
c
|
JS_SetModuleExport:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq %rdx, %rdi
callq 0xe240
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1f8ef
testl %eax, %eax
je 0x30e40
movslq 0x30(%r12), %rcx
testq %rcx, %rcx
jle 0x30e36
movq 0x28(%r12), %r12
shlq $0x5, %rcx
xorl %r13d, %r13d
cmpl %eax, 0x18(%r12,%r13)
je 0x30e69
addq $0x20, %r13
cmpq %r13, %rcx
jne 0x30e26
movq %r15, %rdi
movl %eax, %esi
callq 0x202f5
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $-0x9, %ebx
jb 0x30ea1
movq 0x18(%r15), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x30ea1
movq %r14, %rsi
movq %rbx, %rdx
callq 0x20d90
jmp 0x30ea1
movq %r15, %rdi
movl %eax, %esi
callq 0x202f5
movq 0x8(%r12,%r13), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
xorl %ebp, %ebp
cmpl $-0x9, %edx
jb 0x30ea1
movq 0x18(%r15), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jle 0x30e62
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_SetModuleExport:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, r8
mov r14, rcx
mov r13, rdx
mov r12, rsi
mov r15, rdi
mov rdi, rdx
call _strlen
mov rdi, r15
mov rsi, r13
mov rdx, rax
call JS_NewAtomLen
test eax, eax
jz short loc_30E40
movsxd rcx, dword ptr [r12+30h]
test rcx, rcx
jle short loc_30E36
mov r12, [r12+28h]
shl rcx, 5
xor r13d, r13d
loc_30E26:
cmp [r12+r13+18h], eax
jz short loc_30E69
add r13, 20h ; ' '
cmp rcx, r13
jnz short loc_30E26
loc_30E36:
mov rdi, r15
mov esi, eax
call JS_FreeAtom
loc_30E40:
mov ebp, 0FFFFFFFFh
cmp ebx, 0FFFFFFF7h
jb short loc_30EA1
mov rdi, [r15+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_30EA1
mov rsi, r14
mov rdx, rbx
loc_30E62:
call js_free_value_rt
jmp short loc_30EA1
loc_30E69:
mov rdi, r15
mov esi, eax
call JS_FreeAtom
mov rax, [r12+r13+8]
mov rax, [rax+18h]
mov rsi, [rax]
mov rdx, [rax+8]
mov [rax], r14
mov [rax+8], rbx
xor ebp, ebp
cmp edx, 0FFFFFFF7h
jb short loc_30EA1
mov rdi, [r15+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jle short loc_30E62
loc_30EA1:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long JS_SetModuleExport(long long a1, long long a2, unsigned __int8 *a3, int *a4, long long a5)
{
long long v8; // rax
int v9; // eax
long long v10; // r8
long long v11; // r9
long long v12; // rcx
long long v13; // r12
long long v14; // rcx
long long v15; // r13
unsigned int v16; // ebp
long long v17; // rdi
int v18; // eax
long long v19; // rcx
int *v20; // rsi
long long v21; // rdx
long long v22; // rax
int v23; // eax
v8 = strlen(a3);
v9 = JS_NewAtomLen(a1, a3, v8);
if ( !v9 )
goto LABEL_7;
v12 = *(int *)(a2 + 48);
if ( v12 <= 0 )
{
LABEL_6:
JS_FreeAtom(a1, v9);
LABEL_7:
v16 = -1;
if ( (unsigned int)a5 < 0xFFFFFFF7 )
return v16;
v17 = *(_QWORD *)(a1 + 24);
v18 = *a4;
v19 = (unsigned int)(*a4 - 1);
*a4 = v19;
if ( v18 > 1 )
return v16;
v20 = a4;
v21 = a5;
LABEL_10:
js_free_value_rt(v17, v20, v21, v19, v10, v11);
return v16;
}
v13 = *(_QWORD *)(a2 + 40);
v14 = 32 * v12;
v15 = 0LL;
while ( *(_DWORD *)(v13 + v15 + 24) != v9 )
{
v15 += 32LL;
if ( v14 == v15 )
goto LABEL_6;
}
JS_FreeAtom(a1, v9);
v22 = *(_QWORD *)(*(_QWORD *)(v13 + v15 + 8) + 24LL);
v20 = *(int **)v22;
v21 = *(_QWORD *)(v22 + 8);
*(_QWORD *)v22 = a4;
*(_QWORD *)(v22 + 8) = a5;
v16 = 0;
if ( (unsigned int)v21 >= 0xFFFFFFF7 )
{
v17 = *(_QWORD *)(a1 + 24);
v23 = *v20;
v19 = (unsigned int)(*v20 - 1);
*v20 = v19;
if ( v23 <= 1 )
goto LABEL_10;
}
return v16;
}
|
JS_SetModuleExport:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R14,RCX
MOV R13,RDX
MOV R12,RSI
MOV R15,RDI
MOV RDI,RDX
CALL 0x0010e240
MOV RDI,R15
MOV RSI,R13
MOV RDX,RAX
CALL 0x0011f8ef
TEST EAX,EAX
JZ 0x00130e40
MOVSXD RCX,dword ptr [R12 + 0x30]
TEST RCX,RCX
JLE 0x00130e36
MOV R12,qword ptr [R12 + 0x28]
SHL RCX,0x5
XOR R13D,R13D
LAB_00130e26:
CMP dword ptr [R12 + R13*0x1 + 0x18],EAX
JZ 0x00130e69
ADD R13,0x20
CMP RCX,R13
JNZ 0x00130e26
LAB_00130e36:
MOV RDI,R15
MOV ESI,EAX
CALL 0x001202f5
LAB_00130e40:
MOV EBP,0xffffffff
CMP EBX,-0x9
JC 0x00130ea1
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00130ea1
MOV RSI,R14
MOV RDX,RBX
LAB_00130e62:
CALL 0x00120d90
JMP 0x00130ea1
LAB_00130e69:
MOV RDI,R15
MOV ESI,EAX
CALL 0x001202f5
MOV RAX,qword ptr [R12 + R13*0x1 + 0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX],R14
MOV qword ptr [RAX + 0x8],RBX
XOR EBP,EBP
CMP EDX,-0x9
JC 0x00130ea1
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JLE 0x00130e62
LAB_00130ea1:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
JS_SetModuleExport(long param_1,long param_2,char *param_3,int *param_4,int8 param_5)
{
long lVar1;
int8 uVar2;
int8 *puVar3;
int *piVar4;
int8 uVar5;
int iVar6;
size_t sVar7;
int8 uVar8;
long lVar9;
sVar7 = strlen(param_3);
iVar6 = JS_NewAtomLen(param_1,param_3,sVar7);
if (iVar6 != 0) {
if (0 < (long)*(int *)(param_2 + 0x30)) {
lVar1 = *(long *)(param_2 + 0x28);
lVar9 = 0;
do {
if (*(int *)(lVar1 + 0x18 + lVar9) == iVar6) {
JS_FreeAtom(param_1,iVar6);
puVar3 = *(int8 **)(*(long *)(lVar1 + 8 + lVar9) + 0x18);
piVar4 = (int *)*puVar3;
uVar5 = puVar3[1];
*puVar3 = param_4;
puVar3[1] = param_5;
uVar8 = 0;
if ((uint)uVar5 < 0xfffffff7) {
return 0;
}
uVar2 = *(int8 *)(param_1 + 0x18);
iVar6 = *piVar4;
*piVar4 = iVar6 + -1;
param_4 = piVar4;
param_5 = uVar5;
goto joined_r0x00130e9f;
}
lVar9 = lVar9 + 0x20;
} while ((long)*(int *)(param_2 + 0x30) * 0x20 != lVar9);
}
JS_FreeAtom(param_1,iVar6);
}
uVar8 = 0xffffffff;
if (0xfffffff6 < (uint)param_5) {
uVar2 = *(int8 *)(param_1 + 0x18);
iVar6 = *param_4;
*param_4 = iVar6 + -1;
joined_r0x00130e9f:
if (iVar6 < 2) {
js_free_value_rt(uVar2,param_4,param_5);
}
}
return uVar8;
}
|
|
16,043
|
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*)
|
monkey531[P]llama/common/./json.hpp
|
static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x57d57(%rip), %rsi # 0x9c2c8
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x262e2
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x3b93c
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3b9b2
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rcx
callq 0x3b8d2
leaq 0x8(%rsp), %rdi
callq 0x20d78
leaq 0x48(%rsp), %rdi
callq 0x20d78
leaq 0x28(%rsp), %rdi
callq 0x20d78
movq 0x68(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4485e
leaq 0x68(%rsp), %rdi
callq 0x20d78
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x4462d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d78
jmp 0x44619
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20d78
jmp 0x44628
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d78
jmp 0x44637
movq %rax, %rbx
movq %rbx, %rdi
callq 0x20b90
|
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_:
push rbp
push r15
push r14
push rbx
sub rsp, 88h
mov r15, rcx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
lea rsi, aOutOfRange; "out_of_range"
lea rdi, [rsp+0A8h+var_80]
lea rdx, [rsp+0A8h+var_A1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+0A8h+var_60]
lea rsi, [rsp+0A8h+var_80]
mov edx, ebp
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea rdi, [rsp+0A8h+var_A0]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail9exception11diagnosticsINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEESC_PKT_; nlohmann::json_abi_v3_11_3::detail::exception::diagnostics<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*)
lea rdi, [rsp+0A8h+var_40]
lea rsi, [rsp+0A8h+var_60]
lea rdx, [rsp+0A8h+var_A0]
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_S8_RKS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(std::string,std::string,std::string const&)
lea rdi, [rsp+0A8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdx, [rsp+0A8h+var_40]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeC2EiPKc; nlohmann::json_abi_v3_11_3::detail::out_of_range::out_of_range(int,char const*)
lea rdi, [rsp+0A8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 88h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_60]
jmp short loc_4462D
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_44619
mov rbx, rax
loc_44619:
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_44628
mov rbx, rax
loc_44628:
lea rdi, [rsp+arg_20]; void *
loc_4462D:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_44637
mov rbx, rax
loc_44637:
mov rdi, rbx
call __Unwind_Resume
|
nlohmann::json_abi_v3_11_3::detail::out_of_range * ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
nlohmann::json_abi_v3_11_3::detail::out_of_range *this,
int a2,
long long a3)
{
_QWORD v5[4]; // [rsp+8h] [rbp-A0h] BYREF
_QWORD v6[4]; // [rsp+28h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+48h] [rbp-60h] BYREF
char *v8[8]; // [rsp+68h] [rbp-40h] BYREF
std::string::basic_string<std::allocator<char>>(v6, (long long)"out_of_range");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v7, (long long)v6, a2);
nlohmann::json_abi_v3_11_3::detail::exception::diagnostics<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>>(v5);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,std::string,std::string,std::string const&>(
(long long)v8,
(long long)v7,
(long long)v5,
a3);
std::string::~string(v5);
std::string::~string(v7);
std::string::~string(v6);
nlohmann::json_abi_v3_11_3::detail::out_of_range::out_of_range(this, a2, v8[0]);
std::string::~string(v8);
return this;
}
| |||
16,044
|
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*)
|
monkey531[P]llama/common/./json.hpp
|
static out_of_range create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("out_of_range", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::out_of_range nlohmann::json_abi_v3_11_3::detail::out_of_range::create<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>*, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x706b1(%rip), %rsi # 0xb9140
leaq 0x706b6(%rip), %rdx # 0xb914c
leaq 0x28(%rsp), %rdi
callq 0x590a2
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %ebp, %edx
callq 0x3e0b6
leaq 0x78(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq 0x8(%r15), %rsi
addq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x18a30
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x181e0
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x181e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x181e0
movq 0x68(%rsp), %rdi
cmpq %r14, %rdi
je 0x48b39
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x48b54
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x186a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x48b6b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x186a0
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3e31e
leaq 0xa5847(%rip), %rax # 0xee3c8
movq %rax, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x48b9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x48c29
movq 0x18(%rsp), %rsi
jmp 0x48c21
movq %rax, %rbx
jmp 0x48c12
movq %rax, %rbx
jmp 0x48c29
movq %rdx, %rbx
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x48beb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x88(%rsp), %r12
movq %r14, %rsi
movq %r15, %rcx
movl %ebx, %r8d
movq %r12, %r9
callq 0x1906d
movq (%r12), %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x48c29
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x186a0
movq %rbx, %rdi
callq 0x18b90
|
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r15, rdx
mov ebp, esi
mov rbx, rdi
lea r13, [rsp+0C8h+var_90]
mov [r13-10h], r13
lea rsi, aOutOfRange; "out_of_range"
lea rdx, aOutOfRange+0Ch; ""
lea rdi, [rsp+0C8h+var_A0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0C8h+var_80]; int
lea rsi, [rsp+0C8h+var_A0]; int
mov edx, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; nlohmann::json_abi_v3_11_3::detail::exception::name(std::string const&,int)
lea r14, [rsp+0C8h+var_50]
mov [r14-10h], r14
xor eax, eax
mov [r14-8], rax
mov [r14], al
lea r12, [rsp+0C8h+var_B0]
mov [r12-10h], r12
mov [r12-8], rax
mov [r12], al
mov rsi, [r15+8]
add rsi, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rsi, qword ptr [rsp+0C8h+var_80]
mov rdx, [rsp+0C8h+var_78]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [rsp+0C8h+var_60]
mov rdx, [rsp+0C8h+var_58]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rsi, [r15]
mov rdx, [r15+8]
lea rdi, [rsp+0C8h+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rdi, [rsp+0C8h+var_60]; void *
cmp rdi, r14
jz short loc_48B39
mov rsi, [rsp+0C8h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48B39:
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_48B54
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48B54:
mov rdi, [rsp+0C8h+var_A0]; void *
cmp rdi, r13
jz short loc_48B6B
mov rsi, [rsp+0C8h+var_90]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48B6B:
mov rdx, [rsp+0C8h+var_C0]; char *
mov rdi, rbx; this
mov esi, ebp; int
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionC2EiPKc; nlohmann::json_abi_v3_11_3::detail::exception::exception(int,char const*)
lea rax, off_EE3C8
mov [rbx], rax
mov rdi, [rsp+0C8h+var_C0]; void *
cmp rdi, r12
jz short loc_48B9B
mov rsi, [rsp+0C8h+var_B0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48B9B:
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+arg_0]
cmp rdi, r12
jz short loc_48C29
mov rsi, [rsp+arg_10]
jmp short loc_48C21
mov rbx, rax
jmp short loc_48C12
mov rbx, rax
jmp short loc_48C29
mov rbx, rdx
mov r15, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_48BEB
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48BEB:
lea rdi, [rsp+arg_60]
lea rdx, [rsp+arg_40]
lea r12, [rsp+arg_80]
mov rsi, r14
mov rcx, r15
mov r8d, ebx
mov r9, r12
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5__cold_1
mov rbx, [r12]
loc_48C12:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r13
jz short loc_48C29
mov rsi, [rsp+arg_30]
loc_48C21:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48C29:
mov rdi, rbx
call __Unwind_Resume
|
nlohmann::json_abi_v3_11_3::detail::exception * ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
nlohmann::json_abi_v3_11_3::detail::exception *this,
int a2,
_QWORD *a3)
{
char *v5[2]; // [rsp+8h] [rbp-C0h] BYREF
_QWORD v6[2]; // [rsp+18h] [rbp-B0h] BYREF
void *v7[2]; // [rsp+28h] [rbp-A0h] BYREF
_QWORD v8[2]; // [rsp+38h] [rbp-90h] BYREF
int v9[2]; // [rsp+48h] [rbp-80h] BYREF
long long v10; // [rsp+50h] [rbp-78h]
long long v11; // [rsp+58h] [rbp-70h] BYREF
void *v12; // [rsp+68h] [rbp-60h]
long long v13; // [rsp+70h] [rbp-58h]
_QWORD v14[10]; // [rsp+78h] [rbp-50h] BYREF
v7[0] = v8;
std::string::_M_construct<char const*>(v7, "out_of_range", "");
nlohmann::json_abi_v3_11_3::detail::exception::name((long long)v9, (long long)v7, a2);
v12 = v14;
v13 = 0LL;
LOBYTE(v14[0]) = 0;
v5[0] = (char *)v6;
v5[1] = 0LL;
LOBYTE(v6[0]) = 0;
std::string::reserve(v5, v10 + a3[1]);
std::string::_M_append(v5, *(_QWORD *)v9, v10);
std::string::_M_append(v5, v12, v13);
std::string::_M_append(v5, *a3, a3[1]);
if ( v12 != v14 )
operator delete(v12, v14[0] + 1LL);
if ( *(long long **)v9 != &v11 )
operator delete(*(void **)v9, v11 + 1);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
nlohmann::json_abi_v3_11_3::detail::exception::exception(this, a2, v5[0]);
*(_QWORD *)this = off_EE3C8;
if ( (_QWORD *)v5[0] != v6 )
operator delete(v5[0], v6[0] + 1LL);
return this;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R15,RDX
MOV EBP,ESI
MOV RBX,RDI
LEA R13,[RSP + 0x38]
MOV qword ptr [R13 + -0x10],R13
LAB_00148a88:
LEA RSI,[0x1b9140]
LEA RDX,[0x1b914c]
LEA RDI,[RSP + 0x28]
CALL 0x001590a2
LAB_00148aa0:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
MOV EDX,EBP
CALL 0x0013e0b6
LEA R14,[RSP + 0x78]
MOV qword ptr [R14 + -0x10],R14
XOR EAX,EAX
MOV qword ptr [R14 + -0x8],RAX
MOV byte ptr [R14],AL
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV qword ptr [R12 + -0x8],RAX
MOV byte ptr [R12],AL
MOV RSI,qword ptr [R15 + 0x8]
ADD RSI,qword ptr [RSP + 0x50]
LAB_00148adf:
LEA RDI,[RSP + 0x8]
CALL 0x00118a30
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
LEA RDI,[RSP + 0x8]
CALL 0x001181e0
MOV RSI,qword ptr [RSP + 0x68]
MOV RDX,qword ptr [RSP + 0x70]
LEA RDI,[RSP + 0x8]
CALL 0x001181e0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LEA RDI,[RSP + 0x8]
CALL 0x001181e0
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,R14
JZ 0x00148b39
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001186a0
LAB_00148b39:
LEA RAX,[RSP + 0x58]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00148b54
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001186a0
LAB_00148b54:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R13
JZ 0x00148b6b
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001186a0
LAB_00148b6b:
MOV RDX,qword ptr [RSP + 0x8]
LAB_00148b70:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x0013e31e
LAB_00148b7a:
LEA RAX,[0x1ee3c8]
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x00148b9b
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186a0
LAB_00148b9b:
MOV RAX,RBX
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
exception *
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(exception *param_1,int param_2,ulong *param_3)
{
char *local_c0;
int8 local_b8;
char local_b0;
int7 uStack_af;
long *local_a0 [2];
long local_90 [2];
long *local_80 [2];
long local_70 [2];
int1 *local_60;
int8 local_58;
int1 local_50;
int7 uStack_4f;
/* try { // try from 00148a88 to 00148a9f has its CatchHandler @ 00148bc9 */
local_a0[0] = local_90;
std::__cxx11::string::_M_construct<char_const*>(local_a0,"out_of_range","");
/* try { // try from 00148aa0 to 00148ab0 has its CatchHandler @ 00148bc4 */
nlohmann::json_abi_v3_11_3::detail::exception::name
((exception *)local_80,(string *)local_a0,param_2);
local_58 = 0;
local_50 = 0;
local_b8 = 0;
local_b0 = '\0';
/* try { // try from 00148adf to 00148b21 has its CatchHandler @ 00148bce */
local_c0 = &local_b0;
local_60 = &local_50;
std::__cxx11::string::reserve((ulong)&local_c0);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_80[0]);
std::__cxx11::string::_M_append((char *)&local_c0,(ulong)local_60);
std::__cxx11::string::_M_append((char *)&local_c0,*param_3);
if (local_60 != &local_50) {
operator_delete(local_60,CONCAT71(uStack_4f,local_50) + 1);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0],local_70[0] + 1);
}
if (local_a0[0] != local_90) {
operator_delete(local_a0[0],local_90[0] + 1);
}
/* try { // try from 00148b70 to 00148b79 has its CatchHandler @ 00148bb0 */
nlohmann::json_abi_v3_11_3::detail::exception::exception(param_1,param_2,local_c0);
*(int ***)param_1 = &PTR__exception_001ee3c8;
if (local_c0 != &local_b0) {
operator_delete(local_c0,CONCAT71(uStack_af,local_b0) + 1);
}
return param_1;
}
|
|
16,045
|
set_process_priority(ggml_sched_priority)
|
monkey531[P]llama/common/common.cpp
|
bool set_process_priority(enum ggml_sched_priority prio) {
if (prio == GGML_SCHED_PRIO_NORMAL) {
return true;
}
int p = 0;
switch (prio) {
case GGML_SCHED_PRIO_NORMAL: p = 0; break;
case GGML_SCHED_PRIO_MEDIUM: p = -5; break;
case GGML_SCHED_PRIO_HIGH: p = -10; break;
case GGML_SCHED_PRIO_REALTIME: p = -20; break;
}
if (!setpriority(PRIO_PROCESS, 0, p)) {
LOG_WRN("failed to set process priority %d : %s (%d)\n", prio, strerror(errno), errno);
return false;
}
return true;
}
|
O0
|
cpp
|
set_process_priority(ggml_sched_priority):
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
cmpl $0x0, 0x30(%rsp)
jne 0xed399
movb $0x1, 0x37(%rsp)
jmp 0xed466
movl $0x0, 0x2c(%rsp)
movl 0x30(%rsp), %eax
movq %rax, 0x20(%rsp)
subq $0x3, %rax
ja 0xed3eb
movq 0x20(%rsp), %rax
leaq 0x123f54(%rip), %rcx # 0x211310
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, 0x2c(%rsp)
jmp 0xed3eb
movl $0xfffffffb, 0x2c(%rsp) # imm = 0xFFFFFFFB
jmp 0xed3eb
movl $0xfffffff6, 0x2c(%rsp) # imm = 0xFFFFFFF6
jmp 0xed3eb
movl $0xffffffec, 0x2c(%rsp) # imm = 0xFFFFFFEC
movl 0x2c(%rsp), %edx
xorl %esi, %esi
movl %esi, %edi
callq 0x5a9c0
cmpl $0x0, %eax
jne 0xed461
jmp 0xed3ff
xorl %eax, %eax
leaq 0x1b9200(%rip), %rcx # 0x2a6608
cmpl (%rcx), %eax
jg 0xed458
callq 0x1bfde0
movq %rax, 0x8(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x5b150
movl (%rax), %edi
callq 0x5ada0
movq %rax, 0x18(%rsp)
callq 0x5b150
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %r8
movl (%rax), %r9d
movl $0x3, %esi
leaq 0x1247a9(%rip), %rdx # 0x211bfa
movb $0x0, %al
callq 0x1bfed0
jmp 0xed45a
movb $0x0, 0x37(%rsp)
jmp 0xed466
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
|
_Z20set_process_priority19ggml_sched_priority:
sub rsp, 38h
mov [rsp+38h+var_8], edi
cmp [rsp+38h+var_8], 0
jnz short loc_ED399
mov [rsp+38h+var_1], 1
jmp loc_ED466
loc_ED399:
mov [rsp+38h+var_C], 0
mov eax, [rsp+38h+var_8]
mov [rsp+38h+var_18], rax
sub rax, 3; switch 4 cases
ja short def_ED3C3; jumptable 00000000000ED3C3 default case
mov rax, [rsp+38h+var_18]
lea rcx, jpt_ED3C3
movsxd rax, ds:(jpt_ED3C3 - 211310h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_ED3C5:
mov [rsp+38h+var_C], 0; jumptable 00000000000ED3C3 case 0
jmp short def_ED3C3; jumptable 00000000000ED3C3 default case
loc_ED3CF:
mov [rsp+38h+var_C], 0FFFFFFFBh; jumptable 00000000000ED3C3 case 1
jmp short def_ED3C3; jumptable 00000000000ED3C3 default case
loc_ED3D9:
mov [rsp+38h+var_C], 0FFFFFFF6h; jumptable 00000000000ED3C3 case 2
jmp short def_ED3C3; jumptable 00000000000ED3C3 default case
loc_ED3E3:
mov [rsp+38h+var_C], 0FFFFFFECh; jumptable 00000000000ED3C3 case 3
def_ED3C3:
mov edx, [rsp+38h+var_C]; jumptable 00000000000ED3C3 default case
xor esi, esi
mov edi, esi
call _setpriority
cmp eax, 0
jnz short loc_ED461
jmp short $+2
loc_ED3FF:
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_ED458
call _Z15common_log_mainv; common_log_main(void)
mov [rsp+38h+var_30], rax
mov eax, [rsp+38h+var_8]
mov [rsp+38h+var_24], eax
call ___errno_location
mov edi, [rax]
call _strerror
mov [rsp+38h+var_20], rax
call ___errno_location
mov rdi, [rsp+38h+var_30]
mov ecx, [rsp+38h+var_24]
mov r8, [rsp+38h+var_20]
mov r9d, [rax]
mov esi, 3
lea rdx, aFailedToSetPro; "failed to set process priority %d : %s "...
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_ED458:
jmp short $+2
loc_ED45A:
mov [rsp+38h+var_1], 0
jmp short loc_ED466
loc_ED461:
mov [rsp+38h+var_1], 1
loc_ED466:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
|
char set_process_priority(int a1)
{
unsigned int *v1; // rax
_DWORD *v2; // rax
int v4; // [rsp+8h] [rbp-30h]
int v5; // [rsp+18h] [rbp-20h]
unsigned int v6; // [rsp+2Ch] [rbp-Ch]
if ( !a1 )
return 1;
v6 = 0;
switch ( a1 )
{
case 0:
v6 = 0;
break;
case 1:
v6 = -5;
break;
case 2:
v6 = -10;
break;
case 3:
v6 = -20;
break;
default:
break;
}
if ( (unsigned int)setpriority(0LL, 0LL, v6) )
return 1;
if ( common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
v1 = (unsigned int *)__errno_location();
v5 = strerror(*v1);
v2 = (_DWORD *)__errno_location();
common_log_add(v4, 3, (unsigned int)"failed to set process priority %d : %s (%d)\n", a1, v5, *v2);
}
return 0;
}
|
set_process_priority:
SUB RSP,0x38
MOV dword ptr [RSP + 0x30],EDI
CMP dword ptr [RSP + 0x30],0x0
JNZ 0x001ed399
MOV byte ptr [RSP + 0x37],0x1
JMP 0x001ed466
LAB_001ed399:
MOV dword ptr [RSP + 0x2c],0x0
MOV EAX,dword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
SUB RAX,0x3
JA 0x001ed3eb
MOV RAX,qword ptr [RSP + 0x20]
LEA RCX,[0x311310]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV dword ptr [RSP + 0x2c],0xfffffffb
JMP 0x001ed3eb
caseD_2:
MOV dword ptr [RSP + 0x2c],0xfffffff6
JMP 0x001ed3eb
caseD_3:
MOV dword ptr [RSP + 0x2c],0xffffffec
default:
MOV EDX,dword ptr [RSP + 0x2c]
XOR ESI,ESI
MOV EDI,ESI
CALL 0x0015a9c0
CMP EAX,0x0
JNZ 0x001ed461
JMP 0x001ed3ff
LAB_001ed3ff:
XOR EAX,EAX
LEA RCX,[0x3a6608]
CMP EAX,dword ptr [RCX]
JG 0x001ed458
CALL 0x002bfde0
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RSP + 0x30]
MOV dword ptr [RSP + 0x14],EAX
CALL 0x0015b150
MOV EDI,dword ptr [RAX]
CALL 0x0015ada0
MOV qword ptr [RSP + 0x18],RAX
CALL 0x0015b150
MOV RDI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSP + 0x14]
MOV R8,qword ptr [RSP + 0x18]
MOV R9D,dword ptr [RAX]
MOV ESI,0x3
LEA RDX,[0x311bfa]
MOV AL,0x0
CALL 0x002bfed0
LAB_001ed458:
JMP 0x001ed45a
LAB_001ed45a:
MOV byte ptr [RSP + 0x37],0x0
JMP 0x001ed466
LAB_001ed461:
MOV byte ptr [RSP + 0x37],0x1
LAB_001ed466:
MOV AL,byte ptr [RSP + 0x37]
AND AL,0x1
ADD RSP,0x38
RET
|
/* set_process_priority(ggml_sched_priority) */
int1 set_process_priority(int param_1)
{
int iVar1;
int8 uVar2;
int *piVar3;
char *pcVar4;
int local_c;
int1 local_1;
if (param_1 == 0) {
local_1 = 1;
}
else {
local_c = 0;
switch(param_1) {
case 1:
local_c = -5;
break;
case 2:
local_c = -10;
break;
case 3:
local_c = -0x14;
}
iVar1 = setpriority(PRIO_PROCESS,0,local_c);
if (iVar1 == 0) {
if (-1 < common_log_verbosity_thold) {
uVar2 = common_log_main();
piVar3 = __errno_location();
pcVar4 = strerror(*piVar3);
piVar3 = __errno_location();
common_log_add(uVar2,3,"failed to set process priority %d : %s (%d)\n",param_1,pcVar4,
*piVar3);
}
local_1 = 0;
}
else {
local_1 = 1;
}
}
return local_1;
}
|
|
16,046
|
Proc_update_accounts_derived_flags::operator()(PFS_account*)
|
eloqsql/storage/perfschema/pfs_account.cc
|
virtual void operator()(PFS_account *pfs)
{
if (pfs->m_username_length > 0 && pfs->m_hostname_length > 0)
{
lookup_setup_actor(m_thread,
pfs->m_username, pfs->m_username_length,
pfs->m_hostname, pfs->m_hostname_length,
& pfs->m_enabled, & pfs->m_history);
}
else
{
pfs->m_enabled= true;
pfs->m_history= true;
}
}
|
O3
|
cpp
|
Proc_update_accounts_derived_flags::operator()(PFS_account*):
movl 0xa78(%rsi), %edx
testl %edx, %edx
je 0x3faee
movl 0xa88(%rsi), %r8d
testl %r8d, %r8d
je 0x3faee
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x8(%rdi), %rdi
movq 0xa70(%rsi), %rax
movq 0xa80(%rsi), %rcx
leaq 0xa6c(%rsi), %r9
addq $0xa6d, %rsi # imm = 0xA6D
movq %rsi, (%rsp)
movq %rax, %rsi
callq 0x39143
addq $0x10, %rsp
popq %rbp
retq
movw $0x101, 0xa6c(%rsi) # imm = 0x101
retq
|
_ZN34Proc_update_accounts_derived_flagsclEP11PFS_account:
mov edx, [rsi+0A78h]; unsigned int
test edx, edx
jz short loc_3FAEE
mov r8d, [rsi+0A88h]; unsigned int
test r8d, r8d
jz short loc_3FAEE
push rbp
mov rbp, rsp
sub rsp, 10h
mov rdi, [rdi+8]; PFS_thread *
mov rax, [rsi+0A70h]
mov rcx, [rsi+0A80h]; char *
lea r9, [rsi+0A6Ch]; bool *
add rsi, 0A6Dh
mov [rsp+18h+var_18], rsi; bool *
mov rsi, rax; char *
call _Z18lookup_setup_actorP10PFS_threadPKcjS2_jPbS3_; lookup_setup_actor(PFS_thread *,char const*,uint,char const*,uint,bool *,bool *)
add rsp, 10h
pop rbp
retn
loc_3FAEE:
mov word ptr [rsi+0A6Ch], 101h
retn
|
unsigned long long Proc_update_accounts_derived_flags::operator()(long long a1, long long a2)
{
unsigned int v2; // edx
unsigned int v3; // r8d
unsigned long long result; // rax
v2 = *(_DWORD *)(a2 + 2680);
if ( v2 )
{
v3 = *(_DWORD *)(a2 + 2696);
if ( v3 )
return lookup_setup_actor(
*(PFS_thread **)(a1 + 8),
*(const char **)(a2 + 2672),
v2,
*(const char **)(a2 + 2688),
v3,
(bool *)(a2 + 2668),
(bool *)(a2 + 2669));
}
*(_WORD *)(a2 + 2668) = 257;
return result;
}
|
operator():
MOV EDX,dword ptr [RSI + 0xa78]
TEST EDX,EDX
JZ 0x0013faee
MOV R8D,dword ptr [RSI + 0xa88]
TEST R8D,R8D
JZ 0x0013faee
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RSI + 0xa70]
MOV RCX,qword ptr [RSI + 0xa80]
LEA R9,[RSI + 0xa6c]
ADD RSI,0xa6d
MOV qword ptr [RSP],RSI
MOV RSI,RAX
CALL 0x00139143
ADD RSP,0x10
POP RBP
RET
LAB_0013faee:
MOV word ptr [RSI + 0xa6c],0x101
RET
|
/* Proc_update_accounts_derived_flags::TEMPNAMEPLACEHOLDERVALUE(PFS_account*) */
void __thiscall
Proc_update_accounts_derived_flags::operator()
(Proc_update_accounts_derived_flags *this,PFS_account *param_1)
{
if ((*(uint *)(param_1 + 0xa78) != 0) && (*(uint *)(param_1 + 0xa88) != 0)) {
lookup_setup_actor(*(PFS_thread **)(this + 8),*(char **)(param_1 + 0xa70),
*(uint *)(param_1 + 0xa78),*(char **)(param_1 + 0xa80),
*(uint *)(param_1 + 0xa88),(bool *)(param_1 + 0xa6c),
(bool *)(param_1 + 0xa6d));
return;
}
*(int2 *)(param_1 + 0xa6c) = 0x101;
return;
}
|
|
16,047
|
ma_pvio_register_callback
|
eloqsql/libmariadb/libmariadb/ma_pvio.c
|
int ma_pvio_register_callback(my_bool register_callback,
void (*callback_function)(int mode, MYSQL *mysql, const uchar *buffer, size_t length))
{
LIST *list;
if (!callback_function)
return 1;
/* plugin will unregister in it's deinit function */
if (register_callback)
{
list= (LIST *)malloc(sizeof(LIST));
list->data= (void *)callback_function;
pvio_callback= list_add(pvio_callback, list);
}
else /* unregister callback function */
{
LIST *p= pvio_callback;
while (p)
{
if (p->data == callback_function)
{
list_delete(pvio_callback, p);
break;
}
p= p->next;
}
}
return 0;
}
|
O0
|
c
|
ma_pvio_register_callback:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xac7c5
movl $0x1, -0x4(%rbp)
jmp 0xac856
cmpb $0x0, -0x5(%rbp)
je 0xac807
movl $0x18, %edi
callq 0x3a920
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x3c0dfc(%rip), %rax # 0x46d5e8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xab370
movq %rax, %rcx
leaq 0x3c0de6(%rip), %rax # 0x46d5e8
movq %rcx, (%rax)
jmp 0xac84f
leaq 0x3c0dda(%rip), %rax # 0x46d5e8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xac84d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0xac83f
leaq 0x3c0db7(%rip), %rax # 0x46d5e8
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xab3e0
jmp 0xac84d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xac815
jmp 0xac84f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
|
ma_pvio_register_callback:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, dil
mov [rbp+var_5], al
mov [rbp+var_10], rsi
cmp [rbp+var_10], 0
jnz short loc_AC7C5
mov [rbp+var_4], 1
jmp loc_AC856
loc_AC7C5:
cmp [rbp+var_5], 0
jz short loc_AC807
mov edi, 18h
call _malloc
mov [rbp+var_18], rax
mov rcx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+10h], rcx
lea rax, pvio_callback
mov rdi, [rax]
mov rsi, [rbp+var_18]
call list_add
mov rcx, rax
lea rax, pvio_callback
mov [rax], rcx
jmp short loc_AC84F
loc_AC807:
lea rax, pvio_callback
mov rax, [rax]
mov [rbp+var_20], rax
loc_AC815:
cmp [rbp+var_20], 0
jz short loc_AC84D
mov rax, [rbp+var_20]
mov rax, [rax+10h]
cmp rax, [rbp+var_10]
jnz short loc_AC83F
lea rax, pvio_callback
mov rdi, [rax]
mov rsi, [rbp+var_20]
call list_delete
jmp short loc_AC84D
loc_AC83F:
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov [rbp+var_20], rax
jmp short loc_AC815
loc_AC84D:
jmp short $+2
loc_AC84F:
mov [rbp+var_4], 0
loc_AC856:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long ma_pvio_register_callback(char a1, long long a2)
{
_QWORD *i; // [rsp+0h] [rbp-20h]
_QWORD *v4; // [rsp+8h] [rbp-18h]
if ( a2 )
{
if ( a1 )
{
v4 = (_QWORD *)malloc(24LL);
v4[2] = a2;
pvio_callback = (long long)list_add(pvio_callback, v4);
}
else
{
for ( i = (_QWORD *)pvio_callback; i; i = (_QWORD *)i[1] )
{
if ( i[2] == a2 )
{
list_delete(pvio_callback, i);
break;
}
}
}
return 0;
}
else
{
return 1;
}
}
|
ma_pvio_register_callback:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,DIL
MOV byte ptr [RBP + -0x5],AL
MOV qword ptr [RBP + -0x10],RSI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001ac7c5
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001ac856
LAB_001ac7c5:
CMP byte ptr [RBP + -0x5],0x0
JZ 0x001ac807
MOV EDI,0x18
CALL 0x0013a920
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],RCX
LEA RAX,[0x56d5e8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001ab370
MOV RCX,RAX
LEA RAX,[0x56d5e8]
MOV qword ptr [RAX],RCX
JMP 0x001ac84f
LAB_001ac807:
LEA RAX,[0x56d5e8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
LAB_001ac815:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001ac84d
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
CMP RAX,qword ptr [RBP + -0x10]
JNZ 0x001ac83f
LEA RAX,[0x56d5e8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001ab3e0
JMP 0x001ac84d
LAB_001ac83f:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ac815
LAB_001ac84d:
JMP 0x001ac84f
LAB_001ac84f:
MOV dword ptr [RBP + -0x4],0x0
LAB_001ac856:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 ma_pvio_register_callback(char param_1,long param_2)
{
void *pvVar1;
int8 local_28;
int4 local_c;
if (param_2 == 0) {
local_c = 1;
}
else {
if (param_1 == '\0') {
for (local_28 = pvio_callback; local_28 != 0; local_28 = *(long *)(local_28 + 8)) {
if (*(long *)(local_28 + 0x10) == param_2) {
list_delete(pvio_callback,local_28);
break;
}
}
}
else {
pvVar1 = malloc(0x18);
*(long *)((long)pvVar1 + 0x10) = param_2;
pvio_callback = list_add(pvio_callback,pvVar1);
}
local_c = 0;
}
return local_c;
}
|
|
16,048
|
inherit_charset_data
|
eloqsql/mysys/charset.c
|
static void
inherit_charset_data(struct charset_info_st *cs, CHARSET_INFO *refcs)
{
if (!cs->to_upper)
cs->to_upper= refcs->to_upper;
if (!cs->to_lower)
cs->to_lower= refcs->to_lower;
if (!cs->m_ctype)
cs->m_ctype= refcs->m_ctype;
if (!cs->tab_to_uni)
cs->tab_to_uni= refcs->tab_to_uni;
}
|
O0
|
c
|
inherit_charset_data:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xdd9d7
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xdd9f2
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xdda0d
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0xdda28
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
popq %rbp
retq
nopw (%rax,%rax)
|
inherit_charset_data:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
cmp qword ptr [rax+50h], 0
jnz short loc_DD9D7
mov rax, [rbp+var_10]
mov rcx, [rax+50h]
mov rax, [rbp+var_8]
mov [rax+50h], rcx
loc_DD9D7:
mov rax, [rbp+var_8]
cmp qword ptr [rax+48h], 0
jnz short loc_DD9F2
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
mov rax, [rbp+var_8]
mov [rax+48h], rcx
loc_DD9F2:
mov rax, [rbp+var_8]
cmp qword ptr [rax+40h], 0
jnz short loc_DDA0D
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_8]
mov [rax+40h], rcx
loc_DDA0D:
mov rax, [rbp+var_8]
cmp qword ptr [rax+68h], 0
jnz short loc_DDA28
mov rax, [rbp+var_10]
mov rcx, [rax+68h]
mov rax, [rbp+var_8]
mov [rax+68h], rcx
loc_DDA28:
pop rbp
retn
|
_QWORD * inherit_charset_data(_QWORD *a1, _QWORD *a2)
{
_QWORD *result; // rax
if ( !a1[10] )
a1[10] = a2[10];
if ( !a1[9] )
a1[9] = a2[9];
if ( !a1[8] )
a1[8] = a2[8];
result = a1;
if ( !a1[13] )
{
result = a1;
a1[13] = a2[13];
}
return result;
}
|
inherit_charset_data:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x50],0x0
JNZ 0x001dd9d7
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x50],RCX
LAB_001dd9d7:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x48],0x0
JNZ 0x001dd9f2
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x48],RCX
LAB_001dd9f2:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x001dda0d
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],RCX
LAB_001dda0d:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x001dda28
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x68]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x68],RCX
LAB_001dda28:
POP RBP
RET
|
void inherit_charset_data(long param_1,long param_2)
{
if (*(long *)(param_1 + 0x50) == 0) {
*(int8 *)(param_1 + 0x50) = *(int8 *)(param_2 + 0x50);
}
if (*(long *)(param_1 + 0x48) == 0) {
*(int8 *)(param_1 + 0x48) = *(int8 *)(param_2 + 0x48);
}
if (*(long *)(param_1 + 0x40) == 0) {
*(int8 *)(param_1 + 0x40) = *(int8 *)(param_2 + 0x40);
}
if (*(long *)(param_1 + 0x68) == 0) {
*(int8 *)(param_1 + 0x68) = *(int8 *)(param_2 + 0x68);
}
return;
}
|
|
16,049
|
mi_checksum
|
eloqsql/storage/myisam/mi_checksum.c
|
ha_checksum mi_checksum(MI_INFO *info, const uchar *buf)
{
ha_checksum crc=0;
const uchar *record= buf;
MI_COLUMNDEF *column= info->s->rec;
MI_COLUMNDEF *column_end= column+ info->s->base.fields;
my_bool skip_null_bits= MY_TEST(info->s->options & HA_OPTION_NULL_FIELDS);
for ( ; column != column_end ; buf+= column++->length)
{
const uchar *pos;
ulong length;
if ((record[column->null_pos] & column->null_bit) &&
skip_null_bits)
continue; /* Null field */
switch (column->type) {
case FIELD_BLOB:
{
length=_mi_calc_blob_length(column->length-
portable_sizeof_char_ptr,
buf);
memcpy((void*) &pos, buf+column->length - portable_sizeof_char_ptr,
sizeof(char*));
break;
}
case FIELD_VARCHAR:
{
uint pack_length= HA_VARCHAR_PACKLENGTH(column->length-1);
if (pack_length == 1)
length= (ulong) *(uchar*) buf;
else
length= uint2korr(buf);
pos= buf+pack_length;
break;
}
default:
length=column->length;
pos=buf;
break;
}
crc=my_checksum(crc, pos ? pos : (uchar*) "", length);
}
return crc;
}
|
O0
|
c
|
mi_checksum:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x230(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
imulq $0x30, 0x168(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x318(%rax), %rdx
andq $0x400, %rdx # imm = 0x400
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, -0x31(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0xd6c9b
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movzbl 0xc(%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xd6b8c
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0xd6b8c
jmp 0xd6c75
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x50(%rbp)
subl $0x4, %eax
je 0xd6ba9
jmp 0xd6b9c
movl -0x50(%rbp), %eax
subl $0x8, %eax
je 0xd6bdb
jmp 0xd6c2a
movq -0x28(%rbp), %rax
movzwl 0x4(%rax), %edi
subl $0x8, %edi
movq -0x10(%rbp), %rsi
callq 0xaae10
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
movslq %ecx, %rcx
movq -0x8(%rax,%rcx), %rax
movq %rax, -0x40(%rbp)
jmp 0xd6c3e
movq -0x28(%rbp), %rax
movzwl 0x4(%rax), %edx
subl $0x1, %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x100, %edx # imm = 0x100
cmovll %ecx, %eax
movl %eax, -0x4c(%rbp)
cmpl $0x1, -0x4c(%rbp)
jne 0xd6c0f
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x48(%rbp)
jmp 0xd6c1a
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl -0x4c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0xd6c3e
movq -0x28(%rbp), %rax
movzwl 0x4(%rax), %eax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xd6c55
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0xd6c62
leaq 0x80e6e(%rip), %rax # 0x157aca
movq %rax, -0x60(%rbp)
jmp 0xd6c62
movl -0x54(%rbp), %edi
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x102100
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0x28(%rbp)
movzwl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xd6b51
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mi_checksum:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], 0
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+230h]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
imul rcx, [rcx+168h], 30h ; '0'
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rdx, [rax+318h]
and rdx, 400h
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_31], al
loc_D6B51:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jz loc_D6C9B
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
movzx ecx, word ptr [rcx+0Eh]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_28]
movzx ecx, byte ptr [rcx+0Ch]
and eax, ecx
cmp eax, 0
jz short loc_D6B8C
movsx eax, [rbp+var_31]
cmp eax, 0
jz short loc_D6B8C
jmp loc_D6C75
loc_D6B8C:
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_50], eax
sub eax, 4
jz short loc_D6BA9
jmp short $+2
loc_D6B9C:
mov eax, [rbp+var_50]
sub eax, 8
jz short loc_D6BDB
jmp loc_D6C2A
loc_D6BA9:
mov rax, [rbp+var_28]
movzx edi, word ptr [rax+4]
sub edi, 8
mov rsi, [rbp+var_10]
call _mi_calc_blob_length
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
movzx ecx, word ptr [rcx+4]
movsxd rcx, ecx
mov rax, [rax+rcx-8]
mov [rbp+var_40], rax
jmp short loc_D6C3E
loc_D6BDB:
mov rax, [rbp+var_28]
movzx edx, word ptr [rax+4]
sub edx, 1
mov eax, 2
mov ecx, 1
cmp edx, 100h
cmovl eax, ecx
mov [rbp+var_4C], eax
cmp [rbp+var_4C], 1
jnz short loc_D6C0F
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
mov [rbp+var_48], rax
jmp short loc_D6C1A
loc_D6C0F:
mov rax, [rbp+var_10]
movzx eax, word ptr [rax]
mov [rbp+var_48], rax
loc_D6C1A:
mov rax, [rbp+var_10]
mov ecx, [rbp+var_4C]
add rax, rcx
mov [rbp+var_40], rax
jmp short loc_D6C3E
loc_D6C2A:
mov rax, [rbp+var_28]
movzx eax, word ptr [rax+4]
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
loc_D6C3E:
mov eax, [rbp+var_14]
mov [rbp+var_54], eax
cmp [rbp+var_40], 0
jz short loc_D6C55
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
jmp short loc_D6C62
loc_D6C55:
lea rax, asc_157AC6+4; ""
mov [rbp+var_60], rax
jmp short $+2
loc_D6C62:
mov edi, [rbp+var_54]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_48]
call my_checksum
mov [rbp+var_14], eax
loc_D6C75:
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 30h ; '0'
mov [rbp+var_28], rcx
movzx ecx, word ptr [rax+4]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_D6B51
loc_D6C9B:
mov eax, [rbp+var_14]
add rsp, 60h
pop rbp
retn
|
long long mi_checksum(long long a1, unsigned __int8 *a2)
{
unsigned int v2; // eax
unsigned int v3; // eax
long long v4; // rax
long long v6; // [rsp+18h] [rbp-48h]
unsigned __int8 *v7; // [rsp+20h] [rbp-40h]
bool v8; // [rsp+2Fh] [rbp-31h]
long long v9; // [rsp+30h] [rbp-30h]
long long v10; // [rsp+38h] [rbp-28h]
unsigned int v11; // [rsp+4Ch] [rbp-14h]
unsigned __int8 *v12; // [rsp+50h] [rbp-10h]
v12 = a2;
v11 = 0;
v10 = *(_QWORD *)(*(_QWORD *)a1 + 560LL);
v9 = 48LL * *(_QWORD *)(*(_QWORD *)a1 + 360LL) + v10;
v8 = (*(_QWORD *)(*(_QWORD *)a1 + 792LL) & 0x400LL) != 0;
while ( v10 != v9 )
{
if ( (*(_BYTE *)(v10 + 12) & a2[*(unsigned __int16 *)(v10 + 14)]) == 0 || !v8 )
{
if ( *(_DWORD *)v10 == 4 )
{
v6 = mi_calc_blob_length((unsigned int)*(unsigned __int16 *)(v10 + 4) - 8, v12);
v7 = *(unsigned __int8 **)&v12[*(unsigned __int16 *)(v10 + 4) - 8];
}
else if ( *(_DWORD *)v10 == 8 )
{
v2 = 2;
if ( *(unsigned __int16 *)(v10 + 4) - 1 < 256 )
v2 = 1;
if ( v2 == 1 )
v6 = *v12;
else
v6 = *(unsigned __int16 *)v12;
v7 = &v12[v2];
}
else
{
v6 = *(unsigned __int16 *)(v10 + 4);
v7 = v12;
}
if ( v7 )
v3 = my_checksum(v11, v7, v6);
else
v3 = my_checksum(v11, "", v6);
v11 = v3;
}
v4 = v10;
v10 += 48LL;
v12 += *(unsigned __int16 *)(v4 + 4);
}
return v11;
}
|
mi_checksum:
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],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x230]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
IMUL RCX,qword ptr [RCX + 0x168],0x30
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x318]
AND RDX,0x400
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV byte ptr [RBP + -0x31],AL
LAB_001d6b51:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001d6c9b
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RCX + 0xe]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,byte ptr [RCX + 0xc]
AND EAX,ECX
CMP EAX,0x0
JZ 0x001d6b8c
MOVSX EAX,byte ptr [RBP + -0x31]
CMP EAX,0x0
JZ 0x001d6b8c
JMP 0x001d6c75
LAB_001d6b8c:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x50],EAX
SUB EAX,0x4
JZ 0x001d6ba9
JMP 0x001d6b9c
LAB_001d6b9c:
MOV EAX,dword ptr [RBP + -0x50]
SUB EAX,0x8
JZ 0x001d6bdb
JMP 0x001d6c2a
LAB_001d6ba9:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EDI,word ptr [RAX + 0x4]
SUB EDI,0x8
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001aae10
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RCX + 0x4]
MOVSXD RCX,ECX
MOV RAX,qword ptr [RAX + RCX*0x1 + -0x8]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001d6c3e
LAB_001d6bdb:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EDX,word ptr [RAX + 0x4]
SUB EDX,0x1
MOV EAX,0x2
MOV ECX,0x1
CMP EDX,0x100
CMOVL EAX,ECX
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x4c],0x1
JNZ 0x001d6c0f
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001d6c1a
LAB_001d6c0f:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,word ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_001d6c1a:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x4c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001d6c3e
LAB_001d6c2a:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX + 0x4]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
LAB_001d6c3e:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x40],0x0
JZ 0x001d6c55
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001d6c62
LAB_001d6c55:
LEA RAX,[0x257aca]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001d6c62
LAB_001d6c62:
MOV EDI,dword ptr [RBP + -0x54]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00202100
MOV dword ptr [RBP + -0x14],EAX
LAB_001d6c75:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x30
MOV qword ptr [RBP + -0x28],RCX
MOVZX ECX,word ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001d6b51
LAB_001d6c9b:
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0x60
POP RBP
RET
|
int4 mi_checksum(long *param_1,ushort *param_2)
{
ulong uVar1;
uint uVar2;
int *piVar3;
ushort *local_68;
ulong local_50;
ushort *local_48;
int *local_30;
int4 local_1c;
ushort *local_18;
local_1c = 0;
local_30 = *(int **)(*param_1 + 0x230);
piVar3 = local_30 + *(long *)(*param_1 + 0x168) * 0xc;
uVar1 = *(ulong *)(*param_1 + 0x318);
local_18 = param_2;
for (; local_30 != piVar3; local_30 = local_30 + 0xc) {
if (((*(byte *)((long)param_2 + (ulong)*(ushort *)((long)local_30 + 0xe)) &
*(byte *)(local_30 + 3)) == 0) || ((uVar1 & 0x400) == 0)) {
if (*local_30 == 4) {
local_50 = _mi_calc_blob_length(*(ushort *)(local_30 + 1) - 8,local_18);
local_48 = *(ushort **)((long)local_18 + (long)(int)(uint)*(ushort *)(local_30 + 1) + -8);
}
else if (*local_30 == 8) {
uVar2 = 2;
if ((int)(*(ushort *)(local_30 + 1) - 1) < 0x100) {
uVar2 = 1;
}
if (uVar2 == 1) {
local_50 = (ulong)(byte)*local_18;
}
else {
local_50 = (ulong)*local_18;
}
local_48 = (ushort *)((long)local_18 + (ulong)uVar2);
}
else {
local_50 = (ulong)*(ushort *)(local_30 + 1);
local_48 = local_18;
}
if (local_48 == (ushort *)0x0) {
local_68 = (ushort *)&DAT_00257aca;
}
else {
local_68 = local_48;
}
local_1c = my_checksum(local_1c,local_68,local_50);
}
local_18 = (ushort *)((long)local_18 + (long)(int)(uint)*(ushort *)(local_30 + 1));
}
return local_1c;
}
|
|
16,050
|
stbi__paeth(int, int, int)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static int stbi__paeth(int a, int b, int c)
{
int p = a + b - c;
int pa = abs(p-a);
int pb = abs(p-b);
int pc = abs(p-c);
if (pa <= pb && pa <= pc) return a;
if (pb <= pc) return b;
return c;
}
|
O2
|
c
|
stbi__paeth(int, int, int):
movl %edi, %eax
leal (%rsi,%rax), %ecx
subl %edx, %ecx
movl %ecx, %edi
subl %eax, %edi
movl %edi, %r8d
negl %r8d
cmovsl %edi, %r8d
movl %ecx, %edi
subl %esi, %edi
movl %edi, %r9d
negl %r9d
cmovsl %edi, %r9d
subl %edx, %ecx
movl %ecx, %edi
negl %edi
cmovsl %ecx, %edi
cmpl %edi, %r9d
cmoval %edx, %esi
cmpl %edi, %r8d
cmoval %esi, %eax
cmpl %r9d, %r8d
cmoval %esi, %eax
retq
|
_ZL11stbi__paethiii:
mov eax, edi
lea ecx, [rsi+rax]
sub ecx, edx
mov edi, ecx
sub edi, eax
mov r8d, edi
neg r8d
cmovs r8d, edi
mov edi, ecx
sub edi, esi
mov r9d, edi
neg r9d
cmovs r9d, edi
sub ecx, edx
mov edi, ecx
neg edi
cmovs edi, ecx
cmp r9d, edi
cmova esi, edx
cmp r8d, edi
cmova eax, esi
cmp r8d, r9d
cmova eax, esi
retn
|
long long stbi__paeth(unsigned int a1, unsigned int a2, int a3)
{
long long result; // rax
unsigned int v4; // r8d
unsigned int v5; // r9d
int v6; // ecx
unsigned int v7; // edi
result = a1;
v4 = a3 - a2;
if ( (int)(a3 - a2) < 0 )
v4 = a2 - a3;
v5 = a3 - a1;
if ( (int)(a3 - a1) < 0 )
v5 = a1 - a3;
v6 = a2 + a1 - a3 - a3;
v7 = a3 - (a2 + a1 - a3);
if ( v6 > 0 )
v7 = v6;
if ( v5 > v7 )
a2 = a3;
if ( v4 > v7 )
result = a2;
if ( v4 > v5 )
return a2;
return result;
}
|
stbi__paeth:
MOV EAX,EDI
LEA ECX,[RSI + RAX*0x1]
SUB ECX,EDX
MOV EDI,ECX
SUB EDI,EAX
MOV R8D,EDI
NEG R8D
CMOVS R8D,EDI
MOV EDI,ECX
SUB EDI,ESI
MOV R9D,EDI
NEG R9D
CMOVS R9D,EDI
SUB ECX,EDX
MOV EDI,ECX
NEG EDI
CMOVS EDI,ECX
CMP R9D,EDI
CMOVA ESI,EDX
CMP R8D,EDI
CMOVA EAX,ESI
CMP R8D,R9D
CMOVA EAX,ESI
RET
|
/* stbi__paeth(int, int, int) */
int stbi__paeth(int param_1,int param_2,int param_3)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
uint uVar5;
iVar2 = (param_2 + param_1) - param_3;
uVar4 = iVar2 - param_1;
uVar1 = -uVar4;
if (0 < (int)uVar4) {
uVar1 = uVar4;
}
uVar5 = iVar2 - param_2;
uVar4 = -uVar5;
if (0 < (int)uVar5) {
uVar4 = uVar5;
}
uVar3 = iVar2 - param_3;
uVar5 = -uVar3;
if (0 < (int)uVar3) {
uVar5 = uVar3;
}
if (uVar5 < uVar4) {
param_2 = param_3;
}
if (uVar5 < uVar1) {
param_1 = param_2;
}
if (uVar4 < uVar1) {
param_1 = param_2;
}
return param_1;
}
|
|
16,051
|
bf_integer_to_radix_rec
|
bluesky950520[P]quickjs/libbf.c
|
static int bf_integer_to_radix_rec(bf_t *pow_tab,
limb_t *out, const bf_t *a, limb_t n,
int level, limb_t n0, limb_t radixl,
unsigned int radixl_bits)
{
limb_t n1, n2, q_prec;
int ret;
assert(n >= 1);
if (n == 1) {
out[0] = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
} else if (n == 2) {
dlimb_t t;
slimb_t pos;
pos = a->len * LIMB_BITS - a->expn;
t = ((dlimb_t)get_bits(a->tab, a->len, pos + LIMB_BITS) << LIMB_BITS) |
get_bits(a->tab, a->len, pos);
if (likely(radixl == RADIXL_10)) {
/* use division by a constant when possible */
out[0] = t % RADIXL_10;
out[1] = t / RADIXL_10;
} else {
out[0] = t % radixl;
out[1] = t / radixl;
}
} else {
bf_t Q, R, *B, *B_inv;
int q_add;
bf_init(a->ctx, &Q);
bf_init(a->ctx, &R);
n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
n1 = n - n2;
B = &pow_tab[2 * level];
B_inv = &pow_tab[2 * level + 1];
ret = 0;
if (B->len == 0) {
/* compute BASE^n2 */
ret |= bf_pow_ui_ui(B, radixl, n2, BF_PREC_INF, BF_RNDZ);
/* we use enough bits for the maximum possible 'n1' value,
i.e. n2 + 1 */
ret |= bf_set_ui(&R, 1);
ret |= bf_div(B_inv, &R, B, (n2 + 1) * radixl_bits + 2, BF_RNDN);
}
// printf("%d: n1=% " PRId64 " n2=%" PRId64 "\n", level, n1, n2);
q_prec = n1 * radixl_bits;
ret |= bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
ret |= bf_rint(&Q, BF_RNDZ);
ret |= bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
ret |= bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
if (ret & BF_ST_MEM_ERROR)
goto fail;
/* adjust if necessary */
q_add = 0;
while (R.sign && R.len != 0) {
if (bf_add(&R, &R, B, BF_PREC_INF, BF_RNDZ))
goto fail;
q_add--;
}
while (bf_cmpu(&R, B) >= 0) {
if (bf_sub(&R, &R, B, BF_PREC_INF, BF_RNDZ))
goto fail;
q_add++;
}
if (q_add != 0) {
if (bf_add_si(&Q, &Q, q_add, BF_PREC_INF, BF_RNDZ))
goto fail;
}
if (bf_integer_to_radix_rec(pow_tab, out + n2, &Q, n1, level + 1, n0,
radixl, radixl_bits))
goto fail;
if (bf_integer_to_radix_rec(pow_tab, out, &R, n2, level + 1, n0,
radixl, radixl_bits)) {
fail:
bf_delete(&Q);
bf_delete(&R);
return -1;
}
bf_delete(&Q);
bf_delete(&R);
}
return 0;
}
|
O2
|
c
|
bf_integer_to_radix_rec:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %rbp
movq 0xc0(%rsp), %rsi
cmpq $0x2, %rcx
je 0x7d06e
movq %rcx, %r13
cmpq $0x1, %rcx
jne 0x7d0e0
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdi
movq %rsi, %rdx
shlq $0x6, %rdx
subq 0x10(%rbx), %rdx
callq 0x76215
movq %rax, (%rbp)
xorl %ebx, %ebx
jmp 0x7d37e
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %r12
movq %r14, %r13
shlq $0x6, %r13
subq 0x10(%rbx), %r13
movq %rsi, %rbx
leaq 0x40(%r13), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x76215
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x76215
movq %rax, %r14
movabsq $-0x7538dcfb76180000, %r12 # imm = 0x8AC7230489E80000
cmpq %r12, %rbx
jne 0x7d3ab
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x84d00
imulq %rax, %r12
subq %r12, %r14
movq %r14, (%rbp)
movq %rax, 0x8(%rbp)
jmp 0x7d37e
movq %rbp, 0x28(%rsp)
movl 0xc8(%rsp), %edx
movabsq $0x3fffffffffffffff, %r10 # imm = 0x3FFFFFFFFFFFFFFF
movq (%rbx), %rax
movq %rax, 0x60(%rsp)
andl $0x0, 0x68(%rsp)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x70(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rsp)
movq %rax, 0x30(%rsp)
andl $0x0, 0x38(%rsp)
movq %rcx, 0x40(%rsp)
movups %xmm0, 0x48(%rsp)
movq %r9, 0x20(%rsp)
leaq (%r9,%r9), %r14
leal 0x1(%r8), %ecx
movl %ecx, 0xc(%rsp)
shrq %cl, %r14
incq %r14
shrq %r14
subq %r14, %r13
leal (%r8,%r8), %eax
cltq
imulq $0x28, %rax, %rax
leaq (%rdi,%rax), %r15
leal 0x1(,%r8,2), %ecx
movslq %ecx, %rcx
imulq $0x28, %rcx, %r12
addq %rdi, %r12
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rdi,%rax)
movq %r14, 0x10(%rsp)
je 0x7d187
movq %rdx, %r14
movl %r14d, %r14d
xorl %ebp, %ebp
jmp 0x7d1dd
pushq $0x1
popq %r8
movq %r15, %rdi
movq %r14, %rdx
movq %r10, %rcx
callq 0x765cf
movl %eax, %ebp
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x73106
orl %ebp, %eax
movl %eax, 0x8(%rsp)
leaq 0x1(%r14), %rcx
movl 0xc8(%rsp), %eax
movl %eax, %r14d
imulq %r14, %rcx
addq $0x2, %rcx
movq %r12, %rdi
leaq 0x30(%rsp), %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x758a2
movl %eax, %ebp
orl 0x8(%rsp), %ebp
movq %r13, 0x58(%rsp)
imulq %r13, %r14
leaq 0x60(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x74959
movl %eax, 0x8(%rsp)
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0x757ed
movl %eax, %r14d
orl %ebp, %r14d
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
movabsq $0x3fffffffffffffff, %r12 # imm = 0x3FFFFFFFFFFFFFFF
movq %r12, %rcx
pushq $0x1
popq %r8
callq 0x74959
movl %eax, %r13d
orl %r14d, %r13d
movq %rbp, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r12, %rcx
pushq $0x1
popq %r8
callq 0x74fa7
orl %r13d, %eax
orl 0x8(%rsp), %eax
testb $0x20, %al
jne 0x7d367
xorl %ebx, %ebx
leaq 0x30(%rsp), %r14
pushq $0x1
popq %rbp
cmpl $0x0, 0x38(%rsp)
je 0x7d2be
cmpq $0x0, 0x48(%rsp)
je 0x7d2be
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0x757f9
testl %eax, %eax
jne 0x7d367
decq %rbx
jmp 0x7d26c
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %r8
movq %rdi, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x74fa7
testl %eax, %eax
jne 0x7d367
incq %rbx
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x73916
testl %eax, %eax
jns 0x7d29c
testl %ebx, %ebx
je 0x7d2ee
leaq 0x60(%rsp), %rdi
pushq $0x1
popq %r8
movq %rdi, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x74f2a
testl %eax, %eax
jne 0x7d367
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq 0x60(%rsp), %rdx
movq 0x18(%rsp), %rdi
movq 0x58(%rsp), %rcx
movl 0xc(%rsp), %r8d
movq 0x20(%rsp), %r9
movl 0xc8(%rsp), %eax
pushq %rax
pushq 0xc8(%rsp)
callq 0x7d019
popq %rcx
popq %rdx
testl %eax, %eax
jne 0x7d367
leaq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %r8d
movq 0x20(%rsp), %r9
movl 0xc8(%rsp), %eax
pushq %rax
pushq 0xc8(%rsp)
callq 0x7d019
popq %rcx
popq %rdx
testl %eax, %eax
je 0x7d392
leaq 0x60(%rsp), %rdi
callq 0x7500e
leaq 0x30(%rsp), %rdi
callq 0x7500e
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60(%rsp), %rdi
callq 0x7500e
leaq 0x30(%rsp), %rdi
callq 0x7500e
jmp 0x7d067
movq %rbx, %rcx
xorl %ebx, %ebx
movq %r14, %rdi
movq %r15, %rsi
movq %rcx, %r15
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x84d00
imulq %rax, %r15
subq %r15, %r14
jmp 0x7d0d3
|
bf_integer_to_radix_rec:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdx
mov rbp, rsi
mov rsi, [rsp+0B8h+arg_0]
cmp rcx, 2
jz short loc_7D06E
mov r13, rcx
cmp rcx, 1
jnz loc_7D0E0
mov rsi, [rbx+18h]
mov rdi, [rbx+20h]
mov rdx, rsi
shl rdx, 6
sub rdx, [rbx+10h]
call get_bits
mov [rbp+0], rax
loc_7D067:
xor ebx, ebx
jmp loc_7D37E
loc_7D06E:
mov r14, [rbx+18h]
mov r12, [rbx+20h]
mov r13, r14
shl r13, 6
sub r13, [rbx+10h]
mov rbx, rsi
lea rdx, [r13+40h]
mov rdi, r12
mov rsi, r14
call get_bits
mov r15, rax
mov rdi, r12
mov rsi, r14
mov rdx, r13
call get_bits
mov r14, rax
mov r12, 8AC7230489E80000h
cmp rbx, r12
jnz loc_7D3AB
xor ebx, ebx
mov rdi, r14
mov rsi, r15
mov rdx, r12
xor ecx, ecx
call __udivti3
imul r12, rax
sub r14, r12
loc_7D0D3:
mov [rbp+0], r14
mov [rbp+8], rax
jmp loc_7D37E
loc_7D0E0:
mov [rsp+0B8h+var_90], rbp
mov edx, [rsp+0B8h+arg_8]
mov r10, 3FFFFFFFFFFFFFFFh
mov rax, [rbx]
mov [rsp+0B8h+var_58], rax
and [rsp+0B8h+var_50], 0
mov rcx, 8000000000000000h
mov [rsp+0B8h+var_48], rcx
xorps xmm0, xmm0
movups [rsp+0B8h+var_40], xmm0
mov [rsp+0B8h+var_88], rax
and [rsp+0B8h+var_80], 0
mov [rsp+0B8h+var_78], rcx
movups [rsp+0B8h+var_70], xmm0
mov [rsp+0B8h+var_98], r9
lea r14, [r9+r9]
lea ecx, [r8+1]
mov [rsp+0B8h+var_AC], ecx
shr r14, cl
inc r14
shr r14, 1
sub r13, r14
lea eax, [r8+r8]
cdqe
imul rax, 28h ; '('
lea r15, [rdi+rax]
lea ecx, ds:1[r8*2]
movsxd rcx, ecx
imul r12, rcx, 28h ; '('
add r12, rdi
mov [rsp+0B8h+var_A0], rdi
cmp qword ptr [rdi+rax+18h], 0
mov [rsp+0B8h+var_A8], r14
jz short loc_7D187
mov r14, rdx
mov r14d, r14d
xor ebp, ebp
jmp short loc_7D1DD
loc_7D187:
push 1
pop r8
mov rdi, r15
mov rdx, r14
mov rcx, r10
call bf_pow_ui_ui
mov ebp, eax
lea rdi, [rsp+0B8h+var_88]
push 1
pop rsi
call bf_set_ui
or eax, ebp
mov [rsp+0B8h+var_B0], eax
lea rcx, [r14+1]
mov eax, [rsp+0B8h+arg_8]
mov r14d, eax
imul rcx, r14
add rcx, 2
mov rdi, r12
lea rsi, [rsp+0B8h+var_88]
mov rdx, r15
xor r8d, r8d
call bf_div
mov ebp, eax
or ebp, [rsp+0B8h+var_B0]
loc_7D1DD:
mov [rsp+0B8h+var_60], r13
imul r14, r13
lea r13, [rsp+0B8h+var_58]
mov rdi, r13
mov rsi, rbx
mov rdx, r12
mov rcx, r14
xor r8d, r8d
call bf_mul
mov [rsp+0B8h+var_B0], eax
push 1
pop rsi
mov rdi, r13
call bf_rint
mov r14d, eax
or r14d, ebp
lea rbp, [rsp+0B8h+var_88]
mov rdi, rbp
mov rsi, r13
mov rdx, r15
mov r12, 3FFFFFFFFFFFFFFFh
mov rcx, r12
push 1
pop r8
call bf_mul
mov r13d, eax
or r13d, r14d
mov rdi, rbp
mov rsi, rbx
mov rdx, rbp
mov rcx, r12
push 1
pop r8
call bf_sub
or eax, r13d
or eax, [rsp+0B8h+var_B0]
test al, 20h
jnz loc_7D367
xor ebx, ebx
lea r14, [rsp+0B8h+var_88]
push 1
pop rbp
loc_7D26C:
cmp [rsp+0B8h+var_80], 0
jz short loc_7D2BE
cmp qword ptr [rsp+0B8h+var_70], 0
jz short loc_7D2BE
mov rdi, r14
mov rsi, r14
mov rdx, r15
mov rcx, r12
mov r8d, ebp
call bf_add
test eax, eax
jnz loc_7D367
dec rbx
jmp short loc_7D26C
loc_7D29C:
lea rdi, [rsp+0B8h+var_88]
push 1
pop r8
mov rsi, rdi
mov rdx, r15
mov rcx, r12
call bf_sub
test eax, eax
jnz loc_7D367
inc rbx
loc_7D2BE:
lea rdi, [rsp+0B8h+var_88]
mov rsi, r15
call bf_cmpu
test eax, eax
jns short loc_7D29C
test ebx, ebx
jz short loc_7D2EE
lea rdi, [rsp+0B8h+var_58]
push 1
pop r8
mov rsi, rdi
mov rdx, rbx
mov rcx, r12
call bf_add_si
test eax, eax
jnz short loc_7D367
loc_7D2EE:
mov rax, [rsp+0B8h+var_90]
mov rcx, [rsp+0B8h+var_A8]
lea rsi, [rax+rcx*8]
lea rdx, [rsp+0B8h+var_58]
mov rdi, [rsp+0B8h+var_A0]
mov rcx, [rsp+0B8h+var_60]
mov r8d, [rsp+0B8h+var_AC]
mov r9, [rsp+0B8h+var_98]
mov eax, [rsp+0B8h+arg_8]
push rax
push [rsp+0C0h+arg_0]
call bf_integer_to_radix_rec
pop rcx
pop rdx
test eax, eax
jnz short loc_7D367
lea rdx, [rsp+0B8h+var_88]
mov rdi, [rsp+0B8h+var_A0]
mov rsi, [rsp+0B8h+var_90]
mov rcx, [rsp+0B8h+var_A8]
mov r8d, [rsp+0B8h+var_AC]
mov r9, [rsp+0B8h+var_98]
mov eax, [rsp+0B8h+arg_8]
push rax
push [rsp+0C0h+arg_0]
call bf_integer_to_radix_rec
pop rcx
pop rdx
test eax, eax
jz short loc_7D392
loc_7D367:
lea rdi, [rsp+0B8h+var_58]
call bf_delete_0
lea rdi, [rsp+0B8h+var_88]
call bf_delete_0
push 0FFFFFFFFFFFFFFFFh
pop rbx
loc_7D37E:
mov eax, ebx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7D392:
lea rdi, [rsp+0B8h+var_58]
call bf_delete_0
lea rdi, [rsp+0B8h+var_88]
call bf_delete_0
jmp loc_7D067
loc_7D3AB:
mov rcx, rbx
xor ebx, ebx
mov rdi, r14
mov rsi, r15
mov r15, rcx
mov rdx, rcx
xor ecx, ecx
call __udivti3
imul r15, rax
sub r14, r15
jmp loc_7D0D3
|
long long bf_integer_to_radix_rec(
long long a1,
unsigned long long *a2,
long long *a3,
long long a4,
int a5,
long long a6,
unsigned long long a7,
unsigned int a8)
{
unsigned int v9; // ebx
unsigned long long v10; // r14
long long v11; // r12
long long v12; // r13
unsigned long long bits; // r15
unsigned long long v14; // rax
unsigned long long v15; // r14
long long v16; // rax
unsigned long long v17; // r14
unsigned long long v18; // r14
long long v19; // r13
long long v20; // rax
__int128 *v21; // r15
__int128 *v22; // r12
long long v23; // r14
int v24; // ebp
int v25; // ebp
unsigned long long v26; // rcx
int v27; // r14d
int v28; // r13d
signed long long v29; // rbx
int v31; // [rsp+8h] [rbp-B0h]
unsigned __int8 v32; // [rsp+8h] [rbp-B0h]
int v33; // [rsp+Ch] [rbp-ACh]
int v34; // [rsp+10h] [rbp-A8h]
int v35; // [rsp+20h] [rbp-98h]
__int128 v36; // [rsp+30h] [rbp-88h] BYREF
unsigned long long v37; // [rsp+40h] [rbp-78h]
__int128 v38; // [rsp+48h] [rbp-70h]
long long v39; // [rsp+58h] [rbp-60h]
long long v40; // [rsp+60h] [rbp-58h] BYREF
int v41; // [rsp+68h] [rbp-50h]
unsigned long long v42; // [rsp+70h] [rbp-48h]
__int128 v43; // [rsp+78h] [rbp-40h]
if ( a4 == 2 )
{
v10 = a3[3];
v11 = a3[4];
v12 = (v10 << 6) - a3[2];
bits = get_bits(v11, v10, v12 + 64);
v14 = get_bits(v11, v10, v12);
v15 = v14;
v9 = 0;
if ( a7 == 0x8AC7230489E80000LL )
{
v16 = _udivti3(v14, bits, 0x8AC7230489E80000LL, 0LL);
v17 = v15 - 0x8AC7230489E80000LL * v16;
}
else
{
v16 = _udivti3(v14, bits, a7, 0LL);
v17 = v15 - v16 * a7;
}
*a2 = v17;
a2[1] = v16;
}
else
{
if ( a4 == 1 )
{
*a2 = get_bits(a3[4], a3[3], (a3[3] << 6) - a3[2]);
}
else
{
v40 = *a3;
v41 = 0;
v42 = 0x8000000000000000LL;
v43 = 0LL;
*(_QWORD *)&v36 = v40;
DWORD2(v36) = 0;
v37 = 0x8000000000000000LL;
v38 = 0LL;
v35 = a6;
v33 = a5 + 1;
v18 = (((unsigned long long)(2 * a6) >> ((unsigned __int8)a5 + 1)) + 1) >> 1;
v19 = a4 - v18;
v20 = 80LL * a5;
v21 = (__int128 *)(a1 + v20);
v22 = (__int128 *)(a1 + 40LL * (2 * a5 + 1));
v34 = v18;
if ( *(_QWORD *)(a1 + v20 + 24) )
{
v23 = a8;
v24 = 0;
}
else
{
v25 = bf_pow_ui_ui((long long *)(a1 + v20), a7, v18, 0x3FFFFFFFFFFFFFFFLL, 1u);
v31 = v25 | bf_set_ui((long long)&v36, 1uLL);
v26 = v18 + 1;
v23 = a8;
v24 = v31 | bf_div(v22, &v36, v21, a8 * v26 + 2, 0LL);
}
v39 = v19;
v32 = bf_mul(&v40, a3, (long long *)v22, v19 * v23, 0);
v27 = v24 | bf_rint((long long)&v40, 1);
v28 = v27 | bf_mul((long long *)&v36, &v40, (long long *)v21, 0x3FFFFFFFFFFFFFFFLL, 1u);
if ( ((v32 | (unsigned __int8)(v28 | bf_sub((long long)&v36, (long long)a3, (long long)&v36, 0x3FFFFFFFFFFFFFFFLL, 1LL))) & 0x20) != 0 )
goto LABEL_24;
v29 = 0LL;
while ( DWORD2(v36) && (_QWORD)v38 )
{
if ( (unsigned int)bf_add((long long)&v36, (long long)&v36, (long long)v21, 0x3FFFFFFFFFFFFFFFLL, 1LL) )
goto LABEL_24;
--v29;
}
while ( (int)bf_cmpu(&v36, v21) >= 0 )
{
if ( (unsigned int)bf_sub((long long)&v36, (long long)&v36, (long long)v21, 0x3FFFFFFFFFFFFFFFLL, 1LL) )
goto LABEL_24;
++v29;
}
if ( (_DWORD)v29 && (unsigned int)bf_add_si(&v40, (long long)&v40, v29, 0x3FFFFFFFFFFFFFFFLL, 1u)
|| (unsigned int)bf_integer_to_radix_rec(a1, (int)a2 + 8 * v34, (unsigned int)&v40, v39, v33, v35, a7, a8)
|| (unsigned int)bf_integer_to_radix_rec(a1, (_DWORD)a2, (unsigned int)&v36, v34, v33, v35, a7, a8) )
{
LABEL_24:
bf_delete_0(&v40);
bf_delete_0((long long *)&v36);
return (unsigned int)-1;
}
bf_delete_0(&v40);
bf_delete_0((long long *)&v36);
}
return 0;
}
return v9;
}
|
bf_integer_to_radix_rec:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDX
MOV RBP,RSI
MOV RSI,qword ptr [RSP + 0xc0]
CMP RCX,0x2
JZ 0x0017d06e
MOV R13,RCX
CMP RCX,0x1
JNZ 0x0017d0e0
MOV RSI,qword ptr [RBX + 0x18]
MOV RDI,qword ptr [RBX + 0x20]
MOV RDX,RSI
SHL RDX,0x6
SUB RDX,qword ptr [RBX + 0x10]
CALL 0x00176215
MOV qword ptr [RBP],RAX
LAB_0017d067:
XOR EBX,EBX
JMP 0x0017d37e
LAB_0017d06e:
MOV R14,qword ptr [RBX + 0x18]
MOV R12,qword ptr [RBX + 0x20]
MOV R13,R14
SHL R13,0x6
SUB R13,qword ptr [RBX + 0x10]
MOV RBX,RSI
LEA RDX,[R13 + 0x40]
MOV RDI,R12
MOV RSI,R14
CALL 0x00176215
MOV R15,RAX
MOV RDI,R12
MOV RSI,R14
MOV RDX,R13
CALL 0x00176215
MOV R14,RAX
MOV R12,-0x7538dcfb76180000
CMP RBX,R12
JNZ 0x0017d3ab
XOR EBX,EBX
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
XOR ECX,ECX
CALL 0x00184d00
IMUL R12,RAX
SUB R14,R12
LAB_0017d0d3:
MOV qword ptr [RBP],R14
MOV qword ptr [RBP + 0x8],RAX
JMP 0x0017d37e
LAB_0017d0e0:
MOV qword ptr [RSP + 0x28],RBP
MOV EDX,dword ptr [RSP + 0xc8]
MOV R10,0x3fffffffffffffff
MOV RAX,qword ptr [RBX]
MOV qword ptr [RSP + 0x60],RAX
AND dword ptr [RSP + 0x68],0x0
MOV RCX,-0x8000000000000000
MOV qword ptr [RSP + 0x70],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x78],XMM0
MOV qword ptr [RSP + 0x30],RAX
AND dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],RCX
MOVUPS xmmword ptr [RSP + 0x48],XMM0
MOV qword ptr [RSP + 0x20],R9
LEA R14,[R9 + R9*0x1]
LEA ECX,[R8 + 0x1]
MOV dword ptr [RSP + 0xc],ECX
SHR R14,CL
INC R14
SHR R14,0x1
SUB R13,R14
LEA EAX,[R8 + R8*0x1]
CDQE
IMUL RAX,RAX,0x28
LEA R15,[RDI + RAX*0x1]
LEA ECX,[0x1 + R8*0x2]
MOVSXD RCX,ECX
IMUL R12,RCX,0x28
ADD R12,RDI
MOV qword ptr [RSP + 0x18],RDI
CMP qword ptr [RDI + RAX*0x1 + 0x18],0x0
MOV qword ptr [RSP + 0x10],R14
JZ 0x0017d187
MOV R14,RDX
MOV R14D,R14D
XOR EBP,EBP
JMP 0x0017d1dd
LAB_0017d187:
PUSH 0x1
POP R8
MOV RDI,R15
MOV RDX,R14
MOV RCX,R10
CALL 0x001765cf
MOV EBP,EAX
LEA RDI,[RSP + 0x30]
PUSH 0x1
POP RSI
CALL 0x00173106
OR EAX,EBP
MOV dword ptr [RSP + 0x8],EAX
LEA RCX,[R14 + 0x1]
MOV EAX,dword ptr [RSP + 0xc8]
MOV R14D,EAX
IMUL RCX,R14
ADD RCX,0x2
MOV RDI,R12
LEA RSI,[RSP + 0x30]
MOV RDX,R15
XOR R8D,R8D
CALL 0x001758a2
MOV EBP,EAX
OR EBP,dword ptr [RSP + 0x8]
LAB_0017d1dd:
MOV qword ptr [RSP + 0x58],R13
IMUL R14,R13
LEA R13,[RSP + 0x60]
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R14
XOR R8D,R8D
CALL 0x00174959
MOV dword ptr [RSP + 0x8],EAX
PUSH 0x1
POP RSI
MOV RDI,R13
CALL 0x001757ed
MOV R14D,EAX
OR R14D,EBP
LEA RBP,[RSP + 0x30]
MOV RDI,RBP
MOV RSI,R13
MOV RDX,R15
MOV R12,0x3fffffffffffffff
MOV RCX,R12
PUSH 0x1
POP R8
CALL 0x00174959
MOV R13D,EAX
OR R13D,R14D
MOV RDI,RBP
MOV RSI,RBX
MOV RDX,RBP
MOV RCX,R12
PUSH 0x1
POP R8
CALL 0x00174fa7
OR EAX,R13D
OR EAX,dword ptr [RSP + 0x8]
TEST AL,0x20
JNZ 0x0017d367
XOR EBX,EBX
LEA R14,[RSP + 0x30]
PUSH 0x1
POP RBP
LAB_0017d26c:
CMP dword ptr [RSP + 0x38],0x0
JZ 0x0017d2be
CMP qword ptr [RSP + 0x48],0x0
JZ 0x0017d2be
MOV RDI,R14
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
MOV R8D,EBP
CALL 0x001757f9
TEST EAX,EAX
JNZ 0x0017d367
DEC RBX
JMP 0x0017d26c
LAB_0017d29c:
LEA RDI,[RSP + 0x30]
PUSH 0x1
POP R8
MOV RSI,RDI
MOV RDX,R15
MOV RCX,R12
CALL 0x00174fa7
TEST EAX,EAX
JNZ 0x0017d367
INC RBX
LAB_0017d2be:
LEA RDI,[RSP + 0x30]
MOV RSI,R15
CALL 0x00173916
TEST EAX,EAX
JNS 0x0017d29c
TEST EBX,EBX
JZ 0x0017d2ee
LEA RDI,[RSP + 0x60]
PUSH 0x1
POP R8
MOV RSI,RDI
MOV RDX,RBX
MOV RCX,R12
CALL 0x00174f2a
TEST EAX,EAX
JNZ 0x0017d367
LAB_0017d2ee:
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x10]
LEA RSI,[RAX + RCX*0x8]
LEA RDX,[RSP + 0x60]
MOV RDI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x58]
MOV R8D,dword ptr [RSP + 0xc]
MOV R9,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0xc8]
PUSH RAX
PUSH qword ptr [RSP + 0xc8]
CALL 0x0017d019
POP RCX
POP RDX
TEST EAX,EAX
JNZ 0x0017d367
LEA RDX,[RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x10]
MOV R8D,dword ptr [RSP + 0xc]
MOV R9,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0xc8]
PUSH RAX
PUSH qword ptr [RSP + 0xc8]
CALL 0x0017d019
POP RCX
POP RDX
TEST EAX,EAX
JZ 0x0017d392
LAB_0017d367:
LEA RDI,[RSP + 0x60]
CALL 0x0017500e
LEA RDI,[RSP + 0x30]
CALL 0x0017500e
PUSH -0x1
POP RBX
LAB_0017d37e:
MOV EAX,EBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017d392:
LEA RDI,[RSP + 0x60]
CALL 0x0017500e
LEA RDI,[RSP + 0x30]
CALL 0x0017500e
JMP 0x0017d067
LAB_0017d3ab:
MOV RCX,RBX
XOR EBX,EBX
MOV RDI,R14
MOV RSI,R15
MOV R15,RCX
MOV RDX,RCX
XOR ECX,ECX
CALL 0x00184d00
IMUL R15,RAX
SUB R14,R15
JMP 0x0017d0d3
|
int4
bf_integer_to_radix_rec
(long param_1,long *param_2,int8 *param_3,long param_4,int param_5,long param_6,
long param_7,uint param_8)
{
int8 uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
int iVar7;
long lVar8;
int8 uVar9;
long lVar10;
int iVar11;
int4 uVar12;
long lVar13;
ulong uVar14;
int8 local_88;
int local_80;
int8 local_78;
long local_70;
int8 uStack_68;
long local_60;
int8 local_58;
int4 local_50;
int8 local_48;
int8 local_40;
int8 uStack_38;
if (param_4 == 2) {
lVar8 = param_3[3];
uVar1 = param_3[4];
lVar10 = lVar8 * 0x40 - param_3[2];
uVar9 = get_bits(uVar1,lVar8,lVar10 + 0x40);
lVar8 = get_bits(uVar1,lVar8,lVar10);
if (param_7 == -0x7538dcfb76180000) {
lVar13 = __udivti3(lVar8,uVar9,10000000000000000000,0);
lVar10 = lVar13 * 0x7538dcfb76180000;
}
else {
lVar13 = __udivti3(lVar8,uVar9,param_7,0);
lVar10 = -(param_7 * lVar13);
}
*param_2 = lVar8 + lVar10;
param_2[1] = lVar13;
return 0;
}
if (param_4 == 1) {
lVar8 = get_bits(param_3[4],param_3[3],param_3[3] * 0x40 - param_3[2]);
*param_2 = lVar8;
LAB_0017d067:
uVar12 = 0;
}
else {
local_88 = *param_3;
local_50 = 0;
local_48 = 0x8000000000000000;
local_40 = 0;
uStack_38 = 0;
local_80 = 0;
local_78 = 0x8000000000000000;
local_70 = 0;
uStack_68 = 0;
iVar11 = param_5 + 1;
uVar14 = ((ulong)(param_6 * 2) >> ((byte)iVar11 & 0x3f)) + 1 >> 1;
lVar10 = (long)(param_5 * 2) * 0x28;
lVar8 = param_1 + lVar10;
lVar13 = (long)(param_5 * 2 + 1) * 0x28 + param_1;
local_58 = local_88;
if (*(long *)(param_1 + 0x18 + lVar10) == 0) {
uVar3 = bf_pow_ui_ui(lVar8,param_7,uVar14,0x3fffffffffffffff,1);
uVar4 = bf_set_ui(&local_88,1);
uVar2 = bf_div(lVar13,&local_88,lVar8,(uVar14 + 1) * (ulong)param_8 + 2,0);
uVar2 = uVar2 | uVar4 | uVar3;
}
else {
uVar2 = 0;
}
local_60 = param_4 - uVar14;
uVar3 = bf_mul(&local_58,param_3,lVar13,(ulong)param_8 * (param_4 - uVar14),0);
uVar4 = bf_rint(&local_58,1);
uVar5 = bf_mul(&local_88,&local_58,lVar8,0x3fffffffffffffff,1);
uVar6 = bf_sub(&local_88,param_3,&local_88,0x3fffffffffffffff,1);
if (((uVar6 | uVar5 | uVar4 | uVar2 | uVar3) & 0x20) == 0) {
lVar10 = 0;
while ((local_80 != 0 && (local_70 != 0))) {
iVar7 = bf_add(&local_88,&local_88,lVar8,0x3fffffffffffffff,1);
if (iVar7 != 0) goto LAB_0017d367;
lVar10 = lVar10 + -1;
}
while (iVar7 = bf_cmpu(&local_88,lVar8), -1 < iVar7) {
iVar7 = bf_sub(&local_88,&local_88,lVar8,0x3fffffffffffffff,1);
if (iVar7 != 0) goto LAB_0017d367;
lVar10 = lVar10 + 1;
}
if (((((int)lVar10 == 0) ||
(iVar7 = bf_add_si(&local_58,&local_58,lVar10,0x3fffffffffffffff,1), iVar7 == 0)) &&
(iVar7 = bf_integer_to_radix_rec
(param_1,param_2 + uVar14,&local_58,local_60,iVar11,param_6,param_7),
iVar7 == 0)) &&
(iVar11 = bf_integer_to_radix_rec(param_1,param_2,&local_88,uVar14,iVar11,param_6),
iVar11 == 0)) {
bf_delete(&local_58);
bf_delete(&local_88);
goto LAB_0017d067;
}
}
LAB_0017d367:
bf_delete(&local_58);
bf_delete(&local_88);
uVar12 = 0xffffffff;
}
return uVar12;
}
|
|
16,052
|
maria_page_crc_set_index
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_crc_set_index(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int data_length= _ma_get_page_used(share, page);
uint32 crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ENTER("maria_page_crc_set_index");
DBUG_PRINT("info", ("Page %lu crc: %lu",
(ulong) page_no, (ulong) crc));
DBUG_ASSERT((uint)data_length <= share->block_size - CRC_SIZE);
/* crc is on the stack so it is aligned, pagecache buffer is aligned, too */
int4store_aligned(page + share->block_size - CRC_SIZE, crc);
DBUG_RETURN(0);
}
|
O3
|
c
|
maria_page_crc_set_index:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %r14
movl 0x744(%r14), %ecx
movzwl -0x2(%rbx,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %edx
movl %eax, %edi
movq %rbx, %rsi
callq 0xaebe8
cmpl $-0x3, %eax
movl $0xfffffffd, %ecx # imm = 0xFFFFFFFD
cmovbl %eax, %ecx
movl 0x7bc(%r14), %eax
movl %ecx, -0x4(%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
maria_page_crc_set_index:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, [rdi]
mov eax, [rdi+8]
mov r14, [rdi+10h]
mov ecx, [r14+744h]
movzx ecx, word ptr [rbx+rcx-2]
rol cx, 8
movzx edx, cx
mov edi, eax
mov rsi, rbx
call my_checksum
cmp eax, 0FFFFFFFDh
mov ecx, 0FFFFFFFDh
cmovb ecx, eax
mov eax, [r14+7BCh]
mov [rbx+rax-4], ecx
xor eax, eax
pop rbx
pop r14
pop rbp
retn
|
long long maria_page_crc_set_index(long long *a1)
{
long long v1; // rbx
long long v2; // r14
unsigned int v3; // eax
int v4; // ecx
v1 = *a1;
v2 = a1[2];
v3 = my_checksum(
*((unsigned int *)a1 + 2),
*a1,
(unsigned __int16)__ROL2__(*(_WORD *)(*a1 + *(unsigned int *)(v2 + 1860) - 2), 8));
v4 = -3;
if ( v3 < 0xFFFFFFFD )
v4 = v3;
*(_DWORD *)(v1 + *(unsigned int *)(v2 + 1980) - 4) = v4;
return 0LL;
}
|
maria_page_crc_set_index:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI + 0x10]
MOV ECX,dword ptr [R14 + 0x744]
MOVZX ECX,word ptr [RBX + RCX*0x1 + -0x2]
ROL CX,0x8
MOVZX EDX,CX
MOV EDI,EAX
MOV RSI,RBX
CALL 0x001aebe8
CMP EAX,-0x3
MOV ECX,0xfffffffd
CMOVC ECX,EAX
MOV EAX,dword ptr [R14 + 0x7bc]
MOV dword ptr [RBX + RAX*0x1 + -0x4],ECX
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 maria_page_crc_set_index(long *param_1)
{
ushort uVar1;
long lVar2;
long lVar3;
uint uVar4;
uint uVar5;
lVar2 = *param_1;
lVar3 = param_1[2];
uVar1 = *(ushort *)(lVar2 + -2 + (ulong)*(uint *)(lVar3 + 0x744));
uVar4 = my_checksum((int)param_1[1],lVar2,uVar1 << 8 | uVar1 >> 8);
uVar5 = 0xfffffffd;
if (uVar4 < 0xfffffffd) {
uVar5 = uVar4;
}
*(uint *)(lVar2 + -4 + (ulong)*(uint *)(lVar3 + 0x7bc)) = uVar5;
return 0;
}
|
|
16,053
|
queue_insert_safe
|
eloqsql/mysys/queues.c
|
int queue_insert_safe(QUEUE *queue, uchar *element)
{
if (queue->elements == queue->max_elements)
{
if (!queue->auto_extent)
return 2;
if (resize_queue(queue, queue->max_elements + queue->auto_extent))
return 1;
}
queue_insert(queue, element);
return 0;
}
|
O0
|
c
|
queue_insert_safe:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0xfbe7a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xfbe53
movl $0x2, -0x4(%rbp)
jmp 0xfbe8e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
movq -0x10(%rbp), %rax
addl 0x20(%rax), %esi
callq 0xfbc00
cmpl $0x0, %eax
je 0xfbe78
movl $0x1, -0x4(%rbp)
jmp 0xfbe8e
jmp 0xfbe7a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xfbce0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
queue_insert_safe:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov eax, [rax+10h]
mov rcx, [rbp+var_10]
cmp eax, [rcx+14h]
jnz short loc_FBE7A
mov rax, [rbp+var_10]
cmp dword ptr [rax+20h], 0
jnz short loc_FBE53
mov [rbp+var_4], 2
jmp short loc_FBE8E
loc_FBE53:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov esi, [rax+14h]
mov rax, [rbp+var_10]
add esi, [rax+20h]
call resize_queue
cmp eax, 0
jz short loc_FBE78
mov [rbp+var_4], 1
jmp short loc_FBE8E
loc_FBE78:
jmp short $+2
loc_FBE7A:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call queue_insert
mov [rbp+var_4], 0
loc_FBE8E:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long queue_insert_safe(_DWORD *a1, long long a2)
{
if ( a1[4] != a1[5] )
goto LABEL_6;
if ( a1[8] )
{
if ( (unsigned int)resize_queue((long long)a1, a1[8] + a1[5]) )
return 1;
LABEL_6:
queue_insert((long long)a1, a2);
return 0;
}
return 2;
}
|
queue_insert_safe:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x14]
JNZ 0x001fbe7a
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x20],0x0
JNZ 0x001fbe53
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001fbe8e
LAB_001fbe53:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RAX + 0x14]
MOV RAX,qword ptr [RBP + -0x10]
ADD ESI,dword ptr [RAX + 0x20]
CALL 0x001fbc00
CMP EAX,0x0
JZ 0x001fbe78
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001fbe8e
LAB_001fbe78:
JMP 0x001fbe7a
LAB_001fbe7a:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001fbce0
MOV dword ptr [RBP + -0x4],0x0
LAB_001fbe8e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 queue_insert_safe(long param_1,int8 param_2)
{
int iVar1;
if (*(int *)(param_1 + 0x10) == *(int *)(param_1 + 0x14)) {
if (*(int *)(param_1 + 0x20) == 0) {
return 2;
}
iVar1 = resize_queue(param_1,*(int *)(param_1 + 0x14) + *(int *)(param_1 + 0x20));
if (iVar1 != 0) {
return 1;
}
}
queue_insert(param_1,param_2);
return 0;
}
|
|
16,054
|
nglog::ColoredWriteToStdout(nglog::LogSeverity, char const*, unsigned long)
|
ng-log[P]ng-log/src/logging.cc
|
static void ColoredWriteToStdout(LogSeverity severity, const char* message,
size_t len) {
FILE* output = stdout;
// We also need to send logs to the stderr when the severity is
// higher or equal to the stderr threshold.
if (severity >= FLAGS_stderrthreshold) {
output = stderr;
}
ColoredWriteToStderrOrStdout(output, severity, message, len);
}
|
O2
|
cpp
|
nglog::ColoredWriteToStdout(nglog::LogSeverity, char const*, unsigned long):
movq %rdx, %rcx
movq %rsi, %rdx
movl %edi, %esi
leaq 0x25751(%rip), %rax # 0x31af0
cmpl %edi, (%rax)
jle 0xc3ac
movq 0x24b76(%rip), %rax # 0x30f20
jmp 0xc3b3
movq 0x24bdd(%rip), %rax # 0x30f90
movq (%rax), %rdi
jmp 0xfd2b
|
_ZN5nglogL20ColoredWriteToStdoutENS_11LogSeverityEPKcm:
mov rcx, rdx
mov rdx, rsi
mov esi, edi
lea rax, _ZN3fLI21FLAGS_stderrthresholdE; fLI::FLAGS_stderrthreshold
cmp [rax], edi
jle short loc_C3AC
mov rax, cs:stdout_ptr
jmp short loc_C3B3
loc_C3AC:
mov rax, cs:stderr_ptr
loc_C3B3:
mov rdi, [rax]
jmp _ZN5nglogL28ColoredWriteToStderrOrStdoutEP8_IO_FILENS_11LogSeverityEPKcm; nglog::ColoredWriteToStderrOrStdout(_IO_FILE *,nglog::LogSeverity,char const*,ulong)
|
long long nglog::ColoredWriteToStdout(int a1, long long a2, long long a3)
{
_QWORD *v3; // rax
if ( fLI::FLAGS_stderrthreshold <= a1 )
v3 = &stderr;
else
v3 = &stdout;
return nglog::ColoredWriteToStderrOrStdout(*v3, (unsigned int)a1, a2, a3);
}
|
ColoredWriteToStdout:
MOV RCX,RDX
MOV RDX,RSI
MOV ESI,EDI
LEA RAX,[0x131af0]
CMP dword ptr [RAX],EDI
JLE 0x0010c3ac
MOV RAX,qword ptr [0x00130f20]
JMP 0x0010c3b3
LAB_0010c3ac:
MOV RAX,qword ptr [0x00130f90]
LAB_0010c3b3:
MOV RDI,qword ptr [RAX]
JMP 0x0010fd2b
|
/* nglog::ColoredWriteToStdout(nglog::LogSeverity, char const*, unsigned long) */
void nglog::ColoredWriteToStdout(int param_1,int8 param_2,int8 param_3)
{
int8 *puVar1;
puVar1 = (int8 *)PTR_stderr_00130f90;
if (param_1 < fLI::FLAGS_stderrthreshold) {
puVar1 = (int8 *)PTR_stdout_00130f20;
}
ColoredWriteToStderrOrStdout(*puVar1,param_1,param_2,param_3);
return;
}
|
|
16,055
|
blst_sign_pk2_in_g2
|
corpus-core[P]colibri-stateless/build_O1/_deps/blst-src/src/e1.c
|
void blst_sign_pk2_in_g2(unsigned char out[96], POINTonE1_affine *sig,
const POINTonE1 *hash, const pow256 SK)
{
POINTonE1 P[1];
POINTonE1_sign(P, hash, SK);
if (sig != NULL)
vec_copy(sig, P, sizeof(*sig));
if (out != NULL) {
limb_t sgn0_pty = POINTonE1_Serialize_BE(out, P);
out[0] |= (sgn0_pty & 2) << 4; /* pre-decorate */
out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;
}
}
|
O1
|
c
|
blst_sign_pk2_in_g2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0xa0(%rbp), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x5f46c
testq %r14, %r14
je 0x5f66f
leaq -0xa0(%rbp), %rsi
movl $0xc, %ecx
movq %r14, %rdi
rep movsq (%rsi), %es:(%rdi)
testq %rbx, %rbx
je 0x5f69d
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x5f5d4
shlb $0x4, %al
andb $0x20, %al
orb %al, (%rbx)
leaq -0x40(%rbp), %rdi
movl $0x30, %esi
callq 0x74d40
shlb $0x6, %al
orb %al, (%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
blst_sign_pk2_in_g2:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 90h
mov r14, rsi
mov rbx, rdi
lea rdi, [rbp+var_A0]
mov rsi, rdx
mov rdx, rcx
call POINTonE1_sign
test r14, r14
jz short loc_5F66F
lea rsi, [rbp+var_A0]
mov ecx, 0Ch
mov rdi, r14
rep movsq
loc_5F66F:
test rbx, rbx
jz short loc_5F69D
lea rsi, [rbp+var_A0]
mov rdi, rbx
call POINTonE1_Serialize_BE
shl al, 4
and al, 20h
or [rbx], al
lea rdi, [rbp+var_40]
mov esi, 30h ; '0'
call vec_is_zero_16x
shl al, 6
or [rbx], al
loc_5F69D:
add rsp, 90h
pop rbx
pop r14
pop rbp
retn
|
char blst_sign_pk2_in_g2(_BYTE *a1, void *a2)
{
char result; // al
_BYTE v3[96]; // [rsp+0h] [rbp-A0h] BYREF
_BYTE v4[64]; // [rsp+60h] [rbp-40h] BYREF
result = POINTonE1_sign((long long)v3);
if ( a2 )
qmemcpy(a2, v3, 0x60uLL);
if ( a1 )
{
*a1 |= (16 * POINTonE1_Serialize_BE(a1, (long long)v3)) & 0x20;
result = (unsigned __int8)vec_is_zero_16x(v4, 48LL) << 6;
*a1 |= result;
}
return result;
}
|
blst_sign_pk2_in_g2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x90
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RBP + -0xa0]
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0015f46c
TEST R14,R14
JZ 0x0015f66f
LEA RSI,[RBP + -0xa0]
MOV ECX,0xc
MOV RDI,R14
MOVSQ.REP RDI,RSI
LAB_0015f66f:
TEST RBX,RBX
JZ 0x0015f69d
LEA RSI,[RBP + -0xa0]
MOV RDI,RBX
CALL 0x0015f5d4
SHL AL,0x4
AND AL,0x20
OR byte ptr [RBX],AL
LEA RDI,[RBP + -0x40]
MOV ESI,0x30
CALL 0x00174d40
SHL AL,0x6
OR byte ptr [RBX],AL
LAB_0015f69d:
ADD RSP,0x90
POP RBX
POP R14
POP RBP
RET
|
void blst_sign_pk2_in_g2(byte *param_1,int8 *param_2,int8 param_3,int8 param_4)
{
byte bVar1;
char cVar2;
long lVar3;
int8 *puVar4;
int8 local_a8 [12];
int1 local_48 [48];
bVar1 = 0;
POINTonE1_sign(local_a8,param_3,param_4);
if (param_2 != (int8 *)0x0) {
puVar4 = local_a8;
for (lVar3 = 0xc; lVar3 != 0; lVar3 = lVar3 + -1) {
*param_2 = *puVar4;
puVar4 = puVar4 + (ulong)bVar1 * -2 + 1;
param_2 = param_2 + (ulong)bVar1 * -2 + 1;
}
}
if (param_1 != (byte *)0x0) {
bVar1 = POINTonE1_Serialize_BE(param_1,local_a8);
*param_1 = *param_1 | (bVar1 & 2) << 4;
cVar2 = vec_is_zero_16x(local_48,0x30);
*param_1 = *param_1 | cVar2 << 6;
}
return;
}
|
|
16,056
|
ma_deep_copy_field
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
static int ma_deep_copy_field(const MYSQL_FIELD *src, MYSQL_FIELD *dst,
MA_MEM_ROOT *r)
{
#define MA_STRDUP(f) \
do \
{ \
if (src->f) \
{ \
if ((dst->f= ma_strdup_root(r, src->f)) == NULL) \
return -1; \
} \
else \
{ \
dst->f= NULL; \
} \
} \
while (0)
MA_STRDUP(catalog);
MA_STRDUP(db);
MA_STRDUP(def);
MA_STRDUP(name);
MA_STRDUP(org_name);
MA_STRDUP(org_table);
MA_STRDUP(table);
#undef MA_STRDUP
dst->catalog_length= src->catalog_length;
dst->charsetnr= src->charsetnr;
dst->db_length= src->db_length;
dst->decimals= src->decimals;
dst->def_length= src->def_length;
dst->extension=
src->extension
? ma_field_extension_deep_dup(r,
src->extension)
: NULL;
dst->flags= src->flags;
dst->length= src->length;
dst->max_length = src->max_length;
dst->name_length= src->name_length;
dst->org_name_length= src->org_name_length;
dst->org_table_length= src->org_table_length;
dst->table_length= src->table_length;
dst->type= src->type;
return 0;
}
|
O0
|
c
|
ma_deep_copy_field:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x50cdc
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, 0x28(%rcx)
cmpq $0x0, %rax
jne 0x50cda
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50ce8
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x50cea
jmp 0x50cec
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x50d24
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0x50d22
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50d30
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x50d32
jmp 0x50d34
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x50d6c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
jne 0x50d6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50d78
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
jmp 0x50d7a
jmp 0x50d7c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x50db1
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x50daf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50dbc
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
jmp 0x50dbe
jmp 0x50dc0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x50df8
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x50df6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50e04
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x50e06
jmp 0x50e08
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x50e40
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0x50e3e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50e4c
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x50e4e
jmp 0x50e50
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x50e88
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x56930
movq -0x18(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x50e86
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x50f8d
jmp 0x50e94
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x50e96
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x5c(%rax)
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x6c(%rax)
movq -0x10(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x10(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rax
movl 0x60(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x50efe
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x4b7b0
movq %rax, -0x28(%rbp)
jmp 0x50f06
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x50f06
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
movl 0x64(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rax
movl 0x54(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x50(%rax)
movq -0x10(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x70(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_deep_copy_field:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
cmp qword ptr [rax+28h], 0
jz short loc_50CDC
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx+28h], rax
cmp rax, 0
jnz short loc_50CDA
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50CDA:
jmp short loc_50CE8
loc_50CDC:
mov rax, [rbp+var_18]
mov qword ptr [rax+28h], 0
loc_50CE8:
jmp short $+2
loc_50CEA:
jmp short $+2
loc_50CEC:
mov rax, [rbp+var_10]
cmp qword ptr [rax+20h], 0
jz short loc_50D24
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx+20h], rax
cmp rax, 0
jnz short loc_50D22
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50D22:
jmp short loc_50D30
loc_50D24:
mov rax, [rbp+var_18]
mov qword ptr [rax+20h], 0
loc_50D30:
jmp short $+2
loc_50D32:
jmp short $+2
loc_50D34:
mov rax, [rbp+var_10]
cmp qword ptr [rax+30h], 0
jz short loc_50D6C
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+30h]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx+30h], rax
cmp rax, 0
jnz short loc_50D6A
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50D6A:
jmp short loc_50D78
loc_50D6C:
mov rax, [rbp+var_18]
mov qword ptr [rax+30h], 0
loc_50D78:
jmp short $+2
loc_50D7A:
jmp short $+2
loc_50D7C:
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jz short loc_50DB1
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx], rax
cmp rax, 0
jnz short loc_50DAF
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50DAF:
jmp short loc_50DBC
loc_50DB1:
mov rax, [rbp+var_18]
mov qword ptr [rax], 0
loc_50DBC:
jmp short $+2
loc_50DBE:
jmp short $+2
loc_50DC0:
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_50DF8
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx+8], rax
cmp rax, 0
jnz short loc_50DF6
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50DF6:
jmp short loc_50E04
loc_50DF8:
mov rax, [rbp+var_18]
mov qword ptr [rax+8], 0
loc_50E04:
jmp short $+2
loc_50E06:
jmp short $+2
loc_50E08:
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz short loc_50E40
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+18h]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx+18h], rax
cmp rax, 0
jnz short loc_50E3E
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50E3E:
jmp short loc_50E4C
loc_50E40:
mov rax, [rbp+var_18]
mov qword ptr [rax+18h], 0
loc_50E4C:
jmp short $+2
loc_50E4E:
jmp short $+2
loc_50E50:
mov rax, [rbp+var_10]
cmp qword ptr [rax+10h], 0
jz short loc_50E88
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
call ma_strdup_root
mov rcx, [rbp+var_18]
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_50E86
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_50F8D
loc_50E86:
jmp short loc_50E94
loc_50E88:
mov rax, [rbp+var_18]
mov qword ptr [rax+10h], 0
loc_50E94:
jmp short $+2
loc_50E96:
mov rax, [rbp+var_10]
mov ecx, [rax+5Ch]
mov rax, [rbp+var_18]
mov [rax+5Ch], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+6Ch]
mov rax, [rbp+var_18]
mov [rax+6Ch], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+58h]
mov rax, [rbp+var_18]
mov [rax+58h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+68h]
mov rax, [rbp+var_18]
mov [rax+68h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+60h]
mov rax, [rbp+var_18]
mov [rax+60h], ecx
mov rax, [rbp+var_10]
cmp qword ptr [rax+78h], 0
jz short loc_50EFE
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax+78h]
call ma_field_extension_deep_dup
mov [rbp+var_28], rax
jmp short loc_50F06
loc_50EFE:
xor eax, eax
mov [rbp+var_28], rax
jmp short $+2
loc_50F06:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rax+78h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+64h]
mov rax, [rbp+var_18]
mov [rax+64h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+38h]
mov rax, [rbp+var_18]
mov [rax+38h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_18]
mov [rax+40h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+48h]
mov rax, [rbp+var_18]
mov [rax+48h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+4Ch]
mov rax, [rbp+var_18]
mov [rax+4Ch], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+54h]
mov rax, [rbp+var_18]
mov [rax+54h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
mov rax, [rbp+var_18]
mov [rax+50h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+70h]
mov rax, [rbp+var_18]
mov [rax+70h], ecx
mov [rbp+var_4], 0
loc_50F8D:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long ma_deep_copy_field(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
long long v7; // rax
long long v8; // rax
long long v9; // rax
_QWORD *v11; // [rsp+8h] [rbp-28h]
if ( *(_QWORD *)(a1 + 40) )
{
v3 = ma_strdup_root(a3, *(_QWORD *)(a1 + 40));
*(_QWORD *)(a2 + 40) = v3;
if ( !v3 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)(a2 + 40) = 0LL;
}
if ( *(_QWORD *)(a1 + 32) )
{
v4 = ma_strdup_root(a3, *(_QWORD *)(a1 + 32));
*(_QWORD *)(a2 + 32) = v4;
if ( !v4 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)(a2 + 32) = 0LL;
}
if ( *(_QWORD *)(a1 + 48) )
{
v5 = ma_strdup_root(a3, *(_QWORD *)(a1 + 48));
*(_QWORD *)(a2 + 48) = v5;
if ( !v5 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)(a2 + 48) = 0LL;
}
if ( *(_QWORD *)a1 )
{
v6 = ma_strdup_root(a3, *(_QWORD *)a1);
*(_QWORD *)a2 = v6;
if ( !v6 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)a2 = 0LL;
}
if ( *(_QWORD *)(a1 + 8) )
{
v7 = ma_strdup_root(a3, *(_QWORD *)(a1 + 8));
*(_QWORD *)(a2 + 8) = v7;
if ( !v7 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)(a2 + 8) = 0LL;
}
if ( *(_QWORD *)(a1 + 24) )
{
v8 = ma_strdup_root(a3, *(_QWORD *)(a1 + 24));
*(_QWORD *)(a2 + 24) = v8;
if ( !v8 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)(a2 + 24) = 0LL;
}
if ( *(_QWORD *)(a1 + 16) )
{
v9 = ma_strdup_root(a3, *(_QWORD *)(a1 + 16));
*(_QWORD *)(a2 + 16) = v9;
if ( !v9 )
return (unsigned int)-1;
}
else
{
*(_QWORD *)(a2 + 16) = 0LL;
}
*(_DWORD *)(a2 + 92) = *(_DWORD *)(a1 + 92);
*(_DWORD *)(a2 + 108) = *(_DWORD *)(a1 + 108);
*(_DWORD *)(a2 + 88) = *(_DWORD *)(a1 + 88);
*(_DWORD *)(a2 + 104) = *(_DWORD *)(a1 + 104);
*(_DWORD *)(a2 + 96) = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 120) )
v11 = ma_field_extension_deep_dup(a3, *(_QWORD **)(a1 + 120));
else
v11 = 0LL;
*(_QWORD *)(a2 + 120) = v11;
*(_DWORD *)(a2 + 100) = *(_DWORD *)(a1 + 100);
*(_QWORD *)(a2 + 56) = *(_QWORD *)(a1 + 56);
*(_QWORD *)(a2 + 64) = *(_QWORD *)(a1 + 64);
*(_DWORD *)(a2 + 72) = *(_DWORD *)(a1 + 72);
*(_DWORD *)(a2 + 76) = *(_DWORD *)(a1 + 76);
*(_DWORD *)(a2 + 84) = *(_DWORD *)(a1 + 84);
*(_DWORD *)(a2 + 80) = *(_DWORD *)(a1 + 80);
*(_DWORD *)(a2 + 112) = *(_DWORD *)(a1 + 112);
return 0;
}
|
ma_deep_copy_field:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x28],0x0
JZ 0x00150cdc
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x28]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x28],RAX
CMP RAX,0x0
JNZ 0x00150cda
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150cda:
JMP 0x00150ce8
LAB_00150cdc:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x28],0x0
LAB_00150ce8:
JMP 0x00150cea
LAB_00150cea:
JMP 0x00150cec
LAB_00150cec:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x20],0x0
JZ 0x00150d24
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x20],RAX
CMP RAX,0x0
JNZ 0x00150d22
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150d22:
JMP 0x00150d30
LAB_00150d24:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],0x0
LAB_00150d30:
JMP 0x00150d32
LAB_00150d32:
JMP 0x00150d34
LAB_00150d34:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x30],0x0
JZ 0x00150d6c
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x30]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x30],RAX
CMP RAX,0x0
JNZ 0x00150d6a
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150d6a:
JMP 0x00150d78
LAB_00150d6c:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x30],0x0
LAB_00150d78:
JMP 0x00150d7a
LAB_00150d7a:
JMP 0x00150d7c
LAB_00150d7c:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JZ 0x00150db1
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JNZ 0x00150daf
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150daf:
JMP 0x00150dbc
LAB_00150db1:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],0x0
LAB_00150dbc:
JMP 0x00150dbe
LAB_00150dbe:
JMP 0x00150dc0
LAB_00150dc0:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00150df8
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JNZ 0x00150df6
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150df6:
JMP 0x00150e04
LAB_00150df8:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],0x0
LAB_00150e04:
JMP 0x00150e06
LAB_00150e06:
JMP 0x00150e08
LAB_00150e08:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x00150e40
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x18]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x18],RAX
CMP RAX,0x0
JNZ 0x00150e3e
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150e3e:
JMP 0x00150e4c
LAB_00150e40:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],0x0
LAB_00150e4c:
JMP 0x00150e4e
LAB_00150e4e:
JMP 0x00150e50
LAB_00150e50:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x10],0x0
JZ 0x00150e88
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
CALL 0x00156930
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x00150e86
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00150f8d
LAB_00150e86:
JMP 0x00150e94
LAB_00150e88:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x10],0x0
LAB_00150e94:
JMP 0x00150e96
LAB_00150e96:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x5c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x5c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x6c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x6c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x58],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x68]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x68],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x60],ECX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x78],0x0
JZ 0x00150efe
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x78]
CALL 0x0014b7b0
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00150f06
LAB_00150efe:
XOR EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00150f06
LAB_00150f06:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x78],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x64]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x64],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x48],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x4c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x4c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x54]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x54],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x70]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x70],ECX
MOV dword ptr [RBP + -0x4],0x0
LAB_00150f8d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 ma_deep_copy_field(long *param_1,long *param_2,int8 param_3)
{
long lVar1;
long local_30;
if (param_1[5] == 0) {
param_2[5] = 0;
}
else {
lVar1 = ma_strdup_root(param_3,param_1[5]);
param_2[5] = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
if (param_1[4] == 0) {
param_2[4] = 0;
}
else {
lVar1 = ma_strdup_root(param_3,param_1[4]);
param_2[4] = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
if (param_1[6] == 0) {
param_2[6] = 0;
}
else {
lVar1 = ma_strdup_root(param_3,param_1[6]);
param_2[6] = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
if (*param_1 == 0) {
*param_2 = 0;
}
else {
lVar1 = ma_strdup_root(param_3,*param_1);
*param_2 = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
if (param_1[1] == 0) {
param_2[1] = 0;
}
else {
lVar1 = ma_strdup_root(param_3,param_1[1]);
param_2[1] = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
if (param_1[3] == 0) {
param_2[3] = 0;
}
else {
lVar1 = ma_strdup_root(param_3,param_1[3]);
param_2[3] = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
if (param_1[2] == 0) {
param_2[2] = 0;
}
else {
lVar1 = ma_strdup_root(param_3,param_1[2]);
param_2[2] = lVar1;
if (lVar1 == 0) {
return 0xffffffff;
}
}
*(int4 *)((long)param_2 + 0x5c) = *(int4 *)((long)param_1 + 0x5c);
*(int4 *)((long)param_2 + 0x6c) = *(int4 *)((long)param_1 + 0x6c);
*(int *)(param_2 + 0xb) = (int)param_1[0xb];
*(int *)(param_2 + 0xd) = (int)param_1[0xd];
*(int *)(param_2 + 0xc) = (int)param_1[0xc];
if (param_1[0xf] == 0) {
local_30 = 0;
}
else {
local_30 = ma_field_extension_deep_dup(param_3,param_1[0xf]);
}
param_2[0xf] = local_30;
*(int4 *)((long)param_2 + 100) = *(int4 *)((long)param_1 + 100);
param_2[7] = param_1[7];
param_2[8] = param_1[8];
*(int *)(param_2 + 9) = (int)param_1[9];
*(int4 *)((long)param_2 + 0x4c) = *(int4 *)((long)param_1 + 0x4c);
*(int4 *)((long)param_2 + 0x54) = *(int4 *)((long)param_1 + 0x54);
*(int *)(param_2 + 10) = (int)param_1[10];
*(int *)(param_2 + 0xe) = (int)param_1[0xe];
return 0;
}
|
|
16,057
|
my_lengthsp_mb2
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_lengthsp_mb2(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr, size_t length)
{
const char *end= ptr + length;
while (end > ptr + 1 && end[-1] == ' ' && end[-2] == '\0')
end-= 2;
return (size_t) (end - ptr);
}
|
O0
|
c
|
my_lengthsp_mb2:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jbe 0x59095
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
jne 0x59095
movq -0x20(%rbp), %rax
movsbl -0x2(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x5909e
jmp 0x590ac
movq -0x20(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x5905c
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopl (%rax)
|
my_lengthsp_mb2:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_20], rax
loc_5905C:
mov rcx, [rbp+var_20]
mov rdx, [rbp+var_10]
add rdx, 1
xor eax, eax
cmp rcx, rdx
mov [rbp+var_21], al
jbe short loc_59095
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax-1]
xor eax, eax
cmp ecx, 20h ; ' '
mov [rbp+var_21], al
jnz short loc_59095
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax-2]
cmp eax, 0
setz al
mov [rbp+var_21], al
loc_59095:
mov al, [rbp+var_21]
test al, 1
jnz short loc_5909E
jmp short loc_590AC
loc_5909E:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_20], rax
jmp short loc_5905C
loc_590AC:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
sub rax, rcx
pop rbp
retn
|
long long my_lengthsp_mb2(long long a1, long long a2, long long a3)
{
bool v4; // [rsp+1h] [rbp-21h]
unsigned long long i; // [rsp+2h] [rbp-20h]
for ( i = a3 + a2; ; i -= 2LL )
{
v4 = 0;
if ( i > a2 + 1 )
{
v4 = 0;
if ( *(_BYTE *)(i - 1) == 32 )
v4 = *(_BYTE *)(i - 2) == 0;
}
if ( !v4 )
break;
}
return i - a2;
}
|
my_lengthsp_mb2:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
LAB_0015905c:
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x1
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x21],AL
JBE 0x00159095
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX + -0x1]
XOR EAX,EAX
CMP ECX,0x20
MOV byte ptr [RBP + -0x21],AL
JNZ 0x00159095
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX + -0x2]
CMP EAX,0x0
SETZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_00159095:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x0015909e
JMP 0x001590ac
LAB_0015909e:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x2
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015905c
LAB_001590ac:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
POP RBP
RET
|
long my_lengthsp_mb2(int8 param_1,long param_2,long param_3)
{
bool bVar1;
int8 local_28;
local_28 = param_2 + param_3;
while( true ) {
bVar1 = false;
if ((param_2 + 1U < local_28) && (bVar1 = false, *(char *)(local_28 - 1) == ' ')) {
bVar1 = *(char *)(local_28 - 2) == '\0';
}
if (!bVar1) break;
local_28 = local_28 - 2;
}
return local_28 - param_2;
}
|
|
16,058
|
my_charlen_utf8mb4
|
eloqsql/strings/ctype-utf8.c
|
static int
my_charlen_utf8mb4(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
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;
return 4;
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_charlen_utf8mb4:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0xcc32e
movb (%rsi), %cl
cmpb $-0x11, %cl
ja 0xcc29a
movl $0x1, %eax
testb %cl, %cl
jns 0xcc32e
cmpb $-0x3e, %cl
jb 0xcc32c
cmpb $-0x21, %cl
ja 0xcc2f3
leaq 0x2(%rsi), %rcx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %rcx
ja 0xcc32e
xorl %eax, %eax
cmpb $-0x40, 0x1(%rsi)
setl %al
addl %eax, %eax
jmp 0xcc32e
cmpb $-0xc, %cl
ja 0xcc32c
leaq 0x4(%rsi), %rdi
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %rdi
ja 0xcc32e
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0xcc32c
cmpb $-0x41, 0x2(%rsi)
jg 0xcc32c
cmpb $-0x41, 0x3(%rsi)
jg 0xcc32c
cmpb $-0x10, %cl
sete %sil
cmpb $-0x70, %dl
setb %dil
movl $0x0, %eax
testb %dil, %sil
jne 0xcc32e
cmpb $-0xc, %cl
setne %al
cmpb $-0x70, %dl
setb %cl
orb %al, %cl
movzbl %cl, %eax
shll $0x2, %eax
jmp 0xcc32e
leaq 0x3(%rsi), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %rdi
ja 0xcc32e
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0xcc32c
cmpb $-0x41, 0x2(%rsi)
movl $0x0, %eax
jg 0xcc32e
xorl %eax, %eax
cmpb $-0x60, %dl
setae %al
cmpb $-0x20, %cl
leal (%rax,%rax,2), %ecx
movl $0x3, %eax
cmovel %ecx, %eax
jmp 0xcc32e
xorl %eax, %eax
popq %rbp
retq
|
my_charlen_utf8mb4:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb loc_CC32E
mov cl, [rsi]
cmp cl, 0EFh
ja short loc_CC29A
mov eax, 1
test cl, cl
jns loc_CC32E
cmp cl, 0C2h
jb loc_CC32C
cmp cl, 0DFh
ja short loc_CC2F3
lea rcx, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp rcx, rdx
ja loc_CC32E
xor eax, eax
cmp byte ptr [rsi+1], 0C0h
setl al
add eax, eax
jmp loc_CC32E
loc_CC29A:
cmp cl, 0F4h
ja loc_CC32C
lea rdi, [rsi+4]
mov eax, 0FFFFFF98h
cmp rdi, rdx
ja short loc_CC32E
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_CC32C
cmp byte ptr [rsi+2], 0BFh
jg short loc_CC32C
cmp byte ptr [rsi+3], 0BFh
jg short loc_CC32C
cmp cl, 0F0h
setz sil
cmp dl, 90h
setb dil
mov eax, 0
test sil, dil
jnz short loc_CC32E
cmp cl, 0F4h
setnz al
cmp dl, 90h
setb cl
or cl, al
movzx eax, cl
shl eax, 2
jmp short loc_CC32E
loc_CC2F3:
lea rdi, [rsi+3]
mov eax, 0FFFFFF99h
cmp rdi, rdx
ja short loc_CC32E
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_CC32C
cmp byte ptr [rsi+2], 0BFh
mov eax, 0
jg short loc_CC32E
xor eax, eax
cmp dl, 0A0h
setnb al
cmp cl, 0E0h
lea ecx, [rax+rax*2]
mov eax, 3
cmovz eax, ecx
jmp short loc_CC32E
loc_CC32C:
xor eax, eax
loc_CC32E:
pop rbp
retn
|
long long my_charlen_utf8mb4(long long a1, char *a2, unsigned long long a3)
{
long long result; // rax
char v4; // cl
char v5; // dl
char v6; // dl
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (unsigned __int8)*a2 <= 0xEFu )
{
result = 1LL;
if ( v4 >= 0 )
return result;
if ( (unsigned __int8)v4 >= 0xC2u )
{
if ( (unsigned __int8)v4 <= 0xDFu )
{
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
return 2 * (unsigned int)(a2[1] < -64);
return result;
}
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v6 = a2[1];
if ( v6 <= -65 )
{
result = 0LL;
if ( a2[2] <= -65 )
{
result = 3LL;
if ( v4 == -32 )
return 3 * (unsigned int)((unsigned __int8)v6 >= 0xA0u);
}
return result;
}
}
return 0LL;
}
if ( (unsigned __int8)v4 > 0xF4u )
return 0LL;
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v5 = a2[1];
if ( v5 > -65 || a2[2] > -65 || a2[3] > -65 )
return 0LL;
result = 0LL;
if ( (unsigned __int8)v5 >= 0x90u || v4 != -16 )
return 4 * (unsigned int)(v4 != -12 || (unsigned __int8)v5 < 0x90u);
return result;
}
|
my_charlen_utf8mb4:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001cc32e
MOV CL,byte ptr [RSI]
CMP CL,0xef
JA 0x001cc29a
MOV EAX,0x1
TEST CL,CL
JNS 0x001cc32e
CMP CL,0xc2
JC 0x001cc32c
CMP CL,0xdf
JA 0x001cc2f3
LEA RCX,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP RCX,RDX
JA 0x001cc32e
XOR EAX,EAX
CMP byte ptr [RSI + 0x1],0xc0
SETL AL
ADD EAX,EAX
JMP 0x001cc32e
LAB_001cc29a:
CMP CL,0xf4
JA 0x001cc32c
LEA RDI,[RSI + 0x4]
MOV EAX,0xffffff98
CMP RDI,RDX
JA 0x001cc32e
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cc32c
CMP byte ptr [RSI + 0x2],0xbf
JG 0x001cc32c
CMP byte ptr [RSI + 0x3],0xbf
JG 0x001cc32c
CMP CL,0xf0
SETZ SIL
CMP DL,0x90
SETC DIL
MOV EAX,0x0
TEST SIL,DIL
JNZ 0x001cc32e
CMP CL,0xf4
SETNZ AL
CMP DL,0x90
SETC CL
OR CL,AL
MOVZX EAX,CL
SHL EAX,0x2
JMP 0x001cc32e
LAB_001cc2f3:
LEA RDI,[RSI + 0x3]
MOV EAX,0xffffff99
CMP RDI,RDX
JA 0x001cc32e
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cc32c
CMP byte ptr [RSI + 0x2],0xbf
MOV EAX,0x0
JG 0x001cc32e
XOR EAX,EAX
CMP DL,0xa0
SETNC AL
CMP CL,0xe0
LEA ECX,[RAX + RAX*0x2]
MOV EAX,0x3
CMOVZ EAX,ECX
JMP 0x001cc32e
LAB_001cc32c:
XOR EAX,EAX
LAB_001cc32e:
POP RBP
RET
|
ulong my_charlen_utf8mb4(int8 param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
if (bVar1 < 0xf0) {
if (-1 < (char)bVar1) {
return 1;
}
if (0xc1 < bVar1) {
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
return (ulong)((uint)((char)param_2[1] < -0x40) * 2);
}
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
if ((char)param_2[1] < -0x40) {
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 != 0xe0) {
return 3;
}
return (ulong)((uint)(0x9f < param_2[1]) * 3);
}
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar2 = param_2[1];
if ((((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) {
if (bVar1 == 0xf0 && bVar2 < 0x90) {
return 0;
}
return (ulong)(bVar2 < 0x90 || bVar1 != 0xf4) << 2;
}
}
return 0;
}
|
|
16,059
|
ps_fetch_float
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_float(MYSQL_BIND *r_param, const MYSQL_FIELD * field, unsigned char **row)
{
switch(r_param->buffer_type)
{
case MYSQL_TYPE_FLOAT:
{
float *value= (float *)r_param->buffer;
float4get(*value, *row);
r_param->buffer_length= 4;
*r_param->error= 0;
}
break;
default:
{
float value;
memcpy(&value, *row, sizeof(float));
float4get(value, (char *)*row);
convert_from_float(r_param, field, value, sizeof(float));
}
break;
}
(*row)+= 4;
}
|
O0
|
c
|
ps_fetch_float:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x4, %eax
jne 0x36fa6
jmp 0x36f72
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x4, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, (%rax)
jmp 0x36fd5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movss -0x24(%rbp), %xmm0
movl $0x4, %edx
callq 0x38820
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
ps_fetch_float:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+60h]
sub eax, 4
jnz short loc_36FA6
jmp short $+2
loc_36F72:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
mov ecx, [rcx]
mov [rax], ecx
mov rax, [rbp+var_8]
mov qword ptr [rax+40h], 4
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov byte ptr [rax], 0
jmp short loc_36FD5
loc_36FA6:
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_24], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
movss xmm0, [rbp+var_24]
mov edx, 4
call convert_from_float
loc_36FD5:
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
add rsp, 30h
pop rbp
retn
|
float ** ps_fetch_float(long long a1, long long a2, float **a3)
{
float **result; // rax
if ( *(_DWORD *)(a1 + 96) == 4 )
{
**(float **)(a1 + 16) = **a3;
*(_QWORD *)(a1 + 64) = 4LL;
**(_BYTE **)(a1 + 24) = 0;
}
else
{
convert_from_float(a1, a2, 4LL, **a3);
}
result = a3;
++*a3;
return result;
}
|
ps_fetch_float:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x60]
SUB EAX,0x4
JNZ 0x00136fa6
JMP 0x00136f72
LAB_00136f72:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],0x0
JMP 0x00136fd5
LAB_00136fa6:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RBP + -0x24]
MOV EDX,0x4
CALL 0x00138820
LAB_00136fd5:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
ADD RSP,0x30
POP RBP
RET
|
void ps_fetch_float(long param_1,int8 param_2,long *param_3)
{
if (*(int *)(param_1 + 0x60) == 4) {
**(int4 **)(param_1 + 0x10) = *(int4 *)*param_3;
*(int8 *)(param_1 + 0x40) = 4;
**(int1 **)(param_1 + 0x18) = 0;
}
else {
convert_from_float(*(int4 *)*param_3,param_1,param_2,4);
}
*param_3 = *param_3 + 4;
return;
}
|
|
16,060
|
lunasvg::Canvas::blendCanvas(lunasvg::Canvas const&, lunasvg::BlendMode, float)
|
dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp
|
void Canvas::blendCanvas(const Canvas& canvas, BlendMode blendMode, float opacity)
{
plutovg_matrix_t matrix = { 1, 0, 0, 1, static_cast<float>(canvas.x()), static_cast<float>(canvas.y()) };
plutovg_canvas_reset_matrix(m_canvas);
plutovg_canvas_translate(m_canvas, -m_x, -m_y);
plutovg_canvas_set_operator(m_canvas, static_cast<plutovg_operator_t>(blendMode));
plutovg_canvas_set_texture(m_canvas, canvas.surface(), PLUTOVG_TEXTURE_TYPE_PLAIN, opacity, &matrix);
plutovg_canvas_paint(m_canvas);
}
|
O0
|
cpp
|
lunasvg::Canvas::blendCanvas(lunasvg::Canvas const&, lunasvg::BlendMode, float):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movss 0x77f50(%rip), %xmm0 # 0x8c0c8
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x77f33(%rip), %xmm0 # 0x8c0c8
movss %xmm0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14ea0
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14ec0
movl %eax, %ecx
movq -0x38(%rbp), %rax
cvtsi2ss %ecx, %xmm0
movss %xmm0, -0x1c(%rbp)
movq 0x8(%rax), %rdi
callq 0x55600
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rdi
xorl %eax, %eax
subl 0x10(%rcx), %eax
cvtsi2ss %eax, %xmm0
xorl %eax, %eax
subl 0x14(%rcx), %eax
cvtsi2ss %eax, %xmm1
callq 0x554d0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x550e0
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14d50
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movss -0x18(%rbp), %xmm0
xorl %edx, %edx
leaq -0x30(%rbp), %rcx
callq 0x54f00
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x560f0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN7lunasvg6Canvas11blendCanvasERKS0_NS_9BlendModeEf:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
movss [rbp+var_18], xmm0
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
movss xmm0, cs:flt_8C0C8
movss [rbp+var_30], xmm0
xorps xmm0, xmm0
movss [rbp+var_2C], xmm0
xorps xmm0, xmm0
movss [rbp+var_28], xmm0
movss xmm0, cs:flt_8C0C8
movss [rbp+var_24], xmm0
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg6Canvas1xEv; lunasvg::Canvas::x(void)
cvtsi2ss xmm0, eax
movss [rbp+var_20], xmm0
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg6Canvas1yEv; lunasvg::Canvas::y(void)
mov ecx, eax
mov rax, [rbp+var_38]
cvtsi2ss xmm0, ecx
movss [rbp+var_1C], xmm0
mov rdi, [rax+8]
call plutovg_canvas_reset_matrix
mov rcx, [rbp+var_38]
mov rdi, [rcx+8]
xor eax, eax
sub eax, [rcx+10h]
cvtsi2ss xmm0, eax
xor eax, eax
sub eax, [rcx+14h]
cvtsi2ss xmm1, eax
call plutovg_canvas_translate
mov rax, [rbp+var_38]
mov rdi, [rax+8]
mov esi, [rbp+var_14]
call plutovg_canvas_set_operator
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg6Canvas7surfaceEv; lunasvg::Canvas::surface(void)
mov rdi, [rbp+var_40]
mov rsi, rax
movss xmm0, [rbp+var_18]
xor edx, edx
lea rcx, [rbp+var_30]
call plutovg_canvas_set_texture
mov rax, [rbp+var_38]
mov rdi, [rax+8]
call plutovg_canvas_paint
add rsp, 40h
pop rbp
retn
|
long long lunasvg::Canvas::blendCanvas(long long a1, lunasvg::Canvas *a2, unsigned int a3, float a4)
{
long long v4; // rsi
long long v6; // [rsp+0h] [rbp-40h]
_DWORD v7[6]; // [rsp+10h] [rbp-30h] BYREF
float v8; // [rsp+28h] [rbp-18h]
unsigned int v9; // [rsp+2Ch] [rbp-14h]
lunasvg::Canvas *v10; // [rsp+30h] [rbp-10h]
long long v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v7[0] = 1065353216;
v7[1] = 0;
v7[2] = 0;
v7[3] = 1065353216;
*(float *)&v7[4] = (float)(int)lunasvg::Canvas::x(a2);
*(float *)&v7[5] = (float)(int)lunasvg::Canvas::y(a2);
plutovg_canvas_reset_matrix(*(_QWORD *)(a1 + 8));
plutovg_canvas_translate(*(_QWORD *)(a1 + 8), (float)-*(_DWORD *)(a1 + 16), (float)-*(_DWORD *)(a1 + 20));
plutovg_canvas_set_operator(*(_QWORD *)(a1 + 8), v9);
v6 = *(_QWORD *)(a1 + 8);
v4 = lunasvg::Canvas::surface(a2);
plutovg_canvas_set_texture(v6, v4, 0LL, v7, v8);
return plutovg_canvas_paint(*(_QWORD *)(a1 + 8));
}
|
blendCanvas:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOVSS dword ptr [RBP + -0x18],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOVSS XMM0,dword ptr [0x0018c0c8]
MOVSS dword ptr [RBP + -0x30],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x2c],XMM0
XORPS XMM0,XMM0
MOVSS dword ptr [RBP + -0x28],XMM0
MOVSS XMM0,dword ptr [0x0018c0c8]
MOVSS dword ptr [RBP + -0x24],XMM0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00114ea0
CVTSI2SS XMM0,EAX
MOVSS dword ptr [RBP + -0x20],XMM0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00114ec0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
CVTSI2SS XMM0,ECX
MOVSS dword ptr [RBP + -0x1c],XMM0
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00155600
MOV RCX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RCX + 0x8]
XOR EAX,EAX
SUB EAX,dword ptr [RCX + 0x10]
CVTSI2SS XMM0,EAX
XOR EAX,EAX
SUB EAX,dword ptr [RCX + 0x14]
CVTSI2SS XMM1,EAX
CALL 0x001554d0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x8]
MOV ESI,dword ptr [RBP + -0x14]
CALL 0x001550e0
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00114d50
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,RAX
MOVSS XMM0,dword ptr [RBP + -0x18]
XOR EDX,EDX
LEA RCX,[RBP + -0x30]
CALL 0x00154f00
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001560f0
ADD RSP,0x40
POP RBP
RET
|
/* lunasvg::Canvas::blendCanvas(lunasvg::Canvas const&, lunasvg::BlendMode, float) */
void __thiscall
lunasvg::Canvas::blendCanvas(int4 param_1_00,Canvas *this,Canvas *param_1,int4 param_4)
{
int8 uVar1;
int iVar2;
int8 uVar3;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
float local_28;
float local_24;
int4 local_20;
int4 local_1c;
Canvas *local_18;
Canvas *local_10;
local_38 = DAT_0018c0c8;
local_34 = 0;
local_30 = 0;
local_2c = DAT_0018c0c8;
local_20 = param_1_00;
local_1c = param_4;
local_18 = param_1;
local_10 = this;
iVar2 = x(param_1);
local_28 = (float)iVar2;
iVar2 = y(local_18);
local_24 = (float)iVar2;
plutovg_canvas_reset_matrix(*(int8 *)(this + 8));
plutovg_canvas_translate
((float)-*(int *)(this + 0x10),(float)-*(int *)(this + 0x14),*(int8 *)(this + 8));
plutovg_canvas_set_operator(*(int8 *)(this + 8),local_1c);
uVar1 = *(int8 *)(this + 8);
uVar3 = surface(local_18);
plutovg_canvas_set_texture(local_20,uVar1,uVar3,0,&local_38);
plutovg_canvas_paint(*(int8 *)(this + 8));
return;
}
|
|
16,061
|
lunasvg::Canvas::blendCanvas(lunasvg::Canvas const&, lunasvg::BlendMode, float)
|
dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp
|
void Canvas::blendCanvas(const Canvas& canvas, BlendMode blendMode, float opacity)
{
plutovg_matrix_t matrix = { 1, 0, 0, 1, static_cast<float>(canvas.x()), static_cast<float>(canvas.y()) };
plutovg_canvas_reset_matrix(m_canvas);
plutovg_canvas_translate(m_canvas, -m_x, -m_y);
plutovg_canvas_set_operator(m_canvas, static_cast<plutovg_operator_t>(blendMode));
plutovg_canvas_set_texture(m_canvas, canvas.surface(), PLUTOVG_TEXTURE_TYPE_PLAIN, opacity, &matrix);
plutovg_canvas_paint(m_canvas);
}
|
O1
|
cpp
|
lunasvg::Canvas::blendCanvas(lunasvg::Canvas const&, lunasvg::BlendMode, float):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movss %xmm0, 0xc(%rsp)
movq %rsi, %r15
movaps 0x35134(%rip), %xmm0 # 0x43110
leaq 0x10(%rsp), %rbx
movups %xmm0, (%rbx)
xorps %xmm0, %xmm0
cvtsi2ssl 0x10(%rsi), %xmm0
movss %xmm0, 0x10(%rbx)
xorps %xmm0, %xmm0
cvtsi2ssl 0x14(%rsi), %xmm0
movl %edx, %ebp
movq %rdi, %r14
movss %xmm0, 0x14(%rbx)
movq 0x8(%rdi), %rdi
callq 0x23c30
xorl %eax, %eax
subl 0x10(%r14), %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
xorl %eax, %eax
subl 0x14(%r14), %eax
movq 0x8(%r14), %rdi
cvtsi2ss %eax, %xmm1
callq 0x23bec
movq 0x8(%r14), %rdi
movl %ebp, %esi
callq 0x23a8f
movq 0x8(%r14), %rdi
movq (%r15), %rsi
xorl %edx, %edx
movss 0xc(%rsp), %xmm0
movq %rbx, %rcx
callq 0x23989
movq 0x8(%r14), %rdi
callq 0x23fc6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_ZN7lunasvg6Canvas11blendCanvasERKS0_NS_9BlendModeEf:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
movss [rsp+48h+var_3C], xmm0
mov r15, rsi
movaps xmm0, cs:xmmword_43110
lea rbx, [rsp+48h+var_38]
movups xmmword ptr [rbx], xmm0
xorps xmm0, xmm0
cvtsi2ss xmm0, dword ptr [rsi+10h]
movss dword ptr [rbx+10h], xmm0
xorps xmm0, xmm0
cvtsi2ss xmm0, dword ptr [rsi+14h]
mov ebp, edx
mov r14, rdi
movss dword ptr [rbx+14h], xmm0
mov rdi, [rdi+8]
call plutovg_canvas_reset_matrix
xor eax, eax
sub eax, [r14+10h]
xorps xmm0, xmm0
cvtsi2ss xmm0, eax
xor eax, eax
sub eax, [r14+14h]
mov rdi, [r14+8]
cvtsi2ss xmm1, eax
call plutovg_canvas_translate
mov rdi, [r14+8]
mov esi, ebp
call plutovg_canvas_set_operator
mov rdi, [r14+8]
mov rsi, [r15]
xor edx, edx
movss xmm0, [rsp+48h+var_3C]
mov rcx, rbx
call plutovg_canvas_set_texture
mov rdi, [r14+8]
call plutovg_canvas_paint
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long lunasvg::Canvas::blendCanvas(long long a1, _QWORD *a2, unsigned int a3, float a4)
{
plutovg_canvas_reset_matrix(*(_QWORD *)(a1 + 8));
plutovg_canvas_translate(*(_QWORD *)(a1 + 8), (float)-*(_DWORD *)(a1 + 16), (float)-*(_DWORD *)(a1 + 20));
plutovg_canvas_set_operator(*(_QWORD *)(a1 + 8), a3);
plutovg_canvas_set_texture(*(_QWORD *)(a1 + 8), *a2);
return plutovg_canvas_paint(*(_QWORD *)(a1 + 8), a4);
}
|
blendCanvas:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOVSS dword ptr [RSP + 0xc],XMM0
MOV R15,RSI
MOVAPS XMM0,xmmword ptr [0x00143110]
LEA RBX,[RSP + 0x10]
MOVUPS xmmword ptr [RBX],XMM0
XORPS XMM0,XMM0
CVTSI2SS XMM0,dword ptr [RSI + 0x10]
MOVSS dword ptr [RBX + 0x10],XMM0
XORPS XMM0,XMM0
CVTSI2SS XMM0,dword ptr [RSI + 0x14]
MOV EBP,EDX
MOV R14,RDI
MOVSS dword ptr [RBX + 0x14],XMM0
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x00123c30
XOR EAX,EAX
SUB EAX,dword ptr [R14 + 0x10]
XORPS XMM0,XMM0
CVTSI2SS XMM0,EAX
XOR EAX,EAX
SUB EAX,dword ptr [R14 + 0x14]
MOV RDI,qword ptr [R14 + 0x8]
CVTSI2SS XMM1,EAX
CALL 0x00123bec
MOV RDI,qword ptr [R14 + 0x8]
MOV ESI,EBP
CALL 0x00123a8f
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15]
XOR EDX,EDX
MOVSS XMM0,dword ptr [RSP + 0xc]
MOV RCX,RBX
CALL 0x00123989
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x00123fc6
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* lunasvg::Canvas::blendCanvas(lunasvg::Canvas const&, lunasvg::BlendMode, float) */
void __thiscall
lunasvg::Canvas::blendCanvas
(int4 param_1_00,Canvas *this,int8 *param_1,int4 param_4)
{
int8 local_38;
int8 uStack_30;
float local_28;
float local_24;
local_38 = _DAT_00143110;
uStack_30 = _UNK_00143118;
local_28 = (float)*(int *)(param_1 + 2);
local_24 = (float)*(int *)((long)param_1 + 0x14);
plutovg_canvas_reset_matrix(*(int8 *)(this + 8));
plutovg_canvas_translate
((float)-*(int *)(this + 0x10),(float)-*(int *)(this + 0x14),*(int8 *)(this + 8));
plutovg_canvas_set_operator(*(int8 *)(this + 8),param_4);
plutovg_canvas_set_texture(param_1_00,*(int8 *)(this + 8),*param_1,0,&local_38);
plutovg_canvas_paint(*(int8 *)(this + 8));
return;
}
|
|
16,062
|
skip_spaces
|
bluesky950520[P]quickjs/quickjs.c
|
static int skip_spaces(const char *pc)
{
const uint8_t *p, *p_next, *p_start;
uint32_t c;
p = p_start = (const uint8_t *)pc;
for (;;) {
c = *p++;
if (c < 0x80) {
if (!((c >= 0x09 && c <= 0x0d) || (c == 0x20)))
break;
} else {
c = utf8_decode(p - 1, &p_next);
/* no need to test for invalid UTF-8, 0xFFFD is not a space */
if (!lre_is_space(c))
break;
p = p_next;
}
}
return p - 1 - p_start;
}
|
O2
|
c
|
skip_spaces:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100003e00, %r12 # imm = 0x100003E00
movq %rsp, %r14
movq %rdi, %rax
movq %rax, %r15
movzbl (%rax), %ecx
testb %cl, %cl
js 0x37257
cmpl $0x20, %ecx
ja 0x37273
leaq 0x1(%r15), %rax
movl %ecx, %ecx
btq %rcx, %r12
jb 0x3723a
jmp 0x37273
movq %r15, %rdi
movq %r14, %rsi
callq 0x15f80
movl %eax, %edi
callq 0x7b908
testl %eax, %eax
je 0x37273
movq (%rsp), %rax
jmp 0x3723a
subl %ebx, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
skip_spaces:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov r12, 100003E00h
mov r14, rsp
mov rax, rdi
loc_3723A:
mov r15, rax
movzx ecx, byte ptr [rax]
test cl, cl
js short loc_37257
cmp ecx, 20h ; ' '
ja short loc_37273
lea rax, [r15+1]
mov ecx, ecx
bt r12, rcx
jb short loc_3723A
jmp short loc_37273
loc_37257:
mov rdi, r15
mov rsi, r14
call utf8_decode
mov edi, eax
call lre_is_space
test eax, eax
jz short loc_37273
mov rax, [rsp+28h+var_28]
jmp short loc_3723A
loc_37273:
sub r15d, ebx
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long skip_spaces(char *a1)
{
char *v1; // rax
long long v2; // r12
char *v3; // rax
int v4; // r15d
unsigned int v5; // ecx
unsigned int v6; // eax
char *v8; // [rsp+0h] [rbp-28h] BYREF
v8 = v1;
v2 = 0x100003E00LL;
v3 = a1;
do
{
while ( 1 )
{
v4 = (int)v3;
v5 = (unsigned __int8)*v3;
if ( (v5 & 0x80u) == 0 )
break;
v6 = utf8_decode(v3, &v8);
if ( !(unsigned int)lre_is_space(v6) )
return (unsigned int)(v4 - (_DWORD)a1);
v3 = v8;
}
if ( v5 > 0x20 )
break;
++v3;
}
while ( _bittest64(&v2, v5) );
return (unsigned int)(v4 - (_DWORD)a1);
}
|
skip_spaces:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,0x100003e00
MOV R14,RSP
MOV RAX,RDI
LAB_0013723a:
MOV R15,RAX
MOVZX ECX,byte ptr [RAX]
TEST CL,CL
JS 0x00137257
CMP ECX,0x20
JA 0x00137273
LEA RAX,[R15 + 0x1]
MOV ECX,ECX
BT R12,RCX
JC 0x0013723a
JMP 0x00137273
LAB_00137257:
MOV RDI,R15
MOV RSI,R14
CALL 0x00115f80
MOV EDI,EAX
CALL 0x0017b908
TEST EAX,EAX
JZ 0x00137273
MOV RAX,qword ptr [RSP]
JMP 0x0013723a
LAB_00137273:
SUB R15D,EBX
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int skip_spaces(byte *param_1)
{
byte bVar1;
byte *pbVar2;
int4 uVar3;
int iVar4;
byte *in_RAX;
byte *pbVar5;
byte *local_28;
pbVar2 = param_1;
local_28 = in_RAX;
do {
while (pbVar5 = pbVar2, bVar1 = *pbVar5, -1 < (char)bVar1) {
if ((0x20 < bVar1) ||
(pbVar2 = pbVar5 + 1, (0x100003e00U >> ((ulong)(uint)bVar1 & 0x3f) & 1) == 0))
goto LAB_00137273;
}
uVar3 = utf8_decode(pbVar5,&local_28);
iVar4 = lre_is_space(uVar3);
pbVar2 = local_28;
} while (iVar4 != 0);
LAB_00137273:
return (int)pbVar5 - (int)param_1;
}
|
|
16,063
|
skip_spaces
|
bluesky950520[P]quickjs/quickjs.c
|
static int skip_spaces(const char *pc)
{
const uint8_t *p, *p_next, *p_start;
uint32_t c;
p = p_start = (const uint8_t *)pc;
for (;;) {
c = *p++;
if (c < 0x80) {
if (!((c >= 0x09 && c <= 0x0d) || (c == 0x20)))
break;
} else {
c = utf8_decode(p - 1, &p_next);
/* no need to test for invalid UTF-8, 0xFFFD is not a space */
if (!lre_is_space(c))
break;
p = p_next;
}
}
return p - 1 - p_start;
}
|
O3
|
c
|
skip_spaces:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, %rax
movq %rax, %r15
movzbl (%rax), %ecx
testb %cl, %cl
js 0x405cc
leaq 0x1(%r15), %rax
leal -0x9(%rcx), %edx
cmpl $0x5, %edx
jb 0x405af
cmpl $0x20, %ecx
je 0x405af
jmp 0x405e9
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c05a
movl %eax, %edi
callq 0x9704c
testl %eax, %eax
je 0x405e9
movq 0x8(%rsp), %rax
jmp 0x405af
subl %ebx, %r15d
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
skip_spaces:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
lea r14, [rsp+28h+var_20]
mov rax, rdi
loc_405AF:
mov r15, rax
movzx ecx, byte ptr [rax]
test cl, cl
js short loc_405CC
lea rax, [r15+1]
lea edx, [rcx-9]
cmp edx, 5
jb short loc_405AF
cmp ecx, 20h ; ' '
jz short loc_405AF
jmp short loc_405E9
loc_405CC:
mov rdi, r15
mov rsi, r14
call utf8_decode
mov edi, eax
call lre_is_space
test eax, eax
jz short loc_405E9
mov rax, [rsp+28h+var_20]
jmp short loc_405AF
loc_405E9:
sub r15d, ebx
mov eax, r15d
add rsp, 10h
pop rbx
pop r14
pop r15
retn
|
long long skip_spaces(char *a1)
{
char *v1; // rax
int v2; // r15d
int v3; // ecx
unsigned int v4; // eax
char *v6; // [rsp+8h] [rbp-20h] BYREF
v1 = a1;
do
{
while ( 1 )
{
v2 = (int)v1;
v3 = (unsigned __int8)*v1;
if ( (v3 & 0x80u) == 0 )
break;
v4 = utf8_decode(v1, &v6);
if ( !(unsigned int)lre_is_space(v4) )
return (unsigned int)(v2 - (_DWORD)a1);
v1 = v6;
}
++v1;
}
while ( (unsigned int)(v3 - 9) < 5 || v3 == 32 );
return (unsigned int)(v2 - (_DWORD)a1);
}
|
skip_spaces:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RAX,RDI
LAB_001405af:
MOV R15,RAX
MOVZX ECX,byte ptr [RAX]
TEST CL,CL
JS 0x001405cc
LEA RAX,[R15 + 0x1]
LEA EDX,[RCX + -0x9]
CMP EDX,0x5
JC 0x001405af
CMP ECX,0x20
JZ 0x001405af
JMP 0x001405e9
LAB_001405cc:
MOV RDI,R15
MOV RSI,R14
CALL 0x0011c05a
MOV EDI,EAX
CALL 0x0019704c
TEST EAX,EAX
JZ 0x001405e9
MOV RAX,qword ptr [RSP + 0x8]
JMP 0x001405af
LAB_001405e9:
SUB R15D,EBX
MOV EAX,R15D
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
int skip_spaces(byte *param_1)
{
byte bVar1;
byte *pbVar2;
int4 uVar3;
int iVar4;
byte *pbVar5;
byte *local_20;
pbVar2 = param_1;
do {
while (pbVar5 = pbVar2, bVar1 = *pbVar5, (char)bVar1 < '\0') {
uVar3 = utf8_decode(pbVar5,&local_20);
iVar4 = lre_is_space(uVar3);
pbVar2 = local_20;
if (iVar4 == 0) goto LAB_001405e9;
}
pbVar2 = pbVar5 + 1;
} while ((bVar1 - 9 < 5) || (bVar1 == 0x20));
LAB_001405e9:
return (int)pbVar5 - (int)param_1;
}
|
|
16,064
|
PAIRING_FinalVerify
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/aggregate.c
|
static bool_t PAIRING_FinalVerify(const PAIRING *ctx, const vec384fp12 GTsig)
{
vec384fp12 GT;
if (!(ctx->ctrl & AGGR_GT_SET))
return 0;
if (GTsig != NULL) {
vec_copy(GT, GTsig, sizeof(GT));
} else if (ctx->ctrl & AGGR_SIGN_SET) {
AggregatedSignature AggrSign;
switch (ctx->ctrl & MIN_SIG_OR_PK) {
case AGGR_MIN_SIG:
POINTonE1_from_Jacobian(&AggrSign.e1, &ctx->AggrSign.e1);
miller_loop_n(GT, (const POINTonE2_affine *)&BLS12_381_G2,
(const POINTonE1_affine *)&AggrSign.e1, 1);
break;
case AGGR_MIN_PK:
POINTonE2_from_Jacobian(&AggrSign.e2, &ctx->AggrSign.e2);
miller_loop_n(GT, (const POINTonE2_affine *)&AggrSign.e2,
(const POINTonE1_affine *)&BLS12_381_G1, 1);
break;
default:
return 0;
}
} else {
/*
* The aggregated signature was infinite, relation between the
* hashes and the public keys has to be VERY special...
*/
vec_copy(GT, BLS12_381_Rx.p12, sizeof(GT));
}
conjugate_fp12(GT);
mul_fp12(GT, GT, ctx->GT);
final_exp(GT, GT);
/* return GT==1 */
return vec_is_equal(GT[0][0], BLS12_381_Rx.p2, sizeof(GT[0][0])) &
vec_is_zero(GT[0][1], sizeof(GT) - sizeof(GT[0][0]));
}
|
O2
|
c
|
PAIRING_FinalVerify:
movl (%rdi), %eax
testb $0x20, %al
jne 0x57b5d
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x360, %rsp # imm = 0x360
movq %rdi, %rbx
testq %rsi, %rsi
jne 0x57b7e
testb $0x10, %al
jne 0x57bf0
leaq 0x2816a(%rip), %rsi # 0x7fce8
leaq -0x250(%rbp), %rdi
movl $0x240, %edx # imm = 0x240
callq 0x51055
leaq -0x250(%rbp), %r14
movq %r14, %rdi
callq 0x561f3
addq $0x18, %rbx
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x55f2f
movq %r14, %rdi
movq %r14, %rsi
callq 0x56c7e
leaq 0x28126(%rip), %rsi # 0x7fce8
pushq $0x60
popq %rdx
movq %r14, %rdi
callq 0x52f34
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
movl $0x1e0, %esi # imm = 0x1E0
callq 0x510f5
andq %rbx, %rax
addq $0x360, %rsp # imm = 0x360
popq %rbx
popq %r14
popq %rbp
retq
andl $0x3, %eax
cmpl $0x2, %eax
je 0x57c29
cmpl $0x1, %eax
jne 0x57c5d
leaq 0x258(%rbx), %rsi
leaq -0x370(%rbp), %r14
movq %r14, %rdi
callq 0x50f03
leaq 0x27e56(%rip), %rsi # 0x7fa70
leaq -0x250(%rbp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rdx
jmp 0x57c53
leaq 0x258(%rbx), %rsi
leaq -0x370(%rbp), %r14
movq %r14, %rdi
callq 0x5345a
leaq 0x27cea(%rip), %rdx # 0x7f930
leaq -0x250(%rbp), %rdi
pushq $0x1
popq %rcx
movq %r14, %rsi
callq 0x56653
jmp 0x57b8f
xorl %eax, %eax
jmp 0x57be4
|
PAIRING_FinalVerify:
mov eax, [rdi]
test al, 20h
jnz short loc_57B5D
xor eax, eax
retn
loc_57B5D:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 360h
mov rbx, rdi
test rsi, rsi
jnz short loc_57B7E
test al, 10h
jnz short loc_57BF0
lea rsi, BLS12_381_Rx
loc_57B7E:
lea rdi, [rbp-250h]
mov edx, 240h
call vec_copy
loc_57B8F:
lea r14, [rbp-250h]
mov rdi, r14
call conjugate_fp12
add rbx, 18h
mov rdi, r14
mov rsi, r14
mov rdx, rbx
call mul_fp12
mov rdi, r14
mov rsi, r14
call final_exp
lea rsi, BLS12_381_Rx
push 60h ; '`'
pop rdx
mov rdi, r14
call vec_is_equal
mov rbx, rax
lea rdi, [rbp-1F0h]
mov esi, 1E0h
call vec_is_zero
and rax, rbx
loc_57BE4:
add rsp, 360h
pop rbx
pop r14
pop rbp
retn
loc_57BF0:
and eax, 3
cmp eax, 2
jz short loc_57C29
cmp eax, 1
jnz short loc_57C5D
lea rsi, [rbx+258h]
lea r14, [rbp-370h]
mov rdi, r14
call POINTonE1_from_Jacobian
lea rsi, BLS12_381_G2
lea rdi, [rbp-250h]
push 1
pop rcx
mov rdx, r14
jmp short loc_57C53
loc_57C29:
lea rsi, [rbx+258h]
lea r14, [rbp-370h]
mov rdi, r14
call POINTonE2_from_Jacobian
lea rdx, BLS12_381_G1
lea rdi, [rbp-250h]
push 1
pop rcx
mov rsi, r14
loc_57C53:
call miller_loop_n
jmp loc_57B8F
loc_57C5D:
xor eax, eax
jmp short loc_57BE4
|
unsigned long long PAIRING_FinalVerify(_DWORD *a1, void *a2)
{
unsigned long long is_equal; // rbx
int v4; // eax
_BYTE *v5; // rsi
_BYTE *v6; // rdx
_BYTE v7[288]; // [rsp-378h] [rbp-378h] BYREF
_BYTE v8[96]; // [rsp-258h] [rbp-258h] BYREF
long long v9; // [rsp-1F8h] [rbp-1F8h] BYREF
if ( (*a1 & 0x20) == 0 )
return 0LL;
if ( a2 )
goto LABEL_6;
if ( (*a1 & 0x10) == 0 )
{
a2 = &BLS12_381_Rx;
LABEL_6:
vec_copy((long long)v8, (long long)a2, 0x240uLL);
goto LABEL_7;
}
v4 = *a1 & 3;
if ( v4 == 2 )
{
POINTonE2_from_Jacobian((long long)v7, (long long)(a1 + 150));
v6 = &BLS12_381_G1;
v5 = v7;
}
else
{
if ( v4 != 1 )
return 0LL;
POINTonE1_from_Jacobian((long long)v7, (long long)(a1 + 150));
v5 = &BLS12_381_G2;
v6 = v7;
}
miller_loop_n((long long)v8, (long long)v5, (long long)v6, 1LL);
LABEL_7:
conjugate_fp12((long long)v8);
mul_fp12((long long)v8, (long long)v8, (long long)(a1 + 6));
final_exp((long long)v8, (long long)v8);
is_equal = vec_is_equal((long long)v8, (long long)&BLS12_381_Rx, 0x60uLL);
return is_equal & vec_is_zero((long long)&v9, 0x1E0uLL);
}
|
PAIRING_FinalVerify:
MOV EAX,dword ptr [RDI]
TEST AL,0x20
JNZ 0x00157b5d
XOR EAX,EAX
RET
LAB_00157b5d:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x360
MOV RBX,RDI
TEST RSI,RSI
JNZ 0x00157b7e
TEST AL,0x10
JNZ 0x00157bf0
LEA RSI,[0x17fce8]
LAB_00157b7e:
LEA RDI,[RBP + -0x250]
MOV EDX,0x240
CALL 0x00151055
LAB_00157b8f:
LEA R14,[RBP + -0x250]
MOV RDI,R14
CALL 0x001561f3
ADD RBX,0x18
MOV RDI,R14
MOV RSI,R14
MOV RDX,RBX
CALL 0x00155f2f
MOV RDI,R14
MOV RSI,R14
CALL 0x00156c7e
LEA RSI,[0x17fce8]
PUSH 0x60
POP RDX
MOV RDI,R14
CALL 0x00152f34
MOV RBX,RAX
LEA RDI,[RBP + -0x1f0]
MOV ESI,0x1e0
CALL 0x001510f5
AND RAX,RBX
LAB_00157be4:
ADD RSP,0x360
POP RBX
POP R14
POP RBP
RET
LAB_00157bf0:
AND EAX,0x3
CMP EAX,0x2
JZ 0x00157c29
CMP EAX,0x1
JNZ 0x00157c5d
LEA RSI,[RBX + 0x258]
LEA R14,[RBP + -0x370]
MOV RDI,R14
CALL 0x00150f03
LEA RSI,[0x17fa70]
LEA RDI,[RBP + -0x250]
PUSH 0x1
POP RCX
MOV RDX,R14
JMP 0x00157c53
LAB_00157c29:
LEA RSI,[RBX + 0x258]
LEA R14,[RBP + -0x370]
MOV RDI,R14
CALL 0x0015345a
LEA RDX,[0x17f930]
LEA RDI,[RBP + -0x250]
PUSH 0x1
POP RCX
MOV RSI,R14
LAB_00157c53:
CALL 0x00156653
JMP 0x00157b8f
LAB_00157c5d:
XOR EAX,EAX
JMP 0x00157be4
|
ulong PAIRING_FinalVerify(uint *param_1,int1 *param_2)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
int1 *puVar4;
int1 *puVar5;
int1 local_378 [288];
int1 local_258 [96];
int1 local_1f8 [480];
uVar1 = *param_1;
if ((uVar1 & 0x20) == 0) {
return 0;
}
if (param_2 == (int1 *)0x0) {
if ((uVar1 & 0x10) != 0) {
if ((uVar1 & 3) == 2) {
puVar5 = local_378;
POINTonE2_from_Jacobian(puVar5,param_1 + 0x96);
puVar4 = BLS12_381_G1;
}
else {
if ((uVar1 & 3) != 1) {
return 0;
}
puVar4 = local_378;
POINTonE1_from_Jacobian(puVar4,param_1 + 0x96);
puVar5 = BLS12_381_G2;
}
miller_loop_n(local_258,puVar5,puVar4,1);
goto LAB_00157b8f;
}
param_2 = BLS12_381_Rx;
}
vec_copy(local_258,param_2,0x240);
LAB_00157b8f:
conjugate_fp12(local_258);
mul_fp12(local_258,local_258,param_1 + 6);
final_exp(local_258,local_258);
uVar2 = vec_is_equal(local_258,BLS12_381_Rx,0x60);
uVar3 = vec_is_zero(local_1f8,0x1e0);
return uVar3 & uVar2;
}
|
|
16,065
|
my_error
|
eloqsql/mysys/my_error.c
|
void my_error(uint nr, myf MyFlags, ...)
{
const char *format;
va_list args;
char ebuff[ERRMSGSIZE];
DBUG_ENTER("my_error");
DBUG_PRINT("my", ("nr: %d MyFlags: %lu errno: %d", nr, MyFlags, errno));
if (!(format = my_get_err_msg(nr)))
(void) my_snprintf(ebuff, sizeof(ebuff), "Unknown error %d", nr);
else
{
va_start(args,MyFlags);
(void) my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, ebuff,
sizeof(ebuff), format, args);
va_end(args);
}
(*error_handler_hook)(nr, ebuff, MyFlags);
DBUG_VOID_RETURN;
}
|
O0
|
c
|
my_error:
pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
testb %al, %al
je 0x2edc7
movaps %xmm0, -0x2c0(%rbp)
movaps %xmm1, -0x2b0(%rbp)
movaps %xmm2, -0x2a0(%rbp)
movaps %xmm3, -0x290(%rbp)
movaps %xmm4, -0x280(%rbp)
movaps %xmm5, -0x270(%rbp)
movaps %xmm6, -0x260(%rbp)
movaps %xmm7, -0x250(%rbp)
movq %r9, -0x2c8(%rbp)
movq %r8, -0x2d0(%rbp)
movq %rcx, -0x2d8(%rbp)
movq %rdx, -0x2e0(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x214(%rbp)
movq %rsi, -0x220(%rbp)
jmp 0x2edff
movl -0x214(%rbp), %edi
callq 0x2ecd0
movq %rax, -0x228(%rbp)
cmpq $0x0, %rax
jne 0x2ee39
leaq -0x210(%rbp), %rdi
movl -0x214(%rbp), %ecx
movl $0x200, %esi # imm = 0x200
leaq 0x4c394(%rip), %rdx # 0x7b1c4
movb $0x0, %al
callq 0x77200
jmp 0x2ee8d
leaq -0x240(%rbp), %rax
leaq -0x2f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x210(%rbp), %rsi
movq -0x228(%rbp), %rcx
leaq -0x240(%rbp), %r8
leaq 0x353c14(%rip), %rdi # 0x382a90
movl $0x200, %edx # imm = 0x200
callq 0x74be0
leaq -0x240(%rbp), %rax
leaq 0x1a05bc(%rip), %rax # 0x1cf450
movq (%rax), %rax
movl -0x214(%rbp), %edi
leaq -0x210(%rbp), %rsi
movq -0x220(%rbp), %rdx
callq *%rax
jmp 0x2eeaf
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2eeca
addq $0x2f0, %rsp # imm = 0x2F0
popq %rbp
retq
callq 0x242e0
nop
|
my_error:
push rbp
mov rbp, rsp
sub rsp, 2F0h
test al, al
jz short loc_2EDC7
movaps [rbp+var_2C0], xmm0
movaps [rbp+var_2B0], xmm1
movaps [rbp+var_2A0], xmm2
movaps [rbp+var_290], xmm3
movaps [rbp+var_280], xmm4
movaps [rbp+var_270], xmm5
movaps [rbp+var_260], xmm6
movaps [rbp+var_250], xmm7
loc_2EDC7:
mov [rbp+var_2C8], r9
mov [rbp+var_2D0], r8
mov [rbp+var_2D8], rcx
mov [rbp+var_2E0], rdx
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_214], edi
mov [rbp+var_220], rsi
jmp short $+2
loc_2EDFF:
mov edi, [rbp+var_214]
call my_get_err_msg
mov [rbp+var_228], rax
cmp rax, 0
jnz short loc_2EE39
lea rdi, [rbp+var_210]
mov ecx, [rbp+var_214]
mov esi, 200h
lea rdx, aUnknownErrorD; "Unknown error %d"
mov al, 0
call my_snprintf
jmp short loc_2EE8D
loc_2EE39:
lea rax, [rbp+var_240]
lea rcx, [rbp+var_2F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rsi, [rbp+var_210]
mov rcx, [rbp+var_228]
lea r8, [rbp+var_240]
lea rdi, my_charset_utf8mb3_general_ci
mov edx, 200h
call my_vsnprintf_ex
lea rax, [rbp+var_240]
loc_2EE8D:
lea rax, error_handler_hook
mov rax, [rax]
mov edi, [rbp+var_214]
lea rsi, [rbp+var_210]
mov rdx, [rbp+var_220]
call rax
jmp short $+2
loc_2EEAF:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2EECA
add rsp, 2F0h
pop rbp
retn
loc_2EECA:
call ___stack_chk_fail
|
unsigned long long my_error(unsigned int a1, long long a2, ...)
{
int v2; // r8d
int v3; // r9d
va_list va; // [rsp+B0h] [rbp-240h] BYREF
_BYTE *err_msg; // [rsp+C8h] [rbp-228h]
long long v7; // [rsp+D0h] [rbp-220h]
unsigned int v8; // [rsp+DCh] [rbp-214h]
_BYTE v9[520]; // [rsp+E0h] [rbp-210h] BYREF
unsigned long long v10; // [rsp+2E8h] [rbp-8h]
va_start(va, a2);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_arg(va, _QWORD);
va_end(va);
v10 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
err_msg = my_get_err_msg(a1);
if ( err_msg )
{
va_start(va, a2);
my_vsnprintf_ex(&my_charset_utf8mb3_general_ci, v9, 512LL, err_msg, va);
}
else
{
my_snprintf((unsigned int)v9, 512, (unsigned int)"Unknown error %d", v8, v2, v3);
}
error_handler_hook(v8, (long long)v9, v7);
return __readfsqword(0x28u);
}
|
my_error:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x2f0
TEST AL,AL
JZ 0x0012edc7
MOVAPS xmmword ptr [RBP + -0x2c0],XMM0
MOVAPS xmmword ptr [RBP + -0x2b0],XMM1
MOVAPS xmmword ptr [RBP + -0x2a0],XMM2
MOVAPS xmmword ptr [RBP + -0x290],XMM3
MOVAPS xmmword ptr [RBP + -0x280],XMM4
MOVAPS xmmword ptr [RBP + -0x270],XMM5
MOVAPS xmmword ptr [RBP + -0x260],XMM6
MOVAPS xmmword ptr [RBP + -0x250],XMM7
LAB_0012edc7:
MOV qword ptr [RBP + -0x2c8],R9
MOV qword ptr [RBP + -0x2d0],R8
MOV qword ptr [RBP + -0x2d8],RCX
MOV qword ptr [RBP + -0x2e0],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x214],EDI
MOV qword ptr [RBP + -0x220],RSI
JMP 0x0012edff
LAB_0012edff:
MOV EDI,dword ptr [RBP + -0x214]
CALL 0x0012ecd0
MOV qword ptr [RBP + -0x228],RAX
CMP RAX,0x0
JNZ 0x0012ee39
LEA RDI,[RBP + -0x210]
MOV ECX,dword ptr [RBP + -0x214]
MOV ESI,0x200
LEA RDX,[0x17b1c4]
MOV AL,0x0
CALL 0x00177200
JMP 0x0012ee8d
LAB_0012ee39:
LEA RAX,[RBP + -0x240]
LEA RCX,[RBP + -0x2f0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RSI,[RBP + -0x210]
MOV RCX,qword ptr [RBP + -0x228]
LEA R8,[RBP + -0x240]
LEA RDI,[0x482a90]
MOV EDX,0x200
CALL 0x00174be0
LEA RAX,[RBP + -0x240]
LAB_0012ee8d:
LEA RAX,[0x2cf450]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RBP + -0x214]
LEA RSI,[RBP + -0x210]
MOV RDX,qword ptr [RBP + -0x220]
CALL RAX
JMP 0x0012eeaf
LAB_0012eeaf:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012eeca
ADD RSP,0x2f0
POP RBP
RET
LAB_0012eeca:
CALL 0x001242e0
|
void my_error(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int4 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
long in_FS_OFFSET;
int1 local_2f8 [16];
int8 local_2e8;
int8 local_2e0;
int8 local_2d8;
int8 local_2d0;
int8 local_2c8;
int8 local_2b8;
int8 local_2a8;
int8 local_298;
int8 local_288;
int8 local_278;
int8 local_268;
int8 local_258;
int4 local_248;
int4 local_244;
int1 *local_240;
int1 *local_238;
long local_230;
int8 local_228;
int4 local_21c;
int1 local_218 [520];
long local_10;
if (in_AL != '\0') {
local_2c8 = param_1;
local_2b8 = param_2;
local_2a8 = param_3;
local_298 = param_4;
local_288 = param_5;
local_278 = param_6;
local_268 = param_7;
local_258 = param_8;
}
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_2e8 = param_11;
local_2e0 = param_12;
local_2d8 = param_13;
local_2d0 = param_14;
local_228 = param_10;
local_21c = param_9;
local_230 = my_get_err_msg(param_9);
if (local_230 == 0) {
my_snprintf(local_218,0x200,"Unknown error %d",local_21c);
}
else {
local_238 = local_2f8;
local_240 = &stack0x00000008;
local_244 = 0x30;
local_248 = 0x10;
my_vsnprintf_ex(my_charset_utf8mb3_general_ci,local_218,0x200,local_230,&local_248);
}
(*(code *)error_handler_hook)(local_21c,local_218,local_228);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
16,066
|
flt_reciprocal_fp2
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/recip.c
|
static void flt_reciprocal_fp2(vec384x out, const vec384x inp)
{
vec384 t0, t1;
/*
* |out| = 1/(a + b*i) = a/(a^2+b^2) - b/(a^2+b^2)*i
*/
sqr_fp(t0, inp[0]);
sqr_fp(t1, inp[1]);
add_fp(t0, t0, t1);
flt_reciprocal_fp(t1, t0);
mul_fp(out[0], inp[0], t1);
mul_fp(out[1], inp[1], t1);
neg_fp(out[1], out[1]);
}
|
O0
|
c
|
flt_reciprocal_fp2:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb2560
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xb2560
leaq -0x40(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xafde0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xb8650
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0xb6080
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
leaq -0x70(%rbp), %rdx
callq 0xb6080
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
movl $0x1, %edx
callq 0xafe20
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_flt_reciprocal_fp2:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
call sqr_fp
lea rdi, [rbp+var_70]
mov rsi, [rbp+var_10]
add rsi, 30h ; '0'
call sqr_fp
lea rdi, [rbp+var_40]
lea rsi, [rbp+var_40]
lea rdx, [rbp+var_70]
call add_fp
lea rdi, [rbp+var_70]
lea rsi, [rbp+var_40]
call _flt_reciprocal_fp
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_70]
call mul_fp
mov rdi, [rbp+var_8]
add rdi, 30h ; '0'
mov rsi, [rbp+var_10]
add rsi, 30h ; '0'
lea rdx, [rbp+var_70]
call mul_fp
mov rdi, [rbp+var_8]
add rdi, 30h ; '0'
mov rsi, [rbp+var_8]
add rsi, 30h ; '0'
mov edx, 1
call cneg_fp
add rsp, 70h
pop rbp
retn
|
long long flt_reciprocal_fp2(long long a1, long long a2)
{
_BYTE v3[48]; // [rsp+0h] [rbp-70h] BYREF
_BYTE v4[48]; // [rsp+30h] [rbp-40h] BYREF
long long v5; // [rsp+60h] [rbp-10h]
long long v6; // [rsp+68h] [rbp-8h]
v6 = a1;
v5 = a2;
sqr_fp((long long)v4, a2);
sqr_fp((long long)v3, v5 + 48);
add_fp((long long)v4, (long long)v4, (long long)v3);
flt_reciprocal_fp((long long)v3, (long long)v4);
mul_fp(v6, v5, (long long)v3);
mul_fp(v6 + 48, v5 + 48, (long long)v3);
return cneg_fp(v6 + 48, v6 + 48, 1LL);
}
|
flt_reciprocal_fp2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001b2560
LEA RDI,[RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x30
CALL 0x001b2560
LEA RDI,[RBP + -0x40]
LEA RSI,[RBP + -0x40]
LEA RDX,[RBP + -0x70]
CALL 0x001afde0
LEA RDI,[RBP + -0x70]
LEA RSI,[RBP + -0x40]
CALL 0x001b8650
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x70]
CALL 0x001b6080
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x30
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x30
LEA RDX,[RBP + -0x70]
CALL 0x001b6080
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x30
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x30
MOV EDX,0x1
CALL 0x001afe20
ADD RSP,0x70
POP RBP
RET
|
void flt_reciprocal_fp2(long param_1,long param_2)
{
int1 local_78 [48];
int1 local_48 [48];
long local_18;
long local_10;
local_18 = param_2;
local_10 = param_1;
sqr_fp(local_48,param_2);
sqr_fp(local_78,local_18 + 0x30);
add_fp(local_48,local_48,local_78);
flt_reciprocal_fp(local_78,local_48);
mul_fp(local_10,local_18,local_78);
mul_fp(local_10 + 0x30,local_18 + 0x30,local_78);
cneg_fp(local_10 + 0x30,local_10 + 0x30,1);
return;
}
|
|
16,067
|
LefDefParser::lefiVia::setViaRule(char const*, double, double, char const*, char const*, char const*, double, double, double, double, double, double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp
|
void
lefiVia::setViaRule(const char *viaRuleName,
double xSize,
double ySize,
const char *botLayer,
const char *cutLayer,
const char *topLayer,
double xCut,
double yCut,
double xBotEnc,
double yBotEnc,
double xTopEnc,
double yTopEnc)
{
viaRuleName_ = strdup(viaRuleName);
xSize_ = xSize;
ySize_ = ySize;
botLayer_ = strdup(botLayer);
cutLayer_ = strdup(cutLayer);
topLayer_ = strdup(topLayer);
xSpacing_ = xCut;
ySpacing_ = yCut;
xBotEnc_ = xBotEnc;
yBotEnc_ = yBotEnc;
xTopEnc_ = xTopEnc;
yTopEnc_ = yTopEnc;
}
|
O3
|
cpp
|
LefDefParser::lefiVia::setViaRule(char const*, double, double, char const*, char const*, char const*, double, double, double, double, double, double):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movsd %xmm7, 0x40(%rsp)
movsd %xmm6, 0x38(%rsp)
movsd %xmm5, 0x30(%rsp)
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x23a0
movq %rax, 0x80(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x88(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x90(%rbx)
movq %r12, %rdi
callq 0x23a0
movq %rax, 0x98(%rbx)
movq %r15, %rdi
callq 0x23a0
movq %rax, 0xa0(%rbx)
movq %r14, %rdi
callq 0x23a0
movq %rax, 0xa8(%rbx)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0xb0(%rbx)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xb8(%rbx)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0xc0(%rbx)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0xc8(%rbx)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0xd0(%rbx)
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0xd8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZN12LefDefParser7lefiVia10setViaRuleEPKcddS2_S2_S2_dddddd:
push r15
push r14
push r12
push rbx
sub rsp, 48h
movsd [rsp+68h+var_28], xmm7
movsd [rsp+68h+var_30], xmm6
movsd [rsp+68h+var_38], xmm5
movsd [rsp+68h+var_40], xmm4
movsd [rsp+68h+var_48], xmm3
movsd [rsp+68h+var_50], xmm2
mov r14, r8
mov r15, rcx
mov r12, rdx
movsd [rsp+68h+var_58], xmm1
movsd [rsp+68h+var_60], xmm0
mov rbx, rdi
mov rdi, rsi
call _strdup
mov [rbx+80h], rax
movsd xmm0, [rsp+68h+var_60]
movsd qword ptr [rbx+88h], xmm0
movsd xmm0, [rsp+68h+var_58]
movsd qword ptr [rbx+90h], xmm0
mov rdi, r12
call _strdup
mov [rbx+98h], rax
mov rdi, r15
call _strdup
mov [rbx+0A0h], rax
mov rdi, r14
call _strdup
mov [rbx+0A8h], rax
movsd xmm0, [rsp+68h+var_50]
movsd qword ptr [rbx+0B0h], xmm0
movsd xmm0, [rsp+68h+var_48]
movsd qword ptr [rbx+0B8h], xmm0
movsd xmm0, [rsp+68h+var_40]
movsd qword ptr [rbx+0C0h], xmm0
movsd xmm0, [rsp+68h+var_38]
movsd qword ptr [rbx+0C8h], xmm0
movsd xmm0, [rsp+68h+var_30]
movsd qword ptr [rbx+0D0h], xmm0
movsd xmm0, [rsp+68h+var_28]
movsd qword ptr [rbx+0D8h], xmm0
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long LefDefParser::lefiVia::setViaRule(
LefDefParser::lefiVia *this,
const char *a2,
double a3,
double a4,
const char *a5,
const char *a6,
const char *a7,
double a8,
double a9,
double a10,
double a11,
double a12,
double a13)
{
long long v16; // rdx
long long v17; // rdx
long long v18; // rdx
long long result; // rax
*((_QWORD *)this + 16) = strdup(a2, a2, a5);
*((double *)this + 17) = a3;
*((double *)this + 18) = a4;
*((_QWORD *)this + 19) = strdup(a5, a2, v16);
*((_QWORD *)this + 20) = strdup(a6, a2, v17);
result = strdup(a7, a2, v18);
*((_QWORD *)this + 21) = result;
*((double *)this + 22) = a8;
*((double *)this + 23) = a9;
*((double *)this + 24) = a10;
*((double *)this + 25) = a11;
*((double *)this + 26) = a12;
*((double *)this + 27) = a13;
return result;
}
|
setViaRule:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOVSD qword ptr [RSP + 0x40],XMM7
MOVSD qword ptr [RSP + 0x38],XMM6
MOVSD qword ptr [RSP + 0x30],XMM5
MOVSD qword ptr [RSP + 0x28],XMM4
MOVSD qword ptr [RSP + 0x20],XMM3
MOVSD qword ptr [RSP + 0x18],XMM2
MOV R14,R8
MOV R15,RCX
MOV R12,RDX
MOVSD qword ptr [RSP + 0x10],XMM1
MOVSD qword ptr [RSP + 0x8],XMM0
MOV RBX,RDI
MOV RDI,RSI
CALL 0x001023a0
MOV qword ptr [RBX + 0x80],RAX
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RBX + 0x88],XMM0
MOVSD XMM0,qword ptr [RSP + 0x10]
MOVSD qword ptr [RBX + 0x90],XMM0
MOV RDI,R12
CALL 0x001023a0
MOV qword ptr [RBX + 0x98],RAX
MOV RDI,R15
CALL 0x001023a0
MOV qword ptr [RBX + 0xa0],RAX
MOV RDI,R14
CALL 0x001023a0
MOV qword ptr [RBX + 0xa8],RAX
MOVSD XMM0,qword ptr [RSP + 0x18]
MOVSD qword ptr [RBX + 0xb0],XMM0
MOVSD XMM0,qword ptr [RSP + 0x20]
MOVSD qword ptr [RBX + 0xb8],XMM0
MOVSD XMM0,qword ptr [RSP + 0x28]
MOVSD qword ptr [RBX + 0xc0],XMM0
MOVSD XMM0,qword ptr [RSP + 0x30]
MOVSD qword ptr [RBX + 0xc8],XMM0
MOVSD XMM0,qword ptr [RSP + 0x38]
MOVSD qword ptr [RBX + 0xd0],XMM0
MOVSD XMM0,qword ptr [RSP + 0x40]
MOVSD qword ptr [RBX + 0xd8],XMM0
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* LefDefParser::lefiVia::setViaRule(char const*, double, double, char const*, char const*, char
const*, double, double, double, double, double, double) */
void __thiscall
LefDefParser::lefiVia::setViaRule
(lefiVia *this,char *param_1,double param_2,double param_3,char *param_4,char *param_5,
char *param_6,double param_7,double param_8,double param_9,double param_10,double param_11
,double param_12)
{
char *pcVar1;
pcVar1 = strdup(param_1);
*(char **)(this + 0x80) = pcVar1;
*(double *)(this + 0x88) = param_2;
*(double *)(this + 0x90) = param_3;
pcVar1 = strdup(param_4);
*(char **)(this + 0x98) = pcVar1;
pcVar1 = strdup(param_5);
*(char **)(this + 0xa0) = pcVar1;
pcVar1 = strdup(param_6);
*(char **)(this + 0xa8) = pcVar1;
*(double *)(this + 0xb0) = param_7;
*(double *)(this + 0xb8) = param_8;
*(double *)(this + 0xc0) = param_9;
*(double *)(this + 200) = param_10;
*(double *)(this + 0xd0) = param_11;
*(double *)(this + 0xd8) = param_12;
return;
}
|
|
16,068
|
throw_bf_exception
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue throw_bf_exception(JSContext *ctx, int status)
{
const char *str;
if (status & BF_ST_MEM_ERROR)
return JS_ThrowOutOfMemory(ctx);
if (status & BF_ST_DIVIDE_ZERO) {
str = "division by zero";
} else if (status & BF_ST_INVALID_OP) {
str = "invalid operation";
} else {
str = "integer overflow";
}
return JS_ThrowRangeError(ctx, "%s", str);
}
|
O0
|
c
|
throw_bf_exception:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x7770f
movq 0x10(%rsp), %rdi
callq 0x27f00
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
jmp 0x7776f
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x77728
leaq 0x9d179(%rip), %rax # 0x11489b
movq %rax, (%rsp)
jmp 0x7774e
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x77741
leaq 0x9d171(%rip), %rax # 0x1148ac
movq %rax, (%rsp)
jmp 0x7774c
leaq 0x9d176(%rip), %rax # 0x1148be
movq %rax, (%rsp)
jmp 0x7774e
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x9f1ba(%rip), %rsi # 0x116918
movb $0x0, %al
callq 0x2f960
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nop
|
throw_bf_exception:
sub rsp, 28h
mov [rsp+28h+var_18], rdi
mov [rsp+28h+var_1C], esi
mov eax, [rsp+28h+var_1C]
and eax, 20h
cmp eax, 0
jz short loc_7770F
mov rdi, [rsp+28h+var_18]
call JS_ThrowOutOfMemory
mov [rsp+28h+var_10], rax
mov [rsp+28h+var_8], rdx
jmp short loc_7776F
loc_7770F:
mov eax, [rsp+28h+var_1C]
and eax, 2
cmp eax, 0
jz short loc_77728
lea rax, aDivisionByZero; "division by zero"
mov [rsp+28h+var_28], rax
jmp short loc_7774E
loc_77728:
mov eax, [rsp+28h+var_1C]
and eax, 1
cmp eax, 0
jz short loc_77741
lea rax, aInvalidOperati; "invalid operation"
mov [rsp+28h+var_28], rax
jmp short loc_7774C
loc_77741:
lea rax, aIntegerOverflo; "integer overflow"
mov [rsp+28h+var_28], rax
loc_7774C:
jmp short $+2
loc_7774E:
mov rdi, [rsp+28h+var_18]
mov rdx, [rsp+28h+var_28]
lea rsi, aUnsupportedKey+15h; "%s"
mov al, 0
call JS_ThrowRangeError
mov [rsp+28h+var_10], rax
mov [rsp+28h+var_8], rdx
loc_7776F:
mov rax, [rsp+28h+var_10]
mov rdx, [rsp+28h+var_8]
add rsp, 28h
retn
|
long long throw_bf_exception(
long long a1,
long long a2,
int a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
if ( (a2 & 0x20) != 0 )
return JS_ThrowOutOfMemory(a1, a2, a3, a4, a5, a6);
if ( (a2 & 2) != 0 )
return JS_ThrowRangeError(
a1,
(long long)"%s",
(long long)"division by zero",
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
(char)"division by zero");
if ( (a2 & 1) != 0 )
return JS_ThrowRangeError(
a1,
(long long)"%s",
(long long)"invalid operation",
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
(char)"invalid operation");
return JS_ThrowRangeError(
a1,
(long long)"%s",
(long long)"integer overflow",
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
(char)"integer overflow");
}
|
throw_bf_exception:
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0xc],ESI
MOV EAX,dword ptr [RSP + 0xc]
AND EAX,0x20
CMP EAX,0x0
JZ 0x0017770f
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00127f00
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
JMP 0x0017776f
LAB_0017770f:
MOV EAX,dword ptr [RSP + 0xc]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00177728
LEA RAX,[0x21489b]
MOV qword ptr [RSP],RAX
JMP 0x0017774e
LAB_00177728:
MOV EAX,dword ptr [RSP + 0xc]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00177741
LEA RAX,[0x2148ac]
MOV qword ptr [RSP],RAX
JMP 0x0017774c
LAB_00177741:
LEA RAX,[0x2148be]
MOV qword ptr [RSP],RAX
LAB_0017774c:
JMP 0x0017774e
LAB_0017774e:
MOV RDI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP]
LEA RSI,[0x216918]
MOV AL,0x0
CALL 0x0012f960
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
LAB_0017776f:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
int1 [16] throw_bf_exception(int8 param_1,uint param_2)
{
int1 auVar1 [16];
char *local_28;
if ((param_2 & 0x20) == 0) {
if ((param_2 & 2) == 0) {
if ((param_2 & 1) == 0) {
local_28 = "integer overflow";
}
else {
local_28 = "invalid operation";
}
}
else {
local_28 = "division by zero";
}
auVar1 = JS_ThrowRangeError(param_1,"%s",local_28);
}
else {
auVar1 = JS_ThrowOutOfMemory(param_1);
}
return auVar1;
}
|
|
16,069
|
translog_sync
|
eloqsql/storage/maria/ma_loghandler.c
|
void translog_sync()
{
DBUG_ENTER("ma_translog_sync");
/* The following is only true if initalization of translog succeded */
if (log_descriptor.open_files.elements != 0)
{
uint32 max= get_current_logfile()->number;
uint32 min;
min= soft_sync_min;
if (!min)
min= max;
translog_sync_files(min, max, sync_log_dir >= TRANSLOG_SYNC_DIR_ALWAYS);
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
translog_sync:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x420c11(%rip) # 0x4785f0
je 0x57a1e
callq 0x5c7e0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl 0xc218fb(%rip), %eax # 0xc792ec
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x57a00
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl -0x4(%rbp), %esi
cmpq $0x2, 0x2649ca(%rip) # 0x2bc3d8
setae %al
andb $0x1, %al
movzbl %al, %eax
movsbl %al, %edx
callq 0x56700
jmp 0x57a20
jmp 0x57a22
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
translog_sync:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:dword_4785F0, 0
jz short loc_57A1E
call get_current_logfile
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, cs:soft_sync_min
mov [rbp+var_8], eax
cmp [rbp+var_8], 0
jnz short loc_57A00
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
loc_57A00:
mov edi, [rbp+var_8]
mov esi, [rbp+var_4]
cmp cs:sync_log_dir, 2
setnb al
and al, 1
movzx eax, al
movsx edx, al
call translog_sync_files
loc_57A1E:
jmp short $+2
loc_57A20:
jmp short $+2
loc_57A22:
add rsp, 10h
pop rbp
retn
|
void translog_sync()
{
unsigned int v0; // [rsp+8h] [rbp-8h]
unsigned int v1; // [rsp+Ch] [rbp-4h]
if ( dword_4785F0 )
{
v1 = *(_DWORD *)get_current_logfile();
v0 = soft_sync_min;
if ( !soft_sync_min )
v0 = v1;
translog_sync_files(v0, v1, (unsigned long long)sync_log_dir >= 2);
}
}
|
translog_sync:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP dword ptr [0x005785f0],0x0
JZ 0x00157a1e
CALL 0x0015c7e0
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [0x00d792ec]
MOV dword ptr [RBP + -0x8],EAX
CMP dword ptr [RBP + -0x8],0x0
JNZ 0x00157a00
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
LAB_00157a00:
MOV EDI,dword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0x4]
CMP qword ptr [0x003bc3d8],0x2
SETNC AL
AND AL,0x1
MOVZX EAX,AL
MOVSX EDX,AL
CALL 0x00156700
LAB_00157a1e:
JMP 0x00157a20
LAB_00157a20:
JMP 0x00157a22
LAB_00157a22:
ADD RSP,0x10
POP RBP
RET
|
void translog_sync(void)
{
int *piVar1;
int4 local_10;
if (DAT_005785f0 != 0) {
piVar1 = (int *)get_current_logfile();
local_10 = soft_sync_min;
if (soft_sync_min == 0) {
local_10 = *piVar1;
}
translog_sync_files(local_10,*piVar1,1 < sync_log_dir);
}
return;
}
|
|
16,070
|
PVG_FT_Tan
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-ft-math.c
|
PVG_FT_Fixed PVG_FT_Tan(PVG_FT_Angle angle)
{
PVG_FT_Vector v;
v.x = PVG_FT_TRIG_SCALE >> 8;
v.y = 0;
ft_trig_pseudo_rotate(&v, angle);
return PVG_FT_DivFix(v.y, v.x);
}
|
O1
|
c
|
PVG_FT_Tan:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq $0xdbd95b, (%rbx) # imm = 0xDBD95B
movq $0x0, 0x8(%rbx)
movq %rbx, %rdi
callq 0x4221b
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
testq %rsi, %rsi
je 0x42366
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movq %rdi, %rdx
negq %rdx
cmovsq %rdi, %rdx
shlq $0x10, %rdx
movq %rcx, %rax
shrq %rax
addq %rdx, %rax
xorl %edx, %edx
divq %rcx
jmp 0x4236b
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq %rax, %rcx
negq %rcx
xorq %rdi, %rsi
cmovnsq %rax, %rcx
movq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
|
PVG_FT_Tan:
push rbx
sub rsp, 10h
mov rsi, rdi
mov rbx, rsp
mov qword ptr [rbx], 0DBD95Bh
mov qword ptr [rbx+8], 0
mov rdi, rbx
call ft_trig_pseudo_rotate
mov rsi, [rbx]
mov rdi, [rbx+8]
test rsi, rsi
jz short loc_42366
mov rcx, rsi
neg rcx
cmovs rcx, rsi
mov rdx, rdi
neg rdx
cmovs rdx, rdi
shl rdx, 10h
mov rax, rcx
shr rax, 1
add rax, rdx
xor edx, edx
div rcx
jmp short loc_4236B
loc_42366:
mov eax, 7FFFFFFFh
loc_4236B:
mov rcx, rax
neg rcx
xor rsi, rdi
cmovns rcx, rax
mov rax, rcx
add rsp, 10h
pop rbx
retn
|
long long PVG_FT_Tan(long long a1)
{
unsigned long long v1; // rcx
long long v2; // rdx
long long v3; // rax
long long v4; // rcx
long long v6; // [rsp+0h] [rbp-18h] BYREF
long long v7; // [rsp+8h] [rbp-10h]
v6 = 14408027LL;
v7 = 0LL;
ft_trig_pseudo_rotate(&v6, a1);
if ( v6 )
{
v1 = -v6;
if ( v6 > 0 )
v1 = v6;
v2 = -v7;
if ( v7 > 0 )
v2 = v7;
v3 = ((v2 << 16) + (v1 >> 1)) / v1;
}
else
{
v3 = 0x7FFFFFFFLL;
}
v4 = -v3;
if ( (v7 ^ v6) >= 0 )
return v3;
return v4;
}
|
PVG_FT_Tan:
PUSH RBX
SUB RSP,0x10
MOV RSI,RDI
MOV RBX,RSP
MOV qword ptr [RBX],0xdbd95b
MOV qword ptr [RBX + 0x8],0x0
MOV RDI,RBX
CALL 0x0014221b
MOV RSI,qword ptr [RBX]
MOV RDI,qword ptr [RBX + 0x8]
TEST RSI,RSI
JZ 0x00142366
MOV RCX,RSI
NEG RCX
CMOVS RCX,RSI
MOV RDX,RDI
NEG RDX
CMOVS RDX,RDI
SHL RDX,0x10
MOV RAX,RCX
SHR RAX,0x1
ADD RAX,RDX
XOR EDX,EDX
DIV RCX
JMP 0x0014236b
LAB_00142366:
MOV EAX,0x7fffffff
LAB_0014236b:
MOV RCX,RAX
NEG RCX
XOR RSI,RDI
CMOVNS RCX,RAX
MOV RAX,RCX
ADD RSP,0x10
POP RBX
RET
|
ulong PVG_FT_Tan(int8 param_1)
{
ulong uVar1;
ulong uVar2;
ulong local_18;
ulong local_10;
local_18 = 0xdbd95b;
local_10 = 0;
ft_trig_pseudo_rotate(&local_18,param_1);
if (local_18 == 0) {
uVar1 = 0x7fffffff;
}
else {
uVar1 = -local_18;
if (0 < (long)local_18) {
uVar1 = local_18;
}
uVar2 = -local_10;
if (0 < (long)local_10) {
uVar2 = local_10;
}
uVar1 = ((uVar1 >> 1) + uVar2 * 0x10000) / uVar1;
}
uVar2 = -uVar1;
if (-1 < (long)(local_18 ^ local_10)) {
uVar2 = uVar1;
}
return uVar2;
}
|
|
16,071
|
log_proxy
|
eloqsql/plugin/server_audit/server_audit.c
|
static int log_proxy(const struct connection_info *cn,
const struct mysql_event_connection *event)
{
time_t ctime;
size_t csize;
char message[1024];
(void) time(&ctime);
csize= log_header(message, sizeof(message)-1, &ctime,
servhost, servhost_len,
cn->user, cn->user_length,
cn->host, cn->host_length,
cn->ip, cn->ip_length,
event->thread_id, 0, "PROXY_CONNECT");
csize+= my_snprintf(message+csize, sizeof(message) - 1 - csize,
",%.*s,`%.*s`@`%.*s`,%d", cn->db_length, cn->db,
cn->proxy_length, cn->proxy,
cn->proxy_host_length, cn->proxy_host,
event->status);
message[csize]= '\n';
return write_log(message, csize + 1, 1);
}
|
O3
|
c
|
log_proxy:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rsi, %r14
movq %rsi, -0x438(%rbp)
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x31e0
movl 0x9ebc(%rip), %ecx # 0xed00
leaq 0x11c(%rbx), %r8
leaq 0x1a4(%rbx), %rax
movl 0x1a0(%rbx), %r9d
movl 0x2a4(%rbx), %r10d
leaq 0x2a8(%rbx), %r11
movl 0x2e8(%rbx), %r13d
movl 0x8(%r14), %r14d
subq $0x8, %rsp
leaq -0x430(%rbp), %rdi
movl $0x3ff, %r12d # imm = 0x3FF
movl $0x3ff, %esi # imm = 0x3FF
leaq -0x440(%rbp), %rdx
leaq 0x44f0(%rip), %r15 # 0x9386
pushq %r15
pushq $0x0
pushq %r14
pushq %r13
pushq %r11
pushq %r10
pushq %rax
callq 0x6543
addq $0x40, %rsp
movq %rax, %r13
movq 0x70da(%rip), %rax # 0xbf90
movq (%rax), %r10
leaq -0x430(,%r13), %rdi
addq %rbp, %rdi
subq %r13, %r12
movl 0x118(%rbx), %ecx
leaq 0x18(%rbx), %r8
movl 0x790(%rbx), %r9d
leaq 0x70c(%rbx), %r11
movl 0x894(%rbx), %r14d
addq $0x794, %rbx # imm = 0x794
movq -0x438(%rbp), %rax
movl 0x4(%rax), %r15d
leaq 0x4495(%rip), %rdx # 0x9394
movq %r12, %rsi
xorl %eax, %eax
pushq %r15
pushq %rbx
pushq %r14
pushq %r11
callq *(%r10)
addq $0x20, %rsp
leaq (%rax,%r13), %rcx
movb $0xa, -0x430(%rbp,%rcx)
leaq (%rax,%r13), %rsi
incq %rsi
leaq -0x430(%rbp), %rdi
movl $0x1, %edx
callq 0x6920
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x4f57
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3100
|
log_proxy:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov r14, rsi
mov [rbp+var_438], rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rdi, [rbp+var_440]
call _time
mov ecx, cs:servhost_len
lea r8, [rbx+11Ch]
lea rax, [rbx+1A4h]
mov r9d, [rbx+1A0h]
mov r10d, [rbx+2A4h]
lea r11, [rbx+2A8h]
mov r13d, [rbx+2E8h]
mov r14d, [r14+8]
sub rsp, 8
lea rdi, [rbp+var_430]
mov r12d, 3FFh
mov esi, 3FFh
lea rdx, [rbp+var_440]
lea r15, aProxyConnect; "PROXY_CONNECT"
push r15
push 0
push r14
push r13
push r11
push r10
push rax
call log_header
add rsp, 40h
mov r13, rax
mov rax, cs:my_snprintf_service_ptr
mov r10, [rax]
lea rdi, ds:0FFFFFFFFFFFFFBD0h[r13]
add rdi, rbp
sub r12, r13
mov ecx, [rbx+118h]
lea r8, [rbx+18h]
mov r9d, [rbx+790h]
lea r11, [rbx+70Ch]
mov r14d, [rbx+894h]
add rbx, 794h
mov rax, [rbp+var_438]
mov r15d, [rax+4]
lea rdx, aSSSD; ",%.*s,`%.*s`@`%.*s`,%d"
mov rsi, r12
xor eax, eax
push r15
push rbx
push r14
push r11
call qword ptr [r10]
add rsp, 20h
lea rcx, [rax+r13]
mov [rbp+rcx+var_430], 0Ah
lea rsi, [rax+r13]
inc rsi
lea rdi, [rbp+var_430]
mov edx, 1
call write_log
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_4F57
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4F57:
call ___stack_chk_fail
|
unsigned long long log_proxy(long long a1, long long a2)
{
long long v3; // r13
long long v4; // rax
char v6; // [rsp+0h] [rbp-440h] BYREF
long long v7; // [rsp+8h] [rbp-438h]
_BYTE v8[1024]; // [rsp+10h] [rbp-430h] BYREF
unsigned long long v9; // [rsp+410h] [rbp-30h]
long long savedregs; // [rsp+440h] [rbp+0h] BYREF
v7 = a2;
v9 = __readfsqword(0x28u);
time(&v6);
v3 = log_header(
(unsigned int)v8,
1023,
(unsigned int)&v6,
servhost_len,
(int)a1 + 284,
*(_DWORD *)(a1 + 416),
(unsigned __int8)a1 - 92,
*(_DWORD *)(a1 + 676),
(unsigned __int8)a1 - 88,
*(_DWORD *)(a1 + 744),
*(_DWORD *)(a2 + 8),
0LL,
(long long)"PROXY_CONNECT");
v4 = ((long long (*)(char *, long long, const char *, ...))*my_snprintf_service)(
(char *)&savedregs + v3 - 1072,
1023 - v3,
",%.*s,`%.*s`@`%.*s`,%d",
*(_DWORD *)(a1 + 280),
(const char *)(a1 + 24),
*(_DWORD *)(a1 + 1936),
(const char *)(a1 + 1804),
*(_DWORD *)(a1 + 2196),
(const char *)(a1 + 1940),
*(_DWORD *)(v7 + 4));
v8[v4 + v3] = 10;
write_log(v8, v4 + v3 + 1, 1LL);
return __readfsqword(0x28u);
}
|
log_proxy:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV R14,RSI
MOV qword ptr [RBP + -0x438],RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x440]
CALL 0x001031e0
MOV ECX,dword ptr [0x0010ed00]
LEA R8,[RBX + 0x11c]
LEA RAX,[RBX + 0x1a4]
MOV R9D,dword ptr [RBX + 0x1a0]
MOV R10D,dword ptr [RBX + 0x2a4]
LEA R11,[RBX + 0x2a8]
MOV R13D,dword ptr [RBX + 0x2e8]
MOV R14D,dword ptr [R14 + 0x8]
SUB RSP,0x8
LEA RDI,[RBP + -0x430]
MOV R12D,0x3ff
MOV ESI,0x3ff
LEA RDX,[RBP + -0x440]
LEA R15,[0x109386]
PUSH R15
PUSH 0x0
PUSH R14
PUSH R13
PUSH R11
PUSH R10
PUSH RAX
CALL 0x00106543
ADD RSP,0x40
MOV R13,RAX
MOV RAX,qword ptr [0x0010bf90]
MOV R10,qword ptr [RAX]
LEA RDI,[-0x430 + R13*0x1]
ADD RDI,RBP
SUB R12,R13
MOV ECX,dword ptr [RBX + 0x118]
LEA R8,[RBX + 0x18]
MOV R9D,dword ptr [RBX + 0x790]
LEA R11,[RBX + 0x70c]
MOV R14D,dword ptr [RBX + 0x894]
ADD RBX,0x794
MOV RAX,qword ptr [RBP + -0x438]
MOV R15D,dword ptr [RAX + 0x4]
LEA RDX,[0x109394]
MOV RSI,R12
XOR EAX,EAX
PUSH R15
PUSH RBX
PUSH R14
PUSH R11
CALL qword ptr [R10]
ADD RSP,0x20
LEA RCX,[RAX + R13*0x1]
MOV byte ptr [RBP + RCX*0x1 + -0x430],0xa
LEA RSI,[RAX + R13*0x1]
INC RSI
LEA RDI,[RBP + -0x430]
MOV EDX,0x1
CALL 0x00106920
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00104f57
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00104f57:
CALL 0x00103100
|
void log_proxy(long param_1,long param_2)
{
long lVar1;
long lVar2;
long in_FS_OFFSET;
time_t local_448;
long local_440;
int1 local_438 [1024];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_440 = param_2;
time(&local_448);
lVar1 = log_header(local_438,0x3ff,&local_448,servhost_len,param_1 + 0x11c,
*(int4 *)(param_1 + 0x1a0),param_1 + 0x1a4,
*(int4 *)(param_1 + 0x2a4),param_1 + 0x2a8,
*(int4 *)(param_1 + 0x2e8),*(int4 *)(param_2 + 8),0,"PROXY_CONNECT"
);
lVar2 = (*(code *)**(int8 **)PTR_my_snprintf_service_0010bf90)
(local_438 + lVar1,0x3ff - lVar1,",%.*s,`%.*s`@`%.*s`,%d",
*(int4 *)(param_1 + 0x118),param_1 + 0x18,
*(int4 *)(param_1 + 0x790),param_1 + 0x70c,
*(int4 *)(param_1 + 0x894),param_1 + 0x794,*(int4 *)(local_440 + 4)
);
local_438[lVar2 + lVar1] = 10;
write_log(local_438,lVar2 + lVar1 + 1,1);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
16,072
|
js_proxy_isArray
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_proxy_isArray(JSContext *ctx, JSValue obj)
{
JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
if (!s)
return FALSE;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
if (s->is_revoked) {
JS_ThrowTypeErrorRevokedProxy(ctx);
return -1;
}
return JS_IsArray(ctx, s->target);
}
|
O0
|
c
|
js_proxy_isArray:
subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl $0x30, %edx
callq 0x37090
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x389ae
movl $0x0, 0x44(%rsp)
jmp 0x38a25
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4ca20
cmpl $0x0, %eax
je 0x389e3
movq 0x28(%rsp), %rdi
callq 0x5ef20
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x38a25
movq 0x20(%rsp), %rax
cmpb $0x0, 0x21(%rax)
je 0x38a0b
movq 0x28(%rsp), %rdi
callq 0x5ef60
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x38a25
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x388e0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nop
|
js_proxy_isArray:
sub rsp, 48h
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_10], rdx
mov [rsp+48h+var_20], rdi
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_10]
mov edx, 30h ; '0'
call JS_GetOpaque
mov [rsp+48h+var_28], rax
cmp [rsp+48h+var_28], 0
jnz short loc_389AE
mov [rsp+48h+var_4], 0
jmp short loc_38A25
loc_389AE:
mov rax, [rsp+48h+var_20]
mov rdi, [rax+18h]
xor eax, eax
mov esi, eax
call js_check_stack_overflow
cmp eax, 0
jz short loc_389E3
mov rdi, [rsp+48h+var_20]
call JS_ThrowStackOverflow
mov [rsp+48h+var_38], rax
mov [rsp+48h+var_30], rdx
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_38A25
loc_389E3:
mov rax, [rsp+48h+var_28]
cmp byte ptr [rax+21h], 0
jz short loc_38A0B
mov rdi, [rsp+48h+var_20]
call JS_ThrowTypeErrorRevokedProxy
mov [rsp+48h+var_48], rax
mov [rsp+48h+var_40], rdx
mov [rsp+48h+var_4], 0FFFFFFFFh
jmp short loc_38A25
loc_38A0B:
mov rdi, [rsp+48h+var_20]
mov rax, [rsp+48h+var_28]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_IsArray
mov [rsp+48h+var_4], eax
loc_38A25:
mov eax, [rsp+48h+var_4]
add rsp, 48h
retn
|
long long js_proxy_isArray(long long a1, long long a2, int a3)
{
long long Opaque; // [rsp+20h] [rbp-28h]
Opaque = JS_GetOpaque(a2, a3, 48);
if ( Opaque )
{
if ( (unsigned int)js_check_stack_overflow(*(_QWORD *)(a1 + 24), 0LL) )
{
JS_ThrowStackOverflow(a1);
return (unsigned int)-1;
}
else if ( *(_BYTE *)(Opaque + 33) )
{
JS_ThrowTypeErrorRevokedProxy(a1);
return (unsigned int)-1;
}
else
{
return (unsigned int)JS_IsArray(a1, *(_QWORD *)Opaque, *(_QWORD *)(Opaque + 8));
}
}
else
{
return 0;
}
}
|
js_proxy_isArray:
SUB RSP,0x48
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x28],RDI
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
MOV EDX,0x30
CALL 0x00137090
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x001389ae
MOV dword ptr [RSP + 0x44],0x0
JMP 0x00138a25
LAB_001389ae:
MOV RAX,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RAX + 0x18]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0014ca20
CMP EAX,0x0
JZ 0x001389e3
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0015ef20
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x00138a25
LAB_001389e3:
MOV RAX,qword ptr [RSP + 0x20]
CMP byte ptr [RAX + 0x21],0x0
JZ 0x00138a0b
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0015ef60
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
MOV dword ptr [RSP + 0x44],0xffffffff
JMP 0x00138a25
LAB_00138a0b:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001388e0
MOV dword ptr [RSP + 0x44],EAX
LAB_00138a25:
MOV EAX,dword ptr [RSP + 0x44]
ADD RSP,0x48
RET
|
int4 js_proxy_isArray(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 *puVar2;
int4 local_4;
puVar2 = (int8 *)JS_GetOpaque(param_2,param_3,0x30);
if (puVar2 == (int8 *)0x0) {
local_4 = 0;
}
else {
iVar1 = js_check_stack_overflow(*(int8 *)(param_1 + 0x18),0);
if (iVar1 == 0) {
if (*(char *)((long)puVar2 + 0x21) == '\0') {
local_4 = JS_IsArray(param_1,*puVar2,puVar2[1]);
}
else {
JS_ThrowTypeErrorRevokedProxy(param_1);
local_4 = 0xffffffff;
}
}
else {
JS_ThrowStackOverflow(param_1);
local_4 = 0xffffffff;
}
}
return local_4;
}
|
|
16,073
|
js_proxy_isArray
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_proxy_isArray(JSContext *ctx, JSValue obj)
{
JSProxyData *s = JS_GetOpaque(obj, JS_CLASS_PROXY);
if (!s)
return FALSE;
if (js_check_stack_overflow(ctx->rt, 0)) {
JS_ThrowStackOverflow(ctx);
return -1;
}
if (s->is_revoked) {
JS_ThrowTypeErrorRevokedProxy(ctx);
return -1;
}
return JS_IsArray(ctx, s->target);
}
|
O1
|
c
|
js_proxy_isArray:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
xorl %eax, %eax
cmpl $-0x1, %edx
jne 0x2770e
movq -0x8(%rbp), %rcx
cmpw $0x30, 0x6(%rcx)
jne 0x2770e
movq 0x30(%rcx), %rcx
jmp 0x27710
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x2774b
movq 0x18(%rdi), %rax
cmpq %rbp, 0xe8(%rax)
jbe 0x27732
leaq 0x761a5(%rip), %rsi # 0x9d8ce
xorl %eax, %eax
callq 0x1fec9
jmp 0x27746
cmpb $0x0, 0x21(%rcx)
je 0x27751
leaq 0x761b0(%rip), %rsi # 0x9d8ef
xorl %eax, %eax
callq 0x21953
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq $0x10, %rsp
popq %rbp
jmp 0x276be
|
js_proxy_isArray:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rsi
xor eax, eax
cmp edx, 0FFFFFFFFh
jnz short loc_2770E
mov rcx, [rbp+var_8]
cmp word ptr [rcx+6], 30h ; '0'
jnz short loc_2770E
mov rcx, [rcx+30h]
jmp short loc_27710
loc_2770E:
xor ecx, ecx
loc_27710:
test rcx, rcx
jz short loc_2774B
mov rax, [rdi+18h]
cmp [rax+0E8h], rbp
jbe short loc_27732
lea rsi, aMaximumCallSta; "Maximum call stack size exceeded"
xor eax, eax
call JS_ThrowRangeError
jmp short loc_27746
loc_27732:
cmp byte ptr [rcx+21h], 0
jz short loc_27751
lea rsi, aRevokedProxy; "revoked proxy"
xor eax, eax
call JS_ThrowTypeError
loc_27746:
mov eax, 0FFFFFFFFh
loc_2774B:
add rsp, 10h
pop rbp
retn
loc_27751:
mov rsi, [rcx]
mov rdx, [rcx+8]
add rsp, 10h
pop rbp
jmp JS_IsArray
|
long long js_proxy_isArray(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14)
{
long long result; // rax
long long v15; // rcx
char v16; // [rsp+0h] [rbp-10h]
long long savedregs; // [rsp+10h] [rbp+0h] BYREF
result = 0LL;
if ( (_DWORD)a3 == -1 && *(_WORD *)(a2 + 6) == 48 )
v15 = *(_QWORD *)(a2 + 48);
else
v15 = 0LL;
if ( v15 )
{
if ( *(_QWORD *)(*(_QWORD *)(a1 + 24) + 232LL) <= (unsigned long long)&savedregs )
{
if ( !*(_BYTE *)(v15 + 33) )
return JS_IsArray(a1, *(_QWORD *)v15, *(_QWORD *)(v15 + 8));
JS_ThrowTypeError(a1, (long long)"revoked proxy", a3, v15, a13, a14, a4, a5, a6, a7, a8, a9, a10, a11, v16);
}
else
{
JS_ThrowRangeError(
a1,
(long long)"Maximum call stack size exceeded",
a3,
v15,
a13,
a14,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
v16);
}
return 0xFFFFFFFFLL;
}
return result;
}
|
js_proxy_isArray:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RSI
XOR EAX,EAX
CMP EDX,-0x1
JNZ 0x0012770e
MOV RCX,qword ptr [RBP + -0x8]
CMP word ptr [RCX + 0x6],0x30
JNZ 0x0012770e
MOV RCX,qword ptr [RCX + 0x30]
JMP 0x00127710
LAB_0012770e:
XOR ECX,ECX
LAB_00127710:
TEST RCX,RCX
JZ 0x0012774b
MOV RAX,qword ptr [RDI + 0x18]
CMP qword ptr [RAX + 0xe8],RBP
JBE 0x00127732
LEA RSI,[0x19d8ce]
XOR EAX,EAX
CALL 0x0011fec9
JMP 0x00127746
LAB_00127732:
CMP byte ptr [RCX + 0x21],0x0
JZ 0x00127751
LEA RSI,[0x19d8ef]
XOR EAX,EAX
CALL 0x00121953
LAB_00127746:
MOV EAX,0xffffffff
LAB_0012774b:
ADD RSP,0x10
POP RBP
RET
LAB_00127751:
MOV RSI,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x8]
ADD RSP,0x10
POP RBP
JMP 0x001276be
|
int8 js_proxy_isArray(long param_1,long param_2,int param_3)
{
int8 uVar1;
int8 *puVar2;
uVar1 = 0;
if ((param_3 == -1) && (*(short *)(param_2 + 6) == 0x30)) {
puVar2 = *(int8 **)(param_2 + 0x30);
}
else {
puVar2 = (int8 *)0x0;
}
if (puVar2 != (int8 *)0x0) {
if (&stack0xfffffffffffffff8 < *(int1 **)(*(long *)(param_1 + 0x18) + 0xe8)) {
JS_ThrowRangeError(param_1,"Maximum call stack size exceeded");
}
else {
if (*(char *)((long)puVar2 + 0x21) == '\0') {
uVar1 = JS_IsArray(param_1,*puVar2,puVar2[1]);
return uVar1;
}
JS_ThrowTypeError(param_1,"revoked proxy");
}
uVar1 = 0xffffffff;
}
return uVar1;
}
|
|
16,074
|
inline_mysql_file_read
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline size_t
inline_mysql_file_read(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_read(file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_read(file, buffer, count, flags);
return result;
}
|
O3
|
c
|
inline_mysql_file_read:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %r13d
leaq 0x306d52(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7f2fd
movl $0x4, %ecx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa0b10
movq %rax, %r14
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq 0x306d09(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x5c65e(%rip), %rdx # 0xdb96f
movq %r12, %rdi
movq %rbx, %rsi
movl %r13d, %ecx
callq *0x210(%rax)
movl $0x4, %ecx
movl %r15d, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xa0b10
movq %rax, %r14
xorl %esi, %esi
testq %rax, %rax
cmoveq %rbx, %rsi
leaq 0x306cca(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r12, %rdi
callq *0x218(%rax)
jmp 0x7f2eb
|
inline_mysql_file_read:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rcx
mov r14, rdx
mov r15d, esi
mov r13d, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_70]
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz short loc_7F2FD
mov ecx, 4
mov edi, r15d
mov rsi, r14
mov rdx, rbx
call my_read
mov r14, rax
loc_7F2EB:
mov rax, r14
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7F2FD:
mov r12, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_17; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r12
mov rsi, rbx
mov ecx, r13d
call qword ptr [rax+210h]
mov ecx, 4
mov edi, r15d
mov rsi, r14
mov rdx, rbx
call my_read
mov r14, rax
xor esi, esi
test rax, rax
cmovz rsi, rbx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r12
call qword ptr [rax+218h]
jmp short loc_7F2EB
|
long long inline_mysql_file_read(unsigned int a1, long long a2, long long a3, long long a4)
{
long long v6; // rax
long long v7; // r14
long long v9; // r12
long long v10; // rsi
_BYTE v11[112]; // [rsp+0h] [rbp-70h] BYREF
v6 = ((long long ( *)(_BYTE *, long long, long long))PSI_server[43])(v11, a2, 6LL);
if ( !v6 )
return my_read((unsigned int)a2, a3, a4, 4LL);
v9 = v6;
((void ( *)(long long, long long, const char *, _QWORD))PSI_server[66])(
v6,
a4,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
a1);
v7 = my_read((unsigned int)a2, a3, a4, 4LL);
v10 = 0LL;
if ( !v7 )
v10 = a4;
((void ( *)(long long, long long))PSI_server[67])(v9, v10);
return v7;
}
|
inline_mysql_file_read:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RCX
MOV R14,RDX
MOV R15D,ESI
MOV R13D,EDI
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x70]
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017f2fd
MOV ECX,0x4
MOV EDI,R15D
MOV RSI,R14
MOV RDX,RBX
CALL 0x001a0b10
MOV R14,RAX
LAB_0017f2eb:
MOV RAX,R14
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017f2fd:
MOV R12,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1db96f]
MOV RDI,R12
MOV RSI,RBX
MOV ECX,R13D
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,R15D
MOV RSI,R14
MOV RDX,RBX
CALL 0x001a0b10
MOV R14,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,RBX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R12
CALL qword ptr [RAX + 0x218]
JMP 0x0017f2eb
|
long inline_mysql_file_read(int4 param_1,ulong param_2,int8 param_3,int8 param_4)
{
long lVar1;
long lVar2;
int8 uVar3;
int1 local_78 [72];
lVar1 = (**(code **)(PSI_server + 0x158))(local_78,param_2,6);
if (lVar1 == 0) {
lVar2 = my_read(param_2 & 0xffffffff,param_3,param_4,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar1,param_4,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
param_1);
lVar2 = my_read(param_2 & 0xffffffff,param_3,param_4,4);
uVar3 = 0;
if (lVar2 == 0) {
uVar3 = param_4;
}
(**(code **)(PSI_server + 0x218))(lVar1,uVar3);
}
return lVar2;
}
|
|
16,075
|
inline_mysql_file_close
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, 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_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
|
O0
|
c
|
inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq 0x229a08(%rip), %rax # 0x2617d8
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x78(%rbp), %rdi
movl $0x4, %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 0x37e5b
leaq 0x2299c5(%rip), %rax # 0x2617d8
movq (%rax), %rax
movq 0x220(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xa0d60
movl %eax, -0x24(%rbp)
leaq 0x229998(%rip), %rax # 0x2617d8
movq (%rax), %rax
movq 0x228(%rax), %rax
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq *%rax
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x37e70
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0xa0d60
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
|
inline_mysql_file_close_0:
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
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_78]
mov edx, 4
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_37E5B
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+220h]
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+228h]
mov rdi, [rbp+var_30]
mov esi, [rbp+var_24]
call rax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
jmp short loc_37E70
loc_37E5B:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_close
mov [rbp+var_24], eax
mov eax, [rbp+var_24]
mov [rbp+var_4], eax
loc_37E70:
mov eax, [rbp+var_4]
add rsp, 80h
pop rbp
retn
|
long long inline_mysql_file_close_0(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;
v6 = (*((long long ( **)(_BYTE *, _QWORD, long long))PSI_server + 43))(v5, a3, 4LL);
if ( v6 )
{
(*((void ( **)(long long, long long, _QWORD))PSI_server + 68))(v6, v11, v10);
v7 = my_close(v9, v8);
(*((void ( **)(long long, _QWORD))PSI_server + 69))(v6, v7);
}
else
{
return (unsigned int)my_close(v9, v8);
}
return v7;
}
|
inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
LEA RAX,[0x3617d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x78]
MOV EDX,0x4
CALL RAX
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00137e5b
LEA RAX,[0x3617d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x220]
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001a0d60
MOV dword ptr [RBP + -0x24],EAX
LEA RAX,[0x3617d8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x228]
MOV RDI,qword ptr [RBP + -0x30]
MOV ESI,dword ptr [RBP + -0x24]
CALL RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00137e70
LAB_00137e5b:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001a0d60
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x4],EAX
LAB_00137e70:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x80
POP RBP
RET
|
int4
inline_mysql_file_close(int8 param_1,int4 param_2,int4 param_3,int8 param_4)
{
int1 local_80 [72];
long local_38;
int4 local_2c;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
int4 local_c;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_38 = (**(code **)(PSI_server + 0x158))(local_80,param_3,4);
if (local_38 == 0) {
local_c = my_close(local_20,local_28);
}
else {
(**(code **)(PSI_server + 0x220))(local_38,local_18,local_1c);
local_2c = my_close(local_20,local_28);
(**(code **)(PSI_server + 0x228))(local_38,local_2c);
local_c = local_2c;
}
return local_c;
}
|
|
16,076
|
inline_mysql_file_close
|
eloqsql/include/mysql/psi/mysql_file.h
|
static inline int
inline_mysql_file_close(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, 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_CLOSE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_close_wait)(locker, src_file, src_line);
result= my_close(file, flags);
PSI_FILE_CALL(end_file_close_wait)(locker, result);
return result;
}
#endif
result= my_close(file, flags);
return result;
}
|
O3
|
c
|
inline_mysql_file_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movl %edi, %r14d
leaq 0x312040(%rip), %rax # 0x34f4e8
movq (%rax), %rax
leaq -0x68(%rbp), %rdi
movl $0x4, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x3d4d3
movl %ebx, %edi
xorl %esi, %esi
callq 0x708c5
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1c(%rbp), %r15
movq %rax, %rdi
movl %r14d, %esi
movl %ebx, %edx
movq %r15, %rcx
callq 0x2a4ac
movl (%r15), %eax
jmp 0x3d4c8
|
inline_mysql_file_close_1:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 58h
mov ebx, esi
mov r14d, edi
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_68]
mov edx, 4
call qword ptr [rax+158h]
test rax, rax
jnz short loc_3D4D3
mov edi, ebx
xor esi, esi
call my_close
loc_3D4C8:
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3D4D3:
lea r15, [rbp+var_1C]
mov rdi, rax
mov esi, r14d
mov edx, ebx
mov rcx, r15
call inline_mysql_file_close_cold_1_1
mov eax, [r15]
jmp short loc_3D4C8
|
long long inline_mysql_file_close_1(unsigned int a1, long long a2)
{
long long v2; // rax
_BYTE v4[76]; // [rsp+8h] [rbp-68h] BYREF
unsigned int v5[7]; // [rsp+54h] [rbp-1Ch] BYREF
v2 = (*((long long ( **)(_BYTE *, long long, long long))PSI_server + 43))(v4, a2, 4LL);
if ( !v2 )
return my_close((unsigned int)a2, 0LL);
inline_mysql_file_close_cold_1_1(v2, a1, a2, v5);
return v5[0];
}
|
inline_mysql_file_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV EBX,ESI
MOV R14D,EDI
LEA RAX,[0x44f4e8]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x68]
MOV EDX,0x4
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0013d4d3
MOV EDI,EBX
XOR ESI,ESI
CALL 0x001708c5
LAB_0013d4c8:
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013d4d3:
LEA R15,[RBP + -0x1c]
MOV RDI,RAX
MOV ESI,R14D
MOV EDX,EBX
MOV RCX,R15
CALL 0x0012a4ac
MOV EAX,dword ptr [R15]
JMP 0x0013d4c8
|
ulong inline_mysql_file_close(int4 param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
int1 local_70 [76];
uint local_24;
lVar1 = (**(code **)(PSI_server + 0x158))(local_70,param_2,4);
if (lVar1 == 0) {
uVar2 = my_close(param_2 & 0xffffffff,0);
}
else {
inline_mysql_file_close_cold_1(lVar1,param_1,param_2 & 0xffffffff,&local_24);
uVar2 = (ulong)local_24;
}
return uVar2;
}
|
|
16,077
|
lunasvg::Path::reset()
|
dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp
|
void Path::reset()
{
if(m_data == nullptr)
return;
if(isUnique()) {
plutovg_path_reset(m_data);
} else {
plutovg_path_destroy(m_data);
m_data = nullptr;
}
}
|
O0
|
cpp
|
lunasvg::Path::reset():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x1262c
jmp 0x12660
movq -0x10(%rbp), %rdi
callq 0x12670
testb $0x1, %al
jne 0x1263b
jmp 0x12649
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x60bd0
jmp 0x12660
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5fdf0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN7lunasvg4Path5resetEv:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
cmp qword ptr [rax], 0
jnz short loc_1262C
jmp short loc_12660
loc_1262C:
mov rdi, [rbp+var_10]; this
call _ZNK7lunasvg4Path8isUniqueEv; lunasvg::Path::isUnique(void)
test al, 1
jnz short loc_1263B
jmp short loc_12649
loc_1263B:
mov rax, [rbp+var_10]
mov rdi, [rax]
call plutovg_path_reset
jmp short loc_12660
loc_12649:
mov rax, [rbp+var_10]
mov rdi, [rax]
call plutovg_path_destroy
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
loc_12660:
add rsp, 10h
pop rbp
retn
|
lunasvg::Path * lunasvg::Path::reset(lunasvg::Path *this)
{
lunasvg::Path *result; // rax
result = this;
if ( *(_QWORD *)this )
{
if ( (lunasvg::Path::isUnique(this) & 1) != 0 )
{
return (lunasvg::Path *)plutovg_path_reset(*(_QWORD *)this);
}
else
{
plutovg_path_destroy(*(_QWORD *)this);
result = this;
*(_QWORD *)this = 0LL;
}
}
return result;
}
|
reset:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RAX],0x0
JNZ 0x0011262c
JMP 0x00112660
LAB_0011262c:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00112670
TEST AL,0x1
JNZ 0x0011263b
JMP 0x00112649
LAB_0011263b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x00160bd0
JMP 0x00112660
LAB_00112649:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
CALL 0x0015fdf0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
LAB_00112660:
ADD RSP,0x10
POP RBP
RET
|
/* lunasvg::Path::reset() */
void __thiscall lunasvg::Path::reset(Path *this)
{
ulong uVar1;
if (*(long *)this != 0) {
uVar1 = isUnique(this);
if ((uVar1 & 1) == 0) {
plutovg_path_destroy(*(int8 *)this);
*(int8 *)this = 0;
}
else {
plutovg_path_reset(*(int8 *)this);
}
}
return;
}
|
|
16,078
|
lunasvg::Path::reset()
|
dmazzella[P]pylunasvg/lunasvg/source/graphics.cpp
|
void Path::reset()
{
if(m_data == nullptr)
return;
if(isUnique()) {
plutovg_path_reset(m_data);
} else {
plutovg_path_destroy(m_data);
m_data = nullptr;
}
}
|
O2
|
cpp
|
lunasvg::Path::reset():
pushq %rbx
cmpq $0x0, (%rdi)
je 0xc96f
movq %rdi, %rbx
callq 0xc972
movq (%rbx), %rdi
testb %al, %al
je 0xc966
popq %rbx
jmp 0x25dc9
callq 0x25534
andq $0x0, (%rbx)
popq %rbx
retq
nop
|
_ZN7lunasvg4Path5resetEv:
push rbx
cmp qword ptr [rdi], 0
jz short loc_C96F
mov rbx, rdi
call _ZNK7lunasvg4Path8isUniqueEv; lunasvg::Path::isUnique(void)
mov rdi, [rbx]
test al, al
jz short loc_C966
pop rbx
jmp plutovg_path_reset
loc_C966:
call plutovg_path_destroy
and qword ptr [rbx], 0
loc_C96F:
pop rbx
retn
|
void lunasvg::Path::reset(lunasvg::Path *this)
{
char isUnique; // al
long long v3; // rdi
if ( *(_QWORD *)this )
{
isUnique = lunasvg::Path::isUnique(this);
v3 = *(_QWORD *)this;
if ( isUnique )
{
plutovg_path_reset(v3);
}
else
{
plutovg_path_destroy(v3);
*(_QWORD *)this = 0LL;
}
}
}
|
reset:
PUSH RBX
CMP qword ptr [RDI],0x0
JZ 0x0010c96f
MOV RBX,RDI
CALL 0x0010c972
MOV RDI,qword ptr [RBX]
TEST AL,AL
JZ 0x0010c966
POP RBX
JMP 0x00125dc9
LAB_0010c966:
CALL 0x00125534
AND qword ptr [RBX],0x0
LAB_0010c96f:
POP RBX
RET
|
/* lunasvg::Path::reset() */
void __thiscall lunasvg::Path::reset(Path *this)
{
char cVar1;
if (*(long *)this != 0) {
cVar1 = isUnique(this);
if (cVar1 != '\0') {
plutovg_path_reset();
return;
}
plutovg_path_destroy(*(int8 *)this);
*(int8 *)this = 0;
}
return;
}
|
|
16,079
|
evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&)
|
corpus-core[P]colibri-stateless/build_O1/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp
|
const Instruction* op_sstore(const Instruction* instr, AdvancedExecutionState& state) noexcept
{
const auto gas_left_correction = state.current_block_cost - instr->arg.number;
state.gas_left += gas_left_correction;
const auto status = instr::impl<OP_SSTORE>(state);
if (status != EVMC_SUCCESS)
return state.exit(status);
if ((state.gas_left -= gas_left_correction) < 0)
return state.exit(EVMC_OUT_OF_GAS);
return ++instr;
}
|
O1
|
cpp
|
evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x230(%rsi), %r15d
subq 0x8(%rdi), %r15
movq 0x220(%rsi), %rsi
addq %r15, %rsi
movq %rsi, 0x220(%r14)
movq 0x228(%r14), %rdi
movq %r14, %rdx
callq 0x4d45c
movq %rdx, 0x220(%r14)
addq $-0x40, 0x228(%r14)
testl %eax, %eax
je 0x5115a
movl %eax, 0x78(%r14)
xorl %ebx, %ebx
jmp 0x5116a
subq %r15, %rdx
movq %rdx, 0x220(%r14)
js 0x51173
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, 0x78(%r14)
jmp 0x51156
|
_ZN6evmone8advanced12_GLOBAL__N_19op_sstoreEPKNS0_11InstructionERNS0_22AdvancedExecutionStateE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov r15d, [rsi+230h]
sub r15, [rdi+8]
mov rsi, [rsi+220h]
add rsi, r15
mov [r14+220h], rsi
mov rdi, [r14+228h]
mov rdx, r14
call _ZN6evmone5instr4core6sstoreENS_8StackTopElRNS_14ExecutionStateE; evmone::instr::core::sstore(evmone::StackTop,long,evmone::ExecutionState &)
mov [r14+220h], rdx
add qword ptr [r14+228h], 0FFFFFFFFFFFFFFC0h
test eax, eax
jz short loc_5115A
mov [r14+78h], eax
loc_51156:
xor ebx, ebx
jmp short loc_5116A
loc_5115A:
sub rdx, r15
mov [r14+220h], rdx
js short loc_51173
add rbx, 10h
loc_5116A:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_51173:
mov dword ptr [r14+78h], 3
jmp short loc_51156
|
long long evmone::advanced::`anonymous namespace'::op_sstore(long long a1, long long a2)
{
long long v3; // r15
long long v4; // rsi
int v5; // eax
long long v6; // rdx
long long v8; // rdx
v3 = *(unsigned int *)(a2 + 560) - *(_QWORD *)(a1 + 8);
v4 = v3 + *(_QWORD *)(a2 + 544);
*(_QWORD *)(a2 + 544) = v4;
v5 = evmone::instr::core::sstore(*(unsigned long long **)(a2 + 552), v4, a2);
*(_QWORD *)(a2 + 544) = v6;
*(_QWORD *)(a2 + 552) -= 64LL;
if ( v5 )
{
*(_DWORD *)(a2 + 120) = v5;
}
else
{
v8 = v6 - v3;
*(_QWORD *)(a2 + 544) = v8;
if ( v8 >= 0 )
return a1 + 16;
*(_DWORD *)(a2 + 120) = 3;
}
return 0LL;
}
|
op_sstore:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV R15D,dword ptr [RSI + 0x230]
SUB R15,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RSI + 0x220]
ADD RSI,R15
MOV qword ptr [R14 + 0x220],RSI
MOV RDI,qword ptr [R14 + 0x228]
MOV RDX,R14
CALL 0x0014d45c
MOV qword ptr [R14 + 0x220],RDX
ADD qword ptr [R14 + 0x228],-0x40
TEST EAX,EAX
JZ 0x0015115a
MOV dword ptr [R14 + 0x78],EAX
LAB_00151156:
XOR EBX,EBX
JMP 0x0015116a
LAB_0015115a:
SUB RDX,R15
MOV qword ptr [R14 + 0x220],RDX
JS 0x00151173
ADD RBX,0x10
LAB_0015116a:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_00151173:
MOV dword ptr [R14 + 0x78],0x3
JMP 0x00151156
|
/* evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*,
evmone::advanced::AdvancedExecutionState&) */
Instruction *
evmone::advanced::(anonymous_namespace)::op_sstore
(Instruction *param_1,AdvancedExecutionState *param_2)
{
uint uVar1;
int iVar2;
long extraout_RDX;
long lVar3;
long lVar4;
uVar1 = *(uint *)(param_2 + 0x230);
lVar3 = *(long *)(param_1 + 8);
lVar4 = *(long *)(param_2 + 0x220) + ((ulong)uVar1 - lVar3);
*(long *)(param_2 + 0x220) = lVar4;
iVar2 = instr::core::sstore(*(int8 *)(param_2 + 0x228),lVar4,param_2);
*(long *)(param_2 + 0x220) = extraout_RDX;
*(long *)(param_2 + 0x228) = *(long *)(param_2 + 0x228) + -0x40;
if (iVar2 == 0) {
lVar3 = extraout_RDX - ((ulong)uVar1 - lVar3);
*(long *)(param_2 + 0x220) = lVar3;
if (-1 < lVar3) {
return param_1 + 0x10;
}
*(int4 *)(param_2 + 0x78) = 3;
}
else {
*(int *)(param_2 + 0x78) = iVar2;
}
return (Instruction *)0x0;
}
|
|
16,080
|
OpenGL_Init_2_1
|
SDL3Lite/dependencies/OpenGL.h
|
void OpenGL_Init_2_1()
{
glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)OpenGL_Load("glUniformMatrix2x3fv");
glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)OpenGL_Load("glUniformMatrix3x2fv");
glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)OpenGL_Load("glUniformMatrix2x4fv");
glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)OpenGL_Load("glUniformMatrix4x2fv");
glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)OpenGL_Load("glUniformMatrix3x4fv");
glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)OpenGL_Load("glUniformMatrix4x3fv");
}
|
O3
|
c
|
OpenGL_Init_2_1:
pushq %rax
leaq 0x10835(%rip), %rdi # 0x3840d
callq 0x220c0
movq %rax, %rcx
movq 0x1c411(%rip), %rax # 0x43ff8
movq %rcx, (%rax)
leaq 0x10831(%rip), %rdi # 0x38422
callq 0x220c0
movq %rax, %rcx
movq 0x1acf8(%rip), %rax # 0x428f8
movq %rcx, (%rax)
leaq 0x1082d(%rip), %rdi # 0x38437
callq 0x220c0
movq %rax, %rcx
movq 0x1bff7(%rip), %rax # 0x43c10
movq %rcx, (%rax)
leaq 0x10829(%rip), %rdi # 0x3844c
callq 0x220c0
movq %rax, %rcx
movq 0x1b196(%rip), %rax # 0x42dc8
movq %rcx, (%rax)
leaq 0x10825(%rip), %rdi # 0x38461
callq 0x220c0
movq %rax, %rcx
movq 0x1af2d(%rip), %rax # 0x42b78
movq %rcx, (%rax)
leaq 0x10821(%rip), %rdi # 0x38476
callq 0x220c0
movq %rax, %rcx
movq 0x1b11c(%rip), %rax # 0x42d80
movq %rcx, (%rax)
popq %rax
retq
nopl (%rax)
|
OpenGL_Init_2_1:
push rax
lea rdi, aGluniformmatri_20; "glUniformMatrix2x3fv"
call _OpenGL_Load
mov rcx, rax
mov rax, cs:glUniformMatrix2x3fv_ptr
mov [rax], rcx
lea rdi, aGluniformmatri_21; "glUniformMatrix3x2fv"
call _OpenGL_Load
mov rcx, rax
mov rax, cs:glUniformMatrix3x2fv_ptr
mov [rax], rcx
lea rdi, aGluniformmatri_22; "glUniformMatrix2x4fv"
call _OpenGL_Load
mov rcx, rax
mov rax, cs:glUniformMatrix2x4fv_ptr
mov [rax], rcx
lea rdi, aGluniformmatri_23; "glUniformMatrix4x2fv"
call _OpenGL_Load
mov rcx, rax
mov rax, cs:glUniformMatrix4x2fv_ptr
mov [rax], rcx
lea rdi, aGluniformmatri_24; "glUniformMatrix3x4fv"
call _OpenGL_Load
mov rcx, rax
mov rax, cs:glUniformMatrix3x4fv_ptr
mov [rax], rcx
lea rdi, aGluniformmatri_25; "glUniformMatrix4x3fv"
call _OpenGL_Load
mov rcx, rax
mov rax, cs:glUniformMatrix4x3fv_ptr
mov [rax], rcx
pop rax
retn
|
void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> OpenGL_Init_2_1()
{
glUniformMatrix2x3fv = OpenGL_Load("glUniformMatrix2x3fv");
glUniformMatrix3x2fv = OpenGL_Load("glUniformMatrix3x2fv");
glUniformMatrix2x4fv = OpenGL_Load("glUniformMatrix2x4fv");
glUniformMatrix4x2fv = OpenGL_Load("glUniformMatrix4x2fv");
glUniformMatrix3x4fv = OpenGL_Load("glUniformMatrix3x4fv");
glUniformMatrix4x3fv = OpenGL_Load("glUniformMatrix4x3fv");
}
|
OpenGL_Init_2_1:
PUSH RAX
LEA RDI,[0x13840d]
CALL 0x001220c0
MOV RCX,RAX
MOV RAX,qword ptr [0x00143ff8]
MOV qword ptr [RAX],RCX
LEA RDI,[0x138422]
CALL 0x001220c0
MOV RCX,RAX
MOV RAX,qword ptr [0x001428f8]
MOV qword ptr [RAX],RCX
LEA RDI,[0x138437]
CALL 0x001220c0
MOV RCX,RAX
MOV RAX,qword ptr [0x00143c10]
MOV qword ptr [RAX],RCX
LEA RDI,[0x13844c]
CALL 0x001220c0
MOV RCX,RAX
MOV RAX,qword ptr [0x00142dc8]
MOV qword ptr [RAX],RCX
LEA RDI,[0x138461]
CALL 0x001220c0
MOV RCX,RAX
MOV RAX,qword ptr [0x00142b78]
MOV qword ptr [RAX],RCX
LEA RDI,[0x138476]
CALL 0x001220c0
MOV RCX,RAX
MOV RAX,qword ptr [0x00142d80]
MOV qword ptr [RAX],RCX
POP RAX
RET
|
int8 OpenGL_Init_2_1(void)
{
int8 in_RAX;
int8 uVar1;
uVar1 = OpenGL_Load("glUniformMatrix2x3fv");
*(int8 *)PTR_glUniformMatrix2x3fv_00143ff8 = uVar1;
uVar1 = OpenGL_Load("glUniformMatrix3x2fv");
*(int8 *)PTR_glUniformMatrix3x2fv_001428f8 = uVar1;
uVar1 = OpenGL_Load("glUniformMatrix2x4fv");
*(int8 *)PTR_glUniformMatrix2x4fv_00143c10 = uVar1;
uVar1 = OpenGL_Load("glUniformMatrix4x2fv");
*(int8 *)PTR_glUniformMatrix4x2fv_00142dc8 = uVar1;
uVar1 = OpenGL_Load("glUniformMatrix3x4fv");
*(int8 *)PTR_glUniformMatrix3x4fv_00142b78 = uVar1;
uVar1 = OpenGL_Load("glUniformMatrix4x3fv");
*(int8 *)PTR_glUniformMatrix4x3fv_00142d80 = uVar1;
return in_RAX;
}
|
|
16,081
|
backtick_string
|
eloqsql/strings/my_vsnprintf.c
|
static char *backtick_string(CHARSET_INFO *cs, char *to, const char *end,
char *par, size_t par_len, char quote_char,
my_bool cut)
{
char *last[3]= {0,0,0};
uint char_len;
char *start= to;
char *par_end= par + par_len;
size_t buff_length= (size_t) (end - to);
uint index= 0;
if (buff_length <= par_len)
goto err;
*start++= quote_char;
for ( ; par < par_end; par+= char_len)
{
uchar c= *(uchar *) par;
if (cut)
{
last[index]= start;
index= (index + 1) % 3;
}
char_len= my_ci_charlen_fix(cs, (const uchar *) par, (const uchar *) par_end);
if (char_len == 1 && c == (uchar) quote_char )
{
if (start + 1 >= end)
goto err;
*start++= quote_char;
}
if (start + char_len >= end)
goto err;
start= strnmov(start, par, char_len);
}
if (start + 1 >= end)
goto err;
if (cut)
{
uint dots= 0;
start= NULL;
for (; dots < 3; dots++)
{
if (index == 0)
index= 2;
else
index--;
if (!last[index])
break;
start= last[index];
}
if (start == NULL)
goto err; // there was no characters at all
for (; dots; dots--)
*start++= '.';
}
*start++= quote_char;
return start;
err:
*to='\0';
return to;
}
|
O0
|
c
|
backtick_string:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r9b, %al
movb 0x10(%rbp), %r9b
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x24190
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x74(%rbp)
movq -0x70(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x768c2
jmp 0x76a5a
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x7699e
movq -0x28(%rbp), %rax
movb (%rax), %al
movb %al, -0x75(%rbp)
cmpb $0x0, 0x10(%rbp)
je 0x76911
movq -0x60(%rbp), %rcx
movl -0x74(%rbp), %eax
movq %rcx, -0x50(%rbp,%rax,8)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x74(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x76ad0
movl %eax, -0x54(%rbp)
cmpl $0x1, -0x54(%rbp)
jne 0x7695e
movzbl -0x75(%rbp), %eax
movzbl -0x31(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7695e
movq -0x60(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0x7694a
jmp 0x76a5a
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jb 0x76973
jmp 0x76a5a
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x54(%rbp), %eax
movl %eax, %edx
callq 0x76fd0
movq %rax, -0x60(%rbp)
movl -0x54(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x768d6
movq -0x60(%rbp), %rax
addq $0x1, %rax
cmpq -0x20(%rbp), %rax
jb 0x769b1
jmp 0x76a5a
cmpb $0x0, 0x10(%rbp)
je 0x76a3c
movl $0x0, -0x7c(%rbp)
movq $0x0, -0x60(%rbp)
cmpl $0x3, -0x7c(%rbp)
jae 0x76a0c
cmpl $0x0, -0x74(%rbp)
jne 0x769df
movl $0x2, -0x74(%rbp)
jmp 0x769e8
movl -0x74(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %eax
cmpq $0x0, -0x50(%rbp,%rax,8)
jne 0x769f5
jmp 0x76a0c
movl -0x74(%rbp), %eax
movq -0x50(%rbp,%rax,8), %rax
movq %rax, -0x60(%rbp)
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x769ca
cmpq $0x0, -0x60(%rbp)
jne 0x76a15
jmp 0x76a5a
jmp 0x76a17
cmpl $0x0, -0x7c(%rbp)
je 0x76a3a
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2e, (%rax)
movl -0x7c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x76a17
jmp 0x76a3c
movb -0x31(%rbp), %cl
movq -0x60(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %cl, (%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x76a69
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
backtick_string:
push rbp
mov rbp, rsp
sub rsp, 80h
mov al, r9b
mov r9b, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 18h
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_68], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
mov [rbp+var_70], rax
mov [rbp+var_74], 0
mov rax, [rbp+var_70]
cmp rax, [rbp+var_30]
ja short loc_768C2
jmp loc_76A5A
loc_768C2:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
loc_768D6:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_68]
jnb loc_7699E
mov rax, [rbp+var_28]
mov al, [rax]
mov [rbp+var_75], al
cmp [rbp+arg_0], 0
jz short loc_76911
mov rcx, [rbp+var_60]
mov eax, [rbp+var_74]
mov [rbp+rax*8+var_50], rcx
mov eax, [rbp+var_74]
add eax, 1
mov ecx, 3
xor edx, edx
div ecx
mov [rbp+var_74], edx
loc_76911:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_68]
call my_ci_charlen_fix
mov [rbp+var_54], eax
cmp [rbp+var_54], 1
jnz short loc_7695E
movzx eax, [rbp+var_75]
movzx ecx, [rbp+var_31]
cmp eax, ecx
jnz short loc_7695E
mov rax, [rbp+var_60]
add rax, 1
cmp rax, [rbp+var_20]
jb short loc_7694A
jmp loc_76A5A
loc_7694A:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
loc_7695E:
mov rax, [rbp+var_60]
mov ecx, [rbp+var_54]
add rax, rcx
cmp rax, [rbp+var_20]
jb short loc_76973
jmp loc_76A5A
loc_76973:
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_28]
mov eax, [rbp+var_54]
mov edx, eax
call strnmov
mov [rbp+var_60], rax
mov ecx, [rbp+var_54]
mov rax, [rbp+var_28]
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
jmp loc_768D6
loc_7699E:
mov rax, [rbp+var_60]
add rax, 1
cmp rax, [rbp+var_20]
jb short loc_769B1
jmp loc_76A5A
loc_769B1:
cmp [rbp+arg_0], 0
jz loc_76A3C
mov [rbp+var_7C], 0
mov [rbp+var_60], 0
loc_769CA:
cmp [rbp+var_7C], 3
jnb short loc_76A0C
cmp [rbp+var_74], 0
jnz short loc_769DF
mov [rbp+var_74], 2
jmp short loc_769E8
loc_769DF:
mov eax, [rbp+var_74]
add eax, 0FFFFFFFFh
mov [rbp+var_74], eax
loc_769E8:
mov eax, [rbp+var_74]
cmp [rbp+rax*8+var_50], 0
jnz short loc_769F5
jmp short loc_76A0C
loc_769F5:
mov eax, [rbp+var_74]
mov rax, [rbp+rax*8+var_50]
mov [rbp+var_60], rax
mov eax, [rbp+var_7C]
add eax, 1
mov [rbp+var_7C], eax
jmp short loc_769CA
loc_76A0C:
cmp [rbp+var_60], 0
jnz short loc_76A15
jmp short loc_76A5A
loc_76A15:
jmp short $+2
loc_76A17:
cmp [rbp+var_7C], 0
jz short loc_76A3A
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Eh ; '.'
mov eax, [rbp+var_7C]
add eax, 0FFFFFFFFh
mov [rbp+var_7C], eax
jmp short loc_76A17
loc_76A3A:
jmp short $+2
loc_76A3C:
mov cl, [rbp+var_31]
mov rax, [rbp+var_60]
mov rdx, rax
add rdx, 1
mov [rbp+var_60], rdx
mov [rax], cl
mov rax, [rbp+var_60]
mov [rbp+var_8], rax
jmp short loc_76A69
loc_76A5A:
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
loc_76A69:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
_BYTE * backtick_string(
long long a1,
_BYTE *a2,
unsigned long long a3,
char *a4,
unsigned long long a5,
char a6,
char a7)
{
_BYTE *v7; // rax
_BYTE *v8; // rax
unsigned int v10; // [rsp+4h] [rbp-7Ch]
char v11; // [rsp+Bh] [rbp-75h]
unsigned int v12; // [rsp+Ch] [rbp-74h]
char *v13; // [rsp+18h] [rbp-68h]
_BYTE *v14; // [rsp+20h] [rbp-60h]
unsigned int v15; // [rsp+2Ch] [rbp-54h]
_QWORD v16[3]; // [rsp+30h] [rbp-50h] BYREF
char v17; // [rsp+4Fh] [rbp-31h]
unsigned long long v18; // [rsp+50h] [rbp-30h]
char *v19; // [rsp+58h] [rbp-28h]
unsigned long long v20; // [rsp+60h] [rbp-20h]
_BYTE *v21; // [rsp+68h] [rbp-18h]
long long v22; // [rsp+70h] [rbp-10h]
v22 = a1;
v21 = a2;
v20 = a3;
v19 = a4;
v18 = a5;
v17 = a6;
memset(v16, 0LL, sizeof(v16));
v13 = &v19[v18];
v12 = 0;
if ( v20 - (unsigned long long)v21 <= v18 )
goto LABEL_25;
v14 = v21 + 1;
*v21 = v17;
while ( v19 < v13 )
{
v11 = *v19;
if ( a7 )
{
v16[v12] = v14;
v12 = (v12 + 1) % 3;
}
v15 = my_ci_charlen_fix(v22, v19, v13);
if ( v15 == 1 && v11 == v17 )
{
if ( (unsigned long long)(v14 + 1) >= v20 )
goto LABEL_25;
v7 = v14++;
*v7 = v17;
}
if ( (unsigned long long)&v14[v15] >= v20 )
goto LABEL_25;
v14 = (_BYTE *)strnmov(v14, v19, v15);
v19 += v15;
}
if ( (unsigned long long)(v14 + 1) >= v20 )
goto LABEL_25;
if ( a7 )
{
v10 = 0;
v14 = 0LL;
while ( v10 < 3 )
{
if ( v12 )
--v12;
else
v12 = 2;
if ( !v16[v12] )
break;
v14 = (_BYTE *)v16[v12];
++v10;
}
if ( v14 )
{
while ( v10 )
{
v8 = v14++;
*v8 = 46;
--v10;
}
goto LABEL_24;
}
LABEL_25:
*v21 = 0;
return v21;
}
LABEL_24:
*v14 = v17;
return v14 + 1;
}
|
backtick_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AL,R9B
MOV R9B,byte ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x00124190
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV dword ptr [RBP + -0x74],0x0
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x30]
JA 0x001768c2
JMP 0x00176a5a
LAB_001768c2:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
LAB_001768d6:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x68]
JNC 0x0017699e
MOV RAX,qword ptr [RBP + -0x28]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x75],AL
CMP byte ptr [RBP + 0x10],0x0
JZ 0x00176911
MOV RCX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RBP + -0x74]
MOV qword ptr [RBP + RAX*0x8 + -0x50],RCX
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,0x1
MOV ECX,0x3
XOR EDX,EDX
DIV ECX
MOV dword ptr [RBP + -0x74],EDX
LAB_00176911:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x00176ad0
MOV dword ptr [RBP + -0x54],EAX
CMP dword ptr [RBP + -0x54],0x1
JNZ 0x0017695e
MOVZX EAX,byte ptr [RBP + -0x75]
MOVZX ECX,byte ptr [RBP + -0x31]
CMP EAX,ECX
JNZ 0x0017695e
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x20]
JC 0x0017694a
JMP 0x00176a5a
LAB_0017694a:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
LAB_0017695e:
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JC 0x00176973
JMP 0x00176a5a
LAB_00176973:
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x54]
MOV EDX,EAX
CALL 0x00176fd0
MOV qword ptr [RBP + -0x60],RAX
MOV ECX,dword ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001768d6
LAB_0017699e:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
CMP RAX,qword ptr [RBP + -0x20]
JC 0x001769b1
JMP 0x00176a5a
LAB_001769b1:
CMP byte ptr [RBP + 0x10],0x0
JZ 0x00176a3c
MOV dword ptr [RBP + -0x7c],0x0
MOV qword ptr [RBP + -0x60],0x0
LAB_001769ca:
CMP dword ptr [RBP + -0x7c],0x3
JNC 0x00176a0c
CMP dword ptr [RBP + -0x74],0x0
JNZ 0x001769df
MOV dword ptr [RBP + -0x74],0x2
JMP 0x001769e8
LAB_001769df:
MOV EAX,dword ptr [RBP + -0x74]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x74],EAX
LAB_001769e8:
MOV EAX,dword ptr [RBP + -0x74]
CMP qword ptr [RBP + RAX*0x8 + -0x50],0x0
JNZ 0x001769f5
JMP 0x00176a0c
LAB_001769f5:
MOV EAX,dword ptr [RBP + -0x74]
MOV RAX,qword ptr [RBP + RAX*0x8 + -0x50]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x001769ca
LAB_00176a0c:
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x00176a15
JMP 0x00176a5a
LAB_00176a15:
JMP 0x00176a17
LAB_00176a17:
CMP dword ptr [RBP + -0x7c],0x0
JZ 0x00176a3a
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2e
MOV EAX,dword ptr [RBP + -0x7c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x7c],EAX
JMP 0x00176a17
LAB_00176a3a:
JMP 0x00176a3c
LAB_00176a3c:
MOV CL,byte ptr [RBP + -0x31]
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00176a69
LAB_00176a5a:
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_00176a69:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
char * backtick_string(int8 param_1,char *param_2,char *param_3,char *param_4,ulong param_5,
char param_6,char param_7)
{
char cVar1;
uint uVar2;
char *pcVar3;
uint local_84;
uint local_7c;
char *local_68;
long local_58 [3];
char local_39;
ulong local_38;
char *local_30;
char *local_28;
char *local_20;
int8 local_18;
local_39 = param_6;
local_38 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_58,0,0x18);
pcVar3 = local_30 + local_38;
local_7c = 0;
if (local_38 < (ulong)((long)local_28 - (long)local_20)) {
local_68 = local_20 + 1;
*local_20 = local_39;
for (; local_30 < pcVar3; local_30 = local_30 + uVar2) {
cVar1 = *local_30;
if (param_7 != '\0') {
local_58[local_7c] = (long)local_68;
local_7c = (local_7c + 1) % 3;
}
uVar2 = my_ci_charlen_fix(local_18,local_30,pcVar3);
if ((uVar2 == 1) && (cVar1 == local_39)) {
if (local_28 <= local_68 + 1) goto LAB_00176a5a;
*local_68 = local_39;
local_68 = local_68 + 1;
}
if (local_28 <= local_68 + uVar2) goto LAB_00176a5a;
local_68 = (char *)strnmov(local_68,local_30,uVar2);
}
if (local_68 + 1 < local_28) {
if (param_7 != '\0') {
local_68 = (char *)0x0;
for (local_84 = 0; local_84 < 3; local_84 = local_84 + 1) {
if (local_7c == 0) {
local_7c = 2;
}
else {
local_7c = local_7c - 1;
}
if (local_58[local_7c] == 0) break;
local_68 = (char *)local_58[local_7c];
}
if (local_68 == (char *)0x0) goto LAB_00176a5a;
for (; local_84 != 0; local_84 = local_84 - 1) {
*local_68 = '.';
local_68 = local_68 + 1;
}
}
*local_68 = local_39;
return local_68 + 1;
}
}
LAB_00176a5a:
*local_20 = '\0';
return local_20;
}
|
|
16,082
|
process_str_arg
|
eloqsql/strings/my_vsnprintf.c
|
static char *process_str_arg(CHARSET_INFO *cs, char *to, const char *end,
longlong length_arg, size_t width, char *par,
uint print_type, my_bool nice_cut)
{
int well_formed_error;
uint dots= 0;
size_t plen, left_len= (size_t) (end - to) + 1, slen=0;
my_bool left_fill= 1;
size_t length;
/*
The sign of the length argument specific the string should be right
or left adjusted
*/
if (length_arg < 0)
{
length= (size_t) -length_arg;
left_fill= 0;
}
else
length= (size_t) length_arg;
if (!par)
par = (char*) "(null)";
if (nice_cut)
{
plen= slen= strnlen(par, width + 1);
if (plen > width)
plen= width;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
if ((slen > plen))
{
if (plen < 3)
{
dots= (uint) plen;
plen= 0;
}
else
{
dots= 3;
plen-= 3;
}
}
}
else
{
plen= slen= strnlen(par, width);
dots= 0;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
}
plen= my_well_formed_length(cs, par, par + plen, width, &well_formed_error);
if (print_type & ESCAPED_ARG)
{
const char *org_to= to;
to= backtick_string(cs, to, end, par, plen + dots, '`', MY_TEST(dots));
plen= (size_t) (to - org_to);
dots= 0;
}
else
{
if (left_fill)
{
if (plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
}
to= strnmov(to,par,plen);
if (dots)
to= strfill(to, dots, '.');
}
if (!left_fill && plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
return to;
}
|
O0
|
c
|
process_str_arg:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x1, -0x51(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x7f2f3
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x51(%rbp)
jmp 0x7f2fb
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7f30d
leaq 0x729a(%rip), %rax # 0x865a3
movq %rax, -0x30(%rbp)
cmpb $0x0, 0x18(%rbp)
je 0x7f399
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x255b0
movq %rax, -0x50(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x7f342
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0x7f360
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0x7f397
cmpq $0x3, -0x40(%rbp)
jae 0x7f382
movq -0x40(%rbp), %rax
movl %eax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0x7f395
movl $0x3, -0x38(%rbp)
movq -0x40(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x7f397
jmp 0x7f3d5
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x255b0
movq %rax, -0x50(%rbp)
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0x7f3d3
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x7f3d5
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0x7fdf0
movq %rax, -0x40(%rbp)
movl 0x10(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7f464
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r8
movl -0x38(%rbp), %eax
addq %rax, %r8
movl -0x38(%rbp), %r10d
xorl %eax, %eax
movl $0x1, %r9d
cmpl $0x0, %r10d
cmovnel %r9d, %eax
movl $0x60, %r9d
movsbl %al, %eax
movl %eax, (%rsp)
callq 0x7fe50
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
jmp 0x7f4d0
cmpb $0x0, -0x51(%rbp)
je 0x7f49c
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
addq %rcx, %rax
cmpq -0x60(%rbp), %rax
jae 0x7f49a
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
subq -0x40(%rbp), %rsi
movl -0x38(%rbp), %eax
subq %rax, %rsi
movl $0x20, %edx
callq 0x80570
movq %rax, -0x10(%rbp)
jmp 0x7f49c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x80630
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x7f4ce
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
movl $0x2e, %edx
callq 0x80570
movq %rax, -0x10(%rbp)
jmp 0x7f4d0
cmpb $0x0, -0x51(%rbp)
jne 0x7f506
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
addq %rcx, %rax
cmpq -0x60(%rbp), %rax
jae 0x7f506
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
subq -0x40(%rbp), %rsi
movl -0x38(%rbp), %eax
subq %rax, %rsi
movl $0x20, %edx
callq 0x80570
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
|
process_str_arg:
push rbp
mov rbp, rsp
sub rsp, 70h
mov al, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov [rbp+var_38], 0
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
add rax, 1
mov [rbp+var_48], rax
mov [rbp+var_50], 0
mov [rbp+var_51], 1
cmp [rbp+var_20], 0
jge short loc_7F2F3
xor eax, eax
sub rax, [rbp+var_20]
mov [rbp+var_60], rax
mov [rbp+var_51], 0
jmp short loc_7F2FB
loc_7F2F3:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
loc_7F2FB:
cmp [rbp+var_30], 0
jnz short loc_7F30D
lea rax, aNull; "(null)"
mov [rbp+var_30], rax
loc_7F30D:
cmp [rbp+arg_8], 0
jz loc_7F399
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
add rsi, 1
call _strnlen
mov [rbp+var_50], rax
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
cmp rax, [rbp+var_28]
jbe short loc_7F342
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
loc_7F342:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
ja short loc_7F360
mov rax, [rbp+var_48]
sub rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
loc_7F360:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_40]
jbe short loc_7F397
cmp [rbp+var_40], 3
jnb short loc_7F382
mov rax, [rbp+var_40]
mov [rbp+var_38], eax
mov [rbp+var_40], 0
jmp short loc_7F395
loc_7F382:
mov [rbp+var_38], 3
mov rax, [rbp+var_40]
sub rax, 3
mov [rbp+var_40], rax
loc_7F395:
jmp short $+2
loc_7F397:
jmp short loc_7F3D5
loc_7F399:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
call _strnlen
mov [rbp+var_50], rax
mov [rbp+var_40], rax
mov [rbp+var_38], 0
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
ja short loc_7F3D3
mov rax, [rbp+var_48]
sub rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
loc_7F3D3:
jmp short $+2
loc_7F3D5:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_30]
add rdx, [rbp+var_40]
mov rcx, [rbp+var_28]
lea r8, [rbp+var_34]
call my_well_formed_length_0
mov [rbp+var_40], rax
mov eax, [rbp+arg_0]
and eax, 8
cmp eax, 0
jz short loc_7F464
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_30]
mov r8, [rbp+var_40]
mov eax, [rbp+var_38]
add r8, rax
mov r10d, [rbp+var_38]
xor eax, eax
mov r9d, 1
cmp r10d, 0
cmovnz eax, r9d
mov r9d, 60h ; '`'
movsx eax, al
mov [rsp+70h+var_70], eax
call backtick_string
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_68]
sub rax, rcx
mov [rbp+var_40], rax
mov [rbp+var_38], 0
jmp short loc_7F4D0
loc_7F464:
cmp [rbp+var_51], 0
jz short loc_7F49C
mov rax, [rbp+var_40]
mov ecx, [rbp+var_38]
add rax, rcx
cmp rax, [rbp+var_60]
jnb short loc_7F49A
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_60]
sub rsi, [rbp+var_40]
mov eax, [rbp+var_38]
sub rsi, rax
mov edx, 20h ; ' '
call strfill
mov [rbp+var_10], rax
loc_7F49A:
jmp short $+2
loc_7F49C:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_40]
call strnmov
mov [rbp+var_10], rax
cmp [rbp+var_38], 0
jz short loc_7F4CE
mov rdi, [rbp+var_10]
mov eax, [rbp+var_38]
mov esi, eax
mov edx, 2Eh ; '.'
call strfill
mov [rbp+var_10], rax
loc_7F4CE:
jmp short $+2
loc_7F4D0:
cmp [rbp+var_51], 0
jnz short loc_7F506
mov rax, [rbp+var_40]
mov ecx, [rbp+var_38]
add rax, rcx
cmp rax, [rbp+var_60]
jnb short loc_7F506
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_60]
sub rsi, [rbp+var_40]
mov eax, [rbp+var_38]
sub rsi, rax
mov edx, 20h ; ' '
call strfill
mov [rbp+var_10], rax
loc_7F506:
mov rax, [rbp+var_10]
add rsp, 70h
pop rbp
retn
|
long long process_str_arg(
long long a1,
long long a2,
long long a3,
long long a4,
unsigned long long a5,
const char *a6,
char a7,
char a8)
{
long long v9; // [rsp+8h] [rbp-68h]
unsigned long long v10; // [rsp+10h] [rbp-60h]
char v11; // [rsp+1Fh] [rbp-51h]
unsigned long long v12; // [rsp+20h] [rbp-50h]
unsigned long long v13; // [rsp+28h] [rbp-48h]
unsigned long long v14; // [rsp+30h] [rbp-40h]
long long v15; // [rsp+30h] [rbp-40h]
unsigned int v16; // [rsp+38h] [rbp-38h]
char v17[4]; // [rsp+3Ch] [rbp-34h] BYREF
const char *v18; // [rsp+40h] [rbp-30h]
unsigned long long v19; // [rsp+48h] [rbp-28h]
long long v20; // [rsp+50h] [rbp-20h]
long long v21; // [rsp+58h] [rbp-18h]
long long v22; // [rsp+60h] [rbp-10h]
long long v23; // [rsp+68h] [rbp-8h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v16 = 0;
v13 = a3 - a2 + 1;
v11 = 1;
if ( a4 >= 0 )
{
v10 = v20;
}
else
{
v10 = -v20;
v11 = 0;
}
if ( !v18 )
v18 = "(null)";
if ( a8 )
{
v12 = strnlen(v18, v19 + 1);
v14 = v12;
if ( v12 > v19 )
v14 = v19;
if ( v13 <= v14 )
{
v14 = v13 - 1;
v10 = v13 - 1;
}
if ( v12 > v14 )
{
if ( v14 >= 3 )
{
v16 = 3;
v14 -= 3LL;
}
else
{
v16 = v14;
v14 = 0LL;
}
}
}
else
{
v14 = strnlen(v18, v19);
v16 = 0;
if ( v13 <= v14 )
{
v14 = v13 - 1;
v10 = v13 - 1;
}
}
v15 = my_well_formed_length_0(v23, v18, &v18[v14], v19, v17);
if ( (a7 & 8) != 0 )
{
v9 = v22;
v22 = backtick_string(v23, v22, v21, (_DWORD)v18, v16 + (unsigned int)v15, 96, v16 != 0);
v15 = v22 - v9;
v16 = 0;
}
else
{
if ( v11 && (unsigned long long)v16 + v15 < v10 )
v22 = strfill(v22, v10 - v15 - v16, 32LL);
v22 = strnmov(v22, v18, v15);
if ( v16 )
v22 = strfill(v22, v16, 46LL);
}
if ( !v11 && (unsigned long long)v16 + v15 < v10 )
return strfill(v22, v10 - v15 - v16, 32LL);
return v22;
}
|
process_str_arg:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV AL,byte ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x50],0x0
MOV byte ptr [RBP + -0x51],0x1
CMP qword ptr [RBP + -0x20],0x0
JGE 0x0017f2f3
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV byte ptr [RBP + -0x51],0x0
JMP 0x0017f2fb
LAB_0017f2f3:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
LAB_0017f2fb:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0017f30d
LEA RAX,[0x1865a3]
MOV qword ptr [RBP + -0x30],RAX
LAB_0017f30d:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0017f399
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x1
CALL 0x001255b0
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0017f342
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
LAB_0017f342:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x0017f360
MOV RAX,qword ptr [RBP + -0x48]
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LAB_0017f360:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x40]
JBE 0x0017f397
CMP qword ptr [RBP + -0x40],0x3
JNC 0x0017f382
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x38],EAX
MOV qword ptr [RBP + -0x40],0x0
JMP 0x0017f395
LAB_0017f382:
MOV dword ptr [RBP + -0x38],0x3
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
LAB_0017f395:
JMP 0x0017f397
LAB_0017f397:
JMP 0x0017f3d5
LAB_0017f399:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001255b0
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x0017f3d3
MOV RAX,qword ptr [RBP + -0x48]
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LAB_0017f3d3:
JMP 0x0017f3d5
LAB_0017f3d5:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x30]
ADD RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
LEA R8,[RBP + -0x34]
CALL 0x0017fdf0
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x8
CMP EAX,0x0
JZ 0x0017f464
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x38]
ADD R8,RAX
MOV R10D,dword ptr [RBP + -0x38]
XOR EAX,EAX
MOV R9D,0x1
CMP R10D,0x0
CMOVNZ EAX,R9D
MOV R9D,0x60
MOVSX EAX,AL
MOV dword ptr [RSP],EAX
CALL 0x0017fe50
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x0017f4d0
LAB_0017f464:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x0017f49c
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x38]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x60]
JNC 0x0017f49a
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x60]
SUB RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x38]
SUB RSI,RAX
MOV EDX,0x20
CALL 0x00180570
MOV qword ptr [RBP + -0x10],RAX
LAB_0017f49a:
JMP 0x0017f49c
LAB_0017f49c:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x00180630
MOV qword ptr [RBP + -0x10],RAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x0017f4ce
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x38]
MOV ESI,EAX
MOV EDX,0x2e
CALL 0x00180570
MOV qword ptr [RBP + -0x10],RAX
LAB_0017f4ce:
JMP 0x0017f4d0
LAB_0017f4d0:
CMP byte ptr [RBP + -0x51],0x0
JNZ 0x0017f506
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x38]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x60]
JNC 0x0017f506
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x60]
SUB RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x38]
SUB RSI,RAX
MOV EDX,0x20
CALL 0x00180570
MOV qword ptr [RBP + -0x10],RAX
LAB_0017f506:
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x70
POP RBP
RET
|
long process_str_arg(int8 param_1,long param_2,long param_3,size_t param_4,size_t param_5,
char *param_6,uint param_7,char param_8)
{
long lVar1;
size_t sVar2;
size_t sVar3;
bool bVar4;
size_t local_68;
size_t local_48;
uint local_40;
int1 local_3c [4];
char *local_38;
ulong local_30;
size_t local_28;
long local_20;
long local_18;
int8 local_10;
local_40 = 0;
sVar2 = param_3 - param_2;
bVar4 = -1 < (long)param_4;
local_68 = param_4;
if (!bVar4) {
local_68 = -param_4;
}
local_38 = param_6;
if (param_6 == (char *)0x0) {
local_38 = "(null)";
}
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (param_8 == '\0') {
local_48 = strnlen(local_38,param_5);
local_40 = 0;
if (sVar2 + 1 <= local_48) {
local_68 = sVar2;
local_48 = sVar2;
}
}
else {
sVar3 = strnlen(local_38,param_5 + 1);
local_48 = sVar3;
if (local_30 < sVar3) {
local_48 = local_30;
}
if (sVar2 + 1 <= local_48) {
local_68 = sVar2;
local_48 = sVar2;
}
if (local_48 < sVar3) {
if (local_48 < 3) {
local_40 = (uint)local_48;
local_48 = 0;
}
else {
local_40 = 3;
local_48 = local_48 - 3;
}
}
}
local_48 = my_well_formed_length(local_10,local_38,local_38 + local_48,local_30,local_3c);
lVar1 = local_18;
if ((param_7 & 8) == 0) {
if ((bVar4) && (local_48 + local_40 < local_68)) {
local_18 = strfill(local_18,(local_68 - local_48) - (ulong)local_40,0x20);
}
local_18 = strnmov(local_18,local_38,local_48);
if (local_40 != 0) {
local_18 = strfill(local_18,local_40,0x2e);
}
}
else {
local_18 = backtick_string(local_10,local_18,local_20,local_38,local_48 + local_40,0x60,
local_40 != 0);
local_48 = local_18 - lVar1;
local_40 = 0;
}
if ((!bVar4) && (local_48 + local_40 < local_68)) {
local_18 = strfill(local_18,(local_68 - local_48) - (ulong)local_40,0x20);
}
return local_18;
}
|
|
16,083
|
process_str_arg
|
eloqsql/strings/my_vsnprintf.c
|
static char *process_str_arg(CHARSET_INFO *cs, char *to, const char *end,
longlong length_arg, size_t width, char *par,
uint print_type, my_bool nice_cut)
{
int well_formed_error;
uint dots= 0;
size_t plen, left_len= (size_t) (end - to) + 1, slen=0;
my_bool left_fill= 1;
size_t length;
/*
The sign of the length argument specific the string should be right
or left adjusted
*/
if (length_arg < 0)
{
length= (size_t) -length_arg;
left_fill= 0;
}
else
length= (size_t) length_arg;
if (!par)
par = (char*) "(null)";
if (nice_cut)
{
plen= slen= strnlen(par, width + 1);
if (plen > width)
plen= width;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
if ((slen > plen))
{
if (plen < 3)
{
dots= (uint) plen;
plen= 0;
}
else
{
dots= 3;
plen-= 3;
}
}
}
else
{
plen= slen= strnlen(par, width);
dots= 0;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
}
plen= my_well_formed_length(cs, par, par + plen, width, &well_formed_error);
if (print_type & ESCAPED_ARG)
{
const char *org_to= to;
to= backtick_string(cs, to, end, par, plen + dots, '`', MY_TEST(dots));
plen= (size_t) (to - org_to);
dots= 0;
}
else
{
if (left_fill)
{
if (plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
}
to= strnmov(to,par,plen);
if (dots)
to= strfill(to, dots, '.');
}
if (!left_fill && plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
return to;
}
|
O3
|
c
|
process_str_arg:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rdi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
subq %rsi, %r14
leaq 0x1(%r14), %rbx
movq %rcx, %r13
negq %r13
movq %rcx, -0x40(%rbp)
cmovsq %rcx, %r13
testq %r9, %r9
leaq 0x68be(%rip), %r12 # 0x654f8
cmovneq %r9, %r12
cmpb $0x0, 0x18(%rbp)
je 0x5ec82
leaq 0x1(%r15), %rsi
movq %r12, %rdi
callq 0x24600
cmpq %r15, %rax
movq %r15, %rdx
cmovbq %rax, %rdx
cmpq %rdx, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movl $0x0, -0x2c(%rbp)
cmpq %rdx, %rax
movq %r13, -0x48(%rbp)
jbe 0x5ecb3
cmpq $0x2, %rdx
ja 0x5eca8
movl %edx, -0x2c(%rbp)
xorl %edx, %edx
jmp 0x5ecb3
movq %r12, %rdi
movq %r15, %rsi
callq 0x24600
movq %rax, %rdx
cmpq %rax, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movq %r13, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x5ecb3
addq $-0x3, %rdx
movl $0x3, -0x2c(%rbp)
addq %r12, %rdx
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
leaq -0x70(%rbp), %rbx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
callq *0xc8(%rax)
movq (%rbx), %r13
subq %r12, %r13
movl 0x10(%rbp), %eax
testb $0x8, %al
jne 0x5ed1b
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
js 0x5edee
movl -0x2c(%rbp), %r14d
movl %r14d, %eax
addq %r13, %rax
movq -0x48(%rbp), %rsi
subq %rax, %rsi
jbe 0x5edf8
movq -0x38(%rbp), %rdi
movl $0x20, %edx
callq 0x5f53c
movq %rax, %rdi
jmp 0x5edfc
movl -0x2c(%rbp), %eax
addq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
cmpq %r13, %r14
jbe 0x5ee78
movq -0x38(%rbp), %rax
leaq 0x1(%rax), %r15
movb $0x60, (%rax)
testq %r13, %r13
jle 0x5ee27
addq %r12, %r13
xorl %r14d, %r14d
cmpl $0x0, -0x2c(%rbp)
je 0x5ed7e
movl %r14d, %eax
movq %r15, -0x70(%rbp,%rax,8)
movl %r14d, %eax
incl %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
negl %eax
addl %eax, %r14d
incl %r14d
movb (%r12), %bl
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r12, %rsi
movq %r13, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
movl $0x1, %ecx
cmovll %ecx, %eax
jge 0x5edbf
cmpb $0x60, %bl
jne 0x5edbf
leaq 0x1(%r15), %rdi
cmpq -0x50(%rbp), %rdi
jae 0x5ee78
movb $0x60, (%r15)
jmp 0x5edc2
movq %r15, %rdi
movl %eax, %ebx
leaq (%rdi,%rbx), %rax
cmpq -0x50(%rbp), %rax
jae 0x5ee78
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5f59c
movq %rax, %r15
addq %rbx, %r12
cmpq %r13, %r12
jb 0x5ed53
jmp 0x5ee2a
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %r14d
jmp 0x5edfc
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5f59c
movq %rax, %r15
testl %r14d, %r14d
je 0x5ee8c
movl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x5f53c
movq %rax, %r15
jmp 0x5ee8f
xorl %r14d, %r14d
leaq 0x1(%r15), %rax
cmpq -0x50(%rbp), %rax
jae 0x5ee78
cmpl $0x0, -0x2c(%rbp)
je 0x5eeda
subl $0x1, %r14d
movl $0x2, %eax
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %rdx
testq %rdx, %rdx
je 0x5ee78
movl $0x1, %ecx
subl $0x1, %r14d
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %r15
testq %r15, %r15
je 0x5eec2
incl %ecx
movq %r15, %rdx
cmpl $0x3, %ecx
jne 0x5ee5a
jmp 0x5eec5
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq %rax, %r15
movq -0x40(%rbp), %rbx
movq %r15, %r13
subq %rax, %r13
xorl %r14d, %r14d
testq %rbx, %rbx
jns 0x5eeb0
addq %r14, %r13
movq -0x48(%rbp), %rsi
subq %r13, %rsi
jbe 0x5eeb0
movq %r15, %rdi
movl $0x20, %edx
callq 0x5f53c
movq %rax, %r15
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movl %ecx, %ebx
movq %r15, %rdi
movl $0x2e, %esi
movq %rbx, %rdx
callq 0x241e0
addq %rbx, %r15
movb $0x60, (%r15)
incq %r15
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rax
jmp 0x5ee86
|
process_str_arg:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, r8
mov [rbp+var_58], rdi
mov [rbp+var_50], rdx
mov r14, rdx
mov [rbp+var_38], rsi
sub r14, rsi
lea rbx, [r14+1]
mov r13, rcx
neg r13
mov [rbp+var_40], rcx
cmovs r13, rcx
test r9, r9
lea r12, aNull; "(null)"
cmovnz r12, r9
cmp [rbp+arg_8], 0
jz short loc_5EC82
lea rsi, [r15+1]
mov rdi, r12
call _strnlen
cmp rax, r15
mov rdx, r15
cmovb rdx, rax
cmp rbx, rdx
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_2C], 0
cmp rax, rdx
mov [rbp+var_48], r13
jbe short loc_5ECB3
cmp rdx, 2
ja short loc_5ECA8
mov [rbp+var_2C], edx
xor edx, edx
jmp short loc_5ECB3
loc_5EC82:
mov rdi, r12
mov rsi, r15
call _strnlen
mov rdx, rax
cmp rbx, rax
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_48], r13
mov [rbp+var_2C], 0
jmp short loc_5ECB3
loc_5ECA8:
add rdx, 0FFFFFFFFFFFFFFFDh
mov [rbp+var_2C], 3
loc_5ECB3:
add rdx, r12
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
lea rbx, [rbp+var_70]
mov rsi, r12
mov rcx, r15
mov r8, rbx
call qword ptr [rax+0C8h]
mov r13, [rbx]
sub r13, r12
mov eax, [rbp+arg_0]
test al, 8
jnz short loc_5ED1B
mov rbx, [rbp+var_40]
test rbx, rbx
js loc_5EDEE
mov r14d, [rbp+var_2C]
mov eax, r14d
add rax, r13
mov rsi, [rbp+var_48]
sub rsi, rax
jbe loc_5EDF8
mov rdi, [rbp+var_38]
mov edx, 20h ; ' '
call strfill
mov rdi, rax
jmp loc_5EDFC
loc_5ED1B:
mov eax, [rbp+var_2C]
add r13, rax
xorps xmm0, xmm0
movaps [rbp+var_70], xmm0
mov [rbp+var_60], 0
cmp r14, r13
jbe loc_5EE78
mov rax, [rbp+var_38]
lea r15, [rax+1]
mov byte ptr [rax], 60h ; '`'
test r13, r13
jle loc_5EE27
add r13, r12
xor r14d, r14d
loc_5ED53:
cmp [rbp+var_2C], 0
jz short loc_5ED7E
mov eax, r14d
mov qword ptr [rbp+rax*8+var_70], r15
mov eax, r14d
inc eax
mov ecx, 0AAAAAAABh
imul rax, rcx
shr rax, 21h
lea eax, [rax+rax*2]
neg eax
add r14d, eax
inc r14d
loc_5ED7E:
mov bl, [r12]
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
mov rsi, r12
mov rdx, r13
call qword ptr [rax+0C0h]
cmp eax, 2
mov ecx, 1
cmovl eax, ecx
jge short loc_5EDBF
cmp bl, 60h ; '`'
jnz short loc_5EDBF
lea rdi, [r15+1]
cmp rdi, [rbp+var_50]
jnb loc_5EE78
mov byte ptr [r15], 60h ; '`'
jmp short loc_5EDC2
loc_5EDBF:
mov rdi, r15
loc_5EDC2:
mov ebx, eax
lea rax, [rdi+rbx]
cmp rax, [rbp+var_50]
jnb loc_5EE78
mov rsi, r12
mov rdx, rbx
call strnmov
mov r15, rax
add r12, rbx
cmp r12, r13
jb loc_5ED53
jmp short loc_5EE2A
loc_5EDEE:
mov rdi, [rbp+var_38]
mov r14d, [rbp+var_2C]
jmp short loc_5EDFC
loc_5EDF8:
mov rdi, [rbp+var_38]
loc_5EDFC:
mov rsi, r12
mov rdx, r13
call strnmov
mov r15, rax
test r14d, r14d
jz short loc_5EE8C
mov r14d, r14d
mov rdi, r15
mov rsi, r14
mov edx, 2Eh ; '.'
call strfill
mov r15, rax
jmp short loc_5EE8F
loc_5EE27:
xor r14d, r14d
loc_5EE2A:
lea rax, [r15+1]
cmp rax, [rbp+var_50]
jnb short loc_5EE78
cmp [rbp+var_2C], 0
jz loc_5EEDA
sub r14d, 1
mov eax, 2
cmovb r14d, eax
mov rdx, qword ptr [rbp+r14*8+var_70]
test rdx, rdx
jz short loc_5EE78
mov ecx, 1
loc_5EE5A:
sub r14d, 1
cmovb r14d, eax
mov r15, qword ptr [rbp+r14*8+var_70]
test r15, r15
jz short loc_5EEC2
inc ecx
mov rdx, r15
cmp ecx, 3
jnz short loc_5EE5A
jmp short loc_5EEC5
loc_5EE78:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov r15, rax
mov rbx, [rbp+var_40]
loc_5EE86:
mov r13, r15
sub r13, rax
loc_5EE8C:
xor r14d, r14d
loc_5EE8F:
test rbx, rbx
jns short loc_5EEB0
add r13, r14
mov rsi, [rbp+var_48]
sub rsi, r13
jbe short loc_5EEB0
mov rdi, r15
mov edx, 20h ; ' '
call strfill
mov r15, rax
loc_5EEB0:
mov rax, r15
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5EEC2:
mov r15, rdx
loc_5EEC5:
mov ebx, ecx
mov rdi, r15
mov esi, 2Eh ; '.'
mov rdx, rbx
call _memset
add r15, rbx
loc_5EEDA:
mov byte ptr [r15], 60h ; '`'
inc r15
mov rbx, [rbp+var_40]
mov rax, [rbp+var_38]
jmp short loc_5EE86
|
long long process_str_arg(
long long a1,
_BYTE *a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
const char *a6,
char a7,
char a8)
{
unsigned long long v9; // r14
unsigned long long v10; // rbx
long long v11; // r13
const char *v12; // r12
unsigned long long v13; // rax
unsigned long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
long long v18; // r13
long long v19; // rbx
long long v20; // r14
unsigned long long v21; // rax
long long v22; // rdi
long long v23; // r13
_BYTE *v24; // r15
const char *v25; // r13
unsigned int v26; // r14d
char v27; // bl
unsigned int v28; // eax
_BYTE *v29; // rdi
long long v30; // rbx
long long v31; // rax
long long v32; // r15
bool v33; // cf
long long v34; // r14
long long v35; // rdx
unsigned int v36; // ecx
long long v37; // r15
_BYTE *v38; // rax
unsigned long long v39; // r13
long long v41; // rbx
__int128 v42; // [rsp+0h] [rbp-70h] BYREF
long long v43; // [rsp+10h] [rbp-60h]
long long v44; // [rsp+18h] [rbp-58h]
unsigned long long v45; // [rsp+20h] [rbp-50h]
unsigned long long v46; // [rsp+28h] [rbp-48h]
long long v47; // [rsp+30h] [rbp-40h]
_BYTE *v48; // [rsp+38h] [rbp-38h]
unsigned int v49; // [rsp+44h] [rbp-2Ch]
v44 = a1;
v45 = a3;
v48 = a2;
v9 = a3 - (_QWORD)a2;
v10 = a3 - (_QWORD)a2 + 1;
v11 = -a4;
v47 = a4;
if ( a4 > 0 )
v11 = a4;
v12 = "(null)";
if ( a6 )
v12 = a6;
if ( a8 )
{
v13 = strnlen(v12, a5 + 1);
v14 = a5;
if ( v13 < a5 )
v14 = v13;
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v49 = 0;
v46 = v11;
if ( v13 > v14 )
{
if ( v14 > 2 )
{
v14 -= 3LL;
v49 = 3;
}
else
{
v49 = v14;
v14 = 0LL;
}
}
}
else
{
v14 = strnlen(v12, a5);
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v46 = v11;
v49 = 0;
}
(*(void ( **)(long long, const char *, const char *, unsigned long long, __int128 *))(*(_QWORD *)(v44 + 184)
+ 200LL))(
v44,
v12,
&v12[v14],
a5,
&v42);
v18 = v42 - (_QWORD)v12;
if ( (a7 & 8) != 0 )
{
v23 = v49 + v18;
v42 = 0LL;
v43 = 0LL;
if ( v9 > v23 )
{
v24 = v48 + 1;
*v48 = 96;
if ( v23 > 0 )
{
v25 = &v12[v23];
v26 = 0;
while ( 1 )
{
if ( v49 )
{
*((_QWORD *)&v42 + v26) = v24;
v15 = 2863311531LL;
v26 += -3 * ((v26 + 1) / 3) + 1;
}
v27 = *v12;
v28 = (*(long long ( **)(long long, const char *, const char *, long long, long long, long long, _QWORD, _QWORD, long long))(*(_QWORD *)(v44 + 184) + 192LL))(
v44,
v12,
v25,
v15,
v16,
v17,
v42,
*((_QWORD *)&v42 + 1),
v43);
if ( (int)v28 < 2 && (v28 = 1, v27 == 96) )
{
v29 = v24 + 1;
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
*v24 = 96;
}
else
{
v29 = v24;
}
v30 = v28;
if ( (unsigned long long)&v29[v28] >= v45 )
goto LABEL_50;
v24 = (_BYTE *)strnmov(v29, v12, v28);
v12 += v30;
if ( v12 >= v25 )
goto LABEL_39;
}
}
v26 = 0;
LABEL_39:
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
if ( !v49 )
{
LABEL_59:
*v24 = 96;
v32 = (long long)(v24 + 1);
v19 = v47;
v38 = v48;
goto LABEL_51;
}
v33 = v26 == 0;
v34 = v26 - 1;
if ( v33 )
v34 = 2LL;
v35 = *((_QWORD *)&v42 + v34);
if ( v35 )
{
v36 = 1;
while ( 1 )
{
v33 = (_DWORD)v34 == 0;
v34 = (unsigned int)(v34 - 1);
if ( v33 )
v34 = 2LL;
v37 = *((_QWORD *)&v42 + v34);
if ( !v37 )
break;
++v36;
v35 = *((_QWORD *)&v42 + v34);
if ( v36 == 3 )
goto LABEL_58;
}
v37 = v35;
LABEL_58:
v41 = v36;
memset(v37, 46LL, v36);
v24 = (_BYTE *)(v41 + v37);
goto LABEL_59;
}
}
LABEL_50:
v38 = v48;
*v48 = 0;
v32 = (long long)v38;
v19 = v47;
LABEL_51:
v18 = v32 - (_QWORD)v38;
LABEL_52:
v20 = 0LL;
goto LABEL_53;
}
v19 = v47;
if ( v47 < 0 )
{
v22 = (long long)v48;
LODWORD(v20) = v49;
}
else
{
LODWORD(v20) = v49;
v21 = v18 + v49;
if ( v46 <= v21 )
v22 = (long long)v48;
else
v22 = strfill(v48, v46 - v21, 32LL);
}
v31 = strnmov(v22, v12, v18);
v32 = v31;
if ( !(_DWORD)v20 )
goto LABEL_52;
v20 = (unsigned int)v20;
v32 = strfill(v31, (unsigned int)v20, 46LL);
LABEL_53:
if ( v19 < 0 )
{
v39 = v20 + v18;
if ( v46 > v39 )
return strfill(v32, v46 - v39, 32LL);
}
return v32;
}
|
process_str_arg:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,R8
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x50],RDX
MOV R14,RDX
MOV qword ptr [RBP + -0x38],RSI
SUB R14,RSI
LEA RBX,[R14 + 0x1]
MOV R13,RCX
NEG R13
MOV qword ptr [RBP + -0x40],RCX
CMOVS R13,RCX
TEST R9,R9
LEA R12,[0x1654f8]
CMOVNZ R12,R9
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0015ec82
LEA RSI,[R15 + 0x1]
MOV RDI,R12
CALL 0x00124600
CMP RAX,R15
MOV RDX,R15
CMOVC RDX,RAX
CMP RBX,RDX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV dword ptr [RBP + -0x2c],0x0
CMP RAX,RDX
MOV qword ptr [RBP + -0x48],R13
JBE 0x0015ecb3
CMP RDX,0x2
JA 0x0015eca8
MOV dword ptr [RBP + -0x2c],EDX
XOR EDX,EDX
JMP 0x0015ecb3
LAB_0015ec82:
MOV RDI,R12
MOV RSI,R15
CALL 0x00124600
MOV RDX,RAX
CMP RBX,RAX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV qword ptr [RBP + -0x48],R13
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0015ecb3
LAB_0015eca8:
ADD RDX,-0x3
MOV dword ptr [RBP + -0x2c],0x3
LAB_0015ecb3:
ADD RDX,R12
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
LEA RBX,[RBP + -0x70]
MOV RSI,R12
MOV RCX,R15
MOV R8,RBX
CALL qword ptr [RAX + 0xc8]
MOV R13,qword ptr [RBX]
SUB R13,R12
MOV EAX,dword ptr [RBP + 0x10]
TEST AL,0x8
JNZ 0x0015ed1b
MOV RBX,qword ptr [RBP + -0x40]
TEST RBX,RBX
JS 0x0015edee
MOV R14D,dword ptr [RBP + -0x2c]
MOV EAX,R14D
ADD RAX,R13
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,RAX
JBE 0x0015edf8
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x20
CALL 0x0015f53c
MOV RDI,RAX
JMP 0x0015edfc
LAB_0015ed1b:
MOV EAX,dword ptr [RBP + -0x2c]
ADD R13,RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV qword ptr [RBP + -0x60],0x0
CMP R14,R13
JBE 0x0015ee78
MOV RAX,qword ptr [RBP + -0x38]
LEA R15,[RAX + 0x1]
MOV byte ptr [RAX],0x60
TEST R13,R13
JLE 0x0015ee27
ADD R13,R12
XOR R14D,R14D
LAB_0015ed53:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0015ed7e
MOV EAX,R14D
MOV qword ptr [RBP + RAX*0x8 + -0x70],R15
MOV EAX,R14D
INC EAX
MOV ECX,0xaaaaaaab
IMUL RAX,RCX
SHR RAX,0x21
LEA EAX,[RAX + RAX*0x2]
NEG EAX
ADD R14D,EAX
INC R14D
LAB_0015ed7e:
MOV BL,byte ptr [R12]
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R12
MOV RDX,R13
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
MOV ECX,0x1
CMOVL EAX,ECX
JGE 0x0015edbf
CMP BL,0x60
JNZ 0x0015edbf
LEA RDI,[R15 + 0x1]
CMP RDI,qword ptr [RBP + -0x50]
JNC 0x0015ee78
MOV byte ptr [R15],0x60
JMP 0x0015edc2
LAB_0015edbf:
MOV RDI,R15
LAB_0015edc2:
MOV EBX,EAX
LEA RAX,[RDI + RBX*0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x0015ee78
MOV RSI,R12
MOV RDX,RBX
CALL 0x0015f59c
MOV R15,RAX
ADD R12,RBX
CMP R12,R13
JC 0x0015ed53
JMP 0x0015ee2a
LAB_0015edee:
MOV RDI,qword ptr [RBP + -0x38]
MOV R14D,dword ptr [RBP + -0x2c]
JMP 0x0015edfc
LAB_0015edf8:
MOV RDI,qword ptr [RBP + -0x38]
LAB_0015edfc:
MOV RSI,R12
MOV RDX,R13
CALL 0x0015f59c
MOV R15,RAX
TEST R14D,R14D
JZ 0x0015ee8c
MOV R14D,R14D
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x2e
CALL 0x0015f53c
MOV R15,RAX
JMP 0x0015ee8f
LAB_0015ee27:
XOR R14D,R14D
LAB_0015ee2a:
LEA RAX,[R15 + 0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x0015ee78
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0015eeda
SUB R14D,0x1
MOV EAX,0x2
CMOVC R14D,EAX
MOV RDX,qword ptr [RBP + R14*0x8 + -0x70]
TEST RDX,RDX
JZ 0x0015ee78
MOV ECX,0x1
LAB_0015ee5a:
SUB R14D,0x1
CMOVC R14D,EAX
MOV R15,qword ptr [RBP + R14*0x8 + -0x70]
TEST R15,R15
JZ 0x0015eec2
INC ECX
MOV RDX,R15
CMP ECX,0x3
JNZ 0x0015ee5a
JMP 0x0015eec5
LAB_0015ee78:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV R15,RAX
MOV RBX,qword ptr [RBP + -0x40]
LAB_0015ee86:
MOV R13,R15
SUB R13,RAX
LAB_0015ee8c:
XOR R14D,R14D
LAB_0015ee8f:
TEST RBX,RBX
JNS 0x0015eeb0
ADD R13,R14
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,R13
JBE 0x0015eeb0
MOV RDI,R15
MOV EDX,0x20
CALL 0x0015f53c
MOV R15,RAX
LAB_0015eeb0:
MOV RAX,R15
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015eec2:
MOV R15,RDX
LAB_0015eec5:
MOV EBX,ECX
MOV RDI,R15
MOV ESI,0x2e
MOV RDX,RBX
CALL 0x001241e0
ADD R15,RBX
LAB_0015eeda:
MOV byte ptr [R15],0x60
INC R15
MOV RBX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
JMP 0x0015ee86
|
int1 *
process_str_arg(long param_1,int1 *param_2,int1 *param_3,ulong param_4,ulong param_5,
char *param_6,uint param_7,char param_8)
{
char cVar1;
void *pvVar2;
uint uVar3;
uint uVar4;
size_t sVar5;
int1 *puVar6;
void *__s;
long lVar7;
char *__string;
long lVar8;
ulong uVar9;
char *pcVar10;
int iVar11;
ulong uVar12;
long local_78 [4];
int1 *local_58;
ulong local_50;
ulong local_48;
int1 *local_40;
uint local_34;
uVar12 = (long)param_3 - (long)param_2;
local_50 = -param_4;
if (0 < (long)param_4) {
local_50 = param_4;
}
__string = "(null)";
if (param_6 != (char *)0x0) {
__string = param_6;
}
local_78[3] = param_1;
local_58 = param_3;
local_48 = param_4;
local_40 = param_2;
if (param_8 == '\0') {
uVar9 = strnlen(__string,param_5);
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
}
else {
sVar5 = strnlen(__string,param_5 + 1);
uVar9 = param_5;
if (sVar5 < param_5) {
uVar9 = sVar5;
}
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
if (uVar9 < sVar5) {
if (uVar9 < 3) {
local_34 = (uint)uVar9;
uVar9 = 0;
}
else {
uVar9 = uVar9 - 3;
local_34 = 3;
}
}
}
(**(code **)(*(long *)(local_78[3] + 0xb8) + 200))
(local_78[3],__string,__string + uVar9,param_5,local_78);
uVar4 = local_34;
uVar9 = local_48;
lVar8 = local_78[0] - (long)__string;
if ((param_7 & 8) == 0) {
puVar6 = local_40;
if ((-1 < (long)local_48) &&
(lVar7 = local_50 - ((ulong)local_34 + lVar8),
(ulong)local_34 + lVar8 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(local_40,lVar7,0x20);
}
uVar12 = (ulong)uVar4;
puVar6 = (int1 *)strnmov(puVar6,__string,lVar8);
if (uVar4 != 0) {
puVar6 = (int1 *)strfill(puVar6,uVar12,0x2e);
goto LAB_0015ee8f;
}
}
else {
uVar9 = lVar8 + (ulong)local_34;
local_78[0] = 0;
local_78[1] = 0;
local_78[2] = 0;
if (uVar9 < uVar12) {
puVar6 = local_40 + 1;
*local_40 = 0x60;
if ((long)uVar9 < 1) {
iVar11 = 0;
}
else {
pcVar10 = __string + uVar9;
uVar12 = 0;
do {
if (local_34 != 0) {
local_78[uVar12] = (long)puVar6;
uVar12 = (ulong)((int)uVar12 + (((int)uVar12 + 1U) / 3) * -3 + 1);
}
iVar11 = (int)uVar12;
cVar1 = *__string;
uVar4 = (**(code **)(*(long *)(local_78[3] + 0xb8) + 0xc0))(local_78[3],__string,pcVar10);
if (((int)uVar4 < 2) && (uVar4 = 1, cVar1 == '`')) {
if (local_58 <= puVar6 + 1) goto LAB_0015ee78;
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
uVar9 = (ulong)uVar4;
if (local_58 <= puVar6 + uVar9) goto LAB_0015ee78;
puVar6 = (int1 *)strnmov(puVar6,__string,uVar9);
__string = __string + uVar9;
} while (__string < pcVar10);
}
if (local_58 <= puVar6 + 1) goto LAB_0015ee78;
if (local_34 != 0) {
uVar4 = iVar11 - 1;
if (iVar11 == 0) {
uVar4 = 2;
}
uVar12 = (ulong)uVar4;
if ((void *)local_78[uVar12] == (void *)0x0) goto LAB_0015ee78;
uVar4 = 1;
__s = (void *)local_78[uVar12];
do {
uVar3 = (int)uVar12 - 1;
if ((int)uVar12 == 0) {
uVar3 = 2;
}
uVar12 = (ulong)uVar3;
pvVar2 = (void *)local_78[uVar12];
} while ((pvVar2 != (void *)0x0) && (uVar4 = uVar4 + 1, __s = pvVar2, uVar4 != 3));
memset(__s,0x2e,(ulong)uVar4);
puVar6 = (int1 *)((long)__s + (ulong)uVar4);
}
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
else {
LAB_0015ee78:
*local_40 = 0;
puVar6 = local_40;
}
lVar8 = (long)puVar6 - (long)local_40;
uVar9 = local_48;
}
uVar12 = 0;
LAB_0015ee8f:
if (((long)uVar9 < 0) &&
(lVar7 = local_50 - (lVar8 + uVar12), lVar8 + uVar12 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(puVar6,lVar7,0x20);
}
return puVar6;
}
|
|
16,084
|
strxnmov
|
eloqsql/strings/strxnmov.c
|
char *strxnmov(char *dst, size_t len, const char *src, ...)
{
va_list pvar;
char *end_of_dst=dst+len;
va_start(pvar,src);
while (src != NullS)
{
do
{
if (dst == end_of_dst)
goto end;
}
while ((*dst++ = *src++));
dst--;
src = va_arg(pvar, char *);
}
end:
*dst=0;
va_end(pvar);
return dst;
}
|
O0
|
c
|
strxnmov:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
testb %al, %al
je 0x78e7b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x78f87
jmp 0x78ed9
movq -0x8(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x78ee8
jmp 0x78f89
jmp 0x78eea
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
cmpb $0x0, %al
jne 0x78ed9
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x78f57
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x78f74
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x78ecc
jmp 0x78f89
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
|
strxnmov:
push rbp
mov rbp, rsp
sub rsp, 90h
test al, al
jz short loc_78E7B
movaps [rbp+var_C0], xmm0
movaps [rbp+var_B0], xmm1
movaps [rbp+var_A0], xmm2
movaps [rbp+var_90], xmm3
movaps [rbp+var_80], xmm4
movaps [rbp+var_70], xmm5
movaps [rbp+var_60], xmm6
movaps [rbp+var_50], xmm7
loc_78E7B:
mov [rbp+var_C8], r9
mov [rbp+var_D0], r8
mov [rbp+var_D8], rcx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_38], rax
lea rax, [rbp+var_30]
lea rcx, [rbp+var_F0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 18h
loc_78ECC:
cmp [rbp+var_18], 0
jz loc_78F87
jmp short $+2
loc_78ED9:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_38]
jnz short loc_78EE8
jmp loc_78F89
loc_78EE8:
jmp short $+2
loc_78EEA:
mov rax, [rbp+var_18]
mov rcx, rax
add rcx, 1
mov [rbp+var_18], rcx
mov al, [rax]
mov rcx, [rbp+var_8]
mov rdx, rcx
add rdx, 1
mov [rbp+var_8], rdx
mov [rcx], al
cmp al, 0
jnz short loc_78ED9
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_8], rax
lea rax, [rbp+var_30]
mov [rbp+var_100], rax
mov eax, [rbp+var_30]
mov [rbp+var_F4], eax
cmp eax, 28h ; '('
ja short loc_78F57
mov rcx, [rbp+var_100]
mov edx, [rbp+var_F4]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_108], rax
jmp short loc_78F74
loc_78F57:
mov rcx, [rbp+var_100]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_108], rax
loc_78F74:
mov rax, [rbp+var_108]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_78ECC
loc_78F87:
jmp short $+2
loc_78F89:
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
|
_BYTE * strxnmov(
_BYTE *a1,
long long a2,
_BYTE *a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
_BYTE *v15; // rax
_BYTE *v16; // rcx
char *v17; // rax
char v19; // [rsp+18h] [rbp-F0h] BYREF
long long v20; // [rsp+30h] [rbp-D8h]
long long v21; // [rsp+38h] [rbp-D0h]
long long v22; // [rsp+40h] [rbp-C8h]
__m128 v23; // [rsp+48h] [rbp-C0h]
__m128 v24; // [rsp+58h] [rbp-B0h]
__m128 v25; // [rsp+68h] [rbp-A0h]
__m128 v26; // [rsp+78h] [rbp-90h]
__m128 v27; // [rsp+88h] [rbp-80h]
__m128 v28; // [rsp+98h] [rbp-70h]
__m128 v29; // [rsp+A8h] [rbp-60h]
__m128 v30; // [rsp+B8h] [rbp-50h]
_BYTE *v31; // [rsp+D0h] [rbp-38h]
int v32; // [rsp+D8h] [rbp-30h]
int v33; // [rsp+DCh] [rbp-2Ch]
char *v34; // [rsp+E0h] [rbp-28h]
char *v35; // [rsp+E8h] [rbp-20h]
_BYTE *v36; // [rsp+F0h] [rbp-18h]
long long v37; // [rsp+F8h] [rbp-10h]
_BYTE *v38; // [rsp+100h] [rbp-8h]
v23 = a7;
v24 = a8;
v25 = a9;
v26 = a10;
v27 = a11;
v28 = a12;
v29 = a13;
v30 = a14;
v22 = a6;
v21 = a5;
v20 = a4;
v38 = a1;
v37 = a2;
v36 = a3;
v31 = &a1[a2];
v35 = &v19;
v34 = &a15;
v33 = 48;
v32 = 24;
LABEL_2:
if ( v36 )
{
while ( v38 != v31 )
{
v15 = v36++;
LOBYTE(v15) = *v15;
v16 = v38++;
*v16 = (_BYTE)v15;
if ( !(_BYTE)v15 )
{
--v38;
if ( (unsigned int)v32 > 0x28 )
{
v17 = v34;
v34 += 8;
}
else
{
v17 = &v35[v32];
v32 += 8;
}
v36 = *(_BYTE **)v17;
goto LABEL_2;
}
}
}
*v38 = 0;
return v38;
}
|
strxnmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
TEST AL,AL
JZ 0x00178e7b
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVAPS xmmword ptr [RBP + -0xb0],XMM1
MOVAPS xmmword ptr [RBP + -0xa0],XMM2
MOVAPS xmmword ptr [RBP + -0x90],XMM3
MOVAPS xmmword ptr [RBP + -0x80],XMM4
MOVAPS xmmword ptr [RBP + -0x70],XMM5
MOVAPS xmmword ptr [RBP + -0x60],XMM6
MOVAPS xmmword ptr [RBP + -0x50],XMM7
LAB_00178e7b:
MOV qword ptr [RBP + -0xc8],R9
MOV qword ptr [RBP + -0xd0],R8
MOV qword ptr [RBP + -0xd8],RCX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xf0]
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],0x18
LAB_00178ecc:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00178f87
JMP 0x00178ed9
LAB_00178ed9:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x00178ee8
JMP 0x00178f89
LAB_00178ee8:
JMP 0x00178eea
LAB_00178eea:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RCX],AL
CMP AL,0x0
JNZ 0x00178ed9
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + -0x30]
MOV qword ptr [RBP + -0x100],RAX
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0xf4],EAX
CMP EAX,0x28
JA 0x00178f57
MOV RCX,qword ptr [RBP + -0x100]
MOV EDX,dword ptr [RBP + -0xf4]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x108],RAX
JMP 0x00178f74
LAB_00178f57:
MOV RCX,qword ptr [RBP + -0x100]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x108],RAX
LAB_00178f74:
MOV RAX,qword ptr [RBP + -0x108]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00178ecc
LAB_00178f87:
JMP 0x00178f89
LAB_00178f89:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
char * strxnmov(char *param_1,long param_2,char *param_3)
{
char cVar1;
char *pcVar2;
int8 *local_110;
int8 local_f8 [24];
uint local_38;
int8 *local_30;
char *local_20;
char *local_10;
local_30 = (int8 *)&stack0x00000008;
local_38 = 0x18;
local_20 = param_3;
local_10 = param_1;
while (pcVar2 = local_10, local_20 != (char *)0x0) {
do {
local_10 = pcVar2;
if (local_10 == param_1 + param_2) goto LAB_00178f89;
cVar1 = *local_20;
*local_10 = cVar1;
local_20 = local_20 + 1;
pcVar2 = local_10 + 1;
} while (cVar1 != '\0');
if (local_38 < 0x29) {
local_110 = (int8 *)((long)local_f8 + (long)(int)local_38);
local_38 = local_38 + 8;
}
else {
local_110 = local_30;
local_30 = local_30 + 1;
}
local_20 = (char *)*local_110;
}
LAB_00178f89:
*local_10 = '\0';
return local_10;
}
|
|
16,085
|
ma_search_no_save
|
eloqsql/storage/maria/ma_search.c
|
static int _ma_search_no_save(register MARIA_HA *info, MARIA_KEY *key,
uint32 nextflag, register my_off_t pos,
MARIA_PINNED_PAGE **res_page_link,
uchar **res_page_buff)
{
my_bool last_key_not_used, buff_alloced;
int error,flag;
uint page_flag, nod_flag, used_length;
uchar *keypos,*maxpos;
uchar *lastkey;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_PAGE page;
MARIA_PINNED_PAGE *page_link;
DBUG_ENTER("_ma_search");
DBUG_PRINT("enter",("page: %lu nextflag: %u lastpos: %lu",
(ulong) (pos / info->s->block_size),
nextflag, (ulong) info->cur_row.lastpos));
DBUG_EXECUTE("key", _ma_print_key(DBUG_FILE, key););
DBUG_ASSERT(info->last_key.keyinfo == key->keyinfo);
if (pos == HA_OFFSET_ERROR)
{
my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
info->cur_row.lastpos= HA_OFFSET_ERROR;
if (!(nextflag & (SEARCH_SMALLER | SEARCH_BIGGER | SEARCH_LAST)))
DBUG_RETURN(-1); /* Not found ; return error */
DBUG_RETURN(1); /* Search at upper levels */
}
alloc_on_stack(*info->stack_end_ptr, lastkey, buff_alloced,
keyinfo->max_store_length);
if (!lastkey)
DBUG_RETURN(1);
if (_ma_fetch_keypage(&page, info, keyinfo, pos,
PAGECACHE_LOCK_READ, DFLT_INIT_HITS, 0, 0))
goto err;
page_link= dynamic_element(&info->pinned_pages,
info->pinned_pages.elements-1,
MARIA_PINNED_PAGE*);
DBUG_DUMP("page", page.buff, page.size);
flag= (*keyinfo->bin_search)(key, &page, nextflag, &keypos, lastkey,
&last_key_not_used);
if (flag == MARIA_FOUND_WRONG_KEY)
{
_ma_print_error(info, HA_ERR_CRASHED, 0);
my_errno= HA_ERR_CRASHED;
goto err;
}
page_flag= page.flag;
used_length= page.size;
nod_flag= page.node;
maxpos= page.buff + used_length -1;
if (flag)
{
if ((error= _ma_search_no_save(info, key, nextflag,
_ma_kpos(nod_flag,keypos),
res_page_link, res_page_buff)) <= 0)
goto ret_error;
error= 1; /* Default return value */
if (flag >0)
{
if (nextflag & (SEARCH_SMALLER | SEARCH_LAST) &&
keypos == page.buff + info->s->keypage_header + nod_flag)
goto ret_error; /* Bigger than key */
}
else if (nextflag & SEARCH_BIGGER && keypos >= maxpos)
goto ret_error; /* Smaller than key */
}
else
{
/* Found matching key */
if ((nextflag & SEARCH_FIND) && nod_flag &&
((keyinfo->flag & (HA_NOSAME | HA_NULL_PART)) != HA_NOSAME ||
(key->flag & SEARCH_PART_KEY) || info->s->base.born_transactional))
{
if ((error= _ma_search_no_save(info, key, (nextflag | SEARCH_FIND) &
~(SEARCH_BIGGER | SEARCH_SMALLER |
SEARCH_LAST),
_ma_kpos(nod_flag,keypos),
res_page_link, res_page_buff)) >= 0 ||
my_errno != HA_ERR_KEY_NOT_FOUND)
goto ret_error;
}
}
if ((nextflag & (SEARCH_SMALLER | SEARCH_LAST)) && flag != 0)
{
uint not_used[2];
if (_ma_get_prev_key(&info->last_key, &page, keypos))
goto err;
/*
We have to use key->flag >> 1 here to transform
SEARCH_PAGE_KEY_HAS_TRANSID to SEARCH_USER_KEY_HAS_TRANSID
*/
if (!(nextflag & SEARCH_SMALLER) &&
ha_key_cmp(keyinfo->seg, info->last_key.data, key->data,
key->data_length + key->ref_length,
SEARCH_FIND | (key->flag >> 1) | info->last_key.flag,
not_used))
{
my_errno=HA_ERR_KEY_NOT_FOUND; /* Didn't find key */
goto err;
}
}
else
{
/* Set info->last_key to temporarily point to last key value */
info->last_key.data= lastkey;
/* Get key value (if not packed key) and position after key */
if (!(*keyinfo->get_key)(&info->last_key, page_flag, nod_flag, &keypos))
goto err;
memcpy(info->lastkey_buff, lastkey,
info->last_key.data_length + info->last_key.ref_length);
info->last_key.data= info->lastkey_buff;
}
info->cur_row.lastpos= _ma_row_pos_from_key(&info->last_key);
info->cur_row.trid= _ma_trid_from_key(&info->last_key);
/* Store offset to key */
info->keypos_offset= (uint) (keypos - page.buff);
info->maxpos_offset= (uint) (maxpos - page.buff);
info->int_nod_flag= nod_flag;
info->last_keypage= pos;
*res_page_link= page_link;
*res_page_buff= page.buff;
stack_alloc_free(lastkey, buff_alloced);
DBUG_PRINT("exit",("found key at %lu",(ulong) info->cur_row.lastpos));
DBUG_RETURN(0);
err:
DBUG_PRINT("exit",("Error: %d",my_errno));
info->cur_row.lastpos= HA_OFFSET_ERROR;
info->page_changed=1;
error= -1;
ret_error:
stack_alloc_free(lastkey, buff_alloced);
DBUG_RETURN(error);
}
|
O3
|
c
|
ma_search_no_save:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %r15d
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rcx
je 0x6dbc6
movq %r9, %r14
movq %r8, %r12
movq %rsi, -0x50(%rbp)
movq 0x8(%rsi), %rax
movq %rax, -0x68(%rbp)
movzwl 0xb0(%rax), %esi
leaq -0xc0(%rbp), %rdx
movq %rsi, (%rdx)
movq 0x78(%rbx), %rax
movq (%rax), %rax
subq %rdx, %rax
subq %rsi, %rax
jbe 0x6dad8
cmpq $0x10000, %rax # imm = 0x10000
ja 0x6daba
cmpl $0x1000, %esi # imm = 0x1000
jb 0x6dad8
cmpq $0x8001, %rax # imm = 0x8001
jb 0x6dad8
movq %r12, -0x58(%rbp)
movq %r14, -0x60(%rbp)
movq %rsp, %r13
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %r13
movq %r13, %rsp
movb $0x1, %al
movl %eax, -0x44(%rbp)
jmp 0x6db05
movq %rcx, %r13
movl $0x0, -0x44(%rbp)
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0xa46f9
testq %rax, %rax
je 0x6dbf3
movq %r12, -0x58(%rbp)
movq %r14, -0x60(%rbp)
movq %r13, %rcx
movq %rax, %r13
leaq -0xc0(%rbp), %rdi
movq %rbx, %rsi
movq -0x68(%rbp), %r12
movq %r12, %rdx
movq %rcx, %r14
movl $0x3, %r8d
movl $0x3, %r9d
pushq $0x0
pushq $0x0
callq 0x7095e
addq $0x10, %rsp
testb %al, %al
jne 0x6db9e
movq %r14, -0x88(%rbp)
movl 0x2f0(%rbx), %eax
decl %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq 0x2e8(%rbx), %rax
movq %rax, -0x80(%rbp)
leaq -0xc0(%rbp), %rsi
leaq -0x40(%rbp), %rcx
leaq -0x45(%rbp), %r9
movq -0x50(%rbp), %rdi
movl %r15d, %edx
movq %r13, %r8
callq *0xd8(%r12)
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jne 0x6dc1e
movq %rbx, %rdi
movl $0x7e, %esi
xorl %edx, %edx
callq 0x4050e
callq 0xa63fe
movl $0x7e, (%rax)
movq $-0x1, 0x98(%rbx)
movb $0x1, 0x684(%rbx)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpb $0x0, -0x44(%rbp)
jne 0x6dbf9
movq %r13, %rdi
callq 0xa4926
jmp 0x6dbf9
callq 0xa63fe
movl $0x78, (%rax)
movq $-0x1, 0x98(%rbx)
andl $0x118, %r15d # imm = 0x118
xorl %r12d, %r12d
cmpl $0x1, %r15d
sbbl %r12d, %r12d
orl $0x1, %r12d
jmp 0x6dbf9
movl $0x1, %r12d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6dec6
movl %r12d, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
movl -0x94(%rbp), %esi
movl -0xa0(%rbp), %eax
movl -0x98(%rbp), %edx
movq -0xb0(%rbp), %rcx
addq %rcx, %rax
decq %rax
movq %rax, -0x78(%rbp)
testl %r14d, %r14d
movq %rdx, -0x70(%rbp)
je 0x6dcc2
movl %esi, -0x34(%rbp)
movq -0x40(%rbp), %rsi
movl %edx, %edi
callq 0x6e96f
movq %rbx, %rdi
movq -0x50(%rbp), %rsi
movl %r15d, %edx
movq %rax, %rcx
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
callq 0x6da3f
testl %eax, %eax
jle 0x6dd3a
testl %r14d, %r14d
jle 0x6dd42
testl $0x110, %r15d # imm = 0x110
movq -0x70(%rbp), %rdx
movl -0x34(%rbp), %esi
je 0x6de04
movq (%rbx), %rax
movl 0x744(%rax), %eax
addq -0xb0(%rbp), %rax
addq %rdx, %rax
cmpq %rax, -0x40(%rbp)
jne 0x6dd70
movl $0x1, %r12d
jmp 0x6dbb6
testl %edx, %edx
setne %al
andb %r15b, %al
cmpb $0x1, %al
jne 0x6de04
movq -0x68(%rbp), %rax
movzwl 0xa2(%rax), %eax
andl $0x11, %eax
cmpw $0x1, %ax
jne 0x6dd00
movq -0x50(%rbp), %rax
testb $0x4, 0x1a(%rax)
jne 0x6dd00
movq (%rbx), %rax
cmpb $0x0, 0x44c(%rax)
je 0x6de04
movl %esi, -0x34(%rbp)
andl $0xfffffee7, %r15d # imm = 0xFFFFFEE7
movq -0x40(%rbp), %rsi
movl %edx, %edi
movq %rdx, %r14
callq 0x6e96f
movq %rbx, %rdi
movq -0x50(%rbp), %rsi
movl %r15d, %edx
movq %rax, %rcx
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
callq 0x6da3f
testl %eax, %eax
js 0x6ddea
movl %eax, %r12d
jmp 0x6dbb6
testb $0x8, %r15b
movq -0x70(%rbp), %rdx
movl -0x34(%rbp), %esi
je 0x6dd63
movl $0x1, %r12d
movq -0x78(%rbp), %rax
cmpq %rax, -0x40(%rbp)
jae 0x6dbb6
testl $0x110, %r15d # imm = 0x110
je 0x6de04
leaq 0x200(%rbx), %rdi
movq -0x40(%rbp), %rdx
leaq -0xc0(%rbp), %rsi
callq 0x7081b
testb %al, %al
jne 0x6db9e
testb $0x10, %r15b
jne 0x6de51
movq -0x68(%rbp), %rax
movq 0xc0(%rax), %rdi
movq 0x200(%rbx), %rsi
movq -0x50(%rbp), %rax
movq (%rax), %rdx
movl 0x14(%rax), %ecx
addl 0x10(%rax), %ecx
movl 0x18(%rax), %r8d
shrl %r8d
orl 0x218(%rbx), %r8d
orl $0x1, %r8d
leaq -0xc8(%rbp), %r9
callq 0xa316a
testl %eax, %eax
je 0x6de51
callq 0xa63fe
movl $0x78, (%rax)
jmp 0x6db9e
callq 0xa63fe
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
cmpl $0x78, (%rax)
movq %r14, %rdx
movl -0x34(%rbp), %esi
jne 0x6dbb6
leaq 0x200(%rbx), %rdi
movq %r13, 0x200(%rbx)
leaq -0x40(%rbp), %rcx
movq -0x68(%rbp), %rax
callq *0xe0(%rax)
testl %eax, %eax
je 0x6db9e
movq 0x388(%rbx), %rdi
movl 0x214(%rbx), %edx
addl 0x210(%rbx), %edx
movq %r13, %rsi
callq 0x2a0a0
movq 0x388(%rbx), %rax
movq %rax, 0x200(%rbx)
leaq 0x200(%rbx), %r14
movq %r14, %rdi
callq 0x6ead4
movq %rax, 0x98(%rbx)
movq %r14, %rdi
callq 0x6eb8c
movq %rax, 0xc0(%rbx)
movl -0x40(%rbp), %eax
movq -0xb0(%rbp), %rcx
subl %ecx, %eax
movl %eax, 0x3c0(%rbx)
movq -0x78(%rbp), %rax
subl %ecx, %eax
movl %eax, 0x3c4(%rbx)
movq -0x70(%rbp), %rax
movl %eax, 0x3d0(%rbx)
movq -0x88(%rbp), %rax
movq %rax, 0x440(%rbx)
movq -0x58(%rbp), %rax
movq -0x80(%rbp), %rdx
movq %rdx, (%rax)
movq -0x60(%rbp), %rax
movq %rcx, (%rax)
xorl %r12d, %r12d
jmp 0x6dbb6
callq 0x2a240
|
_ma_search_no_save:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov r15d, edx
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz loc_6DBC6
mov r14, r9
mov r12, r8
mov [rbp+var_50], rsi
mov rax, [rsi+8]
mov [rbp+var_68], rax
movzx esi, word ptr [rax+0B0h]
lea rdx, [rbp+var_C0]
mov [rdx], rsi
mov rax, [rbx+78h]
mov rax, [rax]
sub rax, rdx
sub rax, rsi
jbe short loc_6DAD8
cmp rax, 10000h
ja short loc_6DABA
cmp esi, 1000h
jb short loc_6DAD8
cmp rax, 8001h
jb short loc_6DAD8
loc_6DABA:
mov [rbp+var_58], r12
mov [rbp+var_60], r14
mov r13, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub r13, rsi
mov rsp, r13
mov al, 1
mov [rbp+var_44], eax
jmp short loc_6DB05
loc_6DAD8:
mov r13, rcx
mov [rbp+var_44], 0
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_6DBF3
mov [rbp+var_58], r12
mov [rbp+var_60], r14
mov rcx, r13
mov r13, rax
loc_6DB05:
lea rdi, [rbp+var_C0]
mov rsi, rbx
mov r12, [rbp+var_68]
mov rdx, r12
mov r14, rcx
mov r8d, 3
mov r9d, 3
push 0
push 0
call _ma_fetch_keypage
add rsp, 10h
test al, al
jnz short loc_6DB9E
mov [rbp+var_88], r14
mov eax, [rbx+2F0h]
dec eax
lea rax, [rax+rax*2]
shl rax, 3
add rax, [rbx+2E8h]
mov [rbp+var_80], rax
lea rsi, [rbp+var_C0]
lea rcx, [rbp+var_40]
lea r9, [rbp+var_45]
mov rdi, [rbp+var_50]
mov edx, r15d
mov r8, r13
call qword ptr [r12+0D8h]
cmp eax, 7FFFFFFFh
jnz loc_6DC1E
mov rdi, rbx
mov esi, 7Eh ; '~'
xor edx, edx
call _ma_print_error
call _my_thread_var
mov dword ptr [rax], 7Eh ; '~'
loc_6DB9E:
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
mov byte ptr [rbx+684h], 1
mov r12d, 0FFFFFFFFh
loc_6DBB6:
cmp byte ptr [rbp+var_44], 0
jnz short loc_6DBF9
mov rdi, r13
call my_free
jmp short loc_6DBF9
loc_6DBC6:
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
mov qword ptr [rbx+98h], 0FFFFFFFFFFFFFFFFh
and r15d, 118h
xor r12d, r12d
cmp r15d, 1
sbb r12d, r12d
or r12d, 1
jmp short loc_6DBF9
loc_6DBF3:
mov r12d, 1
loc_6DBF9:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_6DEC6
mov eax, r12d
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6DC1E:
mov r14d, eax
mov esi, [rbp+var_94]
mov eax, [rbp+var_A0]
mov edx, [rbp+var_98]
mov rcx, [rbp+var_B0]
add rax, rcx
dec rax
mov [rbp+var_78], rax
test r14d, r14d
mov [rbp+var_70], rdx
jz short loc_6DCC2
mov [rbp+var_34], esi
mov rsi, [rbp+var_40]
mov edi, edx
call _ma_kpos
mov rdi, rbx
mov rsi, [rbp+var_50]
mov edx, r15d
mov rcx, rax
mov r8, [rbp+var_58]
mov r9, [rbp+var_60]
call _ma_search_no_save
test eax, eax
jle loc_6DD3A
test r14d, r14d
jle loc_6DD42
test r15d, 110h
mov rdx, [rbp+var_70]
mov esi, [rbp+var_34]
jz loc_6DE04
mov rax, [rbx]
mov eax, [rax+744h]
add rax, [rbp+var_B0]
add rax, rdx
cmp [rbp+var_40], rax
jnz loc_6DD70
mov r12d, 1
jmp loc_6DBB6
loc_6DCC2:
test edx, edx
setnz al
and al, r15b
cmp al, 1
jnz loc_6DE04
mov rax, [rbp+var_68]
movzx eax, word ptr [rax+0A2h]
and eax, 11h
cmp ax, 1
jnz short loc_6DD00
mov rax, [rbp+var_50]
test byte ptr [rax+1Ah], 4
jnz short loc_6DD00
mov rax, [rbx]
cmp byte ptr [rax+44Ch], 0
jz loc_6DE04
loc_6DD00:
mov [rbp+var_34], esi
and r15d, 0FFFFFEE7h
mov rsi, [rbp+var_40]
mov edi, edx
mov r14, rdx
call _ma_kpos
mov rdi, rbx
mov rsi, [rbp+var_50]
mov edx, r15d
mov rcx, rax
mov r8, [rbp+var_58]
mov r9, [rbp+var_60]
call _ma_search_no_save
test eax, eax
js loc_6DDEA
loc_6DD3A:
mov r12d, eax
jmp loc_6DBB6
loc_6DD42:
test r15b, 8
mov rdx, [rbp+var_70]
mov esi, [rbp+var_34]
jz short loc_6DD63
mov r12d, 1
mov rax, [rbp+var_78]
cmp [rbp+var_40], rax
jnb loc_6DBB6
loc_6DD63:
test r15d, 110h
jz loc_6DE04
loc_6DD70:
lea rdi, [rbx+200h]
mov rdx, [rbp+var_40]
lea rsi, [rbp+var_C0]
call _ma_get_prev_key
test al, al
jnz loc_6DB9E
test r15b, 10h
jnz loc_6DE51
mov rax, [rbp+var_68]
mov rdi, [rax+0C0h]
mov rsi, [rbx+200h]
mov rax, [rbp+var_50]
mov rdx, [rax]
mov ecx, [rax+14h]
add ecx, [rax+10h]
mov r8d, [rax+18h]
shr r8d, 1
or r8d, [rbx+218h]
or r8d, 1
lea r9, [rbp+var_C8]
call ha_key_cmp
test eax, eax
jz short loc_6DE51
call _my_thread_var
mov dword ptr [rax], 78h ; 'x'
jmp loc_6DB9E
loc_6DDEA:
call _my_thread_var
mov r12d, 0FFFFFFFFh
cmp dword ptr [rax], 78h ; 'x'
mov rdx, r14
mov esi, [rbp+var_34]
jnz loc_6DBB6
loc_6DE04:
lea rdi, [rbx+200h]
mov [rbx+200h], r13
lea rcx, [rbp+var_40]
mov rax, [rbp+var_68]
call qword ptr [rax+0E0h]
test eax, eax
jz loc_6DB9E
mov rdi, [rbx+388h]
mov edx, [rbx+214h]
add edx, [rbx+210h]
mov rsi, r13
call _memcpy
mov rax, [rbx+388h]
mov [rbx+200h], rax
loc_6DE51:
lea r14, [rbx+200h]
mov rdi, r14
call _ma_row_pos_from_key
mov [rbx+98h], rax
mov rdi, r14
call _ma_trid_from_key
mov [rbx+0C0h], rax
mov eax, dword ptr [rbp+var_40]
mov rcx, [rbp+var_B0]
sub eax, ecx
mov [rbx+3C0h], eax
mov rax, [rbp+var_78]
sub eax, ecx
mov [rbx+3C4h], eax
mov rax, [rbp+var_70]
mov [rbx+3D0h], eax
mov rax, [rbp+var_88]
mov [rbx+440h], rax
mov rax, [rbp+var_58]
mov rdx, [rbp+var_80]
mov [rax], rdx
mov rax, [rbp+var_60]
mov [rax], rcx
xor r12d, r12d
jmp loc_6DBB6
loc_6DEC6:
call ___stack_chk_fail
|
long long ma_search_no_save(long long a1, long long a2, unsigned int a3, long long a4, long long *a5, _QWORD *a6)
{
unsigned long long v10; // rsi
unsigned long long v11; // rax
bool v12; // cc
unsigned long long v13; // rax
char *v14; // r13
long long v15; // r13
long long v16; // rax
long long v17; // r12
long long v18; // r14
int v19; // eax
long long v20; // rcx
long long v21; // r8
int v22; // r9d
unsigned int v23; // r12d
int v25; // r14d
long long v26; // rsi
long long v27; // rdx
long long v28; // rax
int v29; // eax
long long v30; // r14
long long v31; // rax
const char *v32; // rsi
long long v33; // rdi
const char *v34; // rsi
_DWORD *v35; // rax
long long v36; // rcx
char v38[8]; // [rsp+8h] [rbp-C8h] BYREF
_QWORD v39[2]; // [rsp+10h] [rbp-C0h] BYREF
long long v40; // [rsp+20h] [rbp-B0h]
unsigned int v41; // [rsp+30h] [rbp-A0h]
unsigned int v42; // [rsp+38h] [rbp-98h]
unsigned int v43; // [rsp+3Ch] [rbp-94h]
long long v44; // [rsp+48h] [rbp-88h]
long long v45; // [rsp+50h] [rbp-80h]
unsigned long long v46; // [rsp+58h] [rbp-78h]
long long v47; // [rsp+60h] [rbp-70h]
long long v48; // [rsp+68h] [rbp-68h]
_QWORD *v49; // [rsp+70h] [rbp-60h]
long long *v50; // [rsp+78h] [rbp-58h]
_QWORD *v51; // [rsp+80h] [rbp-50h]
char v52; // [rsp+8Bh] [rbp-45h] BYREF
int v53; // [rsp+8Ch] [rbp-44h]
unsigned long long v54; // [rsp+90h] [rbp-40h] BYREF
unsigned int v55; // [rsp+9Ch] [rbp-34h]
unsigned long long v56; // [rsp+A0h] [rbp-30h]
v56 = __readfsqword(0x28u);
if ( a4 == -1 )
{
*(_DWORD *)my_thread_var(a1, (const char *)a2) = 120;
*(_QWORD *)(a1 + 152) = -1LL;
return (a3 & 0x118) == 0 ? -1 : 1;
}
v51 = (_QWORD *)a2;
v48 = *(_QWORD *)(a2 + 8);
v10 = *(unsigned __int16 *)(v48 + 176);
v39[0] = v10;
v11 = **(_QWORD **)(a1 + 120) - (_QWORD)v39;
v12 = v11 <= v10;
v13 = v11 - v10;
if ( v12 || v13 <= 0x10000 && ((unsigned int)v10 < 0x1000 || v13 < 0x8001) )
{
v15 = a4;
v53 = 0;
v16 = my_malloc(0LL, v10, 65552LL);
if ( !v16 )
return 1;
v50 = a5;
v49 = a6;
a4 = v15;
v14 = (char *)v16;
}
else
{
v50 = a5;
v49 = a6;
v14 = &v38[-(((_DWORD)v10 + 15) & 0xFFFFFFF0) - 8];
LOBYTE(v13) = 1;
v53 = v13;
}
v17 = v48;
v18 = a4;
if ( (unsigned __int8)ma_fetch_keypage((unsigned int)v39, a1, v48, a4, 3, 3, 0LL) )
goto LABEL_12;
v44 = v18;
v45 = *(_QWORD *)(a1 + 744) + 24LL * (unsigned int)(*(_DWORD *)(a1 + 752) - 1);
v19 = (*(long long ( **)(_QWORD *, _QWORD *, _QWORD, unsigned long long *, char *, char *))(v17 + 216))(
v51,
v39,
a3,
&v54,
v14,
&v52);
if ( v19 == 0x7FFFFFFF )
{
ma_print_error((_DWORD *)a1, 126, 0, v20, v21, v22);
*(_DWORD *)my_thread_var(a1, (_BYTE *)&dword_7C + 2) = 126;
LABEL_12:
*(_QWORD *)(a1 + 152) = -1LL;
*(_BYTE *)(a1 + 1668) = 1;
v23 = -1;
goto LABEL_13;
}
v25 = v19;
v26 = v43;
v27 = v42;
v46 = v40 + v41 - 1;
v47 = v42;
if ( !v19 )
{
if ( ((unsigned __int8)a3 & (v42 != 0)) != 1
|| (*(_WORD *)(v48 + 162) & 0x11) == 1 && (*((_BYTE *)v51 + 26) & 4) == 0 && !*(_BYTE *)(*(_QWORD *)a1 + 1100LL) )
{
goto LABEL_38;
}
v55 = v43;
v30 = v42;
v31 = ma_kpos(v42, v54);
v32 = (const char *)v51;
v29 = ma_search_no_save(a1, v51, a3 & 0xFFFFFEE7, v31, v50, v49);
if ( v29 < 0 )
{
v35 = (_DWORD *)my_thread_var(a1, v32);
v23 = -1;
v27 = v30;
v26 = v55;
if ( *v35 != 120 )
goto LABEL_13;
goto LABEL_38;
}
LABEL_29:
v23 = v29;
goto LABEL_13;
}
v55 = v43;
v28 = ma_kpos(v42, v54);
v29 = ma_search_no_save(a1, v51, a3, v28, v50, v49);
if ( v29 <= 0 )
goto LABEL_29;
if ( v25 > 0 )
{
v27 = v47;
v26 = v55;
if ( (a3 & 0x110) != 0 )
{
if ( v54 == v47 + v40 + *(unsigned int *)(*(_QWORD *)a1 + 1860LL) )
{
v23 = 1;
goto LABEL_13;
}
goto LABEL_33;
}
goto LABEL_38;
}
v27 = v47;
v26 = v55;
if ( (a3 & 8) == 0 || (v23 = 1, v54 < v46) )
{
if ( (a3 & 0x110) != 0 )
{
LABEL_33:
if ( (unsigned __int8)ma_get_prev_key(a1 + 512, v39, v54) )
goto LABEL_12;
if ( (a3 & 0x10) == 0 )
{
v33 = *(_QWORD *)(v48 + 192);
v34 = *(const char **)(a1 + 512);
if ( (unsigned int)ha_key_cmp(
v33,
v34,
*v51,
(unsigned int)(*((_DWORD *)v51 + 4) + *((_DWORD *)v51 + 5)),
*(_DWORD *)(a1 + 536) | (*((_DWORD *)v51 + 6) >> 1) | 1u,
v38) )
{
*(_DWORD *)my_thread_var(v33, v34) = 120;
goto LABEL_12;
}
}
goto LABEL_40;
}
LABEL_38:
*(_QWORD *)(a1 + 512) = v14;
if ( !(*(unsigned int ( **)(long long, long long, long long, unsigned long long *))(v48 + 224))(
a1 + 512,
v26,
v27,
&v54) )
goto LABEL_12;
memcpy(*(_QWORD *)(a1 + 904), v14, (unsigned int)(*(_DWORD *)(a1 + 528) + *(_DWORD *)(a1 + 532)));
*(_QWORD *)(a1 + 512) = *(_QWORD *)(a1 + 904);
LABEL_40:
*(_QWORD *)(a1 + 152) = ma_row_pos_from_key(a1 + 512);
*(_QWORD *)(a1 + 192) = ma_trid_from_key(a1 + 512);
v36 = v40;
*(_DWORD *)(a1 + 960) = v54 - v40;
*(_DWORD *)(a1 + 964) = v46 - v36;
*(_DWORD *)(a1 + 976) = v47;
*(_QWORD *)(a1 + 1088) = v44;
*v50 = v45;
*v49 = v36;
v23 = 0;
}
LABEL_13:
if ( !(_BYTE)v53 )
my_free(v14);
return v23;
}
|
_ma_search_no_save:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV R15D,EDX
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP RCX,-0x1
JZ 0x0016dbc6
MOV R14,R9
MOV R12,R8
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RBP + -0x68],RAX
MOVZX ESI,word ptr [RAX + 0xb0]
LEA RDX,[RBP + -0xc0]
MOV qword ptr [RDX],RSI
MOV RAX,qword ptr [RBX + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RDX
SUB RAX,RSI
JBE 0x0016dad8
CMP RAX,0x10000
JA 0x0016daba
CMP ESI,0x1000
JC 0x0016dad8
CMP RAX,0x8001
JC 0x0016dad8
LAB_0016daba:
MOV qword ptr [RBP + -0x58],R12
MOV qword ptr [RBP + -0x60],R14
MOV R13,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB R13,RSI
MOV RSP,R13
MOV AL,0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0016db05
LAB_0016dad8:
MOV R13,RCX
MOV dword ptr [RBP + -0x44],0x0
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x001a46f9
TEST RAX,RAX
JZ 0x0016dbf3
MOV qword ptr [RBP + -0x58],R12
MOV qword ptr [RBP + -0x60],R14
MOV RCX,R13
MOV R13,RAX
LAB_0016db05:
LEA RDI,[RBP + -0xc0]
MOV RSI,RBX
MOV R12,qword ptr [RBP + -0x68]
MOV RDX,R12
MOV R14,RCX
MOV R8D,0x3
MOV R9D,0x3
PUSH 0x0
PUSH 0x0
CALL 0x0017095e
ADD RSP,0x10
TEST AL,AL
JNZ 0x0016db9e
MOV qword ptr [RBP + -0x88],R14
MOV EAX,dword ptr [RBX + 0x2f0]
DEC EAX
LEA RAX,[RAX + RAX*0x2]
SHL RAX,0x3
ADD RAX,qword ptr [RBX + 0x2e8]
MOV qword ptr [RBP + -0x80],RAX
LEA RSI,[RBP + -0xc0]
LEA RCX,[RBP + -0x40]
LEA R9,[RBP + -0x45]
MOV RDI,qword ptr [RBP + -0x50]
MOV EDX,R15D
MOV R8,R13
CALL qword ptr [R12 + 0xd8]
CMP EAX,0x7fffffff
JNZ 0x0016dc1e
MOV RDI,RBX
MOV ESI,0x7e
XOR EDX,EDX
CALL 0x0014050e
CALL 0x001a63fe
MOV dword ptr [RAX],0x7e
LAB_0016db9e:
MOV qword ptr [RBX + 0x98],-0x1
MOV byte ptr [RBX + 0x684],0x1
MOV R12D,0xffffffff
LAB_0016dbb6:
CMP byte ptr [RBP + -0x44],0x0
JNZ 0x0016dbf9
MOV RDI,R13
CALL 0x001a4926
JMP 0x0016dbf9
LAB_0016dbc6:
CALL 0x001a63fe
MOV dword ptr [RAX],0x78
MOV qword ptr [RBX + 0x98],-0x1
AND R15D,0x118
XOR R12D,R12D
CMP R15D,0x1
SBB R12D,R12D
OR R12D,0x1
JMP 0x0016dbf9
LAB_0016dbf3:
MOV R12D,0x1
LAB_0016dbf9:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016dec6
MOV EAX,R12D
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016dc1e:
MOV R14D,EAX
MOV ESI,dword ptr [RBP + -0x94]
MOV EAX,dword ptr [RBP + -0xa0]
MOV EDX,dword ptr [RBP + -0x98]
MOV RCX,qword ptr [RBP + -0xb0]
ADD RAX,RCX
DEC RAX
MOV qword ptr [RBP + -0x78],RAX
TEST R14D,R14D
MOV qword ptr [RBP + -0x70],RDX
JZ 0x0016dcc2
MOV dword ptr [RBP + -0x34],ESI
MOV RSI,qword ptr [RBP + -0x40]
MOV EDI,EDX
CALL 0x0016e96f
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,R15D
MOV RCX,RAX
MOV R8,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x60]
CALL 0x0016da3f
TEST EAX,EAX
JLE 0x0016dd3a
TEST R14D,R14D
JLE 0x0016dd42
TEST R15D,0x110
MOV RDX,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RBP + -0x34]
JZ 0x0016de04
MOV RAX,qword ptr [RBX]
MOV EAX,dword ptr [RAX + 0x744]
ADD RAX,qword ptr [RBP + -0xb0]
ADD RAX,RDX
CMP qword ptr [RBP + -0x40],RAX
JNZ 0x0016dd70
MOV R12D,0x1
JMP 0x0016dbb6
LAB_0016dcc2:
TEST EDX,EDX
SETNZ AL
AND AL,R15B
CMP AL,0x1
JNZ 0x0016de04
MOV RAX,qword ptr [RBP + -0x68]
MOVZX EAX,word ptr [RAX + 0xa2]
AND EAX,0x11
CMP AX,0x1
JNZ 0x0016dd00
MOV RAX,qword ptr [RBP + -0x50]
TEST byte ptr [RAX + 0x1a],0x4
JNZ 0x0016dd00
MOV RAX,qword ptr [RBX]
CMP byte ptr [RAX + 0x44c],0x0
JZ 0x0016de04
LAB_0016dd00:
MOV dword ptr [RBP + -0x34],ESI
AND R15D,0xfffffee7
MOV RSI,qword ptr [RBP + -0x40]
MOV EDI,EDX
MOV R14,RDX
CALL 0x0016e96f
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,R15D
MOV RCX,RAX
MOV R8,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x60]
CALL 0x0016da3f
TEST EAX,EAX
JS 0x0016ddea
LAB_0016dd3a:
MOV R12D,EAX
JMP 0x0016dbb6
LAB_0016dd42:
TEST R15B,0x8
MOV RDX,qword ptr [RBP + -0x70]
MOV ESI,dword ptr [RBP + -0x34]
JZ 0x0016dd63
MOV R12D,0x1
MOV RAX,qword ptr [RBP + -0x78]
CMP qword ptr [RBP + -0x40],RAX
JNC 0x0016dbb6
LAB_0016dd63:
TEST R15D,0x110
JZ 0x0016de04
LAB_0016dd70:
LEA RDI,[RBX + 0x200]
MOV RDX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0xc0]
CALL 0x0017081b
TEST AL,AL
JNZ 0x0016db9e
TEST R15B,0x10
JNZ 0x0016de51
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,qword ptr [RAX + 0xc0]
MOV RSI,qword ptr [RBX + 0x200]
MOV RAX,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x14]
ADD ECX,dword ptr [RAX + 0x10]
MOV R8D,dword ptr [RAX + 0x18]
SHR R8D,0x1
OR R8D,dword ptr [RBX + 0x218]
OR R8D,0x1
LEA R9,[RBP + -0xc8]
CALL 0x001a316a
TEST EAX,EAX
JZ 0x0016de51
CALL 0x001a63fe
MOV dword ptr [RAX],0x78
JMP 0x0016db9e
LAB_0016ddea:
CALL 0x001a63fe
MOV R12D,0xffffffff
CMP dword ptr [RAX],0x78
MOV RDX,R14
MOV ESI,dword ptr [RBP + -0x34]
JNZ 0x0016dbb6
LAB_0016de04:
LEA RDI,[RBX + 0x200]
MOV qword ptr [RBX + 0x200],R13
LEA RCX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x68]
CALL qword ptr [RAX + 0xe0]
TEST EAX,EAX
JZ 0x0016db9e
MOV RDI,qword ptr [RBX + 0x388]
MOV EDX,dword ptr [RBX + 0x214]
ADD EDX,dword ptr [RBX + 0x210]
MOV RSI,R13
CALL 0x0012a0a0
MOV RAX,qword ptr [RBX + 0x388]
MOV qword ptr [RBX + 0x200],RAX
LAB_0016de51:
LEA R14,[RBX + 0x200]
MOV RDI,R14
CALL 0x0016ead4
MOV qword ptr [RBX + 0x98],RAX
MOV RDI,R14
CALL 0x0016eb8c
MOV qword ptr [RBX + 0xc0],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0xb0]
SUB EAX,ECX
MOV dword ptr [RBX + 0x3c0],EAX
MOV RAX,qword ptr [RBP + -0x78]
SUB EAX,ECX
MOV dword ptr [RBX + 0x3c4],EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV dword ptr [RBX + 0x3d0],EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBX + 0x440],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RBP + -0x80]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX],RCX
XOR R12D,R12D
JMP 0x0016dbb6
LAB_0016dec6:
CALL 0x0012a240
|
uint _ma_search_no_save(long *param_1,int8 *param_2,uint param_3,long param_4,long *param_5,
long *param_6)
{
ushort uVar1;
int iVar2;
uint uVar3;
code *pcVar4;
int8 uVar5;
void *__dest;
long *plVar6;
long *plVar7;
int8 *puVar8;
char cVar9;
int iVar10;
uint uVar11;
ulong uVar12;
int1 *__src;
int4 *puVar13;
int8 uVar14;
int *piVar15;
long lVar16;
int1 *puVar17;
int1 *puVar18;
int4 uVar19;
long in_FS_OFFSET;
int1 auStack_d8 [8];
int1 local_d0 [8];
ulong local_c8 [2];
long local_b8;
uint local_a8;
uint local_a0;
int4 local_9c;
long local_90;
long local_88;
ulong local_80;
ulong local_78;
long local_70;
long *local_68;
long *local_60;
int8 *local_58;
int1 local_4d;
int4 local_4c;
int local_48;
int4 uStack_44;
int4 local_3c;
long local_38;
puVar17 = auStack_d8;
puVar18 = auStack_d8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (param_4 == -1) {
puVar13 = (int4 *)_my_thread_var();
*puVar13 = 0x78;
param_1[0x13] = -1;
uVar11 = -(uint)((param_3 & 0x118) == 0) | 1;
goto LAB_0016dbf9;
}
local_70 = param_2[1];
uVar1 = *(ushort *)(local_70 + 0xb0);
local_c8[0] = (ulong)uVar1;
uVar12 = (*(long *)param_1[0xf] - (long)local_c8) - local_c8[0];
local_58 = param_2;
if (((ulong)(*(long *)param_1[0xf] - (long)local_c8) < local_c8[0] || uVar12 == 0) ||
((uVar12 < 0x10001 && ((uVar1 < 0x1000 || (uVar12 < 0x8001)))))) {
local_4c = 0;
__src = (int1 *)my_malloc(0,local_c8[0],0x10010);
if (__src == (int1 *)0x0) {
uVar11 = 1;
puVar18 = auStack_d8;
goto LAB_0016dbf9;
}
}
else {
puVar17 = auStack_d8 + -(ulong)(uVar1 + 0xf & 0xfffffff0);
local_4c = (int4)CONCAT71((int7)(uVar12 >> 8),1);
__src = puVar17;
}
lVar16 = local_70;
local_68 = param_6;
local_60 = param_5;
*(int8 *)(puVar17 + -8) = 0;
*(int8 *)(puVar17 + -0x10) = 0;
*(int8 *)(puVar17 + -0x18) = 0x16db2e;
cVar9 = _ma_fetch_keypage(local_c8,param_1,lVar16,param_4,3,3);
puVar8 = local_58;
if (cVar9 == '\0') {
local_88 = (ulong)((int)param_1[0x5e] - 1) * 0x18 + param_1[0x5d];
pcVar4 = *(code **)(lVar16 + 0xd8);
local_90 = param_4;
*(int8 *)(puVar17 + -8) = 0x16db79;
iVar10 = (*pcVar4)(puVar8,local_c8,param_3,&local_48,__src,&local_4d);
if (iVar10 == 0x7fffffff) {
*(int8 *)(puVar17 + -8) = 0x16db93;
_ma_print_error(param_1,0x7e,0);
*(int8 *)(puVar17 + -8) = 0x16db98;
puVar13 = (int4 *)_my_thread_var();
*puVar13 = 0x7e;
goto LAB_0016db9e;
}
uVar12 = (ulong)local_a0;
local_80 = ((ulong)local_a8 + local_b8) - 1;
local_78 = uVar12;
if (iVar10 == 0) {
uVar19 = local_9c;
if (((local_a0 != 0 & (byte)param_3) != 1) ||
((((*(ushort *)(local_70 + 0xa2) & 0x11) == 1 &&
((*(byte *)((long)local_58 + 0x1a) & 4) == 0)) &&
(uVar19 = local_9c, *(char *)(*param_1 + 0x44c) == '\0')))) goto LAB_0016de04;
local_3c = local_9c;
uVar14 = CONCAT44(uStack_44,local_48);
*(int8 *)(puVar17 + -8) = 0x16dd18;
uVar14 = _ma_kpos(uVar12,uVar14);
puVar8 = local_58;
plVar7 = local_60;
plVar6 = local_68;
*(int8 *)(puVar17 + -8) = 0x16dd32;
uVar11 = _ma_search_no_save(param_1,puVar8,param_3 & 0xfffffee7,uVar14,plVar7,plVar6);
if ((int)uVar11 < 0) {
*(int8 *)(puVar17 + -8) = 0x16ddef;
piVar15 = (int *)_my_thread_var();
uVar11 = 0xffffffff;
uVar19 = local_3c;
if (*piVar15 == 0x78) goto LAB_0016de04;
}
}
else {
local_3c = local_9c;
uVar14 = CONCAT44(uStack_44,local_48);
*(int8 *)(puVar17 + -8) = 0x16dc5b;
uVar14 = _ma_kpos(uVar12,uVar14);
puVar8 = local_58;
plVar7 = local_60;
plVar6 = local_68;
*(int8 *)(puVar17 + -8) = 0x16dc75;
uVar11 = _ma_search_no_save(param_1,puVar8,param_3,uVar14,plVar7,plVar6);
if (0 < (int)uVar11) {
uVar12 = local_78;
uVar19 = local_3c;
if (iVar10 < 1) {
if (((param_3 & 8) == 0) || (uVar11 = 1, CONCAT44(uStack_44,local_48) < local_80)) {
if ((param_3 & 0x110) != 0) goto LAB_0016dd70;
goto LAB_0016de04;
}
}
else {
if ((param_3 & 0x110) == 0) {
LAB_0016de04:
param_1[0x40] = (long)__src;
pcVar4 = *(code **)(local_70 + 0xe0);
*(int8 *)(puVar17 + -8) = 0x16de20;
iVar10 = (*pcVar4)(param_1 + 0x40,uVar19,uVar12,&local_48);
if (iVar10 == 0) goto LAB_0016db9e;
__dest = (void *)param_1[0x71];
iVar10 = *(int *)((long)param_1 + 0x214);
lVar16 = param_1[0x42];
*(int8 *)(puVar17 + -8) = 0x16de43;
memcpy(__dest,__src,(ulong)(uint)(iVar10 + (int)lVar16));
param_1[0x40] = param_1[0x71];
}
else {
if (CONCAT44(uStack_44,local_48) ==
(ulong)*(uint *)(*param_1 + 0x744) + local_b8 + local_78) {
uVar11 = 1;
goto LAB_0016dbb6;
}
LAB_0016dd70:
uVar14 = CONCAT44(uStack_44,local_48);
*(int8 *)(puVar17 + -8) = 0x16dd87;
cVar9 = _ma_get_prev_key(param_1 + 0x40,local_c8,uVar14);
if (cVar9 != '\0') goto LAB_0016db9e;
if ((param_3 & 0x10) == 0) {
uVar14 = *(int8 *)(local_70 + 0xc0);
lVar16 = param_1[0x40];
uVar5 = *local_58;
iVar10 = *(int *)((long)local_58 + 0x14);
iVar2 = *(int *)(local_58 + 2);
uVar11 = *(uint *)(local_58 + 3);
uVar3 = *(uint *)(param_1 + 0x43);
*(int8 *)(puVar17 + -8) = 0x16ddd6;
iVar10 = ha_key_cmp(uVar14,lVar16,uVar5,iVar10 + iVar2,uVar11 >> 1 | uVar3 | 1,
local_d0);
if (iVar10 != 0) {
*(int8 *)(puVar17 + -8) = 0x16dddf;
puVar13 = (int4 *)_my_thread_var();
*puVar13 = 0x78;
goto LAB_0016db9e;
}
}
}
*(int8 *)(puVar17 + -8) = 0x16de60;
lVar16 = _ma_row_pos_from_key(param_1 + 0x40);
param_1[0x13] = lVar16;
*(int8 *)(puVar17 + -8) = 0x16de6f;
lVar16 = _ma_trid_from_key(param_1 + 0x40);
param_1[0x18] = lVar16;
*(int *)(param_1 + 0x78) = local_48 - (int)local_b8;
*(int *)((long)param_1 + 0x3c4) = (int)local_80 - (int)local_b8;
*(int *)(param_1 + 0x7a) = (int)local_78;
param_1[0x88] = local_90;
*local_60 = local_88;
*local_68 = local_b8;
uVar11 = 0;
}
}
}
}
else {
LAB_0016db9e:
param_1[0x13] = -1;
*(int1 *)((long)param_1 + 0x684) = 1;
uVar11 = 0xffffffff;
}
LAB_0016dbb6:
puVar18 = puVar17;
if ((char)local_4c == '\0') {
*(int8 *)(puVar17 + -8) = 0x16dbc4;
my_free(__src);
}
LAB_0016dbf9:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)(puVar18 + -8) = _ma_bin_search;
__stack_chk_fail();
}
return uVar11;
}
|
|
16,086
|
ma_crypt_set_data_pagecache_callbacks
|
eloqsql/storage/maria/ma_crypt.c
|
void ma_crypt_set_data_pagecache_callbacks(PAGECACHE_FILE *file,
MARIA_SHARE *share
__attribute__((unused)))
{
/* Only use encryption if we have defined it */
if (encryption_key_id_exists(get_encryption_key_id(share)))
{
file->pre_read_hook= ma_crypt_pre_read_hook;
file->post_read_hook= ma_crypt_data_post_read_hook;
file->pre_write_hook= ma_crypt_data_pre_write_hook;
file->post_write_hook= ma_crypt_post_write_hook;
}
}
|
O0
|
c
|
ma_crypt_set_data_pagecache_callbacks:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2f870
movl %eax, %edi
callq 0xb2fd70
cmpl $0x0, %eax
je 0xb2fd61
movq -0x8(%rbp), %rax
leaq 0x70(%rip), %rcx # 0xb2fda0
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0xe1(%rip), %rcx # 0xb2fe20
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0x2b2(%rip), %rcx # 0xb30000
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0x4a3(%rip), %rcx # 0xb30200
movq %rcx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
ma_crypt_set_data_pagecache_callbacks:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_10]
call get_encryption_key_id
mov edi, eax
call encryption_key_id_exists
cmp eax, 0
jz short loc_B2FD61
mov rax, [rbp+var_8]
lea rcx, ma_crypt_pre_read_hook
mov [rax+18h], rcx
mov rax, [rbp+var_8]
lea rcx, ma_crypt_data_post_read_hook
mov [rax+20h], rcx
mov rax, [rbp+var_8]
lea rcx, ma_crypt_data_pre_write_hook
mov [rax+28h], rcx
mov rax, [rbp+var_8]
lea rcx, ma_crypt_post_write_hook
mov [rax+30h], rcx
loc_B2FD61:
add rsp, 10h
pop rbp
retn
|
long long ma_crypt_set_data_pagecache_callbacks(_QWORD *a1, long long a2)
{
unsigned int encryption_key_id; // eax
long long result; // rax
encryption_key_id = get_encryption_key_id(a2);
result = encryption_key_id_exists(encryption_key_id);
if ( (_DWORD)result )
{
a1[3] = ma_crypt_pre_read_hook;
a1[4] = ma_crypt_data_post_read_hook;
a1[5] = ma_crypt_data_pre_write_hook;
result = (long long)a1;
a1[6] = ma_crypt_post_write_hook;
}
return result;
}
|
operator--:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RDI,qword ptr [RAX]
CALL 0x00533b60
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
ADD RSP,0x10
POP RBP
RET
|
/* std::_Rb_tree_iterator<std::pair<unsigned int const, unsigned int> >::TEMPNAMEPLACEHOLDERVALUE()
*/
void __thiscall
std::_Rb_tree_iterator<std::pair<unsigned_int_const,unsigned_int>>::operator--
(_Rb_tree_iterator<std::pair<unsigned_int_const,unsigned_int>> *this)
{
int8 uVar1;
uVar1 = std::_Rb_tree_decrement(*(_Rb_tree_node_base **)this);
*(int8 *)this = uVar1;
return;
}
|
|
16,087
|
compare_columns
|
eloqsql/storage/maria/ma_create.c
|
static int compare_columns(MARIA_COLUMNDEF **a_ptr, MARIA_COLUMNDEF **b_ptr)
{
MARIA_COLUMNDEF *a= *a_ptr, *b= *b_ptr;
enum en_fieldtype a_type, b_type;
a_type= (a->type == FIELD_CHECK) ? FIELD_NORMAL : a->type;
b_type= (b->type == FIELD_CHECK) ? FIELD_NORMAL : b->type;
if (a_type == FIELD_NORMAL && !a->null_bit)
{
if (b_type != FIELD_NORMAL || b->null_bit)
return -1;
return sign((long) a->offset - (long) b->offset);
}
if (b_type == FIELD_NORMAL && !b->null_bit)
return 1;
if (a_type == b_type)
return sign((long) a->offset - (long) b->offset);
if (a_type == FIELD_NORMAL)
return -1;
if (b_type == FIELD_NORMAL)
return 1;
if (a_type == FIELD_SKIP_ZERO)
return -1;
if (b_type == FIELD_SKIP_ZERO)
return 1;
if (a->type != FIELD_BLOB && b->type != FIELD_BLOB)
if (a->length != b->length)
return sign((long) a->length - (long) b->length);
if (a_type == FIELD_BLOB)
return 1;
if (b_type == FIELD_BLOB)
return -1;
return sign((long) a->offset - (long) b->offset);
}
|
O0
|
c
|
compare_columns:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x77f76
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x77f7f
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x77f95
xorl %eax, %eax
movl %eax, -0x38(%rbp)
jmp 0x77f9e
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x77ff3
movq -0x20(%rbp), %rax
cmpb $0x0, 0x12(%rax)
jne 0x77ff3
cmpl $0x0, -0x30(%rbp)
jne 0x77fc7
movq -0x28(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x0, %eax
je 0x77fd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x780ff
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
subq %rax, %rdi
callq 0x78be0
movl %eax, -0x4(%rbp)
jmp 0x780ff
cmpl $0x0, -0x30(%rbp)
jne 0x7800f
movq -0x28(%rbp), %rax
cmpb $0x0, 0x12(%rax)
jne 0x7800f
movl $0x1, -0x4(%rbp)
jmp 0x780ff
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x78037
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
subq %rax, %rdi
callq 0x78be0
movl %eax, -0x4(%rbp)
jmp 0x780ff
cmpl $0x0, -0x2c(%rbp)
jne 0x78049
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x780ff
cmpl $0x0, -0x30(%rbp)
jne 0x7805b
movl $0x1, -0x4(%rbp)
jmp 0x780ff
cmpl $0x3, -0x2c(%rbp)
jne 0x7806d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x780ff
cmpl $0x3, -0x30(%rbp)
jne 0x7807f
movl $0x1, -0x4(%rbp)
jmp 0x780ff
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
je 0x780c6
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
je 0x780c6
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
je 0x780c4
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, %edi
movq -0x28(%rbp), %rax
movzwl 0x8(%rax), %eax
subq %rax, %rdi
callq 0x78be0
movl %eax, -0x4(%rbp)
jmp 0x780ff
jmp 0x780c6
cmpl $0x4, -0x2c(%rbp)
jne 0x780d5
movl $0x1, -0x4(%rbp)
jmp 0x780ff
cmpl $0x4, -0x30(%rbp)
jne 0x780e4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x780ff
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %edi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
subq %rax, %rdi
callq 0x78be0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
compare_columns:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
cmp dword ptr [rax], 9
jnz short loc_77F76
xor eax, eax
mov [rbp+var_34], eax
jmp short loc_77F7F
loc_77F76:
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_34], eax
loc_77F7F:
mov eax, [rbp+var_34]
mov [rbp+var_2C], eax
mov rax, [rbp+var_28]
cmp dword ptr [rax], 9
jnz short loc_77F95
xor eax, eax
mov [rbp+var_38], eax
jmp short loc_77F9E
loc_77F95:
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_38], eax
loc_77F9E:
mov eax, [rbp+var_38]
mov [rbp+var_30], eax
cmp [rbp+var_2C], 0
jnz short loc_77FF3
mov rax, [rbp+var_20]
cmp byte ptr [rax+12h], 0
jnz short loc_77FF3
cmp [rbp+var_30], 0
jnz short loc_77FC7
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax+12h]
cmp eax, 0
jz short loc_77FD3
loc_77FC7:
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_780FF
loc_77FD3:
mov rax, [rbp+var_20]
mov eax, [rax+4]
mov edi, eax
mov rax, [rbp+var_28]
mov eax, [rax+4]
sub rdi, rax
call sign
mov [rbp+var_4], eax
jmp loc_780FF
loc_77FF3:
cmp [rbp+var_30], 0
jnz short loc_7800F
mov rax, [rbp+var_28]
cmp byte ptr [rax+12h], 0
jnz short loc_7800F
mov [rbp+var_4], 1
jmp loc_780FF
loc_7800F:
mov eax, [rbp+var_2C]
cmp eax, [rbp+var_30]
jnz short loc_78037
mov rax, [rbp+var_20]
mov eax, [rax+4]
mov edi, eax
mov rax, [rbp+var_28]
mov eax, [rax+4]
sub rdi, rax
call sign
mov [rbp+var_4], eax
jmp loc_780FF
loc_78037:
cmp [rbp+var_2C], 0
jnz short loc_78049
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_780FF
loc_78049:
cmp [rbp+var_30], 0
jnz short loc_7805B
mov [rbp+var_4], 1
jmp loc_780FF
loc_7805B:
cmp [rbp+var_2C], 3
jnz short loc_7806D
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_780FF
loc_7806D:
cmp [rbp+var_30], 3
jnz short loc_7807F
mov [rbp+var_4], 1
jmp loc_780FF
loc_7807F:
mov rax, [rbp+var_20]
cmp dword ptr [rax], 4
jz short loc_780C6
mov rax, [rbp+var_28]
cmp dword ptr [rax], 4
jz short loc_780C6
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+8]
mov rcx, [rbp+var_28]
movzx ecx, word ptr [rcx+8]
cmp eax, ecx
jz short loc_780C4
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+8]
mov edi, eax
mov rax, [rbp+var_28]
movzx eax, word ptr [rax+8]
sub rdi, rax
call sign
mov [rbp+var_4], eax
jmp short loc_780FF
loc_780C4:
jmp short $+2
loc_780C6:
cmp [rbp+var_2C], 4
jnz short loc_780D5
mov [rbp+var_4], 1
jmp short loc_780FF
loc_780D5:
cmp [rbp+var_30], 4
jnz short loc_780E4
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_780FF
loc_780E4:
mov rax, [rbp+var_20]
mov eax, [rax+4]
mov edi, eax
mov rax, [rbp+var_28]
mov eax, [rax+4]
sub rdi, rax
call sign
mov [rbp+var_4], eax
loc_780FF:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long compare_columns(_QWORD *a1, int **a2)
{
int v3; // [rsp+8h] [rbp-38h]
int v4; // [rsp+Ch] [rbp-34h]
int *v5; // [rsp+18h] [rbp-28h]
_DWORD *v6; // [rsp+20h] [rbp-20h]
v6 = (_DWORD *)*a1;
v5 = *a2;
if ( *(_DWORD *)*a1 == 9 )
v4 = 0;
else
v4 = *v6;
if ( *v5 == 9 )
v3 = 0;
else
v3 = *v5;
if ( v4 || *((_BYTE *)v6 + 18) )
{
if ( !v3 && !*((_BYTE *)v5 + 18) )
return 1;
if ( v4 != v3 )
{
if ( !v4 )
return (unsigned int)-1;
if ( !v3 )
return 1;
if ( v4 == 3 )
return (unsigned int)-1;
if ( v3 == 3 )
return 1;
if ( *v6 != 4 && *v5 != 4 && *((unsigned __int16 *)v6 + 4) != *((unsigned __int16 *)v5 + 4) )
return (unsigned int)sign(*((unsigned __int16 *)v6 + 4) - (unsigned long long)*((unsigned __int16 *)v5 + 4));
if ( v4 == 4 )
return 1;
if ( v3 == 4 )
return (unsigned int)-1;
}
return (unsigned int)sign((unsigned int)v6[1] - (unsigned long long)(unsigned int)v5[1]);
}
if ( !v3 && !*((_BYTE *)v5 + 18) )
return (unsigned int)sign((unsigned int)v6[1] - (unsigned long long)(unsigned int)v5[1]);
return (unsigned int)-1;
}
|
compare_columns:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x9
JNZ 0x00177f76
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00177f7f
LAB_00177f76:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
LAB_00177f7f:
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX],0x9
JNZ 0x00177f95
XOR EAX,EAX
MOV dword ptr [RBP + -0x38],EAX
JMP 0x00177f9e
LAB_00177f95:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
LAB_00177f9e:
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x30],EAX
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00177ff3
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + 0x12],0x0
JNZ 0x00177ff3
CMP dword ptr [RBP + -0x30],0x0
JNZ 0x00177fc7
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + 0x12]
CMP EAX,0x0
JZ 0x00177fd3
LAB_00177fc7:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001780ff
LAB_00177fd3:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x4]
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x4]
SUB RDI,RAX
CALL 0x00178be0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001780ff
LAB_00177ff3:
CMP dword ptr [RBP + -0x30],0x0
JNZ 0x0017800f
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x12],0x0
JNZ 0x0017800f
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001780ff
LAB_0017800f:
MOV EAX,dword ptr [RBP + -0x2c]
CMP EAX,dword ptr [RBP + -0x30]
JNZ 0x00178037
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x4]
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x4]
SUB RDI,RAX
CALL 0x00178be0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001780ff
LAB_00178037:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00178049
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001780ff
LAB_00178049:
CMP dword ptr [RBP + -0x30],0x0
JNZ 0x0017805b
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001780ff
LAB_0017805b:
CMP dword ptr [RBP + -0x2c],0x3
JNZ 0x0017806d
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001780ff
LAB_0017806d:
CMP dword ptr [RBP + -0x30],0x3
JNZ 0x0017807f
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001780ff
LAB_0017807f:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x4
JZ 0x001780c6
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX],0x4
JZ 0x001780c6
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RCX + 0x8]
CMP EAX,ECX
JZ 0x001780c4
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x8]
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX + 0x8]
SUB RDI,RAX
CALL 0x00178be0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001780ff
LAB_001780c4:
JMP 0x001780c6
LAB_001780c6:
CMP dword ptr [RBP + -0x2c],0x4
JNZ 0x001780d5
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001780ff
LAB_001780d5:
CMP dword ptr [RBP + -0x30],0x4
JNZ 0x001780e4
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001780ff
LAB_001780e4:
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x4]
MOV EDI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x4]
SUB RDI,RAX
CALL 0x00178be0
MOV dword ptr [RBP + -0x4],EAX
LAB_001780ff:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int compare_columns(int8 *param_1,uchar *param_2,size_t *param_3,uchar *param_4,size_t param_5
)
{
int *piVar1;
int *piVar2;
int local_40;
int local_3c;
int local_c;
piVar1 = (int *)*param_1;
piVar2 = *(int **)param_2;
if (*piVar1 == 9) {
local_3c = 0;
}
else {
local_3c = *piVar1;
}
if (*piVar2 == 9) {
local_40 = 0;
}
else {
local_40 = *piVar2;
}
if ((local_3c == 0) && (*(char *)((long)piVar1 + 0x12) == '\0')) {
if ((local_40 == 0) && (*(char *)((long)piVar2 + 0x12) == '\0')) {
local_c = sign((EVP_PKEY_CTX *)((ulong)(uint)piVar1[1] - (ulong)(uint)piVar2[1]),param_2,
param_3,param_4,param_5);
}
else {
local_c = -1;
}
}
else if ((local_40 == 0) && (*(char *)((long)piVar2 + 0x12) == '\0')) {
local_c = 1;
}
else if (local_3c == local_40) {
local_c = sign((EVP_PKEY_CTX *)((ulong)(uint)piVar1[1] - (ulong)(uint)piVar2[1]),param_2,param_3
,param_4,param_5);
}
else if (local_3c == 0) {
local_c = -1;
}
else if (local_40 == 0) {
local_c = 1;
}
else if (local_3c == 3) {
local_c = -1;
}
else if (local_40 == 3) {
local_c = 1;
}
else if (((*piVar1 == 4) || (*piVar2 == 4)) ||
(param_4 = (uchar *)(ulong)*(ushort *)(piVar2 + 2),
*(ushort *)(piVar1 + 2) == *(ushort *)(piVar2 + 2))) {
if (local_3c == 4) {
local_c = 1;
}
else if (local_40 == 4) {
local_c = -1;
}
else {
local_c = sign((EVP_PKEY_CTX *)((ulong)(uint)piVar1[1] - (ulong)(uint)piVar2[1]),param_2,
param_3,param_4,param_5);
}
}
else {
local_c = sign((EVP_PKEY_CTX *)((ulong)*(ushort *)(piVar1 + 2) - (ulong)*(ushort *)(piVar2 + 2))
,param_2,param_3,param_4,param_5);
}
return local_c;
}
|
|
16,088
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
monkey531[P]llama/common/./json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
}
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4beee
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x4, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x4a044
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x497ca
testb %bpl, %bpl
je 0x4a022
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x4a022
leaq 0xa8(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x2c4cc
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x4bf28
leaq 0x20(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x487f0
movq %rax, 0x70(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %rbx, %rdi
callq 0x4bfb8
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x18260
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
jmp 0x4a068
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
movq %rbx, %rdi
callq 0x18b90
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+48h+var_3C], eax
mov [rsp+48h+var_3D], 4
cmp qword ptr [rbx+90h], 0
jz loc_4A044
lea rdi, [rbx+80h]
lea rsi, [rsp+48h+var_3C]
lea rdx, [rsp+48h+var_3D]
lea rcx, [rsp+48h+var_38]
call qword ptr [rbx+98h]
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_4A022
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_4A022
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_28]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator[](std::string const&)
lea r14, [rsp+48h+var_28]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov [rbx+70h], rax
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_4A022:
lea rbx, [rsp+48h+var_38]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov al, 1
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_4A044:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
lea r14, [rsp+48h+var_28]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_4A068
mov rbx, rax
loc_4A068:
lea r14, [rsp+48h+var_38]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
long long a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
char v5; // [rsp+Bh] [rbp-3Dh] BYREF
int v6; // [rsp+Ch] [rbp-3Ch] BYREF
char v7[16]; // [rsp+10h] [rbp-38h] BYREF
char v8[40]; // [rsp+20h] [rbp-28h] BYREF
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v7);
v6 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v5 = 4;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long, int *, char *, char *))(a1 + 152))(a1 + 128, &v6, &v5, v7);
std::vector<bool>::push_back(a1 + 72, v2);
if ( v2 && *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v8,
a1 + 168);
v3 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL) + 8LL),
a2);
*(_QWORD *)(a1 + 112) = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v3,
(long long)v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v8);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v8);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v7);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v7);
return 1;
}
|
key:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x10]
CALL 0x0014beee
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x4
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0014a044
LEA RDI,[RBX + 0x80]
LAB_00149fa4:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
MOV EBP,EAX
LEA RDI,[RBX + 0x48]
MOVZX ESI,AL
CALL 0x001497ca
TEST BPL,BPL
JZ 0x0014a022
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RAX + -0x8],0x0
JZ 0x0014a022
LEA RSI,[RBX + 0xa8]
LEA RDI,[RSP + 0x20]
CALL 0x0012c4cc
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
LAB_00149ff4:
MOV RSI,R14
CALL 0x0014bf28
LEA R14,[RSP + 0x20]
MOV RDI,RAX
MOV RSI,R14
CALL 0x001487f0
MOV qword ptr [RBX + 0x70],RAX
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R14
CALL 0x0014bfb8
LAB_0014a022:
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,RBX
CALL 0x0014bfb8
MOV AL,0x1
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_0014a044:
CALL 0x00118260
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::key(std::__cxx11::string&) */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::key(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,string *param_1)
{
bool bVar1;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar2;
int8 uVar3;
int1 local_3d;
int4 local_3c;
data local_38 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_28 [16];
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_38);
local_3c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_3d = 4;
if (*(long *)(this + 0x90) != 0) {
/* try { // try from 00149fa4 to 00149fe7 has its CatchHandler @ 0014a065 */
bVar1 = (bool)(**(code **)(this + 0x98))(this + 0x80,&local_3c,&local_3d,local_38);
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x48),bVar1);
if ((bVar1 != false) && (*(long *)(*(long *)(this + 0x10) + -8) != 0)) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_28,(basic_json *)(this + 0xa8));
/* try { // try from 00149ff4 to 00149ffb has its CatchHandler @ 0014a049 */
pbVar2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](*(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(*(long *)(*(long *)(this + 0x10) + -8) + 8),param_1);
uVar3 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(pbVar2,(data *)local_28);
*(int8 *)(this + 0x70) = uVar3;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)local_28,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_28);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_38,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_38);
return 1;
}
/* WARNING: Subroutine does not return */
/* try { // try from 0014a044 to 0014a048 has its CatchHandler @ 0014a065 */
std::__throw_bad_function_call();
}
|
|
16,089
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
monkey531[P]llama/common/./json.hpp
|
bool key(string_t& val)
{
BasicJsonType k = BasicJsonType(val);
// check callback for key
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
key_keep_stack.push_back(keep);
// add discarded value at given key and store the reference for later
if (keep && ref_stack.back())
{
object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
}
return true;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x455a0
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x4
popq %rdx
movq %r15, %rcx
callq 0x442d6
movl %eax, %ebp
leaq 0x48(%rbx), %rdi
movzbl %al, %esi
callq 0x4357a
testb %bpl, %bpl
je 0x43e2c
movq 0x10(%rbx), %rax
cmpq $0x0, -0x8(%rax)
je 0x43e2c
leaq 0xa8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2b5c6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
callq 0x455d8
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x429ca
movq %rax, 0x70(%rbx)
movq %r14, %rdi
callq 0x2b1f0
leaq 0x18(%rsp), %rdi
callq 0x2b1f0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2b1f0
jmp 0x43e55
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2b1f0
movq %rbx, %rdi
callq 0x20b90
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyERSB_:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+48h+var_30]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 4
pop rdx
mov rcx, r15
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov ebp, eax
lea rdi, [rbx+48h]
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
test bpl, bpl
jz short loc_43E2C
mov rax, [rbx+10h]
cmp qword ptr [rax-8], 0
jz short loc_43E2C
lea rsi, [rbx+0A8h]
lea rdi, [rsp+48h+var_40]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rdi, [rax+8]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEixERSH_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator[](std::string const&)
lea r14, [rsp+48h+var_40]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov [rbx+70h], rax
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_43E2C:
lea rdi, [rsp+48h+var_30]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov al, 1
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp short loc_43E55
mov rbx, rax
loc_43E55:
lea rdi, [rsp+arg_10]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, rbx
call __Unwind_Resume
|
char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::key(
_QWORD *a1,
long long a2)
{
unsigned __int8 v2; // bp
long long v3; // rax
_BYTE v5[16]; // [rsp+8h] [rbp-40h] BYREF
_BYTE v6[48]; // [rsp+18h] [rbp-30h] BYREF
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(v6);
v2 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 16,
(a1[2] - a1[1]) >> 3,
4LL,
v6);
std::vector<bool>::push_back((long long)(a1 + 9), v2);
if ( v2 && *(_QWORD *)(a1[2] - 8LL) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(long long)v5,
(long long)(a1 + 21));
v3 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator[](
*(_QWORD *)(*(_QWORD *)(a1[2] - 8LL) + 8LL),
a2);
a1[14] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v3,
(long long)v5);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v5);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v6);
return 1;
}
| |||
16,090
|
my_uca_scanner_contraction_find
|
eloqsql/strings/ctype-uca.c
|
static const MY_CONTRACTION *
my_uca_scanner_contraction_find(my_uca_scanner *scanner, my_wc_t *wc,
size_t max_char_length)
{
size_t clen= 1;
int flag;
const uchar *s, *beg[MY_UCA_MAX_CONTRACTION];
memset((void*) beg, 0, sizeof(beg));
/* Scan all contraction candidates */
for (s= scanner->sbeg, flag= MY_UCA_CNT_MID1;
clen < max_char_length;
flag<<= 1)
{
int mblen;
if ((mblen= my_ci_mb_wc(scanner->cs, &wc[clen], s, scanner->send)) <= 0)
break;
beg[clen]= s= s + mblen;
if (!my_uca_can_be_contraction_part(&scanner->level->contractions,
wc[clen++], flag))
break;
}
/* Find among candidates the longest real contraction */
for ( ; clen > 1; clen--)
{
const MY_CONTRACTION *cnt;
if (my_uca_can_be_contraction_tail(&scanner->level->contractions,
wc[clen - 1]) &&
(cnt= my_uca_contraction_find(&scanner->level->contractions,
wc, clen)))
{
scanner->wbeg= cnt->weight + 1;
scanner->sbeg= beg[clen - 1];
return cnt;
}
}
return NULL; /* No contractions were found */
}
|
O0
|
c
|
my_uca_scanner_contraction_find:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x24180
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x4, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x5789a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rsi
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
callq *%rax
movl %eax, -0x74(%rbp)
cmpl $0x0, %eax
jg 0x57842
jmp 0x5789a
movq -0x38(%rbp), %rcx
movslq -0x74(%rbp), %rax
addq %rax, %rcx
movq %rcx, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rcx, -0x70(%rbp,%rax,8)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rcx,8), %rsi
movl -0x2c(%rbp), %edx
callq 0x57950
cmpb $0x0, %al
jne 0x5788b
jmp 0x5789a
jmp 0x5788d
movl -0x2c(%rbp), %eax
shll %eax
movl %eax, -0x2c(%rbp)
jmp 0x577f2
jmp 0x5789c
cmpq $0x1, -0x28(%rbp)
jbe 0x57938
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
callq 0x4eb40
movsbl %al, %eax
cmpl $0x0, %eax
je 0x57925
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x56f70
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x57925
movq -0x80(%rbp), %rcx
addq $0x30, %rcx
addq $0x2, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq -0x70(%rbp,%rax,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x57940
jmp 0x57927
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5789c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
|
my_uca_scanner_contraction_find:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], 1
lea rdi, [rbp+var_70]
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_38], rax
mov [rbp+var_2C], 4
loc_577F2:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb loc_5789A
mov rax, [rbp+var_10]
mov rax, [rax+30h]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rcx, [rbp+var_10]
mov rdi, [rcx+30h]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_28]
shl rcx, 3
add rsi, rcx
mov rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
mov rcx, [rcx+10h]
call rax
mov [rbp+var_74], eax
cmp eax, 0
jg short loc_57842
jmp short loc_5789A
loc_57842:
mov rcx, [rbp+var_38]
movsxd rax, [rbp+var_74]
add rcx, rax
mov [rbp+var_38], rcx
mov rax, [rbp+var_28]
mov [rbp+rax*8+var_70], rcx
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
mov rdx, rcx
add rdx, 1
mov [rbp+var_28], rdx
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_2C]
call my_uca_can_be_contraction_part
cmp al, 0
jnz short loc_5788B
jmp short loc_5789A
loc_5788B:
jmp short $+2
loc_5788D:
mov eax, [rbp+var_2C]
shl eax, 1
mov [rbp+var_2C], eax
jmp loc_577F2
loc_5789A:
jmp short $+2
loc_5789C:
cmp [rbp+var_28], 1
jbe loc_57938
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
sub rcx, 1
mov rsi, [rax+rcx*8]
call my_uca_can_be_contraction_tail
movsx eax, al
cmp eax, 0
jz short loc_57925
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
add rdi, 18h
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call my_uca_contraction_find
mov [rbp+var_80], rax
cmp rax, 0
jz short loc_57925
mov rcx, [rbp+var_80]
add rcx, 30h ; '0'
add rcx, 2
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_28]
sub rax, 1
mov rcx, [rbp+rax*8+var_70]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_80]
mov [rbp+var_8], rax
jmp short loc_57940
loc_57925:
jmp short $+2
loc_57927:
mov rax, [rbp+var_28]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_28], rax
jmp loc_5789C
loc_57938:
mov [rbp+var_8], 0
loc_57940:
mov rax, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
unsigned long long my_uca_scanner_contraction_find(_QWORD *a1, long long a2, unsigned long long a3)
{
long long v3; // rdi
unsigned long long v4; // rcx
unsigned long long v6; // [rsp+0h] [rbp-80h]
int v7; // [rsp+Ch] [rbp-74h]
_QWORD v8[7]; // [rsp+10h] [rbp-70h] BYREF
long long v9; // [rsp+48h] [rbp-38h]
unsigned int i; // [rsp+54h] [rbp-2Ch]
unsigned long long v11; // [rsp+58h] [rbp-28h]
unsigned long long v12; // [rsp+60h] [rbp-20h]
long long v13; // [rsp+68h] [rbp-18h]
_QWORD *v14; // [rsp+70h] [rbp-10h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = 1LL;
memset(v8, 0LL, 48LL);
v9 = v14[1];
for ( i = 4; v11 < v12; i *= 2 )
{
v7 = (*(long long ( **)(_QWORD, unsigned long long, long long, _QWORD))(*(_QWORD *)(v14[6] + 184LL) + 40LL))(
v14[6],
8 * v11 + v13,
v9,
v14[2]);
if ( v7 <= 0 )
break;
v9 += v7;
v8[v11] = v9;
v3 = v14[3] + 24LL;
v4 = v11++;
if ( !(unsigned __int8)my_uca_can_be_contraction_part(v3, *(_QWORD *)(v13 + 8 * v4), i) )
break;
}
while ( v11 > 1 )
{
if ( (unsigned __int8)my_uca_can_be_contraction_tail(v14[3] + 24LL, *(_QWORD *)(v13 + 8 * (v11 - 1))) )
{
v6 = my_uca_contraction_find((_QWORD *)(v14[3] + 24LL), v13, v11);
if ( v6 )
{
*v14 = v6 + 50;
v14[1] = v8[v11 - 1];
return v6;
}
}
--v11;
}
return 0LL;
}
|
my_uca_scanner_contraction_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],0x1
LEA RDI,[RBP + -0x70]
XOR ESI,ESI
MOV EDX,0x30
CALL 0x00124180
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x2c],0x4
LAB_001577f2:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0015789a
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RCX + 0x30]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SHL RCX,0x3
ADD RSI,RCX
MOV RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x10]
CALL RAX
MOV dword ptr [RBP + -0x74],EAX
CMP EAX,0x0
JG 0x00157842
JMP 0x0015789a
LAB_00157842:
MOV RCX,qword ptr [RBP + -0x38]
MOVSXD RAX,dword ptr [RBP + -0x74]
ADD RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + RAX*0x8 + -0x70],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x28],RDX
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x00157950
CMP AL,0x0
JNZ 0x0015788b
JMP 0x0015789a
LAB_0015788b:
JMP 0x0015788d
LAB_0015788d:
MOV EAX,dword ptr [RBP + -0x2c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001577f2
LAB_0015789a:
JMP 0x0015789c
LAB_0015789c:
CMP qword ptr [RBP + -0x28],0x1
JBE 0x00157938
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
SUB RCX,0x1
MOV RSI,qword ptr [RAX + RCX*0x8]
CALL 0x0014eb40
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00157925
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
ADD RDI,0x18
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00156f70
MOV qword ptr [RBP + -0x80],RAX
CMP RAX,0x0
JZ 0x00157925
MOV RCX,qword ptr [RBP + -0x80]
ADD RCX,0x30
ADD RCX,0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0x1
MOV RCX,qword ptr [RBP + RAX*0x8 + -0x70]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00157940
LAB_00157925:
JMP 0x00157927
LAB_00157927:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015789c
LAB_00157938:
MOV qword ptr [RBP + -0x8],0x0
LAB_00157940:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
long my_uca_scanner_contraction_find(long *param_1,long param_2,ulong param_3)
{
char cVar1;
int iVar2;
long lVar3;
long local_78 [7];
long local_40;
int local_34;
ulong local_30;
ulong local_28;
long local_20;
long *local_18;
local_30 = 1;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_78,0,0x30);
local_40 = local_18[1];
local_34 = 4;
while ((local_30 < local_28 &&
(iVar2 = (**(code **)(*(long *)(local_18[6] + 0xb8) + 0x28))
(local_18[6],local_20 + local_30 * 8,local_40,local_18[2]), 0 < iVar2)))
{
local_40 = local_40 + iVar2;
local_78[local_30] = local_40;
lVar3 = local_30 * 8;
local_30 = local_30 + 1;
cVar1 = my_uca_can_be_contraction_part
(local_18[3] + 0x18,*(int8 *)(local_20 + lVar3),local_34);
if (cVar1 == '\0') break;
local_34 = local_34 << 1;
}
while( true ) {
if (local_30 < 2) {
return 0;
}
cVar1 = my_uca_can_be_contraction_tail
(local_18[3] + 0x18,*(int8 *)(local_20 + (local_30 - 1) * 8));
if ((cVar1 != '\0') &&
(lVar3 = my_uca_contraction_find(local_18[3] + 0x18,local_20,local_30), lVar3 != 0)) break;
local_30 = local_30 - 1;
}
*local_18 = lVar3 + 0x32;
local_18[1] = local_78[local_30 - 1];
return lVar3;
}
|
|
16,091
|
common_ngram_cache_save(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
monkey531[P]llama/common/ngram-cache.cpp
|
void common_ngram_cache_save(common_ngram_cache & ngram_cache, std::string & filename) {
std::ofstream file_out(filename, std::ios::binary);
for (std::pair<common_ngram, common_ngram_cache_part> item : ngram_cache) {
const common_ngram ngram = item.first;
common_ngram_cache_part token_counts = item.second;
GGML_ASSERT(!token_counts.empty());
const int32_t ntokens = token_counts.size();
GGML_ASSERT(ntokens > 0);
file_out.write(reinterpret_cast<const char *>(&ngram), sizeof(common_ngram));
file_out.write(reinterpret_cast<const char *>(&ntokens), sizeof(int32_t));
for (std::pair<llama_token, int32_t> item2 : token_counts) {
const llama_token token = item2.first;
const int32_t count = item2.second;
GGML_ASSERT(count > 0);
file_out.write(reinterpret_cast<const char *>(&token), sizeof(llama_token));
file_out.write(reinterpret_cast<const char *>(&count), sizeof(int32_t));
}
}
}
|
O1
|
cpp
|
common_ngram_cache_save(std::unordered_map<common_ngram, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>, common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %rdi, %rbx
leaq 0xb8(%rsp), %rdi
movl $0x4, %edx
callq 0x1c110
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0xceb97
leaq 0x60(%rsp), %r14
leaq 0x80(%rsp), %rcx
xorl %edx, %edx
leaq 0x18(%rsp), %rbp
leaq 0xb8(%rsp), %r12
movups 0x8(%r15), %xmm0
movaps %xmm0, 0x50(%rsp)
leaq 0x18(%r15), %rsi
movq %rdx, 0x60(%rsp)
movq 0x20(%r15), %rax
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x30(%r15), %rax
movq %rax, 0x78(%rsp)
movups 0x38(%r15), %xmm0
movups %xmm0, (%rcx)
movq %rdx, 0x90(%rsp)
movq %r14, 0x18(%rsp)
movq %r14, %rdi
xorl %r13d, %r13d
movq %rbp, %rdx
movq %rcx, %rbx
callq 0xcf542
movaps 0x50(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq %r13, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %r13, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movups (%rbx), %xmm0
leaq 0x38(%rsp), %rax
movups %xmm0, (%rax)
movq %r13, 0x48(%rsp)
movq %rbp, 0x10(%rsp)
movq %rbp, %rdi
movq %r14, %rbx
movq %r14, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0xcf542
movq 0x30(%rsp), %rax
testq %rax, %rax
leaq 0xc(%rsp), %r13
je 0xcec02
movl %eax, 0x10(%rsp)
testl %eax, %eax
jle 0xcec23
movl $0x10, %edx
movq %r12, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x1bb20
movl $0x4, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1bb20
movq 0x28(%rsp), %r14
testq %r14, %r14
je 0xceb6b
movl 0x8(%r14), %eax
movl 0xc(%r14), %ecx
movl %eax, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
jle 0xcebe1
movl $0x4, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x1bb20
movl $0x4, %edx
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1bb20
movq (%r14), %r14
jmp 0xceb27
movq %rbp, %rdi
callq 0x227a2
movq %rbx, %r14
movq %rbx, %rdi
callq 0x227a2
movq (%r15), %r15
testq %r15, %r15
leaq 0x80(%rsp), %rcx
movl $0x0, %edx
jne 0xcea38
movq 0x613a2(%rip), %rax # 0x12ff40
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0xc0(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0xb8(%rsp,%rcx)
callq 0x1b730
leaq 0x1b0(%rsp), %rdi
callq 0x1b2b0
addq $0x2b8, %rsp # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a396(%rip), %rdi # 0xf8f7e
leaq 0x21094(%rip), %rdx # 0xefc83
leaq 0x2a42b(%rip), %rcx # 0xf9021
movl $0xd5, %esi
xorl %eax, %eax
callq 0x1be90
leaq 0x2a375(%rip), %rdi # 0xf8f7e
leaq 0x21073(%rip), %rdx # 0xefc83
leaq 0x2a3e8(%rip), %rcx # 0xf8fff
movl $0xcc, %esi
xorl %eax, %eax
callq 0x1be90
leaq 0x2a354(%rip), %rdi # 0xf8f7e
leaq 0x21052(%rip), %rdx # 0xefc83
leaq 0x2a3dd(%rip), %rcx # 0xf9015
movl $0xce, %esi
xorl %eax, %eax
callq 0x1be90
movq %rax, %r14
jmp 0xcec6b
movq %rax, %r14
jmp 0xcec63
jmp 0xcec56
jmp 0xcec56
jmp 0xcec56
jmp 0xcec56
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x227a2
movq %rbx, %rdi
callq 0x227a2
leaq 0xb8(%rsp), %rdi
callq 0x1bcd0
movq %r14, %rdi
callq 0x1bf90
|
_Z23common_ngram_cache_saveRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 2B8h
mov rbx, rdi
lea rdi, [rsp+2E8h+var_230]
mov edx, 4
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEEC1ERKNSt7__cxx1112basic_stringIcS1_SaIcEEESt13_Ios_Openmode; std::ofstream::basic_ofstream(std::string const&,std::_Ios_Openmode)
mov r15, [rbx+10h]
test r15, r15
jz loc_CEB97
lea r14, [rsp+2E8h+var_288]
lea rcx, [rsp+2E8h+var_268]
xor edx, edx
lea rbp, [rsp+2E8h+var_2D0]
lea r12, [rsp+2E8h+var_230]
loc_CEA38:
movups xmm0, xmmword ptr [r15+8]
movaps [rsp+2E8h+var_298], xmm0
lea rsi, [r15+18h]
mov [rsp+2E8h+var_288], rdx
mov rax, [r15+20h]
mov [rsp+2E8h+var_280], rax
mov [rsp+2E8h+var_278], rdx
mov rax, [r15+30h]
mov [rsp+2E8h+var_270], rax
movups xmm0, xmmword ptr [r15+38h]
movups xmmword ptr [rcx], xmm0
mov [rsp+2E8h+var_258], rdx
mov [rsp+2E8h+var_2D0], r14
mov rdi, r14
xor r13d, r13d
mov rdx, rbp
mov rbx, rcx
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE9_M_assignIRKSF_NS4_10_AllocNodeISaINS4_10_Hash_nodeIS2_Lb0EEEEEEEEvOT_RKT0_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>> const&)
movaps xmm0, [rsp+2E8h+var_298]
movaps xmmword ptr [rsp+2E8h+var_248], xmm0
mov [rsp+2E8h+var_2D0], r13
mov rax, [rsp+2E8h+var_280]
mov [rsp+2E8h+var_2C8], rax
mov [rsp+2E8h+var_2C0], r13
mov rax, [rsp+2E8h+var_270]
mov [rsp+2E8h+var_2B8], rax
movups xmm0, xmmword ptr [rbx]
lea rax, [rsp+2E8h+var_2B0]
movups xmmword ptr [rax], xmm0
mov [rsp+2E8h+var_2A0], r13
mov qword ptr [rsp+2E8h+var_2D8], rbp
mov rdi, rbp
mov rbx, r14
mov rsi, r14
lea r14, [rsp+2E8h+var_2D8]
mov rdx, r14
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEE9_M_assignIRKSF_NS4_10_AllocNodeISaINS4_10_Hash_nodeIS2_Lb0EEEEEEEEvOT_RKT0_; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>> const&)
mov rax, [rsp+2E8h+var_2B8]
test rax, rax
lea r13, [rsp+2E8h+var_2DC]
jz loc_CEC02
mov dword ptr [rsp+2E8h+var_2D8], eax
test eax, eax
jle loc_CEC23
mov edx, 10h; __int64
mov rdi, r12; this
lea rsi, [rsp+2E8h+var_248]; char *
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
mov edx, 4; __int64
mov rdi, r12; this
mov rsi, r14; char *
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
mov r14, [rsp+2E8h+var_2C0]
loc_CEB27:
test r14, r14
jz short loc_CEB6B
mov eax, [r14+8]
mov ecx, [r14+0Ch]
mov dword ptr [rsp+2E8h+var_2DC], eax
mov dword ptr [rsp+2E8h+var_2E0], ecx
test ecx, ecx
jle loc_CEBE1
mov edx, 4; __int64
mov rdi, r12; this
mov rsi, r13; char *
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
mov edx, 4; __int64
mov rdi, r12; this
lea rsi, [rsp+2E8h+var_2E0]; char *
call __ZNSo5writeEPKcl; std::ostream::write(char const*,long)
mov r14, [r14]
jmp short loc_CEB27
loc_CEB6B:
mov rdi, rbp
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov r14, rbx
mov rdi, rbx
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
mov r15, [r15]
test r15, r15
lea rcx, [rsp+2E8h+var_268]
mov edx, 0
jnz loc_CEA38
loc_CEB97:
mov rax, cs:_ZTTSt14basic_ofstreamIcSt11char_traitsIcEE_ptr
mov rcx, [rax]
mov rax, [rax+18h]
lea rdi, [rsp+2E8h+var_228]
mov [rdi-8], rcx
mov rcx, [rcx-18h]
mov [rsp+rcx+2E8h+var_230], rax
call __ZNSt13basic_filebufIcSt11char_traitsIcEED2Ev; std::filebuf::~filebuf()
lea rdi, [rsp+2E8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
add rsp, 2B8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CEBE1:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCount0; "count > 0"
mov esi, 0D5h
xor eax, eax
call _ggml_abort
loc_CEC02:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTokenCountsEmp; "!token_counts.empty()"
mov esi, 0CCh
xor eax, eax
call _ggml_abort
loc_CEC23:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNtokens0; "ntokens > 0"
mov esi, 0CEh
xor eax, eax
call _ggml_abort
mov r14, rax
jmp short loc_CEC6B
mov r14, rax
jmp short loc_CEC63
jmp short loc_CEC56
jmp short loc_CEC56
jmp short loc_CEC56
jmp short $+2
loc_CEC56:
mov r14, rax
lea rdi, [rsp+2E8h+var_2D0]
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
loc_CEC63:
mov rdi, rbx
call _ZNSt10_HashtableIiSt4pairIKiiESaIS2_ENSt8__detail10_Select1stESt8equal_toIiESt4hashIiENS4_18_Mod_range_hashingENS4_20_Default_ranged_hashENS4_20_Prime_rehash_policyENS4_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev; std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable()
loc_CEC6B:
lea rdi, [rsp+2E8h+var_230]
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEED1Ev; std::ofstream::~ofstream()
mov rdi, r14
call __Unwind_Resume
|
void common_ngram_cache_save(long long a1, char *a2)
{
long long v2; // rdx
long long *v3; // r15
long long *v4; // r14
long long v5; // rbx
long long *i; // r14
int v7; // ecx
long long v8; // rax
double v9; // xmm0_8
long long v10; // rax
long long v11; // r14
char v12[4]; // [rsp+8h] [rbp-2E0h] BYREF
char v13[4]; // [rsp+Ch] [rbp-2DCh] BYREF
char v14[8]; // [rsp+10h] [rbp-2D8h] BYREF
_QWORD v15[2]; // [rsp+18h] [rbp-2D0h] BYREF
long long *v16; // [rsp+28h] [rbp-2C0h]
long long v17; // [rsp+30h] [rbp-2B8h]
__int128 v18; // [rsp+38h] [rbp-2B0h]
long long v19; // [rsp+48h] [rbp-2A0h]
__int128 v20; // [rsp+50h] [rbp-298h]
long long v21; // [rsp+60h] [rbp-288h] BYREF
long long v22; // [rsp+68h] [rbp-280h]
long long v23; // [rsp+70h] [rbp-278h]
long long v24; // [rsp+78h] [rbp-270h]
__int128 v25; // [rsp+80h] [rbp-268h]
long long v26; // [rsp+90h] [rbp-258h]
char v27[24]; // [rsp+A0h] [rbp-248h] BYREF
long long v28; // [rsp+B8h] [rbp-230h] BYREF
_BYTE v29[240]; // [rsp+C0h] [rbp-228h] BYREF
_BYTE v30[312]; // [rsp+1B0h] [rbp-138h] BYREF
std::ofstream::basic_ofstream(&v28, a2, 4LL);
v3 = *(long long **)(a1 + 16);
if ( v3 )
{
v4 = &v21;
do
{
v20 = *(_OWORD *)(v3 + 1);
v21 = 0LL;
v22 = v3[4];
v23 = 0LL;
v24 = v3[6];
v25 = *(_OWORD *)(v3 + 7);
v26 = 0LL;
v15[0] = v4;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(
v4,
v3 + 3,
v15);
*(_OWORD *)v27 = v20;
v15[0] = 0LL;
v15[1] = v22;
v16 = 0LL;
v17 = v24;
v18 = v25;
v19 = 0LL;
*(_QWORD *)v14 = v15;
v5 = (long long)v4;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::_M_assign<std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>> const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int const,int>,false>>>>(
v15,
v4,
v14);
if ( !v17 )
goto LABEL_12;
*(_DWORD *)v14 = v17;
if ( (int)v17 <= 0 )
{
LABEL_13:
v9 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp",
206LL,
"GGML_ASSERT(%s) failed",
"ntokens > 0");
v11 = v10;
std::ofstream::~ofstream(&v28, v9);
_Unwind_Resume(v11);
}
std::ostream::write((std::ostream *)&v28, v27, 16LL);
a2 = v14;
std::ostream::write((std::ostream *)&v28, v14, 4LL);
for ( i = v16; i; i = (long long *)*i )
{
v7 = *((_DWORD *)i + 3);
*(_DWORD *)v13 = *((_DWORD *)i + 2);
*(_DWORD *)v12 = v7;
if ( v7 <= 0 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp",
213LL,
"GGML_ASSERT(%s) failed",
"count > 0");
LABEL_12:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp",
204LL,
"GGML_ASSERT(%s) failed",
"!token_counts.empty()");
goto LABEL_13;
}
std::ostream::write((std::ostream *)&v28, v13, 4LL);
a2 = v12;
std::ostream::write((std::ostream *)&v28, v12, 4LL);
}
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable((long long)v15);
v4 = (long long *)v5;
std::_Hashtable<int,std::pair<int const,int>,std::allocator<std::pair<int const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::~_Hashtable(v5);
v3 = (long long *)*v3;
v2 = 0LL;
}
while ( v3 );
}
v8 = `VTT for'std::ofstream[3];
v28 = `VTT for'std::ofstream[0];
*(_QWORD *)&v29[*(_QWORD *)(`VTT for'std::ofstream[0] - 24LL) - 8] = v8;
std::filebuf::~filebuf(v29, a2, v2);
std::ios_base::~ios_base((std::ios_base *)v30);
}
|
common_ngram_cache_save:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x2b8
MOV RBX,RDI
LEA RDI,[RSP + 0xb8]
MOV EDX,0x4
CALL 0x0011c110
MOV R15,qword ptr [RBX + 0x10]
TEST R15,R15
JZ 0x001ceb97
LEA R14,[RSP + 0x60]
LEA RCX,[RSP + 0x80]
XOR EDX,EDX
LEA RBP,[RSP + 0x18]
LEA R12,[RSP + 0xb8]
LAB_001cea38:
MOVUPS XMM0,xmmword ptr [R15 + 0x8]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
LEA RSI,[R15 + 0x18]
MOV qword ptr [RSP + 0x60],RDX
MOV RAX,qword ptr [R15 + 0x20]
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [R15 + 0x30]
MOV qword ptr [RSP + 0x78],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x38]
MOVUPS xmmword ptr [RCX],XMM0
MOV qword ptr [RSP + 0x90],RDX
MOV qword ptr [RSP + 0x18],R14
LAB_001cea77:
MOV RDI,R14
XOR R13D,R13D
MOV RDX,RBP
MOV RBX,RCX
CALL 0x001cf542
MOVAPS XMM0,xmmword ptr [RSP + 0x50]
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOV qword ptr [RSP + 0x18],R13
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],R13
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x30],RAX
MOVUPS XMM0,xmmword ptr [RBX]
LEA RAX,[RSP + 0x38]
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RSP + 0x48],R13
MOV qword ptr [RSP + 0x10],RBP
LAB_001ceac8:
MOV RDI,RBP
MOV RBX,R14
MOV RSI,R14
LEA R14,[RSP + 0x10]
MOV RDX,R14
CALL 0x001cf542
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
LEA R13,[RSP + 0xc]
JZ 0x001cec02
MOV dword ptr [RSP + 0x10],EAX
TEST EAX,EAX
JLE 0x001cec23
LAB_001ceafd:
MOV EDX,0x10
MOV RDI,R12
LEA RSI,[RSP + 0xa0]
CALL 0x0011bb20
MOV EDX,0x4
MOV RDI,R12
MOV RSI,R14
CALL 0x0011bb20
MOV R14,qword ptr [RSP + 0x28]
LAB_001ceb27:
TEST R14,R14
JZ 0x001ceb6b
MOV EAX,dword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0xc]
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x8],ECX
TEST ECX,ECX
JLE 0x001cebe1
LAB_001ceb44:
MOV EDX,0x4
MOV RDI,R12
MOV RSI,R13
CALL 0x0011bb20
MOV EDX,0x4
MOV RDI,R12
LEA RSI,[RSP + 0x8]
CALL 0x0011bb20
MOV R14,qword ptr [R14]
JMP 0x001ceb27
LAB_001ceb6b:
MOV RDI,RBP
CALL 0x001227a2
MOV R14,RBX
MOV RDI,RBX
CALL 0x001227a2
MOV R15,qword ptr [R15]
TEST R15,R15
LEA RCX,[RSP + 0x80]
MOV EDX,0x0
JNZ 0x001cea38
LAB_001ceb97:
MOV RAX,qword ptr [0x0022ff40]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x18]
LEA RDI,[RSP + 0xc0]
MOV qword ptr [RDI + -0x8],RCX
MOV RCX,qword ptr [RCX + -0x18]
MOV qword ptr [RSP + RCX*0x1 + 0xb8],RAX
CALL 0x0011b730
LEA RDI,[RSP + 0x1b0]
CALL 0x0011b2b0
ADD RSP,0x2b8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cebe1:
LEA RDI,[0x1f8f7e]
LEA RDX,[0x1efc83]
LEA RCX,[0x1f9021]
MOV ESI,0xd5
XOR EAX,EAX
CALL 0x0011be90
LAB_001cec02:
LEA RDI,[0x1f8f7e]
LEA RDX,[0x1efc83]
LEA RCX,[0x1f8fff]
MOV ESI,0xcc
XOR EAX,EAX
CALL 0x0011be90
LAB_001cec23:
LEA RDI,[0x1f8f7e]
LEA RDX,[0x1efc83]
LEA RCX,[0x1f9015]
MOV ESI,0xce
XOR EAX,EAX
CALL 0x0011be90
|
/* common_ngram_cache_save(std::unordered_map<common_ngram, std::unordered_map<int, int,
std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int> > >,
common_ngram_hash_function, std::equal_to<common_ngram>, std::allocator<std::pair<common_ngram
const, std::unordered_map<int, int, std::hash<int>, std::equal_to<int>,
std::allocator<std::pair<int const, int> > > > > >&, std::__cxx11::string&) */
void common_ngram_cache_save(unordered_map *param_1,string *param_2)
{
int8 *puVar1;
long *plVar2;
int local_2e0;
int4 local_2dc;
_Hashtable *local_2d8;
_Hashtable *local_2d0;
long local_2c8;
int8 *local_2c0;
long local_2b8;
long local_2b0;
long lStack_2a8;
int8 local_2a0;
long local_298;
long lStack_290;
int8 local_288;
long local_280;
int8 local_278;
long local_270;
long local_268;
long lStack_260;
int8 local_258;
long local_248;
long lStack_240;
long local_230;
filebuf local_228 [240];
ios_base local_138 [264];
std::ofstream::ofstream((ofstream *)&local_230,param_2,4);
plVar2 = *(long **)(param_1 + 0x10);
if (plVar2 != (long *)0x0) {
do {
local_298 = plVar2[1];
lStack_290 = plVar2[2];
local_288 = 0;
local_280 = plVar2[4];
local_278 = 0;
local_270 = plVar2[6];
local_268 = plVar2[7];
lStack_260 = plVar2[8];
local_258 = 0;
local_2d0 = (_Hashtable *)&local_288;
/* try { // try from 001cea77 to 001cea87 has its CatchHandler @ 001cec44 */
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::
_M_assign<std::_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int_const,int>,false>>>>
((_Hashtable *)&local_288,(_AllocNode *)(plVar2 + 3));
local_248 = local_298;
lStack_240 = lStack_290;
local_2d0 = (_Hashtable *)0x0;
local_2c8 = local_280;
local_2c0 = (int8 *)0x0;
local_2b8 = local_270;
local_2b0 = local_268;
lStack_2a8 = lStack_260;
local_2a0 = 0;
/* try { // try from 001ceac8 to 001ceadd has its CatchHandler @ 001cec49 */
local_2d8 = (_Hashtable *)&local_2d0;
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::
_M_assign<std::_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>const&,std::__detail::_AllocNode<std::allocator<std::__detail::_Hash_node<std::pair<int_const,int>,false>>>>
((_Hashtable *)&local_2d0,(_AllocNode *)&local_288);
if (local_2b8 == 0) {
/* try { // try from 001cec02 to 001cec22 has its CatchHandler @ 001cec50 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp"
,0xcc,"GGML_ASSERT(%s) failed","!token_counts.empty()");
}
local_2d8 = (_Hashtable *)CONCAT44(local_2d8._4_4_,(int)local_2b8);
if ((int)local_2b8 < 1) {
/* try { // try from 001cec23 to 001cec43 has its CatchHandler @ 001cec4e */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp"
,0xce,"GGML_ASSERT(%s) failed","ntokens > 0");
}
/* try { // try from 001ceafd to 001ceb21 has its CatchHandler @ 001cec52 */
std::ostream::write((char *)&local_230,(long)&local_248);
std::ostream::write((char *)&local_230,(long)&local_2d8);
for (puVar1 = local_2c0; puVar1 != (int8 *)0x0; puVar1 = (int8 *)*puVar1) {
local_2dc = *(int4 *)(puVar1 + 1);
local_2e0 = *(int *)((long)puVar1 + 0xc);
if (local_2e0 < 1) {
/* try { // try from 001cebe1 to 001cec01 has its CatchHandler @ 001cec54 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/ngram-cache.cpp"
,0xd5,"GGML_ASSERT(%s) failed","count > 0");
}
/* try { // try from 001ceb44 to 001ceb65 has its CatchHandler @ 001cec56 */
std::ostream::write((char *)&local_230,(long)&local_2dc);
std::ostream::write((char *)&local_230,(long)&local_2e0);
}
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)&local_2d0);
std::
_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::~_Hashtable((_Hashtable<int,std::pair<int_const,int>,std::allocator<std::pair<int_const,int>>,std::__detail::_Select1st,std::equal_to<int>,std::hash<int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)&local_288);
plVar2 = (long *)*plVar2;
} while (plVar2 != (long *)0x0);
}
local_230 = *(long *)PTR_VTT_0022ff40;
*(int8 *)(local_228 + *(long *)(local_230 + -0x18) + -8) =
*(int8 *)(PTR_VTT_0022ff40 + 0x18);
std::filebuf::~filebuf(local_228);
std::ios_base::~ios_base(local_138);
return;
}
|
|
16,092
|
mpvio_info
|
eloqsql/libmariadb/plugins/auth/my_auth.c
|
void mpvio_info(MARIADB_PVIO *pvio, MYSQL_PLUGIN_VIO_INFO *info)
{
memset(info, 0, sizeof(*info));
switch (pvio->type) {
case PVIO_TYPE_SOCKET:
info->protocol= MYSQL_VIO_TCP;
ma_pvio_get_handle(pvio, &info->socket);
return;
case PVIO_TYPE_UNIXSOCKET:
info->protocol= MYSQL_VIO_SOCKET;
ma_pvio_get_handle(pvio, &info->socket);
return;
/*
case VIO_TYPE_SSL:
{
struct sockaddr addr;
SOCKET_SIZE_TYPE addrlen= sizeof(addr);
if (getsockname(vio->sd, &addr, &addrlen))
return;
info->protocol= addr.sa_family == AF_UNIX ?
MYSQL_VIO_SOCKET : MYSQL_VIO_TCP;
info->socket= vio->sd;
return;
}
*/
#ifdef _WIN32
/*
case VIO_TYPE_NAMEDPIPE:
info->protocol= MYSQL_VIO_PIPE;
info->handle= vio->hPipe;
return;
*/
/* not supported yet
case VIO_TYPE_SHARED_MEMORY:
info->protocol= MYSQL_VIO_MEMORY;
info->handle= vio->handle_file_map;
return;
*/
#endif
default: DBUG_ASSERT(0);
}
}
|
O3
|
c
|
mpvio_info:
pushq %rbp
movq %rsp, %rbp
movq $0x0, (%rsi)
movl 0x20(%rdi), %eax
cmpl $0x1, %eax
je 0x2da03
testl %eax, %eax
jne 0x2da0f
movl $0x2, %eax
movl %eax, (%rsi)
addq $0x4, %rsi
popq %rbp
jmp 0x1d4a3
popq %rbp
retq
|
mpvio_info:
push rbp
mov rbp, rsp
mov qword ptr [rsi], 0
mov eax, [rdi+20h]
cmp eax, 1
jz short loc_2DA03
test eax, eax
jnz short loc_2DA0F
mov eax, 2
loc_2DA03:
mov [rsi], eax
add rsi, 4
pop rbp
jmp ma_pvio_get_handle
loc_2DA0F:
pop rbp
retn
|
char mpvio_info(long long a1, _QWORD *a2)
{
int v2; // eax
*a2 = 0LL;
v2 = *(_DWORD *)(a1 + 32);
if ( v2 == 1 )
goto LABEL_4;
if ( !v2 )
{
v2 = 2;
LABEL_4:
*(_DWORD *)a2 = v2;
LOBYTE(v2) = ma_pvio_get_handle(a1);
}
return v2;
}
|
mpvio_info:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RSI],0x0
MOV EAX,dword ptr [RDI + 0x20]
CMP EAX,0x1
JZ 0x0012da03
TEST EAX,EAX
JNZ 0x0012da0f
MOV EAX,0x2
LAB_0012da03:
MOV dword ptr [RSI],EAX
ADD RSI,0x4
POP RBP
JMP 0x0011d4a3
LAB_0012da0f:
POP RBP
RET
|
void mpvio_info(long param_1,int *param_2)
{
int iVar1;
param_2[0] = 0;
param_2[1] = 0;
iVar1 = *(int *)(param_1 + 0x20);
if (iVar1 != 1) {
if (iVar1 != 0) {
return;
}
iVar1 = 2;
}
*param_2 = iVar1;
ma_pvio_get_handle(param_1,param_2 + 1);
return;
}
|
|
16,093
|
my_snprintf_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_snprintf_utf32(CHARSET_INFO *cs __attribute__((unused)),
char* to, size_t n, const char* fmt, ...)
{
size_t ret;
va_list args;
va_start(args,fmt);
ret= my_vsnprintf_utf32(to, n, fmt, args);
va_end(args);
return ret;
}
|
O3
|
c
|
my_snprintf_utf32:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
leaq -0x120(%rbp), %rcx
movq %r8, 0x20(%rcx)
movq %r9, 0x28(%rcx)
testb %al, %al
je 0xc4ad3
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movabsq $0x3000000020, %rax # imm = 0x3000000020
movq %rax, -0x60(%rbp)
addq %rsi, %rbx
leaq -0x40(%rbp), %r14
movq %rsi, -0x68(%rbp)
movzbl (%r15), %eax
cmpl $0x25, %eax
je 0xc4b3d
testl %eax, %eax
je 0xc4cbe
cmpq %rbx, %r12
jae 0xc4cbe
movw $0x0, (%r12)
movb $0x0, 0x2(%r12)
movb (%r15), %al
movb %al, 0x3(%r12)
addq $0x4, %r12
incq %r15
jmp 0xc4b05
addq $0x2, %r15
movb -0x1(%r15), %al
leal -0x30(%rax), %ecx
cmpb $0xa, %cl
jb 0xc4b58
movzbl %al, %ecx
leal -0x2d(%rcx), %edx
cmpl $0x2, %edx
jae 0xc4b5d
incq %r15
jmp 0xc4b41
cmpl $0x6c, %ecx
jne 0xc4b67
movb (%r15), %al
jmp 0xc4b6a
decq %r15
cmpb $0x64, %al
je 0xc4b9a
movzbl %al, %eax
cmpl $0x75, %eax
je 0xc4b9a
cmpl $0x73, %eax
jne 0xc4bc2
movl -0x60(%rbp), %ecx
cmpq $0x28, %rcx
ja 0xc4c3b
movq %rcx, %rax
addq -0x50(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x60(%rbp)
jmp 0xc4c47
movq %rbx, %rax
subq %r12, %rax
cmpq $0x3f, %rax
jbe 0xc4cbe
movl -0x60(%rbp), %ecx
cmpq $0x28, %rcx
ja 0xc4bd8
movq %rcx, %rax
addq -0x50(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x60(%rbp)
jmp 0xc4be4
cmpq %rbx, %r12
je 0xc4cbb
movl $0x25000000, (%r12) # imm = 0x25000000
jmp 0xc4b34
movq -0x58(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movslq (%rax), %rdi
cmpb $0x64, (%r15)
jne 0xc4bf7
movq %r14, %rsi
movl $0xfffffff6, %edx # imm = 0xFFFFFFF6
jmp 0xc4c01
movl %edi, %edi
movq %r14, %rsi
movl $0xa, %edx
callq 0xd5802
cmpb $0x0, -0x40(%rbp)
je 0xc4b38
leaq -0x3f(%rbp), %rax
movw $0x0, (%r12)
movb $0x0, 0x2(%r12)
movb -0x1(%rax), %cl
movb %cl, 0x3(%r12)
addq $0x4, %r12
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0xc4c14
jmp 0xc4b38
movq -0x58(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x58(%rbp)
movq (%rax), %r13
movq %rbx, %r14
subq %r12, %r14
testq %r13, %r13
leaq 0x1a381(%rip), %rax # 0xdefdb
cmoveq %rax, %r13
movq %r13, %rdi
callq 0x29350
leaq (,%rax,4), %rdx
movq %r14, %rcx
shrq $0x2, %rcx
decq %rcx
cmpq %rdx, %r14
cmovaq %rax, %rcx
testq %rcx, %rcx
je 0xc4cb2
xorl %eax, %eax
leaq -0x40(%rbp), %r14
movw $0x0, (%r12)
movb $0x0, 0x2(%r12)
movb (%r13,%rax), %dl
movb %dl, 0x3(%r12)
addq $0x4, %r12
incq %rax
cmpq %rax, %rcx
jne 0xc4c8a
jmp 0xc4b38
leaq -0x40(%rbp), %r14
jmp 0xc4b38
movq %rbx, %r12
movl $0x0, (%r12)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xc4cee
subq -0x68(%rbp), %r12
movq %r12, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
my_snprintf_utf32:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r15, rcx
mov rbx, rdx
mov r12, rsi
lea rcx, [rbp+var_120]
mov [rcx+20h], r8
mov [rcx+28h], r9
test al, al
jz short loc_C4AD3
movaps [rbp+var_F0], xmm0
movaps [rbp+var_E0], xmm1
movaps [rbp+var_D0], xmm2
movaps [rbp+var_C0], xmm3
movaps [rbp+var_B0], xmm4
movaps [rbp+var_A0], xmm5
movaps [rbp+var_90], xmm6
movaps [rbp+var_80], xmm7
loc_C4AD3:
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_50], rcx
lea rax, [rbp+arg_0]
mov [rbp+var_58], rax
mov rax, 3000000020h
mov [rbp+var_60], rax
add rbx, rsi
lea r14, [rbp+var_40]
mov [rbp+var_68], rsi
loc_C4B05:
movzx eax, byte ptr [r15]
cmp eax, 25h ; '%'
jz short loc_C4B3D
test eax, eax
jz loc_C4CBE
cmp r12, rbx
jnb loc_C4CBE
mov word ptr [r12], 0
mov byte ptr [r12+2], 0
mov al, [r15]
mov [r12+3], al
loc_C4B34:
add r12, 4
loc_C4B38:
inc r15
jmp short loc_C4B05
loc_C4B3D:
add r15, 2
loc_C4B41:
mov al, [r15-1]
lea ecx, [rax-30h]
cmp cl, 0Ah
jb short loc_C4B58
movzx ecx, al
lea edx, [rcx-2Dh]
cmp edx, 2
jnb short loc_C4B5D
loc_C4B58:
inc r15
jmp short loc_C4B41
loc_C4B5D:
cmp ecx, 6Ch ; 'l'
jnz short loc_C4B67
mov al, [r15]
jmp short loc_C4B6A
loc_C4B67:
dec r15
loc_C4B6A:
cmp al, 64h ; 'd'
jz short loc_C4B9A
movzx eax, al
cmp eax, 75h ; 'u'
jz short loc_C4B9A
cmp eax, 73h ; 's'
jnz short loc_C4BC2
mov ecx, dword ptr [rbp+var_60]
cmp rcx, 28h ; '('
ja loc_C4C3B
mov rax, rcx
add rax, [rbp+var_50]
add ecx, 8
mov dword ptr [rbp+var_60], ecx
jmp loc_C4C47
loc_C4B9A:
mov rax, rbx
sub rax, r12
cmp rax, 3Fh ; '?'
jbe loc_C4CBE
mov ecx, dword ptr [rbp+var_60]
cmp rcx, 28h ; '('
ja short loc_C4BD8
mov rax, rcx
add rax, [rbp+var_50]
add ecx, 8
mov dword ptr [rbp+var_60], ecx
jmp short loc_C4BE4
loc_C4BC2:
cmp r12, rbx
jz loc_C4CBB
mov dword ptr [r12], 25000000h
jmp loc_C4B34
loc_C4BD8:
mov rax, [rbp+var_58]
lea rcx, [rax+8]
mov [rbp+var_58], rcx
loc_C4BE4:
movsxd rdi, dword ptr [rax]
cmp byte ptr [r15], 64h ; 'd'
jnz short loc_C4BF7
mov rsi, r14
mov edx, 0FFFFFFF6h
jmp short loc_C4C01
loc_C4BF7:
mov edi, edi
mov rsi, r14
mov edx, 0Ah
loc_C4C01:
call int10_to_str
cmp [rbp+var_40], 0
jz loc_C4B38
lea rax, [rbp+var_3F]
loc_C4C14:
mov word ptr [r12], 0
mov byte ptr [r12+2], 0
mov cl, [rax-1]
mov [r12+3], cl
add r12, 4
cmp byte ptr [rax], 0
lea rax, [rax+1]
jnz short loc_C4C14
jmp loc_C4B38
loc_C4C3B:
mov rax, [rbp+var_58]
lea rcx, [rax+8]
mov [rbp+var_58], rcx
loc_C4C47:
mov r13, [rax]
mov r14, rbx
sub r14, r12
test r13, r13
lea rax, aNull; "(null)"
cmovz r13, rax
mov rdi, r13
call _strlen
lea rdx, ds:0[rax*4]
mov rcx, r14
shr rcx, 2
dec rcx
cmp r14, rdx
cmova rcx, rax
test rcx, rcx
jz short loc_C4CB2
xor eax, eax
lea r14, [rbp+var_40]
loc_C4C8A:
mov word ptr [r12], 0
mov byte ptr [r12+2], 0
mov dl, [r13+rax+0]
mov [r12+3], dl
add r12, 4
inc rax
cmp rcx, rax
jnz short loc_C4C8A
jmp loc_C4B38
loc_C4CB2:
lea r14, [rbp+var_40]
jmp loc_C4B38
loc_C4CBB:
mov r12, rbx
loc_C4CBE:
mov dword ptr [r12], 0
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_C4CEE
sub r12, [rbp+var_68]
mov rax, r12
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C4CEE:
call ___stack_chk_fail
|
unsigned long long my_snprintf_utf32(
__m128 a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
long long a9,
unsigned long long a10,
long long a11,
unsigned __int8 *a12,
long long a13,
long long a14,
char a15)
{
unsigned long long v16; // r12
unsigned long long v17; // rbx
unsigned __int8 v18; // al
const char **v19; // rax
char *v20; // rax
long long v21; // rdi
long long v22; // rdx
char *v23; // rax
const char *v25; // r13
unsigned long long v26; // r14
long long v27; // rax
long long v28; // rcx
long long i; // rax
char v31; // [rsp+0h] [rbp-120h] BYREF
long long v32; // [rsp+20h] [rbp-100h]
long long v33; // [rsp+28h] [rbp-F8h]
__m128 v34; // [rsp+30h] [rbp-F0h]
__m128 v35; // [rsp+40h] [rbp-E0h]
__m128 v36; // [rsp+50h] [rbp-D0h]
__m128 v37; // [rsp+60h] [rbp-C0h]
__m128 v38; // [rsp+70h] [rbp-B0h]
__m128 v39; // [rsp+80h] [rbp-A0h]
__m128 v40; // [rsp+90h] [rbp-90h]
__m128 v41; // [rsp+A0h] [rbp-80h]
unsigned long long v42; // [rsp+B8h] [rbp-68h]
long long v43; // [rsp+C0h] [rbp-60h]
char *v44; // [rsp+C8h] [rbp-58h]
char *v45; // [rsp+D0h] [rbp-50h]
char v46; // [rsp+E0h] [rbp-40h] BYREF
char v47; // [rsp+E1h] [rbp-3Fh] BYREF
unsigned long long v48; // [rsp+F0h] [rbp-30h]
v34 = a1;
v35 = a2;
v36 = a3;
v37 = a4;
v38 = a5;
v39 = a6;
v40 = a7;
v41 = a8;
v16 = a10;
v32 = a13;
v33 = a14;
v48 = __readfsqword(0x28u);
v45 = &v31;
v44 = &a15;
v43 = 0x3000000020LL;
v17 = a10 + a11;
v42 = a10;
while ( 1 )
{
if ( *a12 != 37 )
{
if ( !*a12 || v16 >= v17 )
goto LABEL_44;
*(_WORD *)v16 = 0;
*(_BYTE *)(v16 + 2) = 0;
*(_BYTE *)(v16 + 3) = *a12;
goto LABEL_6;
}
for ( a12 += 2; ; ++a12 )
{
v18 = *(a12 - 1);
if ( (unsigned __int8)(v18 - 48) >= 0xAu && (unsigned int)v18 - 45 >= 2 )
break;
}
if ( v18 == 108 )
v18 = *a12;
else
--a12;
if ( v18 != 100 && v18 != 117 )
break;
if ( v17 - v16 <= 0x3F )
goto LABEL_44;
if ( (unsigned int)v43 > 0x28uLL )
{
v20 = v44;
v44 += 8;
}
else
{
v20 = &v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
v21 = *(int *)v20;
if ( *a12 == 100 )
{
v22 = 4294967286LL;
}
else
{
v21 = (unsigned int)v21;
v22 = 10LL;
}
int10_to_str(v21, &v46, v22);
if ( v46 )
{
v23 = &v47;
do
{
*(_WORD *)v16 = 0;
*(_BYTE *)(v16 + 2) = 0;
*(_BYTE *)(v16 + 3) = *(v23 - 1);
v16 += 4LL;
}
while ( *v23++ != 0 );
}
LABEL_7:
++a12;
}
if ( v18 == 115 )
{
if ( (unsigned int)v43 > 0x28uLL )
{
v19 = (const char **)v44;
v44 += 8;
}
else
{
v19 = (const char **)&v45[(unsigned int)v43];
LODWORD(v43) = v43 + 8;
}
v25 = *v19;
v26 = v17 - v16;
if ( !*v19 )
v25 = "(null)";
v27 = strlen(v25);
v28 = (v26 >> 2) - 1;
if ( v26 > 4 * v27 )
v28 = v27;
if ( v28 )
{
for ( i = 0LL; i != v28; ++i )
{
*(_WORD *)v16 = 0;
*(_BYTE *)(v16 + 2) = 0;
*(_BYTE *)(v16 + 3) = v25[i];
v16 += 4LL;
}
}
goto LABEL_7;
}
if ( v16 != v17 )
{
*(_DWORD *)v16 = 620756992;
LABEL_6:
v16 += 4LL;
goto LABEL_7;
}
v16 = v17;
LABEL_44:
*(_DWORD *)v16 = 0;
return v16 - v42;
}
|
my_snprintf_utf32:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R15,RCX
MOV RBX,RDX
MOV R12,RSI
LEA RCX,[RBP + -0x120]
MOV qword ptr [RCX + 0x20],R8
MOV qword ptr [RCX + 0x28],R9
TEST AL,AL
JZ 0x001c4ad3
MOVAPS xmmword ptr [RBP + -0xf0],XMM0
MOVAPS xmmword ptr [RBP + -0xe0],XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM2
MOVAPS xmmword ptr [RBP + -0xc0],XMM3
MOVAPS xmmword ptr [RBP + -0xb0],XMM4
MOVAPS xmmword ptr [RBP + -0xa0],XMM5
MOVAPS xmmword ptr [RBP + -0x90],XMM6
MOVAPS xmmword ptr [RBP + -0x80],XMM7
LAB_001c4ad3:
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x50],RCX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,0x3000000020
MOV qword ptr [RBP + -0x60],RAX
ADD RBX,RSI
LEA R14,[RBP + -0x40]
MOV qword ptr [RBP + -0x68],RSI
LAB_001c4b05:
MOVZX EAX,byte ptr [R15]
CMP EAX,0x25
JZ 0x001c4b3d
TEST EAX,EAX
JZ 0x001c4cbe
CMP R12,RBX
JNC 0x001c4cbe
MOV word ptr [R12],0x0
MOV byte ptr [R12 + 0x2],0x0
MOV AL,byte ptr [R15]
MOV byte ptr [R12 + 0x3],AL
LAB_001c4b34:
ADD R12,0x4
LAB_001c4b38:
INC R15
JMP 0x001c4b05
LAB_001c4b3d:
ADD R15,0x2
LAB_001c4b41:
MOV AL,byte ptr [R15 + -0x1]
LEA ECX,[RAX + -0x30]
CMP CL,0xa
JC 0x001c4b58
MOVZX ECX,AL
LEA EDX,[RCX + -0x2d]
CMP EDX,0x2
JNC 0x001c4b5d
LAB_001c4b58:
INC R15
JMP 0x001c4b41
LAB_001c4b5d:
CMP ECX,0x6c
JNZ 0x001c4b67
MOV AL,byte ptr [R15]
JMP 0x001c4b6a
LAB_001c4b67:
DEC R15
LAB_001c4b6a:
CMP AL,0x64
JZ 0x001c4b9a
MOVZX EAX,AL
CMP EAX,0x75
JZ 0x001c4b9a
CMP EAX,0x73
JNZ 0x001c4bc2
MOV ECX,dword ptr [RBP + -0x60]
CMP RCX,0x28
JA 0x001c4c3b
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x50]
ADD ECX,0x8
MOV dword ptr [RBP + -0x60],ECX
JMP 0x001c4c47
LAB_001c4b9a:
MOV RAX,RBX
SUB RAX,R12
CMP RAX,0x3f
JBE 0x001c4cbe
MOV ECX,dword ptr [RBP + -0x60]
CMP RCX,0x28
JA 0x001c4bd8
MOV RAX,RCX
ADD RAX,qword ptr [RBP + -0x50]
ADD ECX,0x8
MOV dword ptr [RBP + -0x60],ECX
JMP 0x001c4be4
LAB_001c4bc2:
CMP R12,RBX
JZ 0x001c4cbb
MOV dword ptr [R12],0x25000000
JMP 0x001c4b34
LAB_001c4bd8:
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x58],RCX
LAB_001c4be4:
MOVSXD RDI,dword ptr [RAX]
CMP byte ptr [R15],0x64
JNZ 0x001c4bf7
MOV RSI,R14
MOV EDX,0xfffffff6
JMP 0x001c4c01
LAB_001c4bf7:
MOV EDI,EDI
MOV RSI,R14
MOV EDX,0xa
LAB_001c4c01:
CALL 0x001d5802
CMP byte ptr [RBP + -0x40],0x0
JZ 0x001c4b38
LEA RAX,[RBP + -0x3f]
LAB_001c4c14:
MOV word ptr [R12],0x0
MOV byte ptr [R12 + 0x2],0x0
MOV CL,byte ptr [RAX + -0x1]
MOV byte ptr [R12 + 0x3],CL
ADD R12,0x4
CMP byte ptr [RAX],0x0
LEA RAX,[RAX + 0x1]
JNZ 0x001c4c14
JMP 0x001c4b38
LAB_001c4c3b:
MOV RAX,qword ptr [RBP + -0x58]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RBP + -0x58],RCX
LAB_001c4c47:
MOV R13,qword ptr [RAX]
MOV R14,RBX
SUB R14,R12
TEST R13,R13
LEA RAX,[0x1defdb]
CMOVZ R13,RAX
MOV RDI,R13
CALL 0x00129350
LEA RDX,[RAX*0x4]
MOV RCX,R14
SHR RCX,0x2
DEC RCX
CMP R14,RDX
CMOVA RCX,RAX
TEST RCX,RCX
JZ 0x001c4cb2
XOR EAX,EAX
LEA R14,[RBP + -0x40]
LAB_001c4c8a:
MOV word ptr [R12],0x0
MOV byte ptr [R12 + 0x2],0x0
MOV DL,byte ptr [R13 + RAX*0x1]
MOV byte ptr [R12 + 0x3],DL
ADD R12,0x4
INC RAX
CMP RCX,RAX
JNZ 0x001c4c8a
JMP 0x001c4b38
LAB_001c4cb2:
LEA R14,[RBP + -0x40]
JMP 0x001c4b38
LAB_001c4cbb:
MOV R12,RBX
LAB_001c4cbe:
MOV dword ptr [R12],0x0
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001c4cee
SUB R12,qword ptr [RBP + -0x68]
MOV RAX,R12
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c4cee:
CALL 0x00129270
|
long my_snprintf_utf32(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,int4 *param_10,long param_11,byte *param_12,
int8 param_13,int8 param_14)
{
char in_AL;
byte bVar1;
uint *puVar2;
size_t sVar3;
size_t sVar4;
int8 uVar5;
int4 *puVar6;
ulong uVar7;
int4 *puVar8;
char *pcVar9;
long in_FS_OFFSET;
int1 local_128 [32];
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int4 *local_70;
ulong local_68;
uint *local_60;
int1 *local_58;
char local_48 [16];
long local_38;
local_58 = local_128;
if (in_AL != '\0') {
local_f8 = param_1;
local_e8 = param_2;
local_d8 = param_3;
local_c8 = param_4;
local_b8 = param_5;
local_a8 = param_6;
local_98 = param_7;
local_88 = param_8;
}
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = (uint *)&stack0x00000008;
local_68 = 0x3000000020;
puVar6 = (int4 *)(param_11 + (long)param_10);
local_108 = param_13;
local_100 = param_14;
local_70 = param_10;
do {
puVar8 = param_10;
if (*param_12 == 0x25) {
param_12 = param_12 + 2;
while ((bVar1 = param_12[-1], (byte)(bVar1 - 0x30) < 10 || (bVar1 - 0x2d < 2))) {
param_12 = param_12 + 1;
}
if (bVar1 == 0x6c) {
bVar1 = *param_12;
}
else {
param_12 = param_12 + -1;
}
if ((bVar1 == 100) || (bVar1 == 0x75)) {
if ((ulong)((long)puVar6 - (long)param_10) < 0x40) {
LAB_001c4cbe:
*puVar8 = 0;
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)puVar8 - (long)local_70;
}
uVar7 = local_68 & 0xffffffff;
if (uVar7 < 0x29) {
local_68 = CONCAT44(local_68._4_4_,(int)local_68 + 8);
puVar2 = (uint *)(local_58 + uVar7);
}
else {
puVar2 = local_60;
local_60 = local_60 + 2;
}
uVar7 = (ulong)(int)*puVar2;
if (*param_12 == 100) {
uVar5 = 0xfffffff6;
}
else {
uVar7 = (ulong)*puVar2;
uVar5 = 10;
}
int10_to_str(uVar7,local_48,uVar5);
if (local_48[0] != '\0') {
pcVar9 = local_48;
do {
pcVar9 = pcVar9 + 1;
*(int2 *)param_10 = 0;
*(int1 *)((long)param_10 + 2) = 0;
*(char *)((long)param_10 + 3) = pcVar9[-1];
param_10 = param_10 + 1;
} while (*pcVar9 != '\0');
}
}
else {
if (bVar1 != 0x73) {
puVar8 = puVar6;
if (param_10 != puVar6) {
*param_10 = 0x25000000;
goto LAB_001c4b34;
}
goto LAB_001c4cbe;
}
uVar7 = local_68 & 0xffffffff;
if (uVar7 < 0x29) {
local_68 = CONCAT44(local_68._4_4_,(int)local_68 + 8);
puVar2 = (uint *)(local_58 + uVar7);
}
else {
puVar2 = local_60;
local_60 = local_60 + 2;
}
pcVar9 = *(char **)puVar2;
if (pcVar9 == (char *)0x0) {
pcVar9 = "(null)";
}
sVar3 = strlen(pcVar9);
sVar4 = ((ulong)((long)puVar6 - (long)param_10) >> 2) - 1;
if (sVar3 * 4 < (ulong)((long)puVar6 - (long)param_10)) {
sVar4 = sVar3;
}
if (sVar4 != 0) {
sVar3 = 0;
do {
*(int2 *)param_10 = 0;
*(int1 *)((long)param_10 + 2) = 0;
*(char *)((long)param_10 + 3) = pcVar9[sVar3];
param_10 = param_10 + 1;
sVar3 = sVar3 + 1;
} while (sVar4 != sVar3);
}
}
}
else {
if ((*param_12 == 0) || (puVar6 <= param_10)) goto LAB_001c4cbe;
*(int2 *)param_10 = 0;
*(int1 *)((long)param_10 + 2) = 0;
*(byte *)((long)param_10 + 3) = *param_12;
LAB_001c4b34:
param_10 = param_10 + 1;
}
param_12 = param_12 + 1;
} while( true );
}
|
|
16,094
|
minja::Parser::unterminated(minja::TemplateToken const&) const
|
monkey531[P]llama/common/minja.hpp
|
std::runtime_error unterminated(const TemplateToken & token) const {
return std::runtime_error("Unterminated " + TemplateToken::typeToString(token.type)
+ error_location_suffix(*template_str, token.location.pos));
}
|
O2
|
cpp
|
minja::Parser::unterminated(minja::TemplateToken const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rdx), %esi
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x72444
leaq 0x41f60(%rip), %rsi # 0xb3a16
leaq 0x28(%rsp), %rdi
movq %r12, %rdx
callq 0x58156
movq (%r15), %rsi
movq 0x20(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5768a
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x38e27
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e50
leaq 0x48(%rsp), %rdi
callq 0x241d8
leaq 0x8(%rsp), %rdi
callq 0x241d8
leaq 0x28(%rsp), %rdi
callq 0x241d8
leaq 0x68(%rsp), %rdi
callq 0x241d8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x241d8
jmp 0x71b41
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241d8
jmp 0x71b50
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x241d8
jmp 0x71b5f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x241d8
movq %rbx, %rdi
callq 0x23fa0
nop
|
_ZNK5minja6Parser12unterminatedERKNS_13TemplateTokenE:
push r15
push r14
push r12
push rbx
sub rsp, 88h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov esi, [rdx+8]
lea r12, [rsp+0A8h+var_40]
mov rdi, r12
call _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE; minja::TemplateToken::typeToString(minja::TemplateToken::Type)
lea rsi, aUnterminated; "Unterminated "
lea rdi, [rsp+0A8h+var_80]
mov rdx, r12
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov rsi, [r15]
mov rdx, [r14+20h]
lea rdi, [rsp+0A8h+var_A0]
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
lea rdi, [rsp+0A8h+var_60]
lea rsi, [rsp+0A8h+var_80]
lea rdx, [rsp+0A8h+var_A0]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rsi, [rsp+0A8h+var_60]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_80]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+0A8h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_71B41
mov rbx, rax
loc_71B41:
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_71B50
mov rbx, rax
loc_71B50:
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_71B5F
mov rbx, rax
loc_71B5F:
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::unterminated(minja::Parser *this, const minja::TemplateToken *a2, long long a3)
{
_QWORD v5[4]; // [rsp+8h] [rbp-A0h] BYREF
_QWORD v6[4]; // [rsp+28h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+48h] [rbp-60h] BYREF
_BYTE v8[64]; // [rsp+68h] [rbp-40h] BYREF
minja::TemplateToken::typeToString[abi:cxx11](v8, *(unsigned int *)(a3 + 8));
std::operator+<char>((long long)v6, (long long)"Unterminated ", (long long)v8);
minja::error_location_suffix((long long)v5, *(_QWORD *)a2, *(_QWORD *)(a3 + 32));
std::operator+<char>((long long)v7, v6, v5);
std::runtime_error::runtime_error(this, v7);
std::string::~string(v7);
std::string::~string(v5);
std::string::~string(v6);
std::string::~string(v8);
return this;
}
|
unterminated:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV ESI,dword ptr [RDX + 0x8]
LEA R12,[RSP + 0x68]
MOV RDI,R12
CALL 0x00172444
LAB_00171aaf:
LEA RSI,[0x1b3a16]
LEA RDI,[RSP + 0x28]
MOV RDX,R12
CALL 0x00158156
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R14 + 0x20]
LAB_00171aca:
LEA RDI,[RSP + 0x8]
CALL 0x0015768a
LAB_00171ad4:
LEA RDI,[RSP + 0x48]
LEA RSI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00138e27
LAB_00171ae8:
LEA RSI,[RSP + 0x48]
MOV RDI,RBX
CALL 0x00123e50
LAB_00171af5:
LEA RDI,[RSP + 0x48]
CALL 0x001241d8
LEA RDI,[RSP + 0x8]
CALL 0x001241d8
LEA RDI,[RSP + 0x28]
CALL 0x001241d8
LEA RDI,[RSP + 0x68]
CALL 0x001241d8
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::Parser::unterminated(minja::TemplateToken const&) const */
TemplateToken * minja::Parser::unterminated(TemplateToken *param_1)
{
long in_RDX;
int8 *in_RSI;
minja local_a0 [32];
string local_80 [32];
string local_60 [32];
TemplateToken local_40 [32];
TemplateToken::typeToString_abi_cxx11_(local_40,*(int4 *)(in_RDX + 8));
/* try { // try from 00171aaf to 00171ac2 has its CatchHandler @ 00171b5c */
std::operator+((char *)local_80,(string *)"Unterminated ");
/* try { // try from 00171aca to 00171ad3 has its CatchHandler @ 00171b4d */
error_location_suffix(local_a0,(string *)*in_RSI,*(ulong *)(in_RDX + 0x20));
/* try { // try from 00171ad4 to 00171ae7 has its CatchHandler @ 00171b3e */
std::operator+(local_60,local_80);
/* try { // try from 00171ae8 to 00171af4 has its CatchHandler @ 00171b2f */
std::runtime_error::runtime_error((runtime_error *)param_1,local_60);
std::__cxx11::string::~string(local_60);
std::__cxx11::string::~string((string *)local_a0);
std::__cxx11::string::~string(local_80);
std::__cxx11::string::~string((string *)local_40);
return param_1;
}
|
|
16,095
|
my_lengthsp_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_lengthsp_utf32(CHARSET_INFO *cs __attribute__((unused)),
const char *ptr, size_t length)
{
const char *end= ptr + length;
DBUG_ASSERT((length % 4) == 0);
while (end > ptr + 3 && end[-1] == ' ' && !end[-2] && !end[-3] && !end[-4])
end-= 4;
return (size_t) (end - ptr);
}
|
O0
|
c
|
my_lengthsp_utf32:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xff24e
jmp 0xff250
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
addq $0x3, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jbe 0xff2a6
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x21(%rbp)
jne 0xff2a6
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, -0x2(%rcx)
movb %al, -0x21(%rbp)
jne 0xff2a6
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, -0x3(%rcx)
movb %al, -0x21(%rbp)
jne 0xff2a6
movq -0x20(%rbp), %rax
cmpb $0x0, -0x4(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xff2af
jmp 0xff2bd
movq -0x20(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0xff250
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
|
my_lengthsp_utf32:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_20], rax
jmp short $+2
loc_FF24E:
jmp short $+2
loc_FF250:
mov rcx, [rbp+var_20]
mov rdx, [rbp+var_10]
add rdx, 3
xor eax, eax
cmp rcx, rdx
mov [rbp+var_21], al
jbe short loc_FF2A6
mov rax, [rbp+var_20]
movsx ecx, byte ptr [rax-1]
xor eax, eax
cmp ecx, 20h ; ' '
mov [rbp+var_21], al
jnz short loc_FF2A6
mov rcx, [rbp+var_20]
xor eax, eax
cmp byte ptr [rcx-2], 0
mov [rbp+var_21], al
jnz short loc_FF2A6
mov rcx, [rbp+var_20]
xor eax, eax
cmp byte ptr [rcx-3], 0
mov [rbp+var_21], al
jnz short loc_FF2A6
mov rax, [rbp+var_20]
cmp byte ptr [rax-4], 0
setnz al
xor al, 0FFh
mov [rbp+var_21], al
loc_FF2A6:
mov al, [rbp+var_21]
test al, 1
jnz short loc_FF2AF
jmp short loc_FF2BD
loc_FF2AF:
mov rax, [rbp+var_20]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rbp+var_20], rax
jmp short loc_FF250
loc_FF2BD:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
sub rax, rcx
pop rbp
retn
|
long long my_lengthsp_utf32(long long a1, long long a2, long long a3)
{
char v4; // [rsp+1h] [rbp-21h]
unsigned long long i; // [rsp+2h] [rbp-20h]
for ( i = a3 + a2; ; i -= 4LL )
{
v4 = 0;
if ( i > a2 + 3 )
{
v4 = 0;
if ( *(_BYTE *)(i - 1) == 32 )
{
v4 = 0;
if ( !*(_BYTE *)(i - 2) )
{
v4 = 0;
if ( !*(_BYTE *)(i - 3) )
v4 = ~(*(_BYTE *)(i - 4) != 0);
}
}
}
if ( (v4 & 1) == 0 )
break;
}
return i - a2;
}
|
my_lengthsp_utf32:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ff24e
LAB_001ff24e:
JMP 0x001ff250
LAB_001ff250:
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x3
XOR EAX,EAX
CMP RCX,RDX
MOV byte ptr [RBP + -0x21],AL
JBE 0x001ff2a6
MOV RAX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RAX + -0x1]
XOR EAX,EAX
CMP ECX,0x20
MOV byte ptr [RBP + -0x21],AL
JNZ 0x001ff2a6
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP byte ptr [RCX + -0x2],0x0
MOV byte ptr [RBP + -0x21],AL
JNZ 0x001ff2a6
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP byte ptr [RCX + -0x3],0x0
MOV byte ptr [RBP + -0x21],AL
JNZ 0x001ff2a6
MOV RAX,qword ptr [RBP + -0x20]
CMP byte ptr [RAX + -0x4],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x21],AL
LAB_001ff2a6:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x001ff2af
JMP 0x001ff2bd
LAB_001ff2af:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,-0x4
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ff250
LAB_001ff2bd:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
POP RBP
RET
|
long my_lengthsp_utf32(int8 param_1,long param_2,long param_3)
{
bool bVar1;
int8 local_28;
local_28 = param_2 + param_3;
while( true ) {
bVar1 = false;
if ((((param_2 + 3U < local_28) && (bVar1 = false, *(char *)(local_28 - 1) == ' ')) &&
(bVar1 = false, *(char *)(local_28 - 2) == '\0')) &&
(bVar1 = false, *(char *)(local_28 - 3) == '\0')) {
bVar1 = *(char *)(local_28 - 4) == '\0';
}
if (!bVar1) break;
local_28 = local_28 - 4;
}
return local_28 - param_2;
}
|
|
16,096
|
ggml_backend_buffer_init
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp
|
ggml_backend_buffer_t ggml_backend_buffer_init(
ggml_backend_buffer_type_t buft,
struct ggml_backend_buffer_i iface,
void * context,
size_t size) {
ggml_backend_buffer_t buffer = new ggml_backend_buffer {
/* .interface = */ iface,
/* .buft = */ buft,
/* .context = */ context,
/* .size = */ size,
/* .usage = */ GGML_BACKEND_BUFFER_USAGE_ANY
};
return buffer;
}
|
O1
|
cpp
|
ggml_backend_buffer_init:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x68, %edi
callq 0x18090
leaq 0x20(%rsp), %rsi
movl $0x9, %ecx
movq %rax, %rdi
rep movsq (%rsi), %es:(%rdi)
movq %r15, 0x48(%rax)
movq %r14, 0x50(%rax)
movq %rbx, 0x58(%rax)
movl $0x0, 0x60(%rax)
popq %rbx
popq %r14
popq %r15
retq
|
ggml_backend_buffer_init:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov edi, 68h ; 'h'; unsigned __int64
call __Znwm; operator new(ulong)
lea rsi, [rsp+18h+arg_0]
mov ecx, 9
mov rdi, rax
rep movsq
mov [rax+48h], r15
mov [rax+50h], r14
mov [rax+58h], rbx
mov dword ptr [rax+60h], 0
pop rbx
pop r14
pop r15
retn
|
long long ggml_backend_buffer_init(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
char a7)
{
long long result; // rax
result = operator new(0x68uLL);
qmemcpy((void *)result, &a7, 0x48uLL);
*(_QWORD *)(result + 72) = a1;
*(_QWORD *)(result + 80) = a2;
*(_QWORD *)(result + 88) = a3;
*(_DWORD *)(result + 96) = 0;
return result;
}
|
ggml_backend_buffer_init:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV EDI,0x68
CALL 0x00118090
LEA RSI,[RSP + 0x20]
MOV ECX,0x9
MOV RDI,RAX
MOVSQ.REP RDI,RSI
MOV qword ptr [RAX + 0x48],R15
MOV qword ptr [RAX + 0x50],R14
MOV qword ptr [RAX + 0x58],RBX
MOV dword ptr [RAX + 0x60],0x0
POP RBX
POP R14
POP R15
RET
|
void ggml_backend_buffer_init(int8 param_1,int8 param_2,int8 param_3)
{
int8 *puVar1;
long lVar2;
int8 *puVar3;
int8 *puVar4;
byte bVar5;
bVar5 = 0;
puVar1 = (int8 *)operator_new(0x68);
puVar3 = (int8 *)&stack0x00000008;
puVar4 = puVar1;
for (lVar2 = 9; lVar2 != 0; lVar2 = lVar2 + -1) {
*puVar4 = *puVar3;
puVar3 = puVar3 + (ulong)bVar5 * -2 + 1;
puVar4 = puVar4 + (ulong)bVar5 * -2 + 1;
}
puVar1[9] = param_1;
puVar1[10] = param_2;
puVar1[0xb] = param_3;
*(int4 *)(puVar1 + 0xc) = 0;
return;
}
|
|
16,097
|
SettingValueWID::~SettingValueWID()
|
untodesu[P]voxelius/game/client/settings.cc
|
virtual ~SettingValueWID(void) = default;
|
O1
|
cpp
|
SettingValueWID::~SettingValueWID():
pushq %rbx
movq %rdi, %rbx
leaq 0x1e9779(%rip), %rax # 0x2554c8
movq %rax, (%rdi)
movq 0x78(%rdi), %rdi
leaq 0x88(%rbx), %rax
cmpq %rax, %rdi
je 0x6bd6d
movq (%rax), %rsi
incq %rsi
callq 0x268d0
movq %rbx, %rdi
popq %rbx
jmp 0x6bd8e
|
_ZN15SettingValueWIDD2Ev:
push rbx
mov rbx, rdi
lea rax, off_2554C8
mov [rdi], rax
mov rdi, [rdi+78h]; void *
lea rax, [rbx+88h]
cmp rdi, rax
jz short loc_6BD6D
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6BD6D:
mov rdi, rbx; this
pop rbx
jmp _ZN12SettingValueD2Ev; SettingValue::~SettingValue()
|
void SettingValueWID::~SettingValueWID(SettingValueWID *this)
{
char *v2; // rdi
*(_QWORD *)this = &off_2554C8;
v2 = (char *)*((_QWORD *)this + 15);
if ( v2 != (char *)this + 136 )
operator delete(v2, *((_QWORD *)this + 17) + 1LL);
SettingValue::~SettingValue(this);
}
|
~SettingValueWID:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x3554c8]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x78]
LEA RAX,[RBX + 0x88]
CMP RDI,RAX
JZ 0x0016bd6d
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001268d0
LAB_0016bd6d:
MOV RDI,RBX
POP RBX
JMP 0x0016bd8e
|
/* SettingValueWID::~SettingValueWID() */
void __thiscall SettingValueWID::~SettingValueWID(SettingValueWID *this)
{
*(int ***)this = &PTR__SettingValueWID_003554c8;
if (*(SettingValueWID **)(this + 0x78) != this + 0x88) {
operator_delete(*(SettingValueWID **)(this + 0x78),*(long *)(this + 0x88) + 1);
}
SettingValue::~SettingValue((SettingValue *)this);
return;
}
|
|
16,098
|
SettingValueWID::~SettingValueWID()
|
untodesu[P]voxelius/game/client/settings.cc
|
virtual ~SettingValueWID(void) = default;
|
O3
|
cpp
|
SettingValueWID::~SettingValueWID():
pushq %rbx
movq %rdi, %rbx
leaq 0x1e500d(%rip), %rax # 0x2516d8
movq %rax, (%rdi)
movq 0x78(%rdi), %rdi
leaq 0x88(%rbx), %rax
cmpq %rax, %rdi
je 0x6c6e9
movq (%rax), %rsi
incq %rsi
callq 0x268e0
movq %rbx, %rdi
popq %rbx
jmp 0x6c70a
|
_ZN15SettingValueWIDD2Ev:
push rbx
mov rbx, rdi
lea rax, off_2516D8
mov [rdi], rax
mov rdi, [rdi+78h]; void *
lea rax, [rbx+88h]
cmp rdi, rax
jz short loc_6C6E9
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6C6E9:
mov rdi, rbx; this
pop rbx
jmp _ZN12SettingValueD2Ev; SettingValue::~SettingValue()
|
void SettingValueWID::~SettingValueWID(SettingValueWID *this)
{
char *v2; // rdi
*(_QWORD *)this = &off_2516D8;
v2 = (char *)*((_QWORD *)this + 15);
if ( v2 != (char *)this + 136 )
operator delete(v2, *((_QWORD *)this + 17) + 1LL);
SettingValue::~SettingValue(this);
}
|
~SettingValueWID:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x3516d8]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x78]
LEA RAX,[RBX + 0x88]
CMP RDI,RAX
JZ 0x0016c6e9
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001268e0
LAB_0016c6e9:
MOV RDI,RBX
POP RBX
JMP 0x0016c70a
|
/* SettingValueWID::~SettingValueWID() */
void __thiscall SettingValueWID::~SettingValueWID(SettingValueWID *this)
{
*(int ***)this = &PTR__SettingValueWID_003516d8;
if (*(SettingValueWID **)(this + 0x78) != this + 0x88) {
operator_delete(*(SettingValueWID **)(this + 0x78),*(long *)(this + 0x88) + 1);
}
SettingValue::~SettingValue((SettingValue *)this);
return;
}
|
|
16,099
|
translog_prev_buffer_flush_wait
|
eloqsql/storage/maria/ma_loghandler.c
|
my_bool translog_prev_buffer_flush_wait(struct st_translog_buffer *buffer)
{
TRANSLOG_ADDRESS offset= buffer->offset;
TRANSLOG_FILE *file= buffer->file;
uint8 ver= buffer->ver;
DBUG_ENTER("translog_prev_buffer_flush_wait");
DBUG_PRINT("enter", ("buffer: %p #%u offset: " LSN_FMT " "
"prev sent: " LSN_FMT " prev offset: " LSN_FMT,
buffer, (uint) buffer->buffer_no,
LSN_IN_PARTS(buffer->offset),
LSN_IN_PARTS(buffer->prev_sent_to_disk),
LSN_IN_PARTS(buffer->prev_buffer_offset)));
translog_buffer_lock_assert_owner(buffer);
if (buffer->prev_buffer_offset != buffer->prev_sent_to_disk)
{
do {
mysql_cond_wait(&buffer->prev_sent_to_disk_cond, &buffer->mutex);
if (buffer->file != file || buffer->offset != offset ||
buffer->ver != ver)
DBUG_RETURN(1); /* some the thread flushed the buffer already */
} while(buffer->prev_buffer_offset != buffer->prev_sent_to_disk);
}
DBUG_RETURN(0);
}
|
O3
|
c
|
translog_prev_buffer_flush_wait:
movq 0x100020(%rdi), %rax
cmpq 0x1000e0(%rdi), %rax
jne 0x48b4d
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x100010(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x100038(%rdi), %r12
movb 0x1000d9(%rdi), %r13b
leaq 0x1000e8(%rdi), %r14
leaq 0x100090(%rdi), %r15
cmpq $0x0, 0x100118(%rbx)
jne 0x48bcd
movq %r14, %rdi
movq %r15, %rsi
callq 0x29430
movb $0x1, %al
cmpq %r12, 0x100038(%rbx)
jne 0x48be8
movq -0x30(%rbp), %rcx
cmpq %rcx, 0x100010(%rbx)
jne 0x48be8
cmpb %r13b, 0x1000d9(%rbx)
jne 0x48be8
movq 0x100020(%rbx), %rax
cmpq 0x1000e0(%rbx), %rax
jne 0x48b85
jmp 0x48be6
movq %r14, %rdi
movq %r15, %rsi
leaq 0x90f7e(%rip), %rdx # 0xd9b58
movl $0xa24, %ecx # imm = 0xA24
callq 0x2eea0
jmp 0x48b9a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
translog_prev_buffer_flush_wait:
mov rax, ds:qword_100020[rdi]
cmp rax, ds:qword_1000E0[rdi]
jnz short loc_48B4D
xor eax, eax
retn
loc_48B4D:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov rax, ds:qword_100010[rdi]
mov [rbp-30h], rax
mov r12, ds:qword_100038[rdi]
mov r13b, ds:byte_1000D9[rdi]
lea r14, unk_1000E8[rdi]
lea r15, unk_100090[rdi]
loc_48B85:
cmp ds:qword_100118[rbx], 0
jnz short loc_48BCD
mov rdi, r14
mov rsi, r15
call _pthread_cond_wait
loc_48B9A:
mov al, 1
cmp ds:qword_100038[rbx], r12
jnz short loc_48BE8
mov rcx, [rbp-30h]
cmp ds:qword_100010[rbx], rcx
jnz short loc_48BE8
cmp ds:byte_1000D9[rbx], r13b
jnz short loc_48BE8
mov rax, ds:qword_100020[rbx]
cmp rax, ds:qword_1000E0[rbx]
jnz short loc_48B85
jmp short loc_48BE6
loc_48BCD:
mov rdi, r14
mov rsi, r15
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0A24h
call psi_cond_wait
jmp short loc_48B9A
loc_48BE6:
xor eax, eax
loc_48BE8:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char translog_prev_buffer_flush_wait(long long a1)
{
char result; // al
long long v2; // r12
char v3; // r13
char *v4; // r14
char *v5; // r15
long long v6; // [rsp-38h] [rbp-38h]
if ( *(long long *)((char *)&qword_100020 + a1) == *(long long *)((char *)&qword_1000E0 + a1) )
return 0;
v6 = *(long long *)((char *)&qword_100010 + a1);
v2 = *(long long *)((char *)&qword_100038 + a1);
v3 = byte_1000D9[a1];
v4 = (char *)&unk_1000E8 + a1;
v5 = (char *)&unk_100090 + a1;
while ( 1 )
{
if ( *(long long *)((char *)&qword_100118 + a1) )
psi_cond_wait(
(long long)v4,
(long long)v5,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0xA24u);
else
pthread_cond_wait(v4, v5);
result = 1;
if ( *(long long *)((char *)&qword_100038 + a1) != v2
|| *(long long *)((char *)&qword_100010 + a1) != v6
|| byte_1000D9[a1] != v3 )
{
break;
}
if ( *(long long *)((char *)&qword_100020 + a1) == *(long long *)((char *)&qword_1000E0 + a1) )
return 0;
}
return result;
}
|
translog_prev_buffer_flush_wait:
MOV RAX,qword ptr [RDI + 0x100020]
CMP RAX,qword ptr [RDI + 0x1000e0]
JNZ 0x00148b4d
XOR EAX,EAX
RET
LAB_00148b4d:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x100010]
MOV qword ptr [RBP + -0x30],RAX
MOV R12,qword ptr [RDI + 0x100038]
MOV R13B,byte ptr [RDI + 0x1000d9]
LEA R14,[RDI + 0x1000e8]
LEA R15,[RDI + 0x100090]
LAB_00148b85:
CMP qword ptr [RBX + 0x100118],0x0
JNZ 0x00148bcd
MOV RDI,R14
MOV RSI,R15
CALL 0x00129430
LAB_00148b9a:
MOV AL,0x1
CMP qword ptr [RBX + 0x100038],R12
JNZ 0x00148be8
MOV RCX,qword ptr [RBP + -0x30]
CMP qword ptr [RBX + 0x100010],RCX
JNZ 0x00148be8
CMP byte ptr [RBX + 0x1000d9],R13B
JNZ 0x00148be8
MOV RAX,qword ptr [RBX + 0x100020]
CMP RAX,qword ptr [RBX + 0x1000e0]
JNZ 0x00148b85
JMP 0x00148be6
LAB_00148bcd:
MOV RDI,R14
MOV RSI,R15
LEA RDX,[0x1d9b58]
MOV ECX,0xa24
CALL 0x0012eea0
JMP 0x00148b9a
LAB_00148be6:
XOR EAX,EAX
LAB_00148be8:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 translog_prev_buffer_flush_wait(long param_1)
{
pthread_cond_t *__cond;
pthread_mutex_t *__mutex;
char cVar1;
long lVar2;
long lVar3;
if (*(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x17) ==
*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_align + param_1)) {
return 0;
}
lVar2 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 7);
lVar3 = *(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x2f);
cVar1 = *(char *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_memsz + param_1 + 1);
__cond = (pthread_cond_t *)((long)&Elf64_Phdr_ARRAY_00100040[3].p_type + param_1);
__mutex = (pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + param_1);
while( true ) {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[3].p_align + param_1) == 0) {
pthread_cond_wait(__cond,__mutex);
}
else {
psi_cond_wait(__cond,__mutex,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",0xa24);
}
if (*(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x2f) != lVar3) {
return 1;
}
if (*(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 7) != lVar2) {
return 1;
}
if (*(char *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_memsz + param_1 + 1) != cVar1) break;
if (*(long *)(Elf64_Ehdr_00100000.e_ident_pad + param_1 + 0x17) ==
*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_align + param_1)) {
return 0;
}
}
return 1;
}
|
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.